.dsy:it. (http://www.dsy.it/forum/)
- Programmazione (http://www.dsy.it/forum/forumdisplay.php?forumid=259)
-- [LAB Programmazione] Esercizi Turno 2 (http://www.dsy.it/forum/showthread.php?threadid=14930)

[LAB Programmazione] Esercizi Turno 2

ecco due esercizi di preparazione:

programma che dato in input una frase verifica se è un acronimo ricorsivo.
-----------------------------------------------------------------------------------
import java.util.*;
import prog.io.*;
import prog.utili.*;

class FraseRicorsiva{
public static void main(String[] args){
ConsoleInputManager in = new ConsoleInputManager();
ConsoleOutputManager out = new ConsoleOutputManager();
boolean fraseRicorsiva = true;
String s;
do{
s = in.readLine("Inserisci la frase ricorsiva [es. SEI Elisa Infelice]\n");
}
while(s.length() < 2);
StringTokenizer st = new StringTokenizer(s," ");
s = st.nextToken();
if(s.length() != st.countTokens()+1)
fraseRicorsiva = false;
else{
for(int k = 1;st.hasMoreTokens();k++)
if(s.charAt(k) != st.nextToken().charAt(0)){
fraseRicorsiva = false;
break;
}
}
if(fraseRicorsiva)
out.println("La frase e' ricorsiva");
else
out.println("La frase non e' ricorsiva");
}
}
----------------------------------------------------------------------------------
programma che calcola l'acronimo ricorsivo su una parola data in input tramite controllo su file acronimi.txt
---------------------------------------------------------------------------------
import java.util.*;
import prog.io.*;
import prog.utili.*;

class AcronimoRicorsivo{
public static void main(String[] args){
ConsoleInputManager in = new ConsoleInputManager();
ConsoleOutputManager out = new ConsoleOutputManager();
FileInputManager fp = new FileInputManager("acronimi.txt");
boolean parolaRicorsiva = false;
int k;
String s,buffer = "";
StringTokenizer st;
do{
s = in.readLine("Inserisci la parola ricorsiva [es. SEI]\n");
}
while(s.length() < 2);
while(!parolaRicorsiva && ((buffer = fp.readLine()) != null)){
st = new StringTokenizer(buffer," ");
if(s.length() == st.countTokens()+1){
for(k = 1;st.hasMoreTokens();k++)
if(s.charAt(k) != st.nextToken().charAt(0))
break;
if(k == s.length())
parolaRicorsiva = true;
}
}
if(parolaRicorsiva)
out.println("La parola " + s + " e' ricorsiva a: " + buffer);
else
out.println("La parola non e' ricorsiva");
}
}
------------------------------------------------------------------------------------
ps. acronimi.txt deve contenere al suo interno gli acronimi [es: Not Unix ]
ciao a tutti NFast

ragazzi qualcuno di voi sa per caso come implementare l'algoritmo dell'anagramma ?

io l'ho scrissi qualke anno fa in C per un compito di laboratorio delle superiori (utilizzando il random), però non è una bella cosa (sovraccarico di memoria).

se qualcuno ha un'idea rispondete a questo post .

ciao

quello per l'anagramma non lo riesco a fare.... mi frega il fatto che non so come togliere una lettera da una stringa, ammesso che si possa fare. Pensavo di risolverlo utilizzando gli array, ma visto che mi pare che non li abbia ancora spiegati suppongo che non sia necessario usarli. Avevo impapocchiato qualcosa giocando con indexOf, ma mi perdeva il caso, tutt'altro che raro, di lettere ripetute (mi avrebbe considerato pippo come anagramma di pipoo, insomma).

__________________
Mai sottovalutare l'ampiezza di banda di una station wagon piena di nastri lanciata a tutta velocità lungo l'autostrada. - Andrew S. Tanenbaum - Reti di Calcolatori

io l'ho fatto cosi quello dell'acronimo..

import prog.io.*;
import java.util.StringTokenizer;

class Enigmistica2
{
public static void main(String[] args)
{
ConsoleInputManager in = new ConsoleInputManager();
ConsoleOutputManager out = new ConsoleOutputManager();

String testo = in.readLine("Inserisci testo: ");

StringTokenizer st = new StringTokenizer(testo);

int lung=st.countTokens(), cont=0;
String primap = st.nextToken(), token;


out.print("\nLa frase \"");
out.print(primap.toUpperCase());

for(int i=1; st.hasMoreTokens()==true ;i++)
{
if(primap.charAt(i)==(token=st.nextToken()).charAt(0))
cont++;

out.print(" "+token);
}

if(cont==lung-1 && lung!=1)
out.println("\" e' un acronimo ricorsivo");
else
out.println("\" non e' un acronimo ricorsivo");
}
}

mentre questo è quello del palindromo per i testi

import prog.io.*;
import java.util.StringTokenizer;

class Enigmistica2
{
public static void main(String[] args)
{
ConsoleInputManager in = new ConsoleInputManager();
ConsoleOutputManager out = new ConsoleOutputManager();

String testo = in.readLine("Inserisci testo: ");

StringTokenizer st = new StringTokenizer(testo," ,.'!\":;");
String token, stringa="";


while(st.hasMoreTokens())
{
token=st.nextToken();
stringa+=token;
}
stringa.toLowerCase();

boolean palindroma = true;
int lung = stringa.length() - 1;
for (int sx = 0, dx = lung ; sx < dx; sx++,
dx--)
if (stringa.charAt(sx) != stringa.charAt(dx))
palindroma = false;

if (palindroma)
out.println("Il testo e' palindromo");
else
out.println("Il testo non e' palindromo");

}
}

in quello dell'acronimo mi pare che non gli fai il controllo iniziali maiuscole sulle parole successive alla prima.... era richiesto nelle specifiche

per gli anagrammi, chiarisco meglio il mio problema, o almeno ci provo ^^

Il discorso che avevo in mente di fare è più o meno questo:

Per ogni token della stringa di testo con lo stesso numero di lettere della parola di cui cerchiamo l'anagramma:

1) Prendo la prima lettera del token
2) La confronto con tutte quelle della parola finchè non trovo una corrispondenza
3) Elimino dalla parola la lettera riscontrata
4) Passo a fare lo stesso giochetto sulla lettera successiva del token

Il punto 3 non so come farlo... non so come dirgli che non deve considerare le lettere già riscontrate. Quindi se ho "pippo" come token e lo sto confrontando con "ippop" voglio al primo passaggio prendere la prima "p" di pippo e beccare la corrispondenza con la prima "p" di ippop. Ma al secondo passaggio non devo più confrontare "pippo" con "ippop", bensì "-ippo" con "i-pop", dove "-" è la lettera già riscontrata che non devo più considerare. Avevo pensato di lavorarci con gli array ma non dovrebbe essere necessario. Avevo pensato di ricostruire la stringa via via più corta man mano che si eliminano lettere, ma a quel punto mi impazziscono i for di scorrimento stringa... avevo pensato di farmi un'altra classe da chiamare in maniera ricorsiva ma mi pare un po' troppo barocco...

__________________
Mai sottovalutare l'ampiezza di banda di una station wagon piena di nastri lanciata a tutta velocità lungo l'autostrada. - Andrew S. Tanenbaum - Reti di Calcolatori

vabbè, l'ha spiegato oggi.... mi era sfuggito il metodo substring

__________________
Mai sottovalutare l'ampiezza di banda di una station wagon piena di nastri lanciata a tutta velocità lungo l'autostrada. - Andrew S. Tanenbaum - Reti di Calcolatori

[anagramma]

avevo capito male il problema che il prof Grossi ci aveva dato settimana scorsa per casa:

pensavo a costruire un anagramma di una parola data in input.

ABC ad esempio è:

ACB
BAC
BCA
CAB
CBA

pensavo che fosse questo l'esercizio

ps: proviamo a farlo raga, eliminando anche le parole doppie.
ad esempio ANNA......(ripeto io l'ho fatto in C qualke anno fa).

Re: [anagramma]

Originally posted by nfast
avevo capito male il problema che il prof Grossi ci aveva dato settimana scorsa per casa:

pensavo a costruire un anagramma di una parola data in input.

ABC ad esempio è:

ACB
BAC
BCA
CAB
CBA