Metodo java esercizio aiuto

[seccia1]

qualcuno sarebbe capace di fare questo metodo in java ?

Esercizio 4. Scrivere un metodo statico iterativo che, dati un array bidimensionale a di
stringhe ed un intero k, restituisce un array bidimensionale b di booleani tale che b[j] vale
true se la lunghezza della stringa a[j] `e maggiore o uguale a k, altrimenti b[j] vale false.
Esempio: se a = {{"ababa","bc","efg",""},{"h","kffh"},{"gtr","alfa","wq","y"}}
e k = 3, il metodo restituisce b = {{true,false,true,false},{false,true},{true,true,
false,false}}.
Esercizio 5. Scrivere una versione ricorsiva del metodo definito per risolvere l’Es.4.

Esercizio 6. Scrivere un metodo statico iterativo che, dati due array monodimensionali a e b
di stringhe, restituisce un array bidimensionale c di stringhe tale che ogni riga c contiene le
stringhe ottenute concatenando i caratteri di a (letti da sinistra a destra) con la stringa b.
Esempio: se a = {"ab","bcd","e","fhgs"} e b = {"rp","k","uxy","st"}, il metodo restituisce
c = {{"arp","brp"},{"bk","ck","dk"},{"euxy"},{"fst","hst","gst","sst"}}.
Nota: si assuma che le lunghezze di a e b siano uguali.
Esercizio 7. Scrivere una versione ricorsiva del metodo definito per risolvere l’Es.6.

grazie è urgenteeeeee

[apatriarca]

Non hai proprio nessuna idea?

[seccia1]

si ho scritto un metodo e volevo confrontarlo per sapere se è corretto

[seccia1]

mi sai aiutare?

[seccia1]

potrebbe andare per l'esercizio 6?

public static String [][] problema1(String [][]a){
    String[][] b = new String[a.length][];
    int i = 0;

    for( i = 0; i < a.length; i++){
        String s = "";
        b[i] = new String[a[i].length-1];

        for(int j = 0; j < a[i].length; j++){
            if (j+1 < a[i].length){
                s = a[i][j] + a[i][j+1];
                b[i][j] = new String(s);
            }
        }
    }

    return b;
}

[apatriarca]

Un primo problema che noto nel tuo codice è che il problema richiede che gli argomenti siano due e non uno solo. Per cui dovrebbe essere qualcosa tipo il seguente:

public static String [][] esercizio6(String []a, String[] b){
    // ...
}

[apatriarca]

Per quanto riguarda la versione iterativa dell'esercizio 4, devi semplicemente creare un array bidimensionale di booleani e inizializzarli attraverso la relazione:

b[i][j] = a[i][j].length() >= k;

Per cui il codice corrispondente dovrebbe essere come il seguente:

public static boolean[][] esercizio4(Stringa[][] a, int k) {
    boolean b[][] = new boolean[a.length][];
    for (int i = 0; i < a.length; ++i) {
        b = new boolean[a[i].length];
        for (int j = 0; j < a[i].length; ++j) {
            b[i][j] = a[i][j].length() >= k;
        }
    }
}

Non ho provato a compilare e testare il codice ma dovrebbe essere corretto. Questa è l'idea generale del codice. Per quanto riguarda l'esercizio 5, diverse soluzioni sono possibili. In un'altra discussione recente ho consigliato di fare la ricorsione dividendo ogni dimensione a metà, ma in questo caso, per via del funzionamento diverso degli array in java, è meglio fare prima la ricorsione sulle righe e poi sulle colonne. Ma prima di passare a questo, hai qualche dubbio sulla versione iterativa? È come immaginavi?

[seccia1]

io invece l'ho fato cosi:]

public static boolean [][] esercizio4 (String[][]a,intk){
boolean [][]b=new boolean[a.length][];
for (int i=0;i<a.length;i++){
      for (int j=0;j<a[i].length;j++){
       if (a[i][j].length()>=k)
       b[i][j]=true;
        else
       b[i][j]=false;
}
}
return b;
}

puo andare secondo te ?

[apatriarca]

Manca l'allocazione delle singole righe. Se supponiamo che si tratti di una matrice quadrata puoi però direttamente usare la dimensione della prima riga di a. Per quanto riguarda l'altra differenza, è corretto usare l'if, ma è secondo me ridondante e meno leggibile. Per la ricorsione invece come pensi di fare?

[seccia1]

mi potresti spiegare cosa intendi per mancanza dell'allocazione delle singole righe?

[apatriarca]

In java, al contrario di altri linguaggi, gli array bidimensionali (e in generale multidimensionali) sono array di array. Ogni riga è insomma un array a parte e le righe non sono quindi necessariamente memorizzate contigue in memoria (o nell'ordine dato dall'indice). Questo ha diverse conseguenze nelle performance e nelle funzionalità di tali array. Esistono principalmente due modi per creare un array bidimensionali (nota che cambia solo il metodo in cui viene creato/allocato e non come appare in memoria):
1. Indicare sia il numero di righe che di colonne nell'array alla sua creazione. In questo modo le righe vengono automaticamente create tutte della stessa lunghezza:

int[][] array = new int[4][4];

2. Indicare solo il numero di righe e poi creare separatamente ogni riga. In questo modo è possibile creare righe di lunghezza diversa:

int[][] array = new int[4][]; //< nota che la seconda dimensione non è segnata
array[0] = new int[1]; //< creo prima riga di lunghezza 1
array[1] = new int[2]; //< creo prima riga di lunghezza 2
array[2] = new int[3]; //< creo prima riga di lunghezza 3
array[3] = new int[4]; //< creo prima riga di lunghezza 4

[seccia1]

grazie del chiarimento adesso ho capito perfettamente