vocali maiuscole con ricorsione

[zipangulu]

Il problema è questo:

Si scriva un metodo ricorsivo
static String vocaliMaiuscole(String s)
che restituisce la stringa ottenuta da "s" mettendo tutte le vocali in maiuscolo. Esempio: con la stringa "Persona" restituisce la stringa "PErsOnA".

Secondo il ragionamento della ricorsività questa implementazione può andar bene?O meglio , lui opera ricorsivamente ma come vi sembra?

private final static String vocali = "aeiou";

	public static String vocaliMaiuscole (String s) {
		String stringa="";
		if(s.length() == 1){
			stringa+=(vocali.indexOf (s.charAt (0)) != -1) ? (s.charAt (0)+"").toUpperCase () : s.charAt (0);
		}else {
			stringa+=(vocali.indexOf (s.charAt (0)) != -1) ? (s.charAt (0)+"").toUpperCase () : s.charAt (0);
			stringa+=vocaliMaiuscole (s.substring (1));
		}
		return stringa;
	}

A mio avviso non è il massimo della eleganza , ma voi come lo implementereste in una maniera più "pulita"?

[andbin]

Originariamente inviato da zipangulu
A mio avviso non è il massimo della eleganza , ma voi come lo implementereste in una maniera più "pulita"?

Come scrittura non è il massimo ma c'è comunque un errore: se inizialmente riceve una stringa vuota ( "" ), passa nel else e il charAt fallisce con eccezione.

[zipangulu]

Originariamente inviato da andbin
Come scrittura non è il massimo ma c'è comunque un errore: se inizialmente riceve una stringa vuota ( "" ), passa nel else e il charAt fallisce con eccezione.

l'errore può essere corretto così:

private final static String vocali = "aeiou";

	public static String vocaliMaiuscole (String s) {
		String stringa="";
		if(s.length()==0){
		}else if(s.length() == 1){
			stringa+=(vocali.indexOf (s.charAt (0)) != -1) ? (s.charAt (0)+"").toUpperCase () : s.charAt (0);
		}else {
			stringa+=(vocali.indexOf (s.charAt (0)) != -1) ? (s.charAt (0)+"").toUpperCase () : s.charAt (0);
			stringa+=vocaliMaiuscole (s.substring (1));
		}
		return stringa;
	}

Un qualche consiglio su come "migliorare la scrittura" ?

[andbin]

Originariamente inviato da zipangulu
Un qualche consiglio su come "migliorare la scrittura" ?

Sì: evitare la ripetizione di s.charAt(0) tenendosi una variabile char, evitare concatenazioni inutili (es. quel s.charAt (0)+"" ), evitare "percorsi" inutili (nel tuo codice può passare per 3 vie ... troppe).

[valia]

in genere quando fai le cose per ricorsione è bene ricordare che devi avere in genere 2 vie e chiederti: hai finito?
Se si ritorni, sennò richiami la funzione con un sottoinsieme.

[zipangulu]

Originariamente inviato da valia
in genere quando fai le cose per ricorsione è bene ricordare che devi avere in genere 2 vie e chiederti: hai finito?
Se si ritorni, sennò richiami la funzione con un sottoinsieme.

Bè si , nella norma i metodi ricorsivi dovrebbero comprendere un caso base e un caso ricorsivo , ma (forse errando ) all'università ( al suo tempo,al primo anno ) mi hanno insegnato che inserire più casi base non è una cosa scorretta ... vabè il tutto deve essere contenuto , logico che i casi base non devono coprire tutto ( o quasi) il range dei possibili casi , altrimenti la ricorsione non avrebbe senso

[VincenzoTheBest]

Originariamente inviato da zipangulu
A mio avviso non è il massimo della eleganza , ma voi come lo implementereste in una maniera più "pulita"?

Io propongo questa possibile soluzione

import java.util.HashMap;

public class Esempio {
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        System.out.println(Esempio.setVocaliToUpperCase("persona"));
        System.out.println(Esempio.setVocaliToUpperCase("arcobaleno"));
    }
    
    public static String setVocaliToUpperCase(String s) {
    	return setVocaliToUpperCase( new StringBuilder(s), 0 );
    }
    
    private static String setVocaliToUpperCase(StringBuilder s, int index){
    	if( index == s.length() )
    		return s.toString();
    	if( VOCALI.get(s.charAt(index)) != null )
    		s.setCharAt(index, Character.toUpperCase(s.charAt(index)));
    	return setVocaliToUpperCase(s, index + 1);
    }
    
    private final static HashMap<Character, Character> VOCALI;
    static {
    	VOCALI = new HashMap<Character, Character>();
    	VOCALI.put('a', 'a');
    	VOCALI.put('e', 'e');
    	VOCALI.put('i', 'i');
    	VOCALI.put('o', 'o');
    	VOCALI.put('u', 'u');
    }
}

Fammi sapere.

[valia]

private String vocaliMaiuscole(String stringa) {
		String ret = "";
		Character test ;
		
		if (stringa.length() == 0) {
			ret = stringa ; 
		} else {
			test = stringa.charAt(0);
			if (isVocale(test)) {
				test = Character.toUpperCase(test);
			}
			ret += test;
			ret += vocaliMaiuscole(stringa.substring(1));
		}
		return ret;
	}

	private boolean isVocale(char character) {
		boolean ret = false;
		switch (character) {
		case 'A':
		case 'a':
		case 'E':
		case 'e':
		case 'I':
		case 'i':
		case 'O':
		case 'o':
		case 'U':
		case 'u':
			ret = true;
			break;
		}

		return ret;

	}

chissà perché io la ricorsione l'ho sempre vista con 2 casi, uno base e uno ricorsivo.
Gli altri secondo me complicano la vita.
Qui hai un esempio della mia implementazione (funziona) e volendo puoi generalizzare (chiedendo anche l'inversione del case)

[andbin]

E questa è la mia (da mettere in una classe, chiaramente, omessa per brevità):

public static String vocaliMaiuscole(String s) {
    if (s == null || s.length() == 0) {
        return s;
    }
        
    char c = s.charAt(0);
    return ("aeiou".indexOf(c) != -1 ? Character.toUpperCase(c) : c) + vocaliMaiuscole(s.substring(1));
}

Sì .. tutto qui.

[zipangulu]

Originariamente inviato da valia

private String vocaliMaiuscole(String stringa) {
		String ret = "";
		Character test ;
		
		if (stringa.length() == 0) {
			ret = stringa ; 
		} else {
			test = stringa.charAt(0);
			if (isVocale(test)) {
				test = Character.toUpperCase(test);
			}
			ret += test;
			ret += vocaliMaiuscole(stringa.substring(1));
		}
		return ret;
	}

	private boolean isVocale(char character) {
		boolean ret = false;
		switch (character) {
		case 'A':
		case 'a':
		case 'E':
		case 'e':
		case 'I':
		case 'i':
		case 'O':
		case 'o':
		case 'U':
		case 'u':
			ret = true;
			break;
		}

		return ret;

	}

chissà perché io la ricorsione l'ho sempre vista con 2 casi, uno base e uno ricorsivo.
Gli altri secondo me complicano la vita.
Qui hai un esempio della mia implementazione (funziona) e volendo puoi generalizzare (chiedendo anche l'inversione del case)

Il tuo esempio va bene se non per il fatto che i tuoi metodi sono d'istanza , andrebbero definiti statici...piccola distrazione (penso)