[Algoritmo] Stabilire se una parola viene alfabeticamente prima di un'altra

[lorenzoakatheking]

Ciao a tutti.
Ho bisogno di un piccolo aiuto nella risoluzione di un algoritmo affrontato all'università e che mi sta lasciando qualche dubbio. Ritengo la sezione più adatta per chiedere sia questa, spero di non aver sbagliato.

Ma torniamo al tema centrale.

"Stabilire se una parola viene alfabeticamente prima di un’altra"

Questo sopra è l'algoritmo che io credo in una sua prima parte vada risolto così:
- Definisco l'alfabeto dicendo che A<B<C<...<Z;
- Leggi parola1;
- Leggi parola2;
- Chiama la prima lettera della parola1 a e la prima lettera della parola2 b
- Confronta a con b: se a < b allora la parola1 viene prima della parola2;
se a > b allora la parola2 viene prima della parola1;


ora però se le lettere son uguali devo confrontare le altre lettere...e come faccio a definire il confronto tra le altre lettere senza scrivere mille righe e soprattutto è possibile questo confronto?

[banryu79]

ora però se le lettere son uguali devo confrontare le altre lettere...e come faccio a definire il confronto tra le altre lettere senza scrivere mille righe...
Il confronto tra due lettere viene eseguito in un ciclo che si ripete finchè non vengono trovate due lettere tra loro diverse.

[||ElChE||88]

Ecco una semplice, chiara e concisa funzione ricorsiva in C:


int
____( char
*_, char
*__, int
___){ return
_[___] =='\0'
&&__ [___] =='\0'
?0:_ [___]
>__ [___]
?1:_ [___]
<__ [___]
?2:____ (_,__,
++___)
;}


:asd:

Edit: Resa più chiara e concisa. :O

[||ElChE||88]

:what: :boh:
E' l'implementazione in C/C++ dell'algoritmo ricorsivo di cui parli.
Ha un difettuccio però: i caratteri maiuscoli hanno un valore più basso di quelli minuscoli. :fagiano:

[Big Bamboo]

Ecco una semplice, chiara e concisa funzione ricorsiva in C:


int
____( char
*_, char
*__, int
___){ return
_[___] =='\0'
&&__ [___] =='\0'
?0:_ [___]
>__ [___]
?1:_ [___]
<__ [___]
?2:____ (_,__,
++___)
;}


:asd:

Edit: Resa più chiara e concisa. :O

E' la cosa più nerd che ho visto da quando sono iscritto qua dentro :asd:

[nico159]

Ecco una semplice, chiara e concisa funzione ricorsiva in C:


int
____( char
*_, char
*__, int
___){ return
_[___] =='\0'
&&__ [___] =='\0'
?0:_ [___]
>__ [___]
?1:_ [___]
<__ [___]
?2:____ (_,__,
++___)
;}


:asd:

Edit: Resa più chiara e concisa. :O
:banned:

[^TiGeRShArK^]

def value(word):
value = 0
for c in word.lower():
value = value + ord(c)
return value

def maggiore(word1, word2):
return value(word1) < value(word2)


print maggiore('ciao', 'ciaa')

print 'ciao'.lower() < 'ciaa'.lower()

Basta sommare il valore di ogni carattere della stringa convertita in lowercase (in modo da mantenere l'ordine anche con i caratteri maiuscoli) e confrontare i due valori ottenuti.
Comunque è un non-sense dato che l'ultima riga di codice fa esattamente la stessa cosa delle due funzioni che ho implementato.

[||ElChE||88]

Basta sommare il valore di ogni carattere della stringa convertita in lowercase (in modo da mantenere l'ordine anche con i caratteri maiuscoli) e confrontare i due valori ottenuti.
Comunque è un non-sense dato che l'ultima riga di codice fa esattamente la stessa cosa delle due funzioni che ho implementato.
Sbaglio, o se sommi il valore di ogni carattere "abbbbbbb" è maggiore di "abc" (e quindi sbagliato)?

[^TiGeRShArK^]

Sbaglio o se sommi ogni carattere il valore di "abbbbbbb" è maggiore del valore di "abc" (e quindi sbagliato)?

vero, bisogna sommare solo quelli fino alla dimensione massima della parola + corta anzichè iterare lungo tutta la parola...
Comunque la soluzione migliore è ovviamente usare l'operatore di confronto < che da sempre il risultato corretto in una sola riga di codice :p

[||ElChE||88]

Comunque la soluzione migliore è ovviamente usare l'operatore di confronto < che da sempre il risultato corretto in una sola riga di codice :p
Dipende dal linguaggio usato però. :O

[wingman87]

vero, bisogna sommare solo quelli fino alla dimensione massima della parola + corta anzichè iterare lungo tutta la parola...
Comunque la soluzione migliore è ovviamente usare l'operatore di confronto < che da sempre il risultato corretto in una sola riga di codice :p

Ma così "azz">"baa" o sbaglio?

[^TiGeRShArK^]

e vabbè...
che 2 palle..
basta assegnare un peso ad ogni carattere :p
Se sapevo scrivevo solo print 'cazz' < 'cip' anzichè fare tutto l'algoritmo :asd: