[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]

Originariamente inviato da lorenzoakatheking

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:____  (_,__,
           ++___)
	      ;}

Edit: Resa più chiara e concisa.

[||ElChE||88]

Originariamente inviato da VeeJ

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.

[Big Bamboo]

Originariamente inviato da ||ElChE||88

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

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

Edit: Resa più chiara e concisa.

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

[nico159]

Originariamente inviato da ||ElChE||88

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

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

Edit: Resa più chiara e concisa.

[^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]

Originariamente inviato da ^TiGeRShArK^

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^]

Originariamente inviato da ||ElChE||88

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

[||ElChE||88]

Originariamente inviato da ^TiGeRShArK^

Comunque la soluzione migliore è ovviamente usare l'operatore di confronto < che da sempre il risultato corretto in una sola riga di codice

Dipende dal linguaggio usato però.

[wingman87]

Originariamente inviato da ^TiGeRShArK^

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

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

[^TiGeRShArK^]

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