-3h -35m -10s

aoc-2017

#82

Leggendo il tuo edit, non è quello il punto (ovvero tra parte 1 e 2 jgz non cambia). Il punto cruciale è:

Many of the instructions can take either a register 
(a single letter) or a number. 
The value of a register is the integer it contains; 
the value of a number is that number.

#83

Si, infatti mi sono accorto che avevo scritto una caxxata. Non avevo il tutto sotto mano e mi sono confuso con un’altra cosa… Quanto a quello che hai scritto non riesco a vedere il codice adesso, ma penso di aver gestito bene la cosa. Quando rientro a casa riguardo meglio il tutto.


#84

Cavolo, avevi ragione!
Come ho rimesso mano al tutto mi sono accorto dell’errore.
Non avevo capito che intendessi che anche il primo dei due parametri potesse essere un numero. :grimacing:
Ti dirò di più, è il primo dubbio che mi era venuto quando ho iniziato a scrivere il codice per la prima parte, ma dato che le istruzioni erano poche gli ho dato un’occhiata veloce per assicurarmi che il primi argomenti dopo l’istruzione fossero lettere e così mi era sembrato, invece ora, appena riaperto l’input l’ho visto! Un 1, un cavolo di 1, probabilmente l’avevo scambiato per una l.
Vabbè, grazie per la dritta! :thumbsup:


#85

Prego prego. Facendo suonare le note per davvero (ogni snd una nota di quella frequenza usando un oscillatore qualsiasi, e avendo cura di far durare le note quel tanto che basta ma non di più, per evitare che scoppi tutto) diventa chiaro cosa fanno questi due programmi in duetto.

Spoiler

Il primo genera dei numeri pseudo casuali da 0 a 9999 usando un Linear Congruential Generator. Poi li passa al secondo, ed entrambi si mettono ad ordinarli palleggiandoseli (quel registro f che alterna 0 e 1 serve a determinare se i numeri sono in ordine oppure no) usando (quello che mi sembra essere) un bubble sort.
Quindi due programmi in uno, visto che è la terza istruzione a determinare il tutto, in base al valore iniziale del registro p (mul p 17 scrive in p 0 nel primo programma e 17 nel secondo), portando la quarta istruzione a fare un jump di 17 solo nel secondo programma, saltando così tutto il codice del LCG e mettendosi in attesa dei numeri mandati dal primo. L’array con questi numeri inizialmente casuali e progressivamente ordinati vive nelle 2 queue. Una mente decisamente raffinata, quella di Eric.


#86

Cosa voleva essere oggi, la quiete prima della tempesta? Uno dei più semplici dell’anno, direi. Goditi queste 2 stelle mattutine. Oggi credo che scriverò una visualizzazione per il JSON della nostra leaderboard, perché a leggerla così non ci si capisce una mazza.


#87

Pensa che io lì per lì ero tentanto di risolvere la prima parte seguendo il filo a mano, giusto per divertirmi…
Fortuna che non l’ho fatto, altrimenti me ne sarei pentito al secondo turno. :joy:


#88

@MacMomo, ho una mezza idea di cosa ti sta creando problemi nella seconda parte (sempre che tu non stia semplicemente facendo altro).


#89

Ho avuto altro da fare, ma una mezz’oretta fa ho lasciato una prova del codice corretto per la parte 2, ma effettivamente sembra non funzionare.
Il mio dubbio al momento era se per collidere dovevano essere identiche tutte e tre le posizioni (x, y, z) o solamente una…
Se hai altro da farmi notare accetto volentieri consigli.


#90

Devono essere identiche tutte e 3 le coordinate.
La soluzione comunque è praticamente istantanea. 1000 ticks dovrebbero essere sufficienti. Con 10000 cadi in piedi.
Diamo per buono il meccanismo che hai usato per identificare quali particelle abbiano effettivamente scontrato tra loro, e pensiamo alla procedura di rimozione.
Se stai usando un array per le particelle, e se stai usando splice per rimuovere quelle che hanno scontrato tra di loro… considera che splice modifica l’array e pertanto…


#91

Boh, a me sembra che vada bene, dagli un po’ un’occhiata tu…

[details=Day20b]```javascript
var times = 0;
while(times < 1000) {
for(var i=0; i<parts.length; i++) {
// faccio gli incrementi
for(var n=0; n<3; n++) {
parts[i][“v”][n] += parts[i][“a”][n];
parts[i][“p”][n] += parts[i][“v”][n];
}

	// verifico la particella corrente con quelle gia' modificate
	var a = i-1;
	while(a>=0) {
		if(parts[i]["p"][0] == parts[a]["p"][0] && parts[i]["p"][1] == parts[a]["p"][1] && parts[i]["p"][2] == parts[a]["p"][2]) {
			parts.splice(i, 1);
			i--;
			break;
		}
		a--;
	}
}
times++;

}
tv(parts.length);


#92

Ho riletto il quesito e ho trovato l’errore… pensavo che solo una delle particelle nella stessa posizione andasse eliminata, cioè che non ne potessero stare più di una sullo stesso posto, invece in caso di collisione le dovevo eliminare tutte.
A volte è l’inglese che mi frega…


#93

Lo sai cosa faccio io? Tranne quando provo a competere con la global leaderboard (cosa che è accaduta una sola volta fino ad oggi), leggo il testo appena mi sveglio. Poi faccio colazione, e quando decido di risolvere il puzzle, rileggo il tutto e mi metto a scrivere la soluzione. In questo modo ho l’occasione di correggere eventuali errori di comprensione. Comunque c’è anche da dire che vivo all’estero da 10 anni, e pertanto la mia comprensione dell’inglese ha raggiunto un buon livello.


#94

Oggi la vedo tosta… :grimacing:


#95

Inizio molto tardi. Mi sembra divertente il quesito.


#96

Sì, per carità, il quesito sarà anche interessante perché richiede (finalmente?) un minimo di ragionamento in più, ma anche diverso codice in più e quindi tanto tempo e concentrazione, possibilmente contigui, per evitare di non capirci niente e dover ricominciare da capo ogni volta… quindi non so se ce la farò.
Qualcosa comunque ho iniziato a scrivere. :wink:


#97

Io ho avuto ospiti fino ad ora. Da una prima lettura penso che approccerò la questione utilizzando i bits piuttosto che i pixels. Fare rotazioni in questo modo è semplice (mask + 2 shifts + or). Le riflessioni sono un po’ più complicate, ma non troppo, ed in fondo sono solo 2 casi. Poi il conto dei pixels diventa un semplice popcount (population count, ovvero il conto dei bits uguali ad 1) che ultilizzando il noto algoritmo di Brian Kernighan (co-autore del linguaggio C) è “semplicemente”:

int count_set_bits(int n){
    int count = 0;
    while(n != 0){
        n &= (n-1);
        count++;
    }
    return count;
}

Vediamo cosa esce fuori…

edit… in realtà non funziona propriamente così.
edit2… idea pessima. lasciare tutto come stringhe è probabilmente assai più semplice.


#98

Io sono costretto ad abbandonare a mezza via che devo uscire e probabilmente tornerò tardi da non poter concludere entro stasera, quindi mi sa che domani me ne toccheranno due (se riesco a risolvere questo).


#99

Sono arrivato al punto in cui l’input di test funziona, e quello vero no…


#100

:joy: Che sbocco di sangue che è stato questo day 21…


#101

Wow, mi sono riportato in pari. :smiley:
Devo dire che è stato meno complicato di quello che pensavo. Sopratturro la parte 2… :laughing:
Adesso provo a guardare quello di oggi che mi sembra più facilotto.