Newsgroup: it.comp.java
Titolo: Mi potete trovare l'errore?

/* Applicazione che verifica se una sequenza di caratteri letti da tastiera
*/
/* e' formata da tutti caratteri maiuscoli */
import fiji.io.*;
class TutteMaiuscoleDue {
public static void main (String[] args) {
    char c;
    boolean risultato;
    risultato=false; //Siccome č una verifica esistenziale allora la
variabile boolean deve
                     //avere come valore iniziale false
    System.out.println("Scrivi una sequenza non vuota terminata da invio");
    c=Lettore.in.leggiChar();
    while (!Lettore.in.eoln()) {
    if (maiuscole(c))
       risultato=true;
    else
    risultato=false;
                }//end while
    if (risultato=true)
    System.out.println("La sequenza contiene tutti caratteri maiuscoli");
    if (risultato=false)
    System.out.println("La sequenza contiene almeno un carattere
minuscolo");//end if-else
    }//end main
    public static boolean maiuscole (char c) {
      if (c>='A' && c<='Z')
      return true;
         else
         return false;
        }//end maiuscole
  }
Quando inserisco una sequenza di sole maiuscole il programma gira, ma quando
inserisco una sequenza di minuscole fa ciclo infinito. Perchč?


Sono riuscito ad evitare il ciclo infinito ma ora dà sempre la scritta che
ci sono caratteri maiuscoli anche quando scrivo caratteri minuscoli
/* Applicazione che verifica se una sequenza di caratteri letti da tastiera
*/
/* e' formata da tutti caratteri maiuscoli */
import fiji.io.*;
class TutteMaiuscoleDue {
public static void main (String[] args) {
    char c;
    boolean risultato;
    risultato=false; //Siccome è una verifica esistenziale allora la
variabile boolean deve
                     //avere come valore iniziale false
    System.out.println("Scrivi una sequenza non vuota terminata da invio");
    c=' ';
    while (!Lettore.in.eoln() && !(maiuscole(c))) {
    c=Lettore.in.leggiChar();


     if (risultato=true)
Attento perché questa è una assegnazione! Quello che volevi fare tu
probabilmente è risultato == true con due uguale
Un'ultima cosa. Quel discorso che facevi sull'esistenza è giusto ma è
invertito.
Posto che:
risultato == true ==> tutti maiuscoli 
risultato == false ==> almeno uno minuscolo
La cosa da fare era il contrario. Inizializzare a true risultato e lasciarlo
true finché non trovavi un carattere minuscolo. Ed in questo caso _non
cambiarlo più_. Cioè dopo l'inizializzazione o risultato rimane true o
diventa false e lo rimane.
Spero di essere stato chiaro
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://www.ilnomedeldominio.it
un piccolo programma per studenti universitari:
http://inutility.ilnomedeldominio.it

     }
2) nota che una volta che risultato è settata a false all' interno del ciclo
non dovrebbe più essere
modificata, cosa che invece può avvenire ad ogni iterazione !
3) nota l' assegnazione diversa a risultato inizialmente: risultato è true,
ovvero per default si immagina
che vengano inseriti solo caratteri maiuscoli. Se anche solo un carattere
non è maiscolo
(istruzione if (!maiuscole(c)) ) risultato è false !
Se hai altri dubbi facci sapere !
Tommaso.


Puoi aiutarmi a risolvere quest'applicazione.
L'ho scritto anche in un altro post.
Verificare se una stringa contiene Due o + cifre consecutive al suo interno.
Es.
auto12mobile : TRUE
1nave53: FALSE

 1nave53: FALSE
veramente anche la seconda dovrebbe essere true... cmq:
in pseudocodice, qualcosa falla pure tu ;)
String stringa = leggi la stringa
boolean lettoUnNumero = false;
for(ogni carattere della stringa) {
  if(carattere corrente è una cifra) {
    if(lettoUnNumero)
      return true;
    else
      lettoUnNumero = true
  }
  else 
    lettoUnNumero = false
}
return false



Si ma i due numeri devono essere CONSECUTIVI (quello è il problema)

 Si ma i due numeri devono essere CONSECUTIVI (quello è il problema)
Il problema è che non hai capito l'algoritmo, ora vai a cena e a stomaco
pieno ripensaci ;)



Io c'ho provato.
import fiji.io.*;
class Stringhe {
public static boolean numero (String s) {
s=Lettore.in.leggiLinea();
boolean lettoUnNumero = false;
for(int i=0;i<s.length();i++) {
  if(s.charAt(i)>='0' && s.charAt(i)<='9')
    lettoUnNumero=true;
  return lettoUnNumero;}
  if (lettoUnNumero)
  System.out.println("La stringa contiene un numero");
}
public static void main (String[] args) {
 String s;
 s=Lettore.in.leggiLinea();
 }
}
Mi da' questo errore
3: missing return statement
public static boolean numero (String s) {

  s=Lettore.in.leggiLinea();
e non lo chiami il tuo metodo numero()? E leggi la stringa due volte, una
dentro e una fuori dal metodo? 
Credo che ti serva un libro di programmazione di base e dovresti stare un
po' più attento... non sono critiche, sono consigli ;)


Caro Marco 1,
1 ) innanzitutto usi una libreria non standard; questo vuol dire che una
qualsiasi persona
non puň copiare/incollare il tuo codice e lavorarci su per trarne una
soluzione.
Quindi ti consiglio di usare solo librerie standard.
PROBLEMA: Verificare se una stringa contiene Due o + cifre consecutive al
suo interno.
auto12mobile : TRUE
1nave53: FALSE
2 ) Scusa ma 1nave53 contiene 2 cifre consecutive al suo interno : '53' !
Quindi l' esempio č sbagliato.
3 ) commentiamo il tuo codice:
ti dice che non c' č uno statement di ritorno; infatti guardando
public static boolean numero (String s) {
s=Lettore.in.leggiLinea();
boolean lettoUnNumero = false;
for(int i=0;i<s.length();i++) {
  if(s.charAt(i)>='0' && s.charAt(i)<='9')
    lettoUnNumero=true;
  return lettoUnNumero;}
  if (lettoUnNumero)
  System.out.println("La stringa contiene un numero");
}
non c' č un return di un valore booleano. Metti return true, almeno ti
compila !
4 ) Supponiamo che Lettore.in.leggiLinea() funzioni.
Dunque:
public static boolean thereAreTwoNumbers ()
{
String s = Lettore.in.leggiLinea();
for (int i = 0; i < s.length()-1; i++)
{
        if (s.charAt(i) >= '0' && s.charAt(i) <= '9' && s.charAt(i+1) >= '0'
&& s.charAt(i+1) <= '9')
        return true;
}
}
public static void main (String[] args)
{
        if (thereAreTwoNumber) System.out.println("Nella stringa sono
presenti almeno 2 numeri consecutivi");
        else System.out.println("Nella stringa non sono presenti 2 numeri
consecutivi");
}
5 ) Prova il codice sopra, che non č testato dato che le tue librerie non
sono standard, e poi dicci se
ti funziona.
Cmq non avere fretta di imparare, nel tuo codice c' erano molti errori piů
che di sintassi proprio
di comprensione. Buona fortuna !
Tommaso.

Caro Marco 1,
ho appena testato profondamente il metodo che testa se in una stringa
passata come
argomento ci sono 2 numeri consecutivi.
Il main richiamerà il metodo passandogli la stringa letta da qualsiasi input
tu voglia.
public static boolean ThereAreTwoConsecutiveDigits(String aString)
{
for (int i = 0; i < aString.length()-1; i++)
{
char currentChar = aString.charAt(i);
char nextChar = aString.charAt(i+1);
if (currentChar>='0' && currentChar <='9' && nextChar>='0' && nextChar
<='9')
return true;
}
return false;
}
Attendo commenti / osservazioni!
Tommaso.

 Tommaso.
io farei una cosa di questo tipo:
 
public static boolean ThereAreTwoConsecutiveDigits(String aString) {
 	boolean check = false;
 	for (int i = 0; i < aString.length()-1; i++)
		{
 			String temp = aString.substring(i,i+1);
			try{
				int num = Integer.parseInt(temp);
				String temp2 = aString.substring(i+1,i+2);
				try{
					int num2 = Integer.parseInt(temp2);
					check = true;
				}catch(Exception e){}
			}catch(Exception e){}	
 		}
 	return check;
 }