Problemino in Java con array strighe..mi date una mano?

[Bruno4000]

Date 2 matrici 3x3,inseriti i 9 nomi,devo fare un controllo su ogni nome,se la somma delle lettere del nome è un numero primo,nell'altra matrice corrispondente mettiamo una x,altrimenti il nome stesso.
Quindi alla fine inseriti i 9 nomi,mi devono uscire 9 output,formati da X o dal nome stesso.
Ho capito come fare ma non riesco a trasformarlo in codice,quindi mi potreste scrivere direttamente il codice..grazie 1000:):help:

Ho fatto vari tentativi,ma per ora con sicurezza ho fatto questo:

import java.util.Scanner;
class esercizio
{
public static void main (String args[])
{
int matrice1[][] = new int [3][3];
int matrice2[][] = new int [3][3];


Scanner in= new Scanner (System.in);
int riga;
int colonna;




//riempimento matrice
for (riga=0; riga<3; riga++)
{
for(colonna=0;colonna<3;colonna++)
{
System.out.print("Inserisci elemento"+" ");
matrice1[riga][colonna]=in.nextInt();

So che dopo aver inserito i 9 nomi,devo come prima cosa contare le lettere del nome e poi fare un controllo per
vedere le la somma delle lettere è un numero primo :grat::)

 

[AttHack]

import java.util.Scanner;
public class Esercizio {

public static void main (String args[]) {

String matrice1[][] = new String [3][3];
String matrice2[][] = new String [3][3];


Scanner in = new Scanner (System.in);
for (int i=0; i<matrice1.length; i++) { // length 'restituisce' la lunghezza della riga (in questo caso 3)
for (int j=0; j<matrice1[0].length; j++) { // matrice[0].length restituisce la lunghezza delle colonne (in questo caso 3)
matrice1[j] = in.nextLine();
if (nPrimo(matrice1[j].length())==true) matrice2[j]="X";
else matrice2[j] = matrice1[j];
}
}
for (int i=0; i<matrice2.length; i++) {
System.out.println();
for (int j=0; j<matrice2[0].length; j++)
System.out.print(matrice2[j]+"\t");
}

}
public static boolean nPrimo(int x) {
if (x<=3) return true;
if (x==4) return false;
int m = x/2;
int cont=0;
for (int i=2; i<m; i++)
if (x%i==0) cont++;

if (cont<1) return true;
else return false;

}

}


Ecco qui la sorgente. Vedi che te ne pare, se servono spiegazioni basta chiedere. :party:

 

[BAT]

solo 2 osservazioni alla soluzione proposta:
1.
invece di
if (nPrimo(matrice1[j].length())==true)
è sufficiente
if (nPrimo(matrice1[j].length())
non c'è bisogno di verificare ulteriormente ==true perché nPrimo(...) già di suo vale true oppure false (provare per credere)

l'istruzione
if (x<=3) return true;
è sbagliata, deve essere sostituita da
if (x<=4) return (x==2 || x==3);
il motivo è che i numeri negativi, il numero 0 ed il numero 1 NON sono numeri primi (-3 non è primo, che ci piaccia o no);
per definizione, un numero primo P è un intero >1 i cui unici divisori propri (cioè senza resto) sono 1 e P
(la definizione esclude il il numero 1 in quanto dice P>1)

l'istruzione
if(x==4) return false
deve essere sostituita da
if(x%2==0) return false
perché tutti i numeri pari NON sono primi eccetto il numero 2 che è già individuato correttamente come numero primo dall'if precedente; in questo modo eviti di eseguire il for sui numeri pari.

2.
il ciclo di controllo della funzione nPrimo fa troppi calcoli, non è necessario controllare tutti i divisori a partire dalla metà del numero in input,
è sufficiente controllare solo eventuali divisori dispari (il 2 è primo ma viene individuato subito senza entrare nel for)
fino alla radice quadrata del numero in input; mi spiego con un esempio: il numero 113 è primo, ma per rilevarlo è sufficiente controllare solo i divisori dispari fino a radice quadrata (intera) di 113 che è 10 perché 10*10=100 ma 11*11=121; basta quindi dividere solo per
3,5,7,9 (solo 4 divisioni) e hai finito. Se invece parti dalla metà (56) prima di concludere che 113 è primo devi fare 55 divisioni (inutile dividere per 1) o al limite 28 divisioni se controlli solo i divisori dispari. Per ottenere il limite userai qualcosa come Math.round.sqrt(N) cioè l'arrotondamento all'intero più vicino della radice quadrata che in generale è un numero in virgola mobile mentre round lo riporta all'intero più vicino.
Il controllo fino alla radice quadrata deriva da una nota proprietà dei numeri interi che dice che
i divisori di un intero si possono disporre a coppie in cui un fattore è minore o uguale alla radice quadrata del numero e l'altro è maggiore (o uguale)

 

[Bruno4000]

import java.util.Scanner;
public class Esercizio {

public static void main (String args[]) {

String matrice1[][] = new String [3][3];
String matrice2[][] = new String [3][3];


Scanner in = new Scanner (System.in);
for (int i=0; i<matrice1.length; i++) { // length 'restituisce' la lunghezza della riga (in questo caso 3)
for (int j=0; j<matrice1[0].length; j++) { // matrice[0].length restituisce la lunghezza delle colonne (in questo caso 3)
matrice1[j] = in.nextLine();
if (nPrimo(matrice1[j].length())==true) matrice2[j]="X";
else matrice2[j] = matrice1[j];
}
}
for (int i=0; i<matrice2.length; i++) {
System.out.println();
for (int j=0; j<matrice2[0].length; j++)
System.out.print(matrice2[j]+"\t");
}

}
public static boolean nPrimo(int x) {
if (x<=3) return true;
if (x==4) return false;
int m = x/2;
int cont=0;
for (int i=2; i<m; i++)
if (x%i==0) cont++;

if (cont<1) return true;
else return false;

}

}


Ecco qui la sorgente. Vedi che te ne pare, se servono spiegazioni basta chiedere. :party:

Tutto chiaro..Graziee 1000!

- - - Updated - - -

solo 2 osservazioni alla soluzione proposta:
1.
invece di
if (nPrimo(matrice1[j].length())==true)
è sufficiente
if (nPrimo(matrice1[j].length())
non c'è bisogno di verificare ulteriormente ==true perché nPrimo(...) già di suo vale true oppure false (provare per credere)

l'istruzione
if (x<=3) return true;
è sbagliata, deve essere sostituita da
if (x<=4) return (x==2 || x==3);
il motivo è che i numeri negativi, il numero 0 ed il numero 1 NON sono numeri primi (-3 non è primo, che ci piaccia o no);
per definizione, un numero primo P è un intero >1 i cui unici divisori propri (cioè senza resto) sono 1 e P
(la definizione esclude il il numero 1 in quanto dice P>1)

l'istruzione
if(x==4) return false
deve essere sostituita da
if(x%2==0) return false
perché tutti i numeri pari NON sono primi eccetto il numero 2 che è già individuato correttamente come numero primo dall'if precedente; in questo modo eviti di eseguire il for sui numeri pari.

2.
il ciclo di controllo della funzione nPrimo fa troppi calcoli, non è necessario controllare tutti i divisori a partire dalla metà del numero in input,
è sufficiente controllare solo eventuali divisori dispari (il 2 è primo ma viene individuato subito senza entrare nel for)
fino alla radice quadrata del numero in input; mi spiego con un esempio: il numero 113 è primo, ma per rilevarlo è sufficiente controllare solo i divisori dispari fino a radice quadrata (intera) di 113 che è 10 perché 10*10=100 ma 11*11=121; basta quindi dividere solo per
3,5,7,9 (solo 4 divisioni) e hai finito. Se invece parti dalla metà (56) prima di concludere che 113 è primo devi fare 55 divisioni (inutile dividere per 1) o al limite 28 divisioni se controlli solo i divisori dispari. Per ottenere il limite userai qualcosa come Math.round.sqrt(N) cioè l'arrotondamento all'intero più vicino della radice quadrata che in generale è un numero in virgola mobile mentre round lo riporta all'intero più vicino.
Il controllo fino alla radice quadrata deriva da una nota proprietà dei numeri interi che dice che
i divisori di un intero si possono disporre a coppie in cui un fattore è minore o uguale alla radice quadrata del numero e l'altro è maggiore (o uguale)

Ti ringrazio della risposta :)

 

[AttHack]

il ciclo di controllo della funzione nPrimo fa troppi calcoli, non è necessario controllare tutti i divisori a partire dalla metà del numero in input,
è sufficiente controllare solo eventuali divisori dispari (il 2 è primo ma viene individuato subito senza entrare nel for)
fino alla radice quadrata del numero in input; mi spiego con un esempio: il numero 113 è primo, ma per rilevarlo è sufficiente controllare solo i divisori dispari fino a radice quadrata (intera) di 113 che è 10 perché 10*10=100 ma 11*11=121; basta quindi dividere solo per
3,5,7,9 (solo 4 divisioni) e hai finito. Se invece parti dalla metà (56) prima di concludere che 113 è primo devi fare 55 divisioni (inutile dividere per 1) o al limite 28 divisioni se controlli solo i divisori dispari. Per ottenere il limite userai qualcosa come Math.round.sqrt(N) cioè l'arrotondamento all'intero più vicino della radice quadrata che in generale è un numero in virgola mobile mentre round lo riporta all'intero più vicino.
Il controllo fino alla radice quadrata deriva da una nota proprietà dei numeri interi che dice che
i divisori di un intero si possono disporre a coppie in cui un fattore è minore o uguale alla radice quadrata del numero e l'altro è maggiore (o uguale)

Ho adottato la soluzione più veloce, ma sicuramente meno efficiente.

Grazie per i consigli sei stato utilissimo :):)