•)Metodo public static boolean almenoDue(int [] array1, int []array2) che restituisce true se

entrambi gli array hanno un n. pari di elementi ed ogni elemento del 1°array array1 compare
almeno 2 volte nel 2°array array2.
Public static boolean almenoDue(int [] array1, int []array2)
{
if(array1.lenght %2!=0 || array2.lenght %2=0) return false;
{
for(int i=0; i<array1.lenght; i++)
{
int cont=0;
for(int j=0; j<array2.lenght;j++)
{
if(array1[i] = array2[j]) cont ++;
}
if(cont>2) return false;
}
return true;
}}

•)Un array di interi si dice sommaPariDispariUguale se la somma dei numeri in posizione pari è
uguale alla somma dei numeri in posizione dispari. Esempio l’array [20,1,1,20] lo è, mentre
[20,1,2,20] non lo è. Implementare metodo public static boolean sommaPariDispariUguale (int[]
myArray) che restituisce true se myArray è sommaPari… e false altrimenti
public static boolean sommaPariDispariUguale (int[] myArray)
{
int sommaPari =0;
for(int i=0; i<myArray.lenght; i++)
{
if( i%2=0) sommaPari = sommaPari+myArray[i];
}
int sommaDispari=0);
for(int i=0; i<myArray.lenght; i++)
{
if( i%2=0) sommaDispari = sommaDispari+myArray[i];
}
if(sommaPari ==sommaDispari) return true;
}
return false;
}

•)Un array di interi si dice triplo se ciascuno dei suoi elementi appare tre volte. Implementare un
metodo public static boolean triplo (int[] myArray) che restituisce true se l’array è triplo e false
altrimenti.
public static boolean triplo (int[] myArray)
{
for(int i=0; i<myArray.lenght;i++)
{
int cont=0;
for(int j=0; j<myArray.lenght;j++)
{
if(myArray[j] = myArray[i]) cont++;
}
if(cont !=3) return false;
}
return true;
}

•)Metodo statico public static boolean treStringheUguali(String s) che restituisce true se la stringa
s è data dalla concatenazione di 3 stringhe uguali e false altrimenti. Ad esempio la stringa
apeapeape da true, apiapo false.
public static boolean treStringheUguali(String s)
{
if(s.lenght()%3!=0) return false;
}
for(int i=0; i<s.lenght()/3; i++)
{
if(s.chartAt(i)!=s.chartAt(i+s.lenght()/3) || s.chartAt(i)!=s.chartAt(i+(s.lenght()/3*2) return false;
}
return true;
}

•)Un array di lunghezza n si dice bilanciato se esiste un indice i tale che la somma dei primi i
elementi dell’array sia uguale alla somma dei rimanenti n-i elementi. Sviluppare un metodo public
static boolean bilanciato (int[] unArray) che da true se bilanciato o false altrimenti.
public static boolean bilanciato (int[] unArray)
{
int sx=0;
int dx=0;
for(int i =0; i<unArray.lenght; i++)
{
sx=sx+unArray[i];
dx=0;
for(int j=0; j<unArray.lenght;i++)
{
dx=dx+unArray[i];
}
if(sx==dx) return true;
}
return false;
}

•)Un array di interi si dice pari se ciascuno dei suoi elementi compari un n pari di volte. Sviluppare
un metodo public static boolean isPari (int[] myArray) che restituisce true se myArray è pari o
false atrimenti.
public static boolean isPari (int[] myArray)
{
if(myArray.lenght%2!=0 || myArray.lenght==0) return false;
for (int i=0; i<myArray.lenght; i++)
{
int cont =0;
for (int j=0; j<myArray.lenght; j++)
{
if(myArray[i] ==myArray[j]) cont ++;
if(cont%2!=0 e j==myArray.lenght –1) return false;
}}
return true;
}

•)Implementare un metodo public static boolean noDuplicate (String s) che restituisce true se la
String s non contiene alcun carattere ripetuto, false altrimenti. App=appare
public static boolean noDuplicate (String s)
{
if(s.lenght()==0) return false;
for(int i=0; i<s.lenght(); i++)
{
int app=0;
for(int j=0; j<s.lenght(); j++)
{
if(s.chartAt(i)==s.charAt(j)) app++;
if(app>i) return false;
}}
return true;
}

•)Due array di interi si dicono bilanciati se hanno la stessa lunghezza e la somma dei primi
elementi è uguale alla somma dei secondi elementi, che è uguale alla somma dei terzi elementi.
Sviluppare metodo public static boolean bilanciato (int []a1, int[]a2) che restituisce true se a1 e a2
sono bilanciati.
public static boolean bilanciato (int []a1, int[]a2)
{
if(a1.lenght!=a2.lenght) return false;
for(int i=0; i<a1.lenght(); i++)
{
if( a1[0] +a2[0] != a1[i]+a2[i]) return false;
}
return true;
}

•)Un tandem è un array di n interi di lunghezza pari, composto dalla concatenazione di 2 array
uguali. Sviluppare metodo public static boolean isTandem( int[]a) che restituisce true solo se lo è.
public static boolean isTandem( int[]a)
{
if(a.lenght2%!=0) return false;
for(int i=0; i<a.lenght/2; i++)
{
if(a[i]!=a[i+a.lenght/2]) return false;
}}
return true;
}

•)Metodo static boolean disgiunte (String s1, String s2) che restituisce true se e solo se la stringa
s1 non contiene alcun carattere della stringa s2, restituisce false altrimenti.
public static boolean disgiunte(String s1, String s2)
{
if(s1.lenght()==0 && s2.lenght()==0) return false;
for(int i=0; i<s1.lenght; i++)
{
for(int j=0; j<s2.lenght; j++)
{
if(s1.substring(i, i+1).equals(s2.substring(j, j+1)) return false;
}}
return true;
}

•)Metodo public static double[] media(double[]x) restituisce un array di double della stessa
dimensione dell’array in ingresso x (array di uscita deve essere creato mediante new). Per ciascun
valore di i, il metodo deve inserire nella cella i dell’array in uscita la media aritmetica dei primi i
elementi dell’array in ingresso x
public static double [] media(double[]x)
{
double[] risultato= new double[x.lenght];
for(int i=0; i<risultato.lenght; i++)
{
double somma = 0;
for(int j=0; j<i; j++)
{
somma=somma+x[j];
}
double media = somma/(i+1);
risultato[i]= media;
}
return risultato;
}}

•)Implementare metodo public statici int[] sommaQuadrati (int[] myArray) che restituisce un
nuovo array della stessa lunghezza di myArray dove il valore in posizione i-esima è dato dalla
somma dei quadrati dei numeri interi presenti in myArray dalla posizione 0 alla pos i-esima.
Esempio [2,3,5] restituisce [4,13,38].
public statici int[] sommaQuadrati (int[] myArray)
{
int []risultato = new int[myArray.lenght];
for(int i=0; i<myArray.lenght; i++)
{
int somma=0;
for(int j=0; j<myArray.lenght; j++)
{
somma = somma+(myArray[j]*myArray[*]);
}
risultato [i]= somma;
}
return risultato;
}

•)Metodo public static int[] filter(int[] unArray) che restituisce un array formato da tutti e solo i
numeri dispari presenti in un array, mantenendo il loro ordine relativo
public static int[] filter(int[] unArray)
{
int index=0;
int[]filtrato= new int [lunghezza(unArray)];
for(int i=0; i<unArray.lenght; i++)
{
if(unArray[i]%2!=0)
{
filtrato [index] = unArray[i];
index++;
}}
return filtrato
}

•)Date due stringhe, la stringa shuffle si ottiene alternando i caratteri della prima con quelli della
seconda e copiando i rimanenti se due stringhe sono di diversa lugnhezza. Esempio “dna” e “on”
danno “donna”.
Public static String shuffle( String s1, String s2)
{
String r=””;
if(s1.lenght()>=s2.lenght())
{
for (int i=0; i<s2.lenght(); i++)
r=r+s1.substring(i, i+1) + s2.substring(i, i+1);
r=r+s1.substring(s2.lenght());
}
else
{
for (int j=0; j<s1.lenght(); j++)
r=r+s1.substring(j, j+1) + s2.substring(j, j+1);
r=r+s2.substring(s1.lenght());
}
return r;
}
•)Sviluppare un metodo statici int[] mix( int[]a1, int[]a2) che accetta in ingresso due array di
uguale lunghezza e restituisce un array formato dal primo elemento di a1, seguito dal primo
elemento di a2, seguito dal secondo elemento di a1 ecc…Se i 2 array in ingresso non hanno
medesima lunghezza, il metodo restituisce null.
Public static int[]mix (int[]a1, int[]a2)
{
if(a1.lenght!=a2.lenght) return null;
int[]a3= new int[a1.lenght*2];
for (int i=0; i<a1.lenght; i++)
{
a3[i*2]=a1[i];
a3[(i*2)+1]=a2[i];
}
return a3;
}