Questa è stata una sfida divertente su cui lavorare, accendere e spegnere tra le celebrazioni natalizie. Grazie per la pubblicazione! Giocare a golf è stato interessante perché le specifiche sono piene di eccezioni e casi speciali, che hanno richiesto molte condizioni. Inoltre, mentre non ho bisogno di convertire da e verso decimali questa volta, ho avuto bisogno di una funzione “max” di sorta per determinare il maggior numero di cifre in ogni numero e il valore più grande delle cifre in ogni luogo.
La prima versione di questo era 4844 byte, solo per darti un'idea di quanto ho giocato a golf.
Il programma prevede l'input come un elenco di numeri interi separati da virgola . Nessuno spazio o newline. L'uso di questi produrrà un comportamento indefinito.
' '' '' ''' "" ' ''' "" ' ''' "" ' '' ' ' '' '' '''' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" "" "" ' ''' "" ' ''' "" ' ''' "" ' '' " ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" '"" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' ''' "" "" "" '" "" "" "" " ' '' ' ' '''' ' ' '''' ' ' '''' '' '' ' ' '''' '''" " ' '''" "' "" ' ''' "" ' ''' "" ' '' ' ' '' '' ' ' '' '' '''' '''' '' '' '' "' '' ''"" "' '' ' ' '' '' '''' '' '' ''" ' '' ' ' '''' "' '' '' ''"' '' '' '' '' ' '' ' ' '' '' ' ' '''' '' '' ' ' '''' ' ' '''' '''' '' '' '' '' " ' '' ''' "" "" "" ' ''' "" ' '' "' '' '' '' ' ' '''' ' ' '''' ' ' '''' "' ''"'""" "" "" "" ' '' '' ''' "" "" "" ' ''' "" " ' '''" "" "" "" ' ''' "" " ' '' ' '' '' ' ' '' '' '''' ' ' '''' ''' "" "" "" "" ' '' '' '' ' ' '''' "' ''" ' '' '' ''' "" ' ''' "" ' '' ' ' '' '' '' '''' '' '' ''' "" ' ''' "" '""" ' '' '' ''' "" "" "" ' '' ' ' '' '' '' '''' '' '' ''' "" "' ''"' '' '' "" ' '' ' ' '' '' '' '''' ''' "" "" "" ' ''' "" ' '' "' '' '' "' '' '' ''" ' '' '' '' ' ' '' ' ' '' '' '''' '''' '' '' '' "' '' '' '' "' ''"' ''"" " ' '' '' '''" "" ' ''' "" "" "" "' '' ' ' '' '''' '' '' ' ' ''''"' '' ' '' ' ' '' '' '' '''' ''' "" "" " ' '' '' '' '''" "" "" "' '' '' ''"' '' " ' '''" "" "" "" ' '' '' '' "' '' "' '' '' '' ''" ' '' '' '' ''"' ''"" "" "' '' '' ''"' '' ' ' '' ' ' '' '' '' '' ' ' '''' '' '' '''' '''' '' ' '' '' '' ''' "" " ' '' '''" "" " ' '' '' '''" "' '' ' ' '''' ' ' ''''"' "" ' ''' "" ' ''' "" "' '' ''" ' '' '' '' ' ' '' '' '''' "' '' ' ' ''''"" "" "" ' ''' "" " ' '' '''" "" " ' '' '' ' ' '' '' '''' ' ' '''' ' ' '''' " ' '''" " ' '' ' ' '' '' '''' ' ' '''' ' ' '''' '''" "" "" "" ' '' '' ''' "" ' '' ' ' '''' '' '' ''' "" ' '' "' '' "' '' ''" ' '' '' ''"' '' '' "" ' '''" "" ' '' '' '' ''' "" "" "" " ' '''" "" ' '' '' '' '' "' '' '' ''" "' '' '' '' ' ' '' '' '''' ' ' '''' ' ' '''' ' ' ''''" ' '' "' '' '' '' '' ' '' '' '' ' ' '''' ' ' '''' ' ' '''' ' ' '''' ''' "" "" "" "" " ' '' ''"" "" ' '' '' '' ''' "" "" "" "' '' '' ''" ' '' "' '' '' '' ''"' '' '' '' " ' '''" " ' '''" "" ' '' '' ''' "" ' ''' "" ' ''' "" "'" ' '' '' '' '' "' "" ' '' '' '' ' ' '' '' '' ' ' '''' '''' '' '' '' ''' "" ' ''' "" """"" ' '' '' '' ' ' '''' ''' "" "" ' '' '' ''' "" "" "" " ' '''" "" ' '' ''" "" "" ' '' '' '' '' ' ' '''' '' '' ''' "" "' ''" ' '' '' '' '' ' ' '''' "' "" "" "" "' '' '' ''" ' '' "' '' "' '' '' '' '' ' ' '''' ' ' '''' ''""" " ' '' '' '' ' ' '''' '''" "" ' '' '' '' ''' "" " ' '''" "" "" "" ' ''" "" "" ' ''' "" " ' '' '' '' '''" "" "" "" "' ''" ' '' '' '' "' '' '' '' '' ' '' "' '' '' '' '' "' '' '' ''" ' '' '' ''"' '' "' '' '' '' ''" ' ''' '' '' '' "' '' "' '' '' '' ' ' '''' ' ' '''' ' ' ''''" ' '' ' ' ''''"' " "" "" "" ' ''' "" ' ''' "" ' ''' "" " ' '' '' '' ' ' '' '' '' '''' '''" "" "" "" ' ''' "" ' ''' "" ' ''' "" " ' '' '''" "" "" "" "" ' '' '' '' ''"' ''' "" "" " ' '' '' '' ' ' '' '' '''' ' ' '''' '''" "" "" "" " ' '' '' '' " ' '''" " ' '' ' ' '' '' '''' '' '' '''" " ' '' ' ' '' '' '' '''' '' '' '' ' '' '' '' ' ' '''' ''' "" "' '' '' '' ''"' '' '' '' ' ' '''' ' ' ''''" ' '''" "" "" "" ' ''' "" ' '' "' '' ' ' '' '' '' '' ' ' '''' '' '' ''''" " ' '' ' ' '' '' '' '''' '''" "" "" " ' '' '' '' ' ' '''' '''" "" "" "" "' "" "" "" " ' '' '' '' ' ' '''' '''" "" ' '' '' "' '' '' ''" ' '' '' ''' ''' "" ' '' ' ' '''' '' '' ''' "" ' ''' "" "' '' ' ' '' '''' ''"' '' '' " ' '' '' '''" "" "" "" ' ''' "" " ' '' '' '' '''" "" "" "" ' '' '' '' "'" "' '' ' ' '' '' '''' '' '' ' ' '''' ' ' '' ' ' '' '' '' '''' '' '' ''''" ' '''" "" ' '' "' '' '' ' ' '' '' '' ' ' '' '' '''' ' ' '''' '''' "' ''" "" "" ' ''' "" ' '' ' ' '' '' '''' '' '' ''' "" ' '' ' ' '''' '' '' ''' "" "" "" " ' '''" "" ' '' '' '' '' ' ' '''' '' '' ''' "" " ' '' '' '''" """" "" " ' '' '' '' '''" "" "" "" " ' '' '' '' '''" "" "" "" ' ''' "" ' ''" ' '' "' '' "' ''" ' '' '' '' ''"' '' '' "' '' '' '' ' ' '' '' ''''" ' '' " ' ''' "" "" "" " ' '''" "" ' '' '' '' ' ' '''' ' ' '''' "' '' "' ''"'""" "" "" "" ' '' '' '' ' ' '''' ' ' '''' ''' " ' '' '' '' ' ' '' '' '' '''' "" ' '' "' '' '' '' '' ' ' '' '' '' '''' '' '' '' ' ' '' '' '' '''' '' ''" "' '' '' ''"' '' " ' '' '' '' '' ' ' '' '' '' ' ' '''' ' ' '''' '''''"" ' ''' "" ' ''' "" ' ''' "" ' ''' "" ' '' " ' '' ' ' '' '' '''' '' '' ''' "" " ' '' '' '' '''" "" "" " ' '''" " ' '''" "" ' '' '' "' '' '' '' "' ''" "" " ' '''" " ' '' ' ' '' '' '' '''' '' '' '''" " ' '''" "" ' '' '' '''"" "" "" " ' '' ' ' '' '' '' '''' '' '' '''" "" "" "" ' '' "' ''"
Spiegazione
Ti guiderò attraverso il funzionamento del programma, mostrandoti come elabora l'input specifico 202,100,1.
All'inizio costruiamo alcuni valori di cui avremo bisogno in seguito, principalmente i codici ASCII dei caratteri che verranno emessi.
Come puoi vedere, '8'e '.'sono già disponibili. '|', tuttavia, è davvero 124, non 14. Usiamo un ciclo while per aggiungere il doppio del valore temporaneo nello slot # 1 su di esso per ottenere 124 (che è 14 + 55 × 2, perché il ciclo while funziona per 56-1 = 55 iterazioni). Ciò consente di risparmiare alcuni byte perché letterali interi di grandi dimensioni come 124 sono molto lunghi. Nel diagramma seguente, mostro la posizione di ogni variabile utilizzata dal programma.
Successivamente, vogliamo inserire tutti i caratteri e memorizzarli sul nastro a partire dalla cella # 12 ( p è il puntatore in esecuzione per questo). Allo stesso tempo, vogliamo sapere quanto è lungo il numero più lungo (quante cifre). Per raggiungere questo obiettivo, manteniamo un totale parziale in unario andando a sinistra a partire dalla cella # −1 (usiamo q come puntatore corrente). Dopo il primo numero di input ( 202), il nastro ora appare così:
Avrai notato che i numeri sono disattivati di 4. Bene, quando li inseriamo per la prima volta, sono i loro valori ASCII, quindi sono "off" di 48 e la virgola è 44. Per ogni carattere, copiamo il 46 da '.'in r e quindi sottralo con un ciclo while (che sottrae 45) e quindi aggiungiamo 1. Lo facciamo in modo che la virgola (il nostro separatore) sia 0, quindi possiamo usare un condizionale per riconoscerlo.
Inoltre, avrai notato che lasciamo la cella n. 11 a 0. Abbiamo bisogno che riconosca il limite del primo numero.
Il prossimo carattere sarà una virgola, quindi memorizziamo uno 0 in # 15, ma ovviamente questa volta non avanziamo q . Invece, riportiamo q su 0 e iniziamo a "sovrascrivere" gli 1 che abbiamo già inserito.
Dopo che tutti i caratteri rimanenti sono stati elaborati, otteniamo questo:
Come puoi vedere, gli 1 scritti da q ora indicano (in unario) la lunghezza del numero più lungo.
Ora usiamo un ciclo while per spostare q all'estrema sinistra, quindi posizioniamo un altro puntatore lì che chiamerò r2 . Lo scopo di r2 diventerà chiaro in seguito.
A questo punto, vorrei chiarire la terminologia che userò in tutto questo.
- Per numero , intendo uno dei numeri di input separati da virgole. Nel nostro esempio, sono 202, 100 e 1.
- Per cifra , intendo una singola cifra in uno specifico dei numeri. Il primo numero ha 3 cifre.
- Per luogo , intendo il posto di uno, il posto di decine, il posto di centinaia, ecc. Quindi, se dico "le cifre nel posto corrente", e il posto corrente è il posto di quelle, quelle cifre sono 2, 0 e 1 in quella ordine.
Ora torniamo alla nostra programmazione regolare. L'intero resto del programma è un grande loop che sposta q in avanti fino a raggiungere la cella # 0. Ciascuna delle celle lungo la strada rappresenta un luogo, con quelle posizionate all'estrema destra e q inizierà nel punto più significativo. Nel nostro esempio, questo è il posto delle centinaia.
Procediamo incrementando i punti q della cella in (ovvero, * q ).
Siamo ora allo "stadio 2" per le centinaia di posti. In questa fase, scopriremo qual è la cifra più grande tra tutte le cifre nelle centinaia. Usiamo lo stesso trucco di conteggio unario per questo, tranne che questa volta il puntatore si chiama r e il puntatore r2 segna la sua posizione iniziale alla quale dobbiamo reimpostarlo ogni volta che passiamo al numero successivo.
Cominciamo con il primo numero. Iniziamo impostando p su 11 (la posizione iniziale codificata di tutti i numeri). Quindi usiamo un ciclo while per trovare la fine del numero e impostiamo p2 lì per contrassegnare la posizione. Allo stesso tempo, impostiamo anche q2 su 0:
Non lasciarti distrarre dal fatto che q2 punta nei var. Non abbiamo un riempimento di una cella vuota perché possiamo rilevare la cella # 0 semplicemente perché è il numero zero.
Quindi, passiamo attraverso il numero corrente diminuendo p e q2 insieme fino a quando * p è zero. In ogni luogo, il valore di * q2 ci dice cosa dobbiamo fare. 1 significa "non fare nulla", quindi continuiamo. Alla fine incontriamo il 2 nella cella # −3. Ogni volta che * q2 non è uguale a 1, q2 è sempre uguale a q .
Come ho già affermato, la fase 2 è "determinare la cifra più grande in questo luogo". Quindi impostiamo r su r2 , usiamo un ciclo while per diminuire * p e spostiamo r verso sinistra e riempiamo il nastro con 1s, quindi usiamo un altro ciclo while per spostare r indietro a destra e incrementare nuovamente * p per ripristinare il valore. Ricorda che ogni ciclo while viene eseguito per una iterazione in meno rispetto al valore su cui lo utilizziamo; per questo motivo, il numero di 1 scritti sarà 3 in più (anziché 4 in più) rispetto al valore della cifra e il valore finale memorizzato in * p sarà 2 in più. Pertanto, questo ha effettivamente diminuito * p di 2.
Dopodiché, impostiamo p sul valore di p2 e poi lo facciamo di nuovo. Per la seconda volta, impostare q2 su 0, trovare la fine del numero spostando p verso destra, quindi scorrere le cifre di questo numero diminuendo p e q2 insieme. Ancora una volta incontreremo il 2 nella cella # −3 e scriveremo che molti 1 restano di * r .
Nel caso del terzo numero, finiamo per non fare nulla perché non ha un posto di centinaia (quindi q2 non raggiunge mai q ), ma va bene perché ciò non influisce sul calcolo del valore massimo della cifra.
Abbiamo anche impostato la cella * (r - 4) , che ho contrassegnato con una freccia senza etichetta qui, su 1 (anche se è già su 1). Non ti dirò ancora perché, ma forse hai già indovinato?
Il successivo incremento di * q ci porta alla fase 3, che è "sottrarre la cifra massima da tutte le cifre nella posizione corrente". Come prima, ripristiniamo p su 11 e q2 su 0 e quindi esaminiamo tutti i numeri proprio come abbiamo fatto nella fase precedente; tranne che questa volta, * q = 3 invece di 2. Ogni volta che q2 incontra q e p è in un posto di centinaia, usiamo un ciclo while per diminuire * p tante volte quante sono 1 s nel blocco a sinistra di * r2 (5 nel nostro esempio) usando rcome puntatore in esecuzione. In realtà la diminuiamo ancora una volta, in modo che la cifra più grande finisca a -2, per una ragione che diventerà più chiara in seguito:
Dopo aver elaborato tutti i numeri, siamo ora alla fine della fase 3. Qui eseguiamo due cose singolari.
- Innanzitutto, sottraggiamo anche la dimensione del blocco r (più 1) da * q , ma usando il puntatore r2 , che lo lascia a sinistra. * q diventa negativo in questo modo. Nel nostro caso, il blocco r ha cinque 1, quindi * q diventa −3.
- In secondo luogo, impostiamo una variabile su un valore diverso da zero per indicare che stiamo entrando nello stadio di output. (Tecnicamente, il fatto che * q sia negativo indica già lo stadio di uscita, ma questo è troppo difficile da verificare, quindi la variabile extra.)
Ora capisci che continuiamo a scorrere i numeri, a trovare il posto corrente (indicato dal valore non 1 di * q ) all'interno di ciascun numero e fare qualcosa in base al valore di * q . Vediamo che * q viene prima incrementato a 2 (= calcola il valore massimo della cifra), quindi 3 (sottrai il valore massimo della cifra da ogni cifra in questo posto) e quindi sottraggiamo da esso per renderlo negativo. Da lì, continuerà a salire fino a raggiungere 1, ripristinando così il valore che significa "non fare nulla". A quel punto, passiamo al posto successivo.
Ora, quando * q è negativo, stiamo producendo. * q ha esattamente il valore corretto in modo che emettiamo il numero corretto di righe di caratteri prima che raggiunga 1; se la cifra più grande è 2, dobbiamo generare 3 righe. Vediamo cosa succede ad ogni valore di * q :
- * q = −2:
- Per il primo numero, * p è −2, che indica che dobbiamo generare un
'.'(punto) o un ':'(due punti). Decidiamo quale guardando q : se è −1, siamo nel posto giusto, quindi ':'produciamo a (che calcoliamo come '8'+2), altrimenti a '.'.
- Per il secondo numero, * p è −3. Tutto ciò che non è −2 significa che viene emesso un
'|'(pipe) e quindi incrementato il valore. In questo modo raggiungerà -2 nel posto giusto e quindi emetteremo '.'s / ':'s per il resto di quella cifra.
- In ogni caso, impostiamo anche una variabile pd su 0 prima di elaborare il numero e impostiamo pd (= "stampato") su un valore diverso da zero per indicare che abbiamo stampato un carattere.
- Per il terzo numero, non si verifica alcuna elaborazione poiché il terzo numero non ha un posto di centinaia. In questo caso, pd sarà ancora 0 dopo aver elaborato il numero, indicando che dobbiamo ancora produrre a
'|'(ma solo se out è diverso da zero, perché altrimenti siamo ancora nella fase 2 o 3).
- Dopo aver elaborato tutti i numeri, se out è diverso da zero, genera una nuova riga. Si noti che abbiamo bisogno della variabile out in modo da non generare la nuova riga nella fase 2 o 3.
- * q = −1: uguale a prima, tranne per il fatto che * p è −2 per entrambi i primi due numeri, quindi entrambi producono a
'.'(e il terzo a a'|'come prima).
- * q = 0: quando * q è 0, questo significa "non fare nulla se ci troviamo in quel posto, altrimenti emettere una riga di
'|'s indipendentemente da * p ". In questo modo otteniamo il riempimento tra le cifre.
Ora incrementiamo q per passare al posto successivo, il posto delle decine e aumentiamo * q lì. All'inizio della fase 2, il nastro è simile al seguente:
Quindi eseguiamo la fase 2 proprio come prima. Ricorda che questo sottrae effettivamente 2 da ogni cifra in questo posto e lascia anche un numero unario a sinistra di * r2 che indica la cifra massima. Lasciamo solo il precedente numero unario e continuiamo a estendere il nastro a sinistra; costerebbe solo il codice aggiuntivo non necessario per "ripulire". Quando abbiamo finito e incrementiamo * q , all'inizio della Fase 3 il nastro ora è:
In realtà, questa è una bugia. Ricordi in precedenza dove ho detto che abbiamo impostato * (r - 4) su 1 e non ti ho detto perché? Ora ti dirò perché. È per casi come questo, in cui la cifra più grande è in realtà 0, il che significa che tutte le cifre in questo posto sono 0. Impostando * (r - 4) , indicato dalla freccia senza etichetta sopra, a 1 si estende il numero unario di 1, ma solo in questo caso speciale. In questo modo facciamo finta che la cifra più grande fosse 1, il che significa che genereremo una riga aggiuntiva.
Dopo la fase 3 (sottrarre la cifra massima da tutte le cifre nella posizione corrente), incluso il passaggio aggiuntivo che rende negativo * q , il nastro appare così. L'ultima volta la cifra più grande è stata rappresentata da −2 nel blocco * p , ma questa volta sono tutte −3 perché in realtà sono tutte azzerate ma stiamo fingendo che la cifra massima fosse 1.
Ora vediamo cosa succede mentre * q avanza verso 1:
- Quando * q = −1, i valori * p sono tutti −3, il che significa che emettiamo
'|'s e li incrementiamo.
- Quando * q = 0, produciamo
'|'perché è quello che facciamo sempre quando * q = 0, indipendentemente da * p .
Quindi, otteniamo due file di tubi.
Infine, spostiamo * q al posto di uno. Questo diventa interessante perché dobbiamo emettere ':'s se la cifra effettiva è tutt'altro che 1, ma '8'se è 1. Vediamo come procede il programma. Innanzitutto, incrementiamo * q per avviare la fase 2:
Dopo la fase 2 ("calcola il valore massimo della cifra"), ci resta questo:
Dopo la fase 3 ("sottrarre il valore massimo della cifra da tutte le cifre nella posizione corrente") il nastro appare così:
Ora esaminiamo a turno ciascuna iterazione di * q :
- * q = −2:
- Primo numero: già a -2, quindi emetti a
':'(anziché a '.'perché q = −1).
- Secondo numero: a −4, quindi emettere a
'|'e incremento.
- Terzo numero: a -3, quindi output a
'|'. Tuttavia, questa volta, anziché incrementare, viene attivato un caso speciale. Solo se stiamo producendo l'ultimo posto ( q = −1), e siamo nella penultima riga per quello ( * q = −2), e la cifra è in realtà un 1 ( * p = −3) , quindi invece di incrementarlo su −2, lo impostiamo su −1. In altre parole, usiamo −1 come valore speciale per indicare che nella prossima iterazione, avremo bisogno di produrre '8'invece di ':'.
- * q = −1:
- Primo numero: già a -2, quindi output a
':'.
- Secondo numero: a -3, quindi output a
'|'. La condizione speciale non si attiva perché * q non è più −2. Pertanto, incrementare.
- Terzo numero: a -1, quindi output
'8'.
- * q = 0: di solito, in questo caso viene visualizzata la riga di riempimento di
'|'s, ma nel caso speciale in cui ci troviamo in quel punto ( q = −1), la ignoriamo.
Successivamente, q viene incrementato a 0 e il ciclo while grande termina.
Ora sai come funziona un input come 202,100,1. Tuttavia, c'è un altro caso speciale che non abbiamo ancora trattato. Potresti ricordare che mentre stavamo elaborando l'ultimo posto, quando * p era −3 lo impostiamo su −1 per 1(invece di incrementarlo a −2) in modo che la successiva iterazione produca '8'invece un . Questo funziona solo perché abbiamo un'iterazione in cui * p è −3 e prendiamo una decisione se incrementarlo o impostarlo su −1. Noi non abbiamo tale iterazione se tutte le cifre nel luogo quelli sono 0 o 1. In tal caso tutti i * p valori dei 1s sarebbe iniziare a -2; non vi è alcuna possibilità di decidere di impostarlo su -1piuttosto che incrementarlo da −3 . Per questo motivo, c'è un'altra condizione di involucro speciale all'interno della Fase 3 ("sottrarre la cifra massima da ogni cifra nella posizione corrente"). Ho affermato che dopo aver sottratto il valore massimo della cifra da ogni cifra (a quel punto la cifra massima è −1), la diminuiamo ancora una volta, ma in realtà c'è una condizione su ciò che segue:
Se la cifra che stiamo guardando è uguale alla cifra massima in questo posto ( * p = −1), e questo posto è quello in cui si trova ( q = −1) e la cifra massima è 1 ( * (r + 5) = 0, cioè il blocco unario all'estrema sinistra è lungo solo 5 celle), solo allora lasciamo * p a −1 per indicare che l'unica iterazione dell'uscita deve generare un '8'. In tutti gli altri casi lo diminuiamo ancora una volta.
Fatto. Felice anno nuovo!
Modifica 1 (3183 → 3001): un po 'di golf Happy New Year! Sono riuscito a sbarazzarmi del tutto delle variabili p2 e r2 ! p ora corre avanti e indietro per continuare a trovare l'inizio e la fine dei numeri, ma sembra essere più breve nel codice. Ho provato anche a sbarazzarmi di q2 , ma non ho potuto accorciare il codice in quel modo.
Ho anche trovato alcuni altri posti in cui avrei potuto applicare i tipici trucchi del golf illeggibili come riutilizzare l'ultimo valore di un ciclo while. Per darti un esempio, invece di
while *(++p) { 1 } // just increment p until *p is 0; the 1 is a noop
if (pd) { x } else { y } // where pd is a variable
Posso salvare il '""""(fai il primo, poi il secondo) e il '"""(costante 1) scrivendolo in un modo che è un po 'come
if (while *(++p) { pd }) { x } else { y }
Ovviamente, questo funziona solo se so che il ciclo while verrà eseguito per almeno un'iterazione, ma se lo fa, il suo valore di ritorno è pd, quindi posso usarlo come condizione per l'if.
