AMICO - ANNULLATO ================= non compila disordine ogni giorno chiama la funzione che deve decidere se stampare o meno do senza while funzione per riempire l'array delle stagioni inutile collaborazione con Ingrosso BARTOCCI - 25 ============= 2 warning poche costanti nel ciclo di scavo c'e' un ciclo che dura sempre 365 giorni pioggia e' vuota BIANCHI - INSUFF ================ non compila (too many errors) && invece di || assegna soltanto i valori di probabilita' alle stagioni i valori assegnati sono sbagliati l'array delle probabilita' e' locale alla funzione che lo assegna nella funzione genera la pioggia ... BORESTA - 22 ============ 16 anni per scavare il tunnel! usa un ciclo per assegnare le probabilita' che pero' poi assegna individualmente nei giorni tra 355 e 360 aumenta di 1 una variabile. perche'? di nuovo usa un blocco di 4 if esclusivi per chiamare sempre la stessa funzione con un parametro il numero di anni cresce di 5 ogni anno... :-O disordine funzione per fare una moltiplicazione nella funzione pioggia ripete tutto l'inutile controllo relativo alla stagione CAZZULANI - INSUFF ================== 8 warning non esce mai dal ciclo di input inutile duplicazione di variabili for per controllare lo scavo = invece di == if invece di else stesso codice ripetuto per le quattro stagioni scava sempre solo una lunghezza intera disordine probabilita' intere estratte come comprese tra 0 e 1 D'ANIELLO - 25+0 = 25 ===================== Abort trap se la taglia dell'array e' 2*N si definisce una costante che vale (2*N) l'abort trap e' provocato dal fatto che gli indici degli array partono da 1 invece che da 0 disordinato non puo' mai fare uno spare non aggiornando la variabile che dovrebbe tenere conto DANJOUX - INSUFF ================ non compila while(nf<1;nf>100000) array che partono da 1 ci sono tre cicli innestati che poi fanno tutti la stessa cosa, che si dovrebbe fare con un ciclo, ma che e' scritta come un'istruzione che fa N cose tutte uguali... ... DANTIS - INSUFF =============== 2 warning il punteggio e' sempre 9 non ci sono le parti finali il main consiste di una sola funzione lancio che restituisce un inutile intero disordinato la probabilita' di abbattimento dei birilli non cambia l'array prob cosi' non serve dice che c'e' un ciclo for, ma io vedo 10 ripetizioni manuali della stessa cosa... aggiorna e' vuota DE CESARIS - 20+0=20 ==================== non finisce mai disordine l'assegnazione delle probabilita' di pioggia e' fatta con N righe di codice di un algoritmo (ne bastano 4) nel ciclo di scavo c'e' un for sulle stagioni con dentro uno sulla durata della stagione c'e' lo stesso codice in due if alternativi stampa quel che succede per i primi 30 giorni, poi piu' niente la funzione pioggia e' lunghissima (bastano 4 righe) contiene codice ripetuto uguale 4 volte DEL BONO - 30 e lode ==================== Ottimo! DEL BORRELLO - INSUFF ===================== durante la partita i birilli si raddrizzano e il punteggio non cambia o addirittura diminuisce inutile array bidimensionale la funzione di lancio scrive il risultato uso l'elemento 10 di un array di 10 componenti if inutile (se il birillo cade si conta quando e' caduto, non si deve ricontrollare successivamente) aggiorna non aggiorna nulla: estrae, ma non usa il risultato DE LEO - INSUFF =============== numeri enormi nell'output (attesi solo 0 o 1) while invece di do nei lanci raddrizza un birillo per volta il lancio non e' un lancio (e' deterministico e non casuale) aggiorna fa cose incomprensibili a ogni lancio DELLE PIANE - 22+0=22 ===================== non rispetta le prescrizioni: fa cose non previste scelta nomi delle costanti inopportuna la probabilita' di caduta dei birilli e' usata senza essere assegnata la scelta di far cadere o meno il birillo non funziona la funzione aggiorna non e' mai chiamata l'aggiornamento delle probabilita' dei birilli, se usato, non funzionerebbe la funzione punteggio fa cose non previste DEL VECCHIO - 27+2=29 ===================== non funziona come dovrebbe gli strike sono segnalati alla fine) per vedere se un intero e' pari basta usare il resto della divisione per due un po' lungo (l'algoritmo e' poco efficiente: molte istruzioni inutilmente ripetute) DE ROSSI - 26+3=29 ================== se fa strike non se ne accorge non usa un ciclo per stampare lo stato dei 10 birilli inutile uso di puntatori punteggio si limita a fare una somma aggiorna non tiene conto degli estremi 1 e 10 DI CESARE - 22 ============== 2 warning non stampa mai il progresso alla fine dice che ci sono voluti 0 giorni ! ripte elo stesso codice per ogni stagione la stampa e' fatta controllando il valore di i con un if a tre alternative boom estrae tra 24 e 49 c = rand() % (1-0+1)+0 ; DI FELICE - 19+0=19 =================== il punteggio e' sempre nullo il primo lancio e' trattato in maniera diversa (ma uguale) dagli altri non fa un lancio, ma 10 lanci ogni mezzo frame assegna un valore a points per cambiarlo subito dopo i birilli cadono sempre con la stessa probabilita' i birilli non si rialzano mai if inutili aggiorna non e' mai invocata non tiene conto delle condizioni al contorno per aggiornare la probabilita' DI GIACOMO - INSUFF =================== non compila disordinatissimo non valutabile DI GIAMPALMA - INSUFF ===================== Abort trap 100 elementi per l'array prob solo il secondo birillo e' in piedi indici array da 1 invece che da 0 fa un lancio per ogni birillo algoritmo contorto e non funzionante l'aggiornamento delle probabilita' non dipende dal birillo a sinistra il secondo lancio dipende da qualcosa che succede nell'aggiornamento i birilli si rialzano durante la partita il lancio non e' random DI PERNA - INSUFF ================= Non compila Le condizioni degli if nel ciclo di input sono mutuamente esclusive, ci va l'else Ciclo su t vuoto Praticamente non c'e' nulla... DI PIETRO - 19+0=19 =================== due warning manca aggiorna solo un birillo in piedi usa l'elemento N di un array di N componenti di fatto lancia piu' volte (e alcuni lanci li ingora) else inutile di fatto abbatte sempre un solo birillo DI SERIO - INSUFF ================= 6 warning non usa costanti non permette di reiterare la richiesta del numero di frame chiama le funzioni senza parametri disordinato reinizializza il seme a ogni lancio = invece che == estrae un solo numero e pretende di abbattere birilli con quel solo numero D'URZO - INSUFF =============== non fa quanto previsto non permette di reiterare la richiesta del numero di frame disordinato fa un lancio per birillo l'aggiornamento contiene l'estrazione di un numero random! il birillo cade sempre se e' in piedi e non cade se e' a terra EL SAYED - INSUFF ================= 3 warning segmentation fault disordine un lancio per birillo non dichiara le funzioni ad aggiorna passa l'elemento N di un array di N elementi estrae i numeri random nel main rimette sempre in piedi i birilli numeri random < 1 senza casting FADALE - INSUFF =============== 3 warning segmentation fault prob di 20000 elementi! nel main fa solo l'input seed nella funzione di lancio genera numeri compresi tra 0 e 75 e tra 0 e 50 doppio loop per stampare i e j senza motivo il lancio cosa fa? = invece di == il punetggio dipende da un input FALLA - INSUFF ============== 4 warning segmentation fault all'inizio le funzioni non hanno parametri usa l'elemento N di un array di N componenti solo un birillo in piedi a ogni frame assegna lo stato di un birillo = invece di == stampa del risultato senza ciclo quando e' ovvio che vada usato dentra lancio sono ridefiniti gli array seed nel lancio FALSINI - INSUFF ================ Abort trap all'inizio non controlla che nframe > 0 prob[l] = lancio() poi birilli[i] = lancio() praticamente vuoto FANCIULLI - 27+2=29 =================== inutili ripetizioni - non usa cicli lungo algoritmo per aggiornare doppio conteggio dei birilli abbattuti FAZZARI = INSUFF ================ non compila non controlla che nframe > 0 disordinato aggiorna stampa il risultato invece di cambiare le probabilita' manca il lancio FIORI - INSUFF ============== fa un solo lancio l'array dei punteggio e' lungo 100, ma puo' fare 10000 frame inizializza i birilli frame volte a lancio passa almento tre variabili inutili (senza valore) non usa un ciclo per stampare il risultato il punteggio e' uguale al numero di frame richiesti inutile uso di puntatori la probabilita' usata per scegliere lo stato del birillo e' sempre la stessa punteggio e' praticamente vuota manca aggiorna FORTI - INSUFF ============== warning lungo output non conforme alle prescrizioni stato dei birilli fatto di numeri a caso non controlla che frame > 0 un lancio per birillo un solo frame quando fa il lancio pero' c'e' un ciclo su n che pero' e' il numero di frame else con inutili condizioni non conta i birilli abbattuti, ma restituisce l'indice del birillo caduto non aggiorna FULLI - INSUFF ============== non compila tutte le funzioni sono dichiarate senza parametri array di taglia variabile non usa costanti mette in birilli in piedi una volta e poi basta .... GABELLINI - 21+0=21 =================== warning array bidimensionali! il punteggio e' sempre nullo praticamente non usa costanti lunghissima sequenza per generare l'abbattimento i non assegnata, ma usata aggiorna sempre le probabilita' dopo il primo lancio ci sono almeno sette condizioni diverse prese in considerazione GALLI - 22+0=22 =============== abbatte sempre e comunque il birillo a destra del corrente lo stato del birillo dipende da quello alla sua sinistra lo stato del birillo puo' essere diverso da 0 o 1 il numero di birilli abbattuti dipende dallo stato dell'ultimo birillo il punteggio e' calcolato male non aggiorna le probabilita' fa un solo lancio per frame GAROFALE - 21+0=21 ================== non compila array bidimensionali se nf < 0 va avanti la probabilita' di caduta e' assegnata male (e' casuale) inutile uso di puntatori il lancio non e' casuale non usa un ciclo per stampare lo stato dei 10 birilli definisce array di una componente se compilasse scriverebbe cose diverse da quelle richieste GIUSTINI - INSUFF ================= 4 warning nell'output compaiono numeri enormi con punteggi giganteschi aggiorna a ogni lancio la probabilita' sara' sempre nulla = invece di == aggiorna lavora sull'array birilli alterandone il contenuto l'aggiornamento e' comunque sbagliato la funzione punteggio si limita a fare una somma GORLA - 26+0=26 =============== disordine non tiene conto delle condizioni dei birilli 1 e 10 in aggiorna proflisso non usa cicli per stampare lo stato dei 10 birilli GRANATA - 18 ============ Se si fa strike il secondo lancio non si fa! considera intere le probabilita' for(i = 0; i > 12; i++) non fa nulla! prob e' un array di 10 elementi, ma usa gli elementi con indice da 1 a 10 aggiorna restituisce un intero che non dipende da i inutile uso di array bidimensionale Birilli[i] = lancio(prob[i-1]); fa 10 lanci, non due, ripetuti due volte un po' disordinato dal momento che le probabilita' sono intere non si capisce perche' generare numeri razionali la funzione punteggio si deve chiamare alla fine della partita, non per stampare il punteggio ottenuto a ogni lancio che e' banale. GREGORI - 30+0=30 ================= Buono. Un po' prolisso...alcune scelte discutibili (while vs for, p.e.) GUARNERA - INSUFF ================= non compila non usa cicli per assegnare i valori iniziali agli array se nframe < 0 va avanti fa un solo lancio uso il risultato fi aggiorna per assegnare l'elemento N di un array di N componenti seme nella funzione di lancio i numeri casuali generati sono sempre nulli codice ripetuto uguale in due blocchi alternativi if aggiorna non tiene conto delle condizioni al contorno alle funzioni non passa array, ma singole componenti IAMPIERI - 29 ============= leggero disordine condizioni per la stampa "costose" boom non e' abbastanza generale (se cambiano le condizioni non funziona piu') IANNARILLI - 29 =============== doppio calcolo per decidere se stampare if ripetuti potendolo evitare IERACI - INSUFF =============== warning ci sono n funzioni che si chiamano una dopo l'altra. ogni funzione ha le sue variabili che pero' usa come fossero di tutte variabili globali la funzione boom e' complicatissima la pioggia si verifica con probabilita' pari al 50% sempre IMPROTA - 25+1=26 ================= usa variabili quando puo' fare tutto usando costanti stesso codice in due alternative if (inutili) for dentro un do per tutti i giorni della stagione min e max scambiati nella generazione dei numeri casuali usa i parametri della funzione per dichiarare le variabili locali INGROSSO - ANNULLATO ==================== collaborazione con Amico (stessi commenti)