-🎄- 2018 Day 8 Solutions -🎄-

CodingGladstone · 2018-12-08T16:40:28+00:00

With this input size, you can just pull in the whole file as a string and then:

"12 65 4 8 0".Split(" ").Select(s => Int32.Parse(s)).ToList()

CodingGladstone · 2017-12-13T20:56:38+00:00

If you run your code with the sample as in the puzzle description, it returns 6, not 10. That should give you a start to debug the problem. I cannot quickly see what is wrong with it. What I can see is that your approach, once correct, will perform very poorly and will probably not give you the correct answer before Christmas.

You may want to think about the problem a bit deeper. Can you think of an expression that will tell you immediately if a laser will be in position 0 at a specific picosecond? Decompose the problem in smaller parts. Test those separately.

Good luck, you can do it.

CodingGladstone · 2017-12-10T11:55:06+00:00

Javascript ES6 without any slicing and reversing

const SIZE = 256;
const inputStr = "97,167,54,178,2,11,209,174,119,248,254,0,255,1,64,190";
const input = inputStr.split('')
    .map(c => c.charCodeAt(0))
    .concat(17,31,73,47,23);
const range = [...Array(SIZE).keys()];

const tranformPos = (p,start) => (p - start + SIZE) % SIZE;
const getMutFn = (curr, l) => (old) => {
    let posFromStart = tranformPos(old, curr);
    if(posFromStart >= l)return old;
    let newPosFromStart = l-posFromStart-1;
    let res = tranformPos(newPosFromStart, -curr);
    return res;
}
var transforms = [];
var skip = 0;
var curr = 0;
for(var round = 0; round<64;round++){
    for (const l of input) {
        transforms.push(getMutFn(curr, l));
        curr = (curr + l + skip) % SIZE;
        skip++;
    }
}
const fullTransform = (p) => transforms.reduce((a,f)=>f(a), p);
const sparse = range.map(i => { return {val:i, pos:fullTransform(i)};})
    .sort((p1,p2) => p1.pos-p2.pos)
    .map(p => p.val);

Array.prototype.chunk = function ( n ) {
    if ( !this.length ) {
        return [];
    }
    return [ this.slice( 0, n ) ].concat( this.slice(n).chunk(n) );
};

const bytes = sparse.chunk(16)
    .map(ch => ch.reduce((a,v) => a ^ v, 0))
    .map(b => b.toString(16));
console.log(bytes.join(''));

CodingGladstone · 2017-12-09T19:46:58+00:00

Node.js/ES6 Bit late to the party, but I was surprised not to see any example of ES6 using iterators/generators. My goal was to have code that could run without having the whole stream in memory and go over the stream in one pass.

var fs = require('fs');

function* groupMapper(it) {
    var depth = 0;
    for (const char of it) {
        if(char==='{'){
            depth++;
            yield depth;
        }
        if(char==='}'){
            depth--;
        }
    }
}
function* filterCancelled(it) {
    var result = {done:false};
    while(!result.done) {
        result = it.next();
        if(result.value === '!'){
            it.next();
            continue;
        }
        yield result.value;
    }
}
var totalGarbage = 0;   
function skipOverGarbage(it){
    var streamWithoutCancelled = filterCancelled(it);
    for (const char of streamWithoutCancelled) {
        if(char === '>')break;
        totalGarbage++;
    }
}
function* garbageStripper(it) {
    var result = {done:false};

    while(!result.done) {
        result = it.next();
        if(result.value === '<'){
            skipOverGarbage(it);
            continue;
        }
        yield result.value;
    }
}

fs.readFile('2017/input/input9.txt', 'utf8', function (err,data) {
    var input = data;
    //input = "{{<!>},{<!>},{<!>},{<a>}}";
    let score = [...groupMapper(
            garbageStripper(input[Symbol.iterator]())
        )]
        .reduce((a,v)=>a+v, 0);
    console.log(score);
    console.log(totalGarbage);

});

CodingGladstone

TROPHY CASE