Advent of Code

Check-in [38c17bcc28]
Login

Check-in [38c17bcc28]

Overview
Comment:202417 2nd star
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 38c17bcc28d7bccf96990ee6f84be8166a6e216ae414a23975f9042798740e5d
User & Date: nnz on 2025-01-09 19:02:52.102
Other Links: manifest | tags
Context
2025-01-09
19:11
added TODO notes check-in: cb68a52d2d user: nnz tags: trunk
19:02
202417 2nd star check-in: 38c17bcc28 user: nnz tags: trunk
2024-12-26
11:56
202417 1st star check-in: acf723019c user: nnz tags: trunk
Changes
Side-by-Side Diff Ignore Whitespace Patch
Modified aoc2024.c from [3996de5fa9] to [8ba34621fd].
︙
50
51
52
53
54
55
56
57

58
59
60
61
62
63
64
65
66

67
68
69
70
71
72
73

50
51
52
53
54
55
56

57
58
59
60
61
62
63
64


65
66
67
68
69
70
71
72








-
+







-
-
+








        case 5: return (unsigned)(r[1] & 0xFFFFFFFF);
        case 6: return (unsigned)(r[2] & 0xFFFFFFFF);
    }
}

static unsigned instruction(unsigned ip, unsigned opcode, unsigned operand,
                            unsigned long long r[3],
                            char *out, size_t *outlen) {
                            unsigned *out, size_t *outlen) {
    unsigned nextip = ip + 2;
    switch (opcode) {
        default: case 3: if (r[0]) { nextip = operand; } break;
        case 0: r[0] = r[0] / (1 << combo(operand, r)); break;
        case 1: r[1] = r[1] ^ operand; break;
        case 2: r[1] = combo(operand, r) % 8; break;
        case 4: r[1] = r[1] ^ r[2]; break;
        case 5: if (*outlen) { out[*outlen] = ','; *outlen += 1; }
                out[*outlen] = combo(operand, r) % 8 + '0';
        case 5: out[*outlen] = combo(operand, r) % 8;
                *outlen += 1;
                break;
        case 6: r[1] = r[0] / (1 << combo(operand, r)); break;
        case 7: r[2] = r[0] / (1 << combo(operand, r)); break;
    }
    return nextip;
}
︙
85
86
87
88
89
90
91
92

93
94
95
96
97
98
99






























100
101
102
103
104
105
106

84
85
86
87
88
89
90

91
92
93
94
95
96


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133








-
+





-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








    unsigned p[100] = {0}, np = 0;
    while (dta && *dta) {
        unsigned v = strtoul(dta, &err, 10);
        p[np++] = v;
        if (*err == 0) dta = NULL;
        else dta = err + 1; // skip comma
    }
    char output[1000];
    unsigned output[100];
    size_t outlen = 0;
    unsigned ip = 0;
    while (ip + 1 < np) {
        ip = instruction(ip, p[ip], p[ip+1], reg, output, &outlen);
    }
    output[outlen] = 0;
    printf("Program's output is {%s}\n", output);
    printf("Program's output is {");
    for (unsigned k = 0; k < outlen; k++) {
        if (k) putchar(',');
        putchar((int)output[k] + '0');
    }
    printf("}\n");

    printf("Program is          (%u", p[0]);
    for (unsigned k = 1; k < np; k++) {
        if (k) putchar(',');
        putchar((int)p[k] + '0');
    }
    printf(")\n");

    reg[3] = 202322936867370;
#if 0
    // I'm not happy with my "solution".
    // It wasn't the program who found it.
    // I found it by studying closer and closer attempts

    // first I noticed that the program work 3 bits at a time,
    // so, to generate a sequence with 16 numbers it needs 48 bits

    // I then simply calculated the output with each 3-bit value one-by-one
    // until I had the whole thing

    // someday, maybe, I'll try to write a proper recursive solution
#else
    printf("Start with A = %llu to get the quine.\n", reg[3]);
#endif
}

/* === aoc202409 =======================================================
   WOW! input consists of a 20,000 long string of numbers!
   Make an array of blocks, each with either -1 or the fileid
   For Part Two: make an array of blocks with the encoded value of
(fileid * 10) + length, or, when empty, the negative length
︙