[java]parole appese

[el92]

Ciao a tutti sto iniziando a studiare java e come sempre ci sono degli esercizi che non riesco a risolvere.
Il problema è: scrivi un programma che stampa delle parole in verticale idealmente appese a un filo. Ad esempio, se le parole sono:
uno due tre quattro cinque
deve essere stampato:

U D T Q C
N U R U I
O E E A N
      T Q
      T U
      R E
      O

Le parole vanno stampate in maiuscole, separate l'una dall'altra da uno spazio.
Il mio programma è (ho lasciato perdere gli spazi tra una parola e l'altra):

import java.util.Scanner;
import java.util.StringTokenizer;
class ParoleAppese{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("insersci le parole");
String f=sc.nextLine();
final int n=4;
String maiuscole[]=new String[n];
StringTokenizer st = new StringTokenizer(f," ");
int count=0;
while(st.hasMoreTokens()){
    String numero1=st.nextToken();
    String m=numero1.toUpperCase();
    maiuscole[count]=m;
    count++;
}
    for(int colonne=0;colonne<count;colonne++){ //colonne
        for(int posizionelettera=0;posizionelettera<maiuscole[colonne].length();posizionelettera++)
            System.out.println(maiuscole[colonne].charAt(posizionelettera));
    }
}
}

Perchè il compilatore stampa le parole tutte in verticale? dov'è che sbaglio?

[minomic]

Ciao, il programma di per sè può sembrare complicato, ma ha una struttura piuttosto semplice. La stampa avviene riga per riga, quindi fai così:
- acquisisci le parole che devi stampare
- stampi la prima lettera di ogni parola in questo modo: lettera + spazio + lettera + spazio + ...
- vai a capo
- stampi la seconda lettera di ogni parola, come prima
- vai a capo
- ...
- quando cerchi di stampare una lettera che ha una posizione superiore alla lunghezza della parola stessa allora stampi uno spazio

E così dovresti aver finito.

[el92]

Ciao ok ho provato a rifarlo riscrivendo il codice considerando le righe:

iimport java.util.Scanner;
import java.util.StringTokenizer;
class ParoleAppese{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("insersci le parole");
String f=sc.nextLine();
final int n=4;
String maiuscole[]=new String[n];
StringTokenizer st = new StringTokenizer(f," ");
int count=0;
while(st.hasMoreTokens()){
    String numero1=st.nextToken();
    String m=numero1.toUpperCase();
    maiuscole[count]=m;
    int size=maiuscole[count].length();
        for(int riga=0;riga<size;riga++){
            for(int posizione=0;posizione<=count;posizione++)
                System.out.print(maiuscole[count].charAt(posizione) + " ");            
            }
        }
            
    }        
}

se inserisco da terminale: uno due tre
Perchè il compilatore mi stampa:U U U D D D T T T? Scusa ma sono in crisi

[minomic]

In quel codice ci sono parecchi problemi. Il primo è che non è nei tag CODE, ma lasciamo perdere... Più che altro cosa sarebbe quella variabile count? E dov'è che la incrementi? Quella vale sempre 0!

Prova a leggere questo, che mi sembra molto più semplice:

import java.util.Scanner;

public class ParoleAppese {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Quante parole vuoi inserire? ");
        int nParole = Integer.parseInt(sc.nextLine().trim());
        String[] parole = new String[nParole];
        // la lunghezza massima delle parole inserite
        int lunghMax = 0;

        for (int i = 0; i < nParole; ++i) {
            System.out.print("Inserisci la prossima parola: ");
            // memorizzo la parola nell'array
            parole[i] = sc.nextLine().trim();
            // aggiorno eventualmente la lunghezza massima
            if (parole[i].length() > lunghMax) {
                lunghMax = parole[i].length();
            }
        }

        for (int i = 0; i < lunghMax; ++i) {
            for (int j = 0; j < nParole; ++j) {
                if (i < parole[j].length()) {
                    // la parola non e' ancora finita: stampo il carattere
                    // (convertito in maiuscolo)
                    System.out.print(Character.toUpperCase(parole[j].charAt(i)));
                } else {
                    // la parola e' finita: stampo uno spazio
                    System.out.print(" ");
                }
                // stampo uno spazio tra due parole
                System.out.print(" ");
            }
            // vado a capo per stampare la riga successiva
            System.out.println();
        }

        sc.close();
    }

}

[el92]

Ciao grazie x il codice è da tutto il giorno che sono su questo problema solo due domande:
il metodo trim() "elimina" gli spazi come nella classe stringtokenizer?
Scrivere nel ciclo for ++i o i++ è la stessa cosa?
Grazie 1000 x la tua disponibilità

[minomic]

Il metodo trim serve solo per eliminare eventuali spazi in fondo. Invece il tokenizer serve per suddividere una frase in tante parole.
Mettere i++ o ++i è spesso la stessa cosa, ma non sempre! Quindi è importante capire bene la differenza tra pre-incremento e post-incremento.

[el92]

ah ok....dovrò fare ancora molta strada prima di imparare bene Grazie 1000 gentilissimo

[minomic]

Prego!