[Java]sequenza palindroma

[geme84]

ciao a tutti dovrei controllare se all'interno di un array di interi vi è presente una sequenza palindorma:
-se presente devo fare una return del numero degli interi palindromi( es. 2 3 1 5 1 7 7 come return devo dare 3 perchè la sequenza palindroma è composta da 1 5 1 cioè 3 numeri)
-altrimenti se non è presente nessuna sequenza palindorma devo dare in return 1

io pensavo di fare un ciclo i che parte da 0 che controlla A[i] , in i++ e poi faccio partire un ciclo j dall'ultimo elemento che controlla A[j] in j--. Se A[i]==A[j] incremento un contatore c che faccio partire da 1(da 1 perchè se elemento dx =elemento sinistra vuol dire che sono 2 numeri uguali) altrimenti se A[i]!=A[j] faccio una return di 1.


voi che ne dite?

[Alex'87]

Originariamente inviato da geme84
voi che ne dite?

Che ti hanno risposto qua

[desa]

Due cicli non ti servono a nulla, e il perchè lo trovi nello snippet di codice che ho postato nella discussione segnalata da Alex'87: ti è sufficiente un indice solo.
Quello che non ho capito è se la sequenza palindroma deve essere consecutiva (come nell'esempio che hai segnalato), oppure no e a te interessa solo sapere quanti numeri hanno un corrispettivo "simmetrico" rispetto al centro dell'array, anche se non consecutivi.

Ipotizzando il primo caso, vedo due soluzioni possibili:
- parti ad analizzare l'array dal centro e ad ogni iterazione te ne allontani di una posizione: nel momento in cui trovi due numeri che non corrispondono restituisci il numero di interi relativo al valore dell'indice che avevi analizzato all'iterazione precedente;
- parti ad analizzare l'array dall'inizio e ti sposti verso il centro: nel corso del ciclo, se trovi due numeri che corrispondono incrementi di uno un contatore; se incontri due interi "diversi" lo resetti a 0. Arrivato al centro dell'array restituisci il valore del contatore opportunamente "raddoppiato".

Credo sia abbastanza evidente ma, anche in termini computazionali, ti suggerisco di seguire la prima strada. Prova a pensare ai dettagli implementativi (soprattutto la gestione degli indici) e fai sempre attenzione al fatto che devi prevedere sia che l'array abbia lunghezza pari, sia che abbia lunghezza dispari

[geme84]

il tema di esame mi riportava

es.3,5,1,5,7,1,13,3,3,13,6 restituisce 4 perchè la sequenza palindorma piu lunga è 13,3,3,13
3,3,1,4,7,1,7,13,3,6 restituisce 3 perchè 7,1,7 palindormo

dici che l'algoritmo che uscirebbe dalla mia idea di risoluzione, non avrebbe nessun utilizzo??

capisco le problematiche a livello computazionale, ma come ti dicevo sopra è solo un esercizio "teorico"(se cosi si puo definire)

PS:ragionando a questo esercizio, mi è sorto un dubbio...come si fa a dichiarare l'ultimo elemento di un array?

[desa]

Ah, ma se le cose stanno così allora cambia tutto!
Riprendendo in mano l'algoritmo che avevi delineato, a occhio direi due cicli non bastano: avresti bisogno anche di mettere in piedi un meccanismo di ricorsione una volta stabilito che A[i] == A[j].

Mi è venuta in mente una idea un po' diversa, prova a pensarci su: la delineo per il caso in cui la sequenza palindroma è sicuramente di lunghezza dispari - che è più semplice - ma con qualche aggiustatina è adattabile anche al caso, che devi prevedere, in cui sia di lunghezza pari.
Definisci sempre un ciclo su un indice "i" che parte da 0: la particolarità è che consideri l'elemento dell'array indicizzato da "i" come l'elemento CENTRALE della (da verificare) sequenza palindroma. A questo punto, utilizzi un nuovo ciclo su un indice "j" in cui ti allontani progressivamente da "i" e verifichi se, da entrambi i lati, gli elementi hanno valore uguale. La sequenza più lunga che riesci a trovare in questo modo è quella ricercata.

Che ne pensi?

[desa]

Ah già, dimenticavo: "dichiarare" l'ultimo elemento di un array non ha senso... che cosa vuoi dire?

[bstefano79]

prova è da testare

public static int palindroma(char[] vet,int i, int j,int max)
{
	int count=0;
	int index=i;
	while(i>=j)
	{
		if(vet[i]!=vet[j])
		{
			count=0;
			j--;
			i=index;
		}
		else
		{
			count++;
			j--;
			i++;
		}
	}
	if((++index)<vet.length())
	{
		if(count>max)
                {
		        palindroma(vet,index,vet.length()-1,count);
                        return count;
                }
                else
                {
		        palindroma(vet,index,vet.length()-1,max);
                        return max;
                }
	}
	return 1;
}

main

public static void main(String[] args)
{
       char vet[10];
        vet={//mettici quello che vuoi};
        System.out.println(palindroma(vet,0,vet.lenght()-1,0));
}

[desa]

In realtà non cambia quasi nulla, ma il tuo problema non ti chiedeva ti trattare una sequenza di int???
Appena posso do un'occhiata all'algoritmo, però ti posso subito segnalare che nel main() ci sono un paio di errori:
- l'array va dichiarato con l'istruzione "char[] vet" (o "char vet[]"): la sua dimensione va indicata solo quando fai l'inizializzazione tramite "new char[10]" (e non è necessaria se gli passi esplicitamente i valori da inserire: "new char[] {'a', 'b', 'c'}" );
- la lunghezza dell'array la recuperi tramite l'operatore ".length"; probabilmente ti confondi con il metodo "length()" di String (che, comunque, hai digitato in maniera errata).

[geme84]

si si..era comunque richiesto lavorare su un array di interi

[desa]

Ok, ho provato a darci un'occhiata, ma non mi sembra che realizzi l'algoritmo che avevo descritto. Vuoi provare a spiegarmi nel dettaglio cosa vorresti fare?