Fondamenti di Informatica - Esercizi

RICORSIVA

} **/

public static int[] f(int[] a,int[] b){ //nel primo return metti subito i valori inizializzati

return f(a,b,0,0,new int[a.length]);

}

public static int[] f(int[]a,int[]b,int i,int j, int[]c){ //nella f di appoggio metti invece i dichiarati

if(i<a.length){

c[i]=a[i];

if(a[i]==0 && j<b.length){ //parti con la funzione come nell it ma il for diventa

un if c[i]=b[j];

j++;

if(j==b.length){

j=0;

}

}

return f(a,b,i+1,j,c); //alla fine ricordati prima di chiudere l'if di fare return f con i

valori del giro dopo

} //chiuso l'if metti il return c che è quello che ti chiede la

funzione

return c;

} public static boolean test(){

return arrayEquals(f(new int[]{1,1,0,1,1,0,0,1,0,0,1,1},new int[]{10,20,30}),new int[]

{1,1,10,1,1,20,30,1,10,20,1,1}) &&

arrayEquals(f(new int[]{1,1,1,1,1},new int[]{10,20,30}),new int[]{1,1,1,1,1}) &&

arrayEquals(f(new int[]{1,0,1,1,1,1},new int[]{10,20,30}),new int[]{1,10,1,1,1,1}) &&

arrayEquals(f(new int[]{0,0,0,1,1,1},new int[]{10,20,30}),new int[]{10,20,30,1,1,1}) &&

arrayEquals(f(new int[]{0,0,0,0,0,0,0},new int[]{10,20,30}),new int[]

{10,20,30,10,20,30,10}) &&

arrayEquals(f(new int[]{1,0,0,0,1,0,1,1,1},new int[]{10}),new int[]

{1,10,10,10,1,10,1,1,1}) &&

arrayEquals(f(new int[]{0,0,0},new int[]{10,20}),new int[]{10,20,10}) &&

arrayEquals(f(new int[]{0,0,0},new int[]{10,20,30,40,50}),new int[]{10,20,30});

}

public static void main(String[] s){

System.out.println(""+test());

}

static String arrayToString(int[] a){

String s="";

for (int i=0;i<a.length;i++) {

s+=a[i]+";";

}

return s;

}

static boolean arrayEquals(int[] a,int[] b){

if (a.length!=b.length) return false;

for (int i=0;i<a.length;i++){

if (a[i]!=b[i]) {

return false;

}

}

return true;

}

}

#include <stdio.h>

#include <stdlib.h>

/* Realizzare la funziona f che dato in ingresso una array 'a' di

puntatori a interi, e la sua lunghezza n(>0), ritorna un nuovo array (allocato con la malloc)

uguale ad 'a' tranne per il fatto che non deve eliminare il suo primo elemento (e quindi

deve avere dimensione n-1).

Come riferimento si consideri che l'esecuzione del test deve

fornire risultato positivo.

*/

int **f(int *a[],int n){

int i=1;

int**b=(int**)malloc((n-1)*sizeof(int*));

for(;i<n;i++){

b[i-1]=a[i];

}

return b;

} int test(){

int a[]={10,20,30,40,50,60};

int *pa[]={&a[0],&a[1],&a[2],&a[3],&a[4],&a[5]};

int **b=f(pa,6);

// si noti che *b[0] sarebbe il contenuto della cella puntata da b[0];

return *b[0]==20 && *b[1]==30 && *b[2]==40 && *b[3]==50 && *b[4]==60;

}

main(){

printf("%s\n",test()?"true":"false");

}

class Esame57{

/*

Realizzare la funzione f qui sotto riportata, che dato un array di interi e un numero 'n'

maggiore di zero, verifichi che l'array contenga una sottosequenza contigua fatta da 'n' zeri.

Si presti attenzione a realizzare una funzione che non comporti inutili penalizzazioni in

performance.

Come riferimento si consideri che l'esecuzione del test

(eseguita dal metodo main) deve riportare il risultato true.

*/ public static boolean f(int[] a,int n){

int i=0;

int j=0;

for(;i<a.length;i++){

if(a[i]==0){

j=i;

for(i=i+1; i<a.length && a[i]==0;i++);

if(i-j==n){

return true;

}

}

} return false;

}

public static boolean test(){

return f(new int[]{1,2,1,0,2,1,2,2},1)&&

f(new int[]{1,0,2,1,0,2,1,2,2},1) &&

f(new int[]{1,2,1,0,0,2,1,2,2},2) &&

f(new int[]{1,2,1,0,0,0,2,1,2,2},3) &&

f(new int[]{1,2,1,0,0,0,2,1,2,0,0,2},3) &&

f(new int[]{1,2,1,0,0,0,2,1,2,0,0,2},2) &&

f(new int[]{1,0,0,2,1,0,0,0,2,1,2,2},2) &&

f(new int[]{1,0,0,2,1,0,0,0,2,1,2,2},3) &&

f(new int[]{1,0,0,2,1,0,0,0,2,1,2,0},1)&&

f(new int[]{0,0,0,0},4) &&

f(new int[]{0,0,0,0,1},4) &&

f(new int[]{1,0,0,0,0},4)&&

!f(new int[]{1,2,1,0,0,0,2,1,2,0,0,2},1)&&

!f(new int[]{1,2,1,0,0,0,2,1,2,0,0,2},4) &&

!f(new int[]{1,0,2,1,0,2,1,2,2},2) &&

!f(new int[]{1,0,2,1,0,2,1,2,2},3)&&

!f(new int[]{0,0,0,0},1) &&

!f(new int[]{0,0,0,0},2) &&

!f(new int[]{0,0,0,0},3) &&

!f(new int[]{0,0,0,0,1},1) &&

!f(new int[]{0,0,0,0,1},2) &&

!f(new int[]{0,0,0,0,1},3);

}

public static void main(String[] s){

System.out.println(""+test());

}

static String arrayToString(int[] a){

String s="";

for (int i=0;i<a.length;i++) {

s+=a[i]+";";

}

return s;

}

static boolean arrayEquals(int[] a,int[] b){

if (a.length!=b.length) return false;

for (int i=0;i<a.length;i++){

if (a[i]!=b[i]) {

return false;

}

}

return true;

}

}

#include <stdio.h>

#include <stdlib.h>

#define TRUE 1

#define FALSE 0

/* Realizzare la funzione sotto riportata che prende in ingresso un intero 'size'produce in uscita

una matrice 'size x size' di interi, del tipo (caso size=4):

0 1 2 3

-1 0 1 2

-2 -1 0 1

-3 -2 -1 0

Come riferimento si consideri che l'esecuzione del test deve fornire risultato positivo.

*/

int **f(int size){ //ricordati che per le matrici devi prima allocare spazio per

il puntatore a puntatore e poi per il puntatore a intero

int **m=(int**)malloc(size*sizeof(int*));

int i=0; //in questo modo , dopo il primo for che scorre le righe,

allochi spazio per gli interi da inserire nelle colonne

// j scorre le colonne, in questo caso la formula di inserimento

è j-i for(;i<size;i++){

m[i]=(int*)malloc(size*sizeof(int));

int j;

for(j=0;j<size;j++){

m[i][j]=j-i;

}

}

return m;

}

int test(){

int **a3=f(3);

int o3[3][3]={{0,1,2},{-1,0,1},{-2,-1,0}};

int **a4=f(4);

int o4[4][4]={{0,1,2,3},{-1,0,1,2},{-2,-1,0,1},{-3,-2,-1,0}};

return

array_equals(a3[0],o3[0],3) &&

array_equals(a3[1],o3[1],3) &&

array_equals(a3[2],o3[2],3) &&

array_equals(a4[0],o4[0],4) &&

array_equals(a4[1],o4[1],4) &&

array_equals(a4[2],o4[2],4) &&

array_equals(a4[3],o4[3],4);

}

main(){

printf("%s\n",test()?"true":"false");

}

int array_equals(int a[],int b[],int size){

for (;size--;)

if (a[size]!=b[size])

return FALSE;

return TRUE;

}

class Esame59{

/*

Realizzare la funzione f qui sotto riportata, che dato un array di interi "a", lo modifica

e ritorna in uscita (quindi NON se ne crei uno nuovo) in modo che l'inizio dell'array sia rimpiazzato

da quello che c'è dopo l'ultimo zero (si assuma che "a" abbia almeno uno zero).

Per ritrovare l'ultimo zero si consiglia di eseguire un ciclo a partire dall'ultimo

elemento dell'elenco.

Come riferimento si consideri che l'esecuzione del test

(eseguita dal metodo main) deve riportare il risultato true.

*/ public static int[] f(int[] a){

int i=a.length-1;

int n=0;

for(;a[i]!=0;i--);

if(a[i]==0){

for(;n<a.length-i-1;n++){

a[n]=a[i+1+n];

}

}

return a;

}

public static boolean test(){

return arrayEquals(f(new int[]{10,20,30,0,40,50,0,60,70}),new int[]

{60,70,30,0,40,50,0,60,70}) &&

arrayEquals(f(new int[]{10,20,30,0,40,50,0,60}),new int[]{60,20,30,0,40,50,0,60}) &&

arrayEquals(f(new int[]{10,20,30,0,0,60,70,80,90}),new int[]

{60,70,80,90,0,60,70,80,90}) &&

arrayEquals(f(new int[]{10,20,0,0,0,60,70,80,90}),new int[]

{60,70,80,90,0,60,70,80,90}) &&

arrayEquals(f(new int[]{10,20,0,21,0,22,0,60,70,80,90}),new int[]

{60,70,80,90,0,22,0,60,70,80,90}) &&

arrayEquals(f(new int[]{10,0,60,70}),new int[]{60,70,60,70}) &&

arrayEquals(f(new int[]{10,20,30,40,0,50}),new int[]{50,20,30,40,0,50}) &&

arrayEquals(f(new int[]{10,20,30,40,50,0}),new int[]{10,20,30,40,50,0}) &&

arrayEquals(f(new int[]{0,0}),new int[]{0,0});

}

public static void main(String[] s){

System.out.println(""+test());

}

static String arrayToString(int[] a){

String s="";

for (int i=0;i<a.length;i++) {

s+=a[i]+";";

}

return s;

}

static boolean arrayEquals(int[] a,int[] b){

if (a.length!=b.length) return false;

for (int i=0;i<a.length;i++){

if (a[i]!=b[i]) {

return false;

}

}

return true;

}

}

class Esame60{

/*

Realizzare la funzione f qui sotto riportata, che dato un intero "n" e un array

di interi "a", ne crea uno nuovo (e lo ritorna in uscita) ottenuto da "a"

aggiungendo in testa e in coda la sequenza dei sui primi "n" elementi.

Si ipotizzi che "n" non sia piu' grande della lunghezza degli elementi di "a".

Come riferimento si consideri che l'esecuzione del test

(eseguita dal metodo main) deve riportare il risultato true.

*/ public static int[] f(int[] a,int n){

int i=0;

int j=0;

int[]b=new int[a.length+2*n];

for(;j<a.length;j++){

b[j+n]=a[j];

for(;i<n;i++){

b[i]=a[i];

b[a.length+n+i]=a[i];

}

}

System.out.println(arrayToString(b));

return b;

}

public static boolean test(){

return arrayEquals(f(new int[]{10,20,30,40},2),new int[]{10,20,10,20,30,40,10,20}) &&

arrayEquals(f(new int[]{10,20,30,40},1),new int[]{10,10,20,30,40,10})&&

arrayEquals(f(new int[]{10,20,30,40},0),new int[]{10,20,30,40}) &&

arrayEquals(f(new int[]{10,20,30,40},4),new int[]

{10,20,30,40,10,20,30,40,10,20,30,40}) &&

arrayEquals(f(new int[]{10,20,30},2),new int[]{10,20,10,20,30,10,20});

}

public static void main(String[] s){

System.out.println(""+test());

}

static String arrayToString(int[] a){

String s="";

for (int i=0;i<a.length;i++) {

s+=a[i]+";";

}

return s;

}

static boolean arrayEquals(int[] a,int[] b){

if (a.length!=b.length) return false;

for (int i=0;i<a.length;i++){

if (a[i]!=b[i]) {

return false;

}

}

return true;

}

}

class Esame61{

/*

Risolvere l'esercizio precedente ma in modalità ricorsiva.

Come riferimento si consideri che l'esecuzione del test

(eseguita dal metodo main) deve riportare il risultato true.

*/ public static int[] f(int[] a,int n){

return f(a,n,new int[a.length+2*n],0,0);

}

public static int[]f(int[]a,i