🌟 Advent of Code (AoC) 2020 🌟

Självklart! Jag kanske inte borde hålla på under en fredagskväll, detta var ju väldigt basic. Att jag inte fattade att det var lite bra för att vara sant när column alltid slutade på precis 30. Fick rätt nu direkt med ditt tips, tack för snabb hjälp.

Dag: 4
Språk: C
Lösning: GitHub

Bara för att C är så fel för denna uppgift var jag tvungen att testa, blev inte så fasligt illa.

-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                                1             26              0            156
-------------------------------------------------------------------------------

Dag: 3
Språk: Kotlin
Lösning: GitHub
Speciellt tack till: @huggeMugg

Men du fuskar ju

Du kan dina funktioner i standardbiblioteket.
Du vet att atoi bara tar siffrorna och att man inte behöver klippa bort "in" eller "cm" från längden.
Du vet att isxdigit kollar om det är en hexadecimalsiffra.
Och strtok, vad är det för mygel?
Istället för ha namngivna medlemmar använder du tabeller och heltalsindexerar. Och kan göra tester genom bitmaskning!

Då blir det ju mycket lättare och mindre kod. Hur påverkar detta läsbarheten? Här gör du trade-offs mellan uppenbar kod för den oinvigde och kodstorlek. Det är ju inte i närheten av de hemskheter jag producerar i Python, men här går du lite åt samma håll.

TL;DR: Ett program skrivet av en erfaren programmerare som kan sina saker. Det innehåller en del trix som är tillämpbara även i andra språk så även de som inte skriver i C borde kolla på koden för att lära sig saker.

Dag 5
Språk: Kotlin

Del 1:

package main.java.dayfive

import main.java.FileReader

fun main() {
    val lines = FileReader().readFile("input.fifth")
    val max = lines.map { getSeatId(it) }.maxOrNull()
    println(max)
}

private fun getSeatId(definition: String): Int {
    val binaryDefinition = definition
        .replace('B', '1').replace('F', '0')
        .replace('R', '1').replace('L', '0')

    return binaryDefinition.toInt(2)
}

Del 2:

package main.java.dayfive

import main.java.FileReader

fun main() {
    val lines = FileReader().readFile("input.fifth")
    val sortedSeatIds = lines.map { getSeatId(it) }.sorted()
    for (i in sortedSeatIds.indices) {
        if (sortedSeatIds[i + 1] - sortedSeatIds[i] == 2) {
            println(sortedSeatIds[i] + 1)
            return
        }
    }
}

private fun getSeatId(definition: String): Int {
    val binaryDefinition = definition
        .replace('B', '1').replace('F', '0')
        .replace('R', '1').replace('L', '0')

    return binaryDefinition.toInt(2)
}

Precis. Jag tycker det är konstigt att fler inte sett det sambandet.

Det blev ju riktigt elegant i Scala också

FET SPOILER, läs inte innan du löst uppgiften.

Dag: 5
Språk: c#

Kul uppgift, har ingen som helst erfarenhet av "binary space partitioning"...

static void Main(string[] args)
{
  var seats = Parse(File.ReadAllLines("input.txt")).ToArray();
  var part1 = seats.Max();
  var part2 = seats.Single(x => !seats.Contains(x + 1) && seats.Contains(x + 2)) + 1;
  Console.WriteLine($"{part1}//{part2}");
}
static IEnumerable<int> Parse(string[] d)
{
  foreach (var s in d)
  {
    int f = 0, b = 127, l = 0, r = 7;
    foreach (var c in s)
    {
           if (c == 'F') { b = (f + b) / 2; }
      else if (c == 'B') { f = (f + b) / 2 + 1; }
      else if (c == 'L') { r = (l + r) / 2; }
      else if (c == 'R') { l = (l + r) / 2 + 1; }
    }
    yield return f * 8 + l;
  }
}

Day: 5
Språk: Powershell
Lösning: GitHub.

Jag känner mig rätt nöjd med min lösning idag, både utifrån hur rent det blev och utifrån att jag tidigt såg ett sätt att lösa uppgiften på ett enklare sätt än specifierat.

@Talarion om du ville se en enklare lösning i Powershell så kan du kolla min lösning.

if (strcmp(key, "byr:") == 0) return BYR;
if (strcmp(key, "iyr:") == 0) return IYR;
if (strcmp(key, "eyr:") == 0) return EYR;
if (strcmp(key, "hgt:") == 0) return HGT;
if (strcmp(key, "hcl:") == 0) return HCL;
if (strcmp(key, "ecl:") == 0) return ECL;
if (strcmp(key, "pid:") == 0) return PID;
if (strcmp(key, "cid:") == 0) return CID;

int ret;

ret = strcmp(key, "byr:");
if (ret == 0)
{
        return BYR;
}

ret = strcmp(key, "iyr:");
if (ret == 0)
{
        return IYR;
}

ret = strcmp(key, "eyr:");
if (ret == 0)
{
        return EYR;
}

ret = strcmp(key, "hgt:");
if (ret == 0)
{
        return HGT;
}

ret = strcmp(key, "hcl:");
if (ret == 0)
{
        return HCL;
}

ret = strcmp(key, "ecl:");
if (ret == 0)
{
        return ECL;
}

ret = strcmp(key, "pid:");
if (ret == 0)
{
        return PID;
}

ret = strcmp(key, "cid:");
if (ret == 0)
{
        return CID;
}

Jag är en hemsk person som faktiskt föredragit den undre varianten. Men du fick mig att testa så i dagens lösning har jag faktiskt gjort vissa saker på en rad istället för flera. Kan se fördelen i vissa scenarion, där jag nu använder det. Har inte kodat så länge att jag riktigt skapat mig en vana för hur jag vill ha det ännu.

Dag: 5
Språk: C#

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

namespace AoC5
{
    class Program
    {
        static void Main()
        {
            List<string> input = File.ReadAllLines("C:\\Users\\willh\\AdventOfCode2020\\AoC5\\input.txt").ToList();

            int[] row = new int[128];
            int[] col = new int[8];

            for (int i = 0; i < row.Length; i++) { row[i] = i; }
            for (int i = 0; i < col.Length; i++) { col[i] = i; }

            //This gives a start, could set it to 0 and it would work but this will ALWAYS work even for negative seatIDs in some alternate reality
            int highestID = CalculateSeatID(row, col, input[0]);
            List<int> allSeats = new List<int>();

            foreach (string instruction in input)
            {
                int candidate = CalculateSeatID(row, col, instruction);

                if (candidate > highestID) { highestID = candidate; }
                
                allSeats.Add(candidate);
            }

            int seatNumber = FindMissingSeat(allSeats);

            Console.WriteLine("Solution 1 = {0}", highestID);
            Console.WriteLine("Solution 2 = {0}", seatNumber);
            Console.ReadLine();
        }
        static int FindMissingSeat(List<int> allSeats)
        {
            allSeats.Sort();

            int seatNumber = allSeats[0];

            for (int i = 0; i < allSeats.Count; i++)
            {
                if (!(seatNumber == allSeats[i])) { return seatNumber; }
                seatNumber += 1;
            }

            return 0;
        }
        static int CalculateSeatID(int[] row, int[] col, string instructions)
        {
            int rowLow = 0;
            int colLow = 0;
            int rowHigh = row.Length - 1;
            int colHigh = col.Length - 1;

            int colMid = (colLow + colHigh) / 2;
            int rowMid = (rowLow + rowHigh) / 2;

            foreach (char instruction in instructions)
            {
                switch (instruction)
                {
                    case 'F':
                        rowHigh = rowMid;
                        rowMid = (rowLow + rowHigh) / 2;
                        break;
                    case 'B':
                        rowLow = rowMid;
                        rowMid = (rowLow + rowHigh) / 2;
                        break;
                    case 'L':
                        colHigh = colMid;
                        colMid = (colLow + colHigh) / 2;
                        break;
                    case 'R':
                        colLow = colMid;
                        colMid = (colLow + colHigh) / 2;
                        break;
                }
            }
            return rowHigh * 8 + colHigh;
        }
    }
}

Lite roligt faktiskt att jag igår började titta i boken grooking algorithms vilken i princip börjar med ett sånt här exempel. Går garanterat att göra mycket effektivare (ska titta på andra svar nu) men jag är riktigt nöjd faktiskt. Under 90 rader idag

Jag kodar ju lite grann för jobbet när det behövs (jobbar som systemadministratör) så jag är inte direkt programmerare på heltid, men jag skulle nog säga att regel 1 för kodstil är att skita i att följa kodstilen om det gör koden svårare att läsa.

Kodstil är tänkt som en riktlinje, en serie regler som kan göra koden lättare att läsa om de följs, men det finns alltid undantag. Det är läsbarheten som är målet, inte att följa kodstilen. Kodstil är bara ett verktyg för att göra koden mer läsbar, inte ett självändamål.

Dag: 5
Språk: Swift
Lösning: GitHub

Är gjort lite för att lära mig Swifts standardbibliotek. Representerar planet som en matris av Range<Int> som smalnas av med information från boardingkort till dessa att rad/kolumn båda är av längd 1.

Andra delen löses genom att skapa en mängd (Set<Int>) av alla tänkbara "seat IDs", för att sedan plocka bort alla IDs som är tagna samt där ID-1 och ID+1 inte är tagna.

Börjar bli lite varm i Swift-kläderna, när första beräkningstunga problemet dyker upp blir att att testa på Metal-compute. En av huvudanledningarna till att jag vill lära mig Swift är att Metal-compute ser riktigt trevligt ut och det verkar klart enklast att jobba med från Swift.

Jag har nyligen hamnat i en roll som systemförvaltare/systemadministratör (de visste inte riktigt vad de skulle kalla mig) och har nyss börjat experimentera med att bygga egna script/verktyg för processer vi gör hela tiden.

Min enda formella kunskap inom programmering är några kortare uppgifter om python på grundnivå där jag och läraren pratade oerhört mycket om just kodstil faktiskt. Jag är generellt ett stort fan av luftig kod med mycket whitespace men allteftersom jag bygger erfarenhet så blir kompaktare kod mer intressant, kanske för att förståelse ökar? Får väl se hur det blir i framtiden, märker ju redan att C# tar upp många fler rader än python för nära nog samma sak men eftersom jag använder powershell på jobbet känns C# som ett bra val just nu.

Med det sagt håller jag med om vad du säger om kodstil, minns att även läraren på högskolan sa att man utvecklar sin egen kodstil över tid och att den ofta ändras allteftersom man får mer erfarenhet. Hoppas på att hitta min egen framgent

$f,$l = $seats.seatid | sort | select -first 1 -last 1

[int32[]]$my = $f..$l |% {$_}

Compare-Object -ReferenceObject $seats.seatid -DifferenceObject $my | Select-Object -ExpandProperty Inputobject

Jag var inne på Compare-Object också, men det bygger på att man måste sortera, något som kostar O(n log n) för att initiera datastrukturen, och sedan O(n) för att jämföra mellan de två listorna, för en total komplexitet på O(n log n).

Det bygger också på att man måste kolla igenom hela listan, även när man hittat vad man är ute efter.

Genom att göra som jag gjorde med ett HashSet sparar man i komplexitet. Att skapa ett set med n värden kostar O(n), och sedan O(n) för att iterera över set:et. På mitt sätt genom att använda en for-loop som stannar när man hittar en ledig stol så slipper du kolla igenom resten av arrayen du inte är intresserad av.

C har inte mycket till standardbibliotek och kanske råkar kunna det ovanligt väl då jag behövt implementera standardbiblioteket C99 som del av jobbet. Men oavsett språk använder ju folk standardbiblioteket, vore rätt hopplöst att lösa något utan det. Alla de funktioner du nämner är ju del av C89, enda jag använder från C99 är möjlighet att deklarera variabler när de först används i stället för i toppen av funktionen.

Gick lite snabbt när jag slängde ihop det hela igår, bitmasken är bara en totalt onödig hastighetsoptimering (programmet körs på ~1 ms med eller utan optimering) och man kan ju enkelt namnge alla fält genom att deklarera en enum. Det är nu gjort, vilket tog ned antalet rader till 141 (d.v.s. SLOC är 141). Det är fortfarande rätt många, Swift varianten har hälften (och är nybörjare i Swift, men använder självklart standardbiblioteket än mer där då det innehåller rätt mycket mer).

En trevlig egenskap med C är att allt är väldigt explicit, så om man bara skippar att gömma saker i macros samt skriva flera satser på samma rad är det alltid enkelt att följa flödet i en debugger. Nestlade högnivåkonstruktioner i språk som Clojure eller Python blir rätt snabbt hopplöst att debugga, så där har man ett OK lackmustest på när saker kanske borde brytas ned i mindre bitar.

I C lösningen var redan tidigare alla moment namngivna, nu är även tabellen med funktionspekare borta och den är väldigt nära min Swift-lösning. Man kan argumentera om fälten i passet är namngivna, det är fortfarande en array men nu kan man göra passport->fields[BYR] för att komma åt fältet "birth year".

Det jag använder som definitivt inte är nybörjarvänligt är pekararitmetik, det kan man absolut peka ut som komplicerade här. Jag tycker det är enkelt då det är något som jag använder ofta p.g.a. effektiviteten (många CPUer har dedicerade instruktioner för sådant, x86 har det även för typer med storlekar från 1 byte till 8 bytes).

Det som diskuterats innan var väl mer att överanvändning av anonyma funktioner leder till write-only kod då enda sättet att fatta vad som händer är att förstå effekten av hela harangen av högre nivå funktioner. Om man bra bryter ned det i de delsteg som faktiskt finns och namnger mellanresultaten går det typiskt från write-only till "ah det är självklart".

Sen finns det en annat problem med språk som Clojure och Python i att "normala" fallet av list-comprehension är "inside-out". Inget problem om man delar upp saker i distinkta delproblem, i det läget har båda dessa språk väldigt kraftull och enkel syntax. Nästlar man det, vilket jag gjorde i denna blir redan rätt enkla saker svåra att greppa.

Fast finns inga regler som inte har undantag. Ibland kan man göra länge haranger som ändå är lätta att förstå, man måste bara skriva det som "gör A, sedan B, sedan C" i stället för "C(B(A()))". Clojure kan visualisera det väldigt väl

Write-only, men är extremt enkelt att skriva detta när man har all kontext i skallen, inte lika lätt att fatta det hela en vecka senare...

(first (.split (.replace (.toUpperCase "a b c d") "A" "X") " "))

Exakt samma logik, men nu rätt enkelt att greppa direkt även om man inte kan Clojure

(-> "a b c d" 
    .toUpperCase 
    (.replace "A" "X") 
    (.split " ") 
    first)

Fast även denna blir rätt snabbt write-only om delmomenten blir minsta komplicerade, i det läget bör de brytas ut som funktioner och namnges.

Båda ger svaret "X"