Domanda Qualche buon' anima che mi aiuti a preparare un esame in Java

[Condom99]

Ciao a tutti frequento la facoltà di informatica sono al primo anno e ho bisogno di aiuto per preparare un maledettissimo esame di Programmazioni I in Java... di per se molto semplice anche perchè non è programmazione a oggetti ancora(che è argomento di Programmazione II),
L' esame è strutturato in questo modo:
-un esercizio dove bisogna creare un metodo iterativo;
-un esercizio dove bisogna creare un metodo ricorsivo(che può essere covariante, controvariante o dicotomico);
-due esercizi carta e penna in cui in uno va fatta una dimostrazione per induzione su una parte di codice e l' altro bisogna fare un disegno dello stato della memoria di un pezzo di codice che viene dato.
Chiedo aiuto per i primo due esercizi gli ultimi due(quelli carta e penna) li sto preparando da solo.
Per chi fosse interessato mi contatti in privato cosi che gli passo anche un esercizio iterativo e uno ricorsivo di una prova d' esame...mi va bene che mi aiuti a tempo suo non pretendo nulla e anzi ringrazio infinitamente chi mi darà una mano.
PS conosco la sintassi del linguaggio e tutto è nel creare l' algoritmo, di per se banale per chi sa programmare, che mi perdo("programmo" da pochi mesi).
PS2 L' esame è il 10 di giugno spero di farcela!
Ringrazio anticipatamente la community e soprattuto chi mi aiuterà!

 

[fisica-all]

Guarda, ti consiglio di non chiedere aiuto in privato, ma per un semplice motivo: piu' soluzioni diverse possono aiutarti nella crescita della programmazione

Qualora accettassi questo consiglio posta qui la prima traccia e il tuo ragionamento, cosi' saremo tutti disposti ad aiutarti

 

[Condom99]

Ok allora vi lascio una prova d' esame e le due relative classi di testing (una volta scritto il metodo basterà compilare la classe dove sta il metodo, quella di test e avviare quella di test se ti da tutti true in output vuol dire che va bene).
Quello iterativo l' ho già fatto(e comunque non so perchè mi da 1/2 false....) ma in quello ricorsivo non saprei come muovermi...lascio a voi.
PS ignorate gli esercizi 3 e 4.
PS2 ho dovuto rinominare i file di codice .java in .txt seno non me li faceva allegare qui su inforge....rinominateli .java

 

[Closure]

Non è un forum di sviluppo su commissione. Dai una tua prima soluzione, postala qui e dopo ti aiuteremo volentieri.

 

[Utente cancellato 236678]

Una roba veloce scritta in python...Penso voglia un qualcosa del genere:

"""
     /* ESERCIZIO 2 (Massimo 7 punti -- da consegnare elettronicamente).
      * Scrivere un metodo ricorsivo di nome ex2 con le seguenti caratteristiche:
      * --) ex2 ha due parametri formali. Il primo e' un riferimento (puntatore, reference)
      *     ad un array di interi di nome a; il secondo e' un intero k.
      * --) ex2 restituisce true se k occorre in tutte le posizioni pari di a.
      *     Altrimenti il risultato e' false.
      * --) ex2 richiama un metodo ricorsivo di nome occorreInPosPari, che visita l'array adicotomicamente,
      *     ovvero suddivide a, ad ogni chiamata, in due parti di lunghezza essenzialmente identica.
     * La classe Febbraio0TestEx2 può essere usata per il testing di ex2 e, quindi, contiene esempi sul funzionamento
     * atteso per ex2.
     * DOVE SCRIVERE ex2: immediatamente al di sotto di questo commento.
      */
"""


def occorreinPosPari(array, testno, match=0):
    """
    Questo metodo splitta l'array in 2 parti, dove l'indice e` pari lo inserisco in pari
    e dove e` dispari faccio lo stesso, poi unisco il tutto in un dizionario
    """
    pari = [x for idx,x in enumerate(array) if idx % 2 == 0]
    dispari = [x for idx,x in enumerate(array) if idx % 2 != 0]
    mycollection = dict(zip(pari,dispari))
    for (pari, dispari) in mycollection.items():
        if pari == testno:
            match += 1
        if match == len(mycollection):
            return True
    return False


def Ex2(a, k):
    if len(a) % 2 != 0:
        a.append(0) # Adding 0 to get always a symmetric array for the split
        print(occorreinPosPari(a, k))
    else:
        print(occorreinPosPari(a, k))


Ex2([3,123,3,456,3,789,3,1011,3,1213], 3)

Alternativa:

def occorreinPosPari(array, testno, match=0):
    pari = [x for idx,x in enumerate(array) if idx % 2 == 0]
    mycollection = dict(zip(pari, [x for idx,x in enumerate(pari) if idx <= len(pari)]))
    for pari in (*mycollection, ):
        if pari == testno:
            match += 1
        if match == len(mycollection):
            return True
    return False

Anche se ti consiglio di esercitarti per conto tuo, questo esercizio non e` complesso, anzi...Potresti farlo anche piu` intelligente, essendo che un dizionario o hashmap per il java non puo` avere key duplicate cio` significa che se zippi pari in una sola key e questa matcha k hai praticamente stabilito che l'array ha nelle index pari lo stesso numero.

 

[Condom99]

Non è un forum di sviluppo su commissione. Dai una tua prima soluzione, postala qui e dopo ti aiuteremo volentieri.

Assolutamente non sto commissionando nulla a nessuno, ho chiesto solo che se qualcuno avesse avuto voglia di aiutarmi mi avrebbe fatto piacere...d' altronde se avessi aperto il file avresti visto che dove sapevo fare ho fatto....ma vabbè non voglio fare ne flame ne altro quindi sorvolo sul tuo messaggio, ti ringrazio di aver perso tempo a rispondere a questo topic e ti auguro una buona serata.

Una roba veloce scritta in python...Penso voglia un qualcosa del genere:

"""
     /* ESERCIZIO 2 (Massimo 7 punti -- da consegnare elettronicamente).
      * Scrivere un metodo ricorsivo di nome ex2 con le seguenti caratteristiche:
      * --) ex2 ha due parametri formali. Il primo e' un riferimento (puntatore, reference)
      *     ad un array di interi di nome a; il secondo e' un intero k.
      * --) ex2 restituisce true se k occorre in tutte le posizioni pari di a.
      *     Altrimenti il risultato e' false.
      * --) ex2 richiama un metodo ricorsivo di nome occorreInPosPari, che visita l'array adicotomicamente,
      *     ovvero suddivide a, ad ogni chiamata, in due parti di lunghezza essenzialmente identica.
     * La classe Febbraio0TestEx2 può essere usata per il testing di ex2 e, quindi, contiene esempi sul funzionamento
     * atteso per ex2.
     * DOVE SCRIVERE ex2: immediatamente al di sotto di questo commento.
      */
"""


def occorreinPosPari(array, testno, match=0):
    """
    Questo metodo splitta l'array in 2 parti, dove l'indice e` pari lo inserisco in pari
    e dove e` dispari faccio lo stesso, poi unisco il tutto in un dizionario
    """
    pari = [x for idx,x in enumerate(array) if idx % 2 == 0]
    dispari = [x for idx,x in enumerate(array) if idx % 2 != 0]
    mycollection = dict(zip(pari,dispari))
    for (pari, dispari) in mycollection.items():
        if pari == testno:
            match += 1
        if match == len(mycollection):
            return True
    return False


def Ex2(a, k):
    if len(a) % 2 != 0:
        a.append(0) # Adding 0 to get always a symmetric array for the split
        print(occorreinPosPari(a, k))
    else:
        print(occorreinPosPari(a, k))


Ex2([3,123,3,456,3,789,3,1011,3,1213], 3)

Alternativa:

def occorreinPosPari(array, testno, match=0):
    pari = [x for idx,x in enumerate(array) if idx % 2 == 0]
    mycollection = dict(zip(pari, [x for idx,x in enumerate(pari) if idx <= len(pari)]))
    for pari in (*mycollection, ):
        if pari == testno:
            match += 1
        if match == len(mycollection):
            return True
    return False

Anche se ti consiglio di esercitarti per conto tuo, questo esercizio non e` complesso, anzi...Potresti farlo anche piu` intelligente, essendo che un dizionario o hashmap per il java non puo` avere key duplicate cio` significa che se zippi pari in una sola key e questa matcha k hai praticamente stabilito che l'array ha nelle index pari lo stesso numero.

Anche se il codice in Python mi è di difficile comprensione cercherò di studiare e capire per bene l' algoritmo che hai usato, ti ringrazio infinitamente per aver dato una risposta sensata nonchè veramente utile ai fini del mio post al contrario di qualcun' altro. Di nuovo grazie.

 

[St3ve]

Anche se ti consiglio di esercitarti per conto tuo, questo esercizio non e` complesso...

Al di la del fatto che hai usato delle strutture in modo... poco appropriato, non stai effettuando la suddivisione dicotomica e non stai usando la ricorsione. Una soluzione che soddisfa i requisiti dell'esercizio potrebbe essere questa:

public static boolean ex2(int[] a, int k) {
    assert a != null;
    return occorreInPosPari(a, k, 0, a.length);  
}
                                                                                                       
public static boolean occorreInPosPari(int[] a, int k, int from, int to) {
    int length = to - from;
    if (length <= 0) return true;  // the range is empty, so `k' appears in each (that is, none) index
    if (length <= 2) return a[from] == k;
                                                                                                       
    int half = (length / 2) + (length / 2) % 2;  // first even number >= length / 2
    return occorreInPosPari(a, k, from, from + half) && occorreInPosPari(a, k, from + half, to);
}

d' altronde se avessi aperto il file avresti visto che dove sapevo fare ho fatto

Magari posta il codice direttamente sul forum usando il tag CODE (nell'editor dei messaggi, clicka sui ...), almeno uno può dare un'occhiata veloce senza sbattersi a scaricare file. Meglio ancora se posti pochi (anche solo 1) esercizi per volta e provi ad accennarci alcuni ragionamenti che hai fatto per provare a risolverlo.

 

[Utente cancellato 236678]

Al di la del fatto che hai usato delle strutture in modo... poco appropriato, non stai effettuando la suddivisione dicotomica e non stai usando la ricorsione. Una soluzione che soddisfa i requisiti dell'esercizio potrebbe essere questa:

public static boolean ex2(int[] a, int k) {
    assert a != null;
    return occorreInPosPari(a, k, 0, a.length); 
}
                                                                                                      
public static boolean occorreInPosPari(int[] a, int k, int from, int to) {
    int length = to - from;
    if (length <= 0) return true;  // the range is empty, so `k' appears in each (that is, none) index
    if (length <= 2) return a[from] == k;
                                                                                                      
    int half = (length / 2) + (length / 2) % 2;  // first even number >= length / 2
    return occorreInPosPari(a, k, from, from + half) && occorreInPosPari(a, k, from + half, to);
}

Magari posta il codice direttamente sul forum usando il tag CODE (nell'editor dei messaggi, clicka sui ...), almeno uno può dare un'occhiata veloce senza sbattersi a scaricare file. Meglio ancora se posti pochi (anche solo 1) esercizi per volta e provi ad accennarci alcuni ragionamenti che hai fatto per provare a risolverlo.

Grazie per la correzione