Die Antwort ist einfacher.
An Tag fünf, war ja noch die Info drin, das nicht alle Reihen in der LIste sind. Nun das waren die VIP Passagiere. Beim Zoll müssen halt alle durch und deshalb die grössere Anzahl.
Gruss Dani
Die Antwort ist einfacher.
An Tag fünf, war ja noch die Info drin, das nicht alle Reihen in der LIste sind. Nun das waren die VIP Passagiere. Beim Zoll müssen halt alle durch und deshalb die grössere Anzahl.
Gruss Dani
Advent of Code? Schau mal ob du hier fündig wirst!
An sich gute Überlegung, aber die Info an Tag 5 war, daß die Sitze an Anfang und Ende gar nicht existieren.
Das gilt für "normal" Sterbliche.....
Heute hatte zum Glück ein anderer Zollbeamter dienst, der ließ mich nun auch endlich mit folgendem Code durch den Zoll:
import os
SKRIPTPFAD = os.path.abspath(os.path.dirname(__file__))
def read_input(datei):
with open(datei) as file:
inhalt = file.readlines()
inhalt.append("")
return inhalt
def read_group_answers_1(inhalt):
groups_answers = []
answers = []
for group_answer in inhalt:
group_answer = group_answer.strip()
if group_answer:
for answer in group_answer:
answers.append(answer)
else:
groups_answers.append(set(answers))
answers = []
return groups_answers
def read_group_answers_2(inhalt):
counters = []
antwort_set_1 = {chr(i) for i in range(ord("a"), ord("z") + 1)}
for gruppen_antwort in inhalt:
gruppen_antwort = gruppen_antwort.strip()
if gruppen_antwort:
antwort_set_2 = {antwort for antwort in gruppen_antwort}
if len(antwort_set_2) > 0:
antwort_set_1 = antwort_set_1 & antwort_set_2
else:
counters.append(len(antwort_set_1))
antwort_set_1 = {chr(i) for i in range(ord("a"), ord("z") + 1)}
return counters
def count_answers(groups_answers):
counters = []
for answers in groups_answers:
counters.append(len(answers))
return counters
def main():
inhalt = read_input(os.path.join(SKRIPTPFAD, "input_6_1"))
groups_answers = read_group_answers_1(inhalt)
counters = count_answers(groups_answers)
print(f"Solution of Day 6 #1: {sum(counters)}")
counters = read_group_answers_2(inhalt)
print(f"Solution of Day 6 #2: {sum(counters)}")
if __name__ == "__main__":
main()
Alles anzeigen
Überleg Dir wie die Gruppenanwort für jede Gruppe initialisiert werden muss. Es ist *nicht* die leere Menge!
Das brachte mich dann letztens auf einen anderen / richtigen Gedanken.
Die restlichen Verbesserungsvorschläge werde ich versuchen für die Zukunft zu beherzigen, danke dafür. In der aktuellen Lösung sind sie aber noch nicht eingearbeitet. Vll hol ich das bei Zeiten einmal nach
Der Tag geht, wie auch meine Nerven dem Ende zu.
Vielleicht reicht ja auch wieder ein Schups in die richtige Richtung, wobei ich mir das bei der heutigen Aufgabe nicht denken kann.
Bin jedenfalls kläglich gescheitert.
Habe bis jetzt überhaupt gebraucht mal ein Ergebnis zu bekommen, aber das ist mit 190 zu hoch.
Hier mein Versuch (und ja einmal habe ich mal wieder continuebenötigt)
import os
SKRIPTPFAD = os.path.abspath(os.path.dirname(__file__))
def read_input(datei):
with open(datei) as file:
inhalt = file.readlines()
return inhalt
def create_content(contents):
bags = {}
for content in contents:
content = content.replace("bags", "").replace("bag", "").replace(".", "")
content = content.strip()
value = ""
for count, char in enumerate(content):
if char.isdigit():
value = f"{value}{char}"
else:
break
if value:
value = int(value)
bag = content[count:].replace("bags", "").replace("bag", "").strip().replace(" ", "_")
bags.update({bag: value})
else:
bags = None
return bags
def create_bags(rules_list):
bags = {}
for rule in rules_list:
key = rule[0].replace("bags", "").replace("bag", "")
key = key.strip()
key = key.replace(" ", "_")
contents = rule[1].split(",")
bags[key] = create_content(contents)
return bags
def create_rules(rules):
rules_list = []
for rule in rules:
rules_list.append(rule.split("contain"))
bags = create_bags(rules_list)
return bags
def search_right_bag(search_bag, contain_bags, bags):
for bag in contain_bags:
if bags[bag] is None:
return False
print(bags[bag].keys())
if search_bag in bags[bag].keys():
return True
else:
if search_right_bag(search_bag, bags[bag].keys(), bags):
return True
return False
def count_right_bag(search_bag, bags):
counter = 0
for relevanter_bag in bags:
if bags[relevanter_bag] is None:
if search_bag == relevanter_bag:
counter += 1
continue
else:
print(bags[relevanter_bag].keys())
if search_bag == relevanter_bag:
counter += 1
elif search_bag in bags[relevanter_bag].keys():
counter += 1
else:
if search_right_bag(search_bag, bags[relevanter_bag].keys(), bags):
counter += 1
print(counter)
def main():
inhalt = read_input(os.path.join(SKRIPTPFAD, "input_7_1"))
bags = create_rules(inhalt)
count_right_bag("shiny_gold", bags)
if __name__ == "__main__":
main()
Alles anzeigen
Manul Code sieht schön schlank aus, aber da ich von selbst schonmal kein Regex behersche, probierte ich einen anderen Weg. Einen falschen Weg.
Wie gings dem Rest mit der heutigen Aufgabe?
aber da ich von selbst schonmal kein Regex behersche, probierte ich einen anderen Weg. Einen falschen Weg.
Abgesehen davon, daß die heutige Aufgabe ein guter Anlaß wäre, sich (noch) mal mit regulären Ausdrücken zu beschäftigen (ich musste auch noch mal nachlesen, sowohl über deren Syntax als auch vor allem über ihre Verwendung in Python), scheint mir Dein Ansatz keineswegs falsch zu sein: Zumindest erzeugt er aus meinen Inputdaten die selben Regeln wie mein Code.
Wo's dann schiefgeht, ist offenbar bei der Suche nach der Antwort. Hier finde ich Deine Funktion wieder unübersichtlich und – zumindest ohne Kommentare – schwer nachzuvollziehen. Was ich beobachtet habe: Wenn ich Deinen Code mehrmals aufrufe, bringt er unterschiedliche Ergebnisse. Die sind mit meinem Input manchmal richtig und manchmal zu niedrig. Die einzige Erklärung, die ich um die Uhrzeit spontan dafür habe, ist, daß beim Iterieren über ein Dictionary die Reihenfolge nicht definiert ist. Vielleicht hilft das ja ein bißchen weiter.
P.S. Nach nochmaligem Drüberschauen: Du brauchst in Deinem Code tatsächlich ein continue, aber nicht da, wo Du es eingebaut hast (da ist es überflüssig), sondern in einer anderen Funktion. Außerdem scheinst Du
ZitatIf you wanted to carry it in at least one other bag
in der Aufgabenstellung überlesen zu haben. Mit 2 kleinen Änderungen liefert Dein Code bei mir konsistent das richtige Ergebnis.
Seit Python 3.6 inoffiziell und danach offiziell sind Dicts geordnet. Und deterministisch waren sie schon immer. Darum würde mich das als Ursache verwundern.
Seit Python 3.6 inoffiziell und danach offiziell sind Dicts geordnet.
Ich habe Hofeis Code mit Python 3.5 getestet (und musste daher auch den f-String rausschmeißen). Tatsächlich hat mich die Beobachtung aber auf die richtige Spur gebracht (s. P.S. zu meinem letzten Post).
aber da ich von selbst schonmal kein Regex behersche, probierte ich einen anderen Weg. Einen falschen Weg.
Viel Regex braucht man heute aber eh nicht - ich bin z.B. mit r"(\d+) (\w+ \w+) bags?" ausgekommen (klar, geht auch ganz ohne). Bei Interesse weisst du ja, wo du meine ganze Lösung findest - verlinken werde ich hier nichts mehr...
Hallo zusammen
Bei der heutigen Aufgabe bin ich bis jetzt auch gescheitert.
Morgen nochmal probieren und dann ggf. Tipps und Hilfe holen.
Habe bis jetzt nicht mal Code, welcher gezeigt werden könnte, läuft nicht rund....
Freundliche Grüsse
Daniel
Ich komme für Tag 7 ohne reguläre Ausdrücke aus. Das liess sich alles mit `strip()`, `split()`, und `rsplit()` erledigen. Der Trenner dafür kann ja auch mal ein fester Satzteil sein. ?
BASIC-Lösung gibt's keine. Ich hatte nicht die Zeit, aber ich denke ich werde das mal in C für den C64 ausprobieren. Problematisch dürfte die Datenmenge werden. Wenn man Arbeitsspeicher der vom System verwendet wird, den Speicher für den Text der angezeigt wird, und die Speicherbereiche in denen I/O-Register und ROM liegen abzieht, bleiben für Programm und Daten ca. 50 KiB. Die Eingabedaten sind aber schon etwas über 42 KiB. 8 KiB für Programm, den Graphen, und Stack sind zu knapp, und ich glaube nicht, dass es viel hilft, dass man aus den Eingabedaten ein bisschen was von dem ”Füllstoff” rauswerfen kann.
Tag 5 in Python "regulär":
#!/usr/bin/env python3
import sys
import pytest
from attr import attrib, attrs
from more_itertools import pairwise
LETTERS_TO_BINARY_DIGITS = str.maketrans("FBLR", "0101")
@attrs(frozen=True)
class BoardingPass:
id = attrib()
@property
def row(self):
return self.id >> 3
@property
def column(self):
return self.id & 0b111
@classmethod
def parse(cls, text):
return cls(int(text.translate(LETTERS_TO_BINARY_DIGITS), 2))
def main():
boarding_passes = sorted(map(BoardingPass.parse, sys.stdin))
#
# Part 1
#
print(boarding_passes[-1])
#
# Part 2
#
for pass_a, pass_b in pairwise(boarding_passes):
if pass_b.id - pass_a.id > 1:
print(pass_a.id + 1)
break
@pytest.mark.parametrize(
"text,row,column,id_",
[
("FBFBBFFRLR", 44, 5, 357),
("BFFFBBFRRR", 70, 7, 567),
("FFFBBBFRRR", 14, 7, 119),
("BBFFBBFRLL", 102, 4, 820),
],
)
def test_boarding_pass(text, row, column, id_):
boarding_pass = BoardingPass.parse(text)
assert boarding_pass.row == row
assert boarding_pass.column == column
assert boarding_pass.id == id_
if __name__ == "__main__":
main()
Alles anzeigen
Und Tag 5 in Python in 127 Zeichen (Gemeinschaftsprodukt aus'm Python-Forum):
Die Eingabedaten sind aber schon etwas über 42 KiB. 8 KiB für Programm, den Graphen, und Stack sind zu knapp, und ich glaube nicht, dass es viel hilft, dass man aus den Eingabedaten ein bisschen was von dem ”Füllstoff” rauswerfen kann.
Bist Du sicher, dass Du das nicht unterschätzt? Wenn ich meine Eingabedaten in dieses Format bringe
vibrant aqua1shiny magenta2muted teal1dim magenta1muted chartreuse
vibrant violet4pale maroon
dark indigo1light maroon3pale red1drab brown4dim magenta
dark coral5dull aqua5plaid green2posh bronze
dim lavender2muted violet5wavy gold3vibrant plum5bright teal
mirrored turquoise5muted olive5bright gold2vibrant violet
faded brown5faded tomato
muted orange5dull aqua2light salmon1striped black1pale gray
posh black4faded silver
muted coral3mirrored turquoise
bleiben von > 43 KiB noch < 25 KiB übrig. Und da habe ich sogar die Leerzeichen in den Farbnamen behalten. Wenn das immer noch zuviel ist, könnte man natürlich auch die Farben indizieren oder abkürzen.
Ich denke, das müsste sogar in BASIC machbar sein. Mit C auf dem C64 habe ich keinerlei Erfahrung, aber ich würde vermuten, daß man damit eher weniger Speicher braucht (und mehr zur Verfügung hat).
So, heutige Aufgabe erledigt. Hat mir bis jetzt fast am besten gefallen.
Hallo zusammen
Teil 1 der heutigen Aufgabe habe ich gelöst.
Bei Teil 2 stecke ich in einem moralischen Dilemma - bis jetzt habe ich nur einen "try and error" Ansatz. Das möchte ich aber nicht programmieren? Was für andere Ansätze kennt ihr?
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#Beginn mit der Aufgabe = 11:15
#Ende mit der Aufgabe = 12:20
#imports
def datei_einlesen(pfad):
vorhandene_zeilen = []
with open(pfad, 'r') as datei:
for zeile in datei:
zeile = zeile.rstrip()
vorhandene_zeilen.append(zeile)
return vorhandene_zeilen
def programmzeile_trennen(programmzeile):
zeile = programmzeile.split()
anweisung = zeile[0]
operation = zeile[1][:1]
wert = int(zeile[1][1:])
return anweisung, operation, wert
def operation_durchfuehren(empfaenger, operation, wert):
if operation == "+":
empfaenger += wert
else:
empfaenger -= wert
return empfaenger
def main():
PFAD = "1208.txt"
acc_wert = 0
programm_ausführen = True
programmzeilennr = 0
programmcode = datei_einlesen(PFAD)
abgearbeitete_programmzeilen = []
while programm_ausführen:
programmzeile = programmcode[programmzeilennr]
anweisung, operation, wert = programmzeile_trennen(programmzeile)
if anweisung == "nop":
programmzeilennr += 1
if anweisung == "jmp":
programmzeilennr = operation_durchfuehren(programmzeilennr, operation, wert)
if anweisung == "acc":
acc_wert = operation_durchfuehren(acc_wert, operation, wert)
programmzeilennr += 1
if programmzeilennr in abgearbeitete_programmzeilen:
programm_ausführen = False
else:
abgearbeitete_programmzeilen.append(programmzeilennr)
print("Lösung Teil 1: Der Accumolator hat den Wert: {}.".format(acc_wert))
if __name__ == "__main__":
main()
Alles anzeigen
Verbessereungstipps zu meinem Code, nehme ich gerne an.
Freundliche Grüsse
Dani
Manul Nee, sicher bin ich nicht. Habe es noch nicht ausprobiert. ?
C vs. BASIC auf dem C64: Der Code wird grösser, Daten (bei Zahlen) kleiner, und man hat mehr Arbeitsspeicher für Programm und Daten. 50 KiB vs. 38 KiB, weil bei C-Programmen das BASIC-ROM ausgeschaltet werden kann und man 4 KiB RAM nutzen kann die vom BASIC nicht verwendet werden. Letzteres könnte man von BASIC natürlich verwenden, aber nicht ”normal” für BASIC-Variablen.
dll-live Ich habe auch „trial & error“ und denke auch alles andere wäre massiv aufwändiger. Hatte auch erst so ein flaues Gefühl dabei, bis mir klar geworden ist, dass es keine bedingten Verzweigungen gibt, so eine Endlosschleife also nach maximal n Schritten erkannt ist, mit n=Anzahl der Anweisungen.
Außerdem scheinst Du
...
in der Aufgabenstellung überlesen zu haben
überlesen oder nicht verstanden - beides möglich. Englisch ist nicht meine Stärke.
Wenn ich das richtig verstehe, dürfte dann dieses Teil den Counter nicht mehr erhöhen:
for relevanter_bag in bags:
if bags[relevanter_bag] is None:
if search_bag == relevanter_bag:
counter += 1
continue
else:
print(bags[relevanter_bag].keys())
if search_bag == relevanter_bag:
counter += 1
Dann wird das Ergebnis nur um 1 tiefer mit 189 was immer noch falsch ist.
Da mir die Ideen ausgehen und die Lust verschwunden ist, kapitulier ich vor Tag 7.
Vielen Dank, dass du dir so viel Zeit nimmst und den Code getestet hast.
Also ich habe Tag 7 nochmals kommentiert, eine Lösung, den Fehler in meinem Code habe ich bisher nicht finden können.
Wäre schön, wenn mir jemand meinen Denkfehler im Code zeigen könnte. Laut Manul bin ich ja knapp dran, aber den Fehler finde ich leider nicht ohne fremde Hilfe
import os
SKRIPTPFAD = os.path.abspath(os.path.dirname(__file__))
def read_input(datei):
with open(datei) as file:
inhalt = file.readlines()
return inhalt
def create_content(contents):
bags = {}
for content in contents:
content = content.replace("bags", "").replace("bag", "").replace(".", "")
content = content.strip()
value = ""
for count, char in enumerate(content):
if char.isdigit():
value = f"{value}{char}"
else:
break
if value:
value = int(value)
bag = content[count:].replace("bags", "").replace("bag", "").strip().replace(" ", "_")
bags.update({bag: value})
else:
bags = None
return bags
def create_bags(rules_list):
bags = {}
for rule in rules_list:
key = rule[0].replace("bags", "").replace("bag", "")
key = key.strip()
key = key.replace(" ", "_")
contents = rule[1].split(",")
bags[key] = create_content(contents)
return bags
def create_rules(rules):
rules_list = []
for rule in rules:
rules_list.append(rule.split("contain"))
bags = create_bags(rules_list)
return bags
def search_right_bag(search_bag, contain_bags, bags):
# Durchsuche die Rücksäcke, ob ein Rucksack davon den goldenen Rucksack aufnehmen kann
# wenn ja gib True zurück, ansonsten False
for bag in contain_bags:
if bags[bag] is None:
return False
print(bags[bag].keys())
# ja der Rucksack kann aufgenommen werden
if search_bag in bags[bag].keys():
return True
else:
# Wenn keiner den goldenen Rucksack aufnehmen kann, durchsuche, ob ein anderer Rucksack welcher enthalten ist
# den goldenen Rucksack aufnehmen kann - Rekrusiver Aufruf der Funktion, nur werden die Rücksäcke der nächst # tieferen Ebene übergeben
if search_right_bag(search_bag, bags[bag].keys(), bags):
return True
return False
def count_right_bag(search_bag, bags):
"""Zähle wie viele Rücksäcke meinen goldenen Rucksack aufnehmen können"""
counter = 0
for relevanter_bag in bags:
# Nur Rucksäcke betrachten, die Rucksäcke aufnehmen können
if not bags[relevanter_bag] is None:
print(bags[relevanter_bag].keys())
# Wenn der goldene Rucksack aufgenommen werden kann, erhöhe den Zähler auf 1, ansonsten durchsuche
# ob die enthaltenen Rucksäcke den goldenen Rucksack aufnehmen können
if search_bag in bags[relevanter_bag].keys():
counter += 1
else:
if search_right_bag(search_bag, bags[relevanter_bag].keys(), bags):
counter += 1
print(counter)
def main():
inhalt = read_input(os.path.join(SKRIPTPFAD, "input_7_1"))
bags = create_rules(inhalt)
count_right_bag("shiny_gold", bags)
if __name__ == "__main__":
main()
Alles anzeigen
Zum heutigen Tag 8,
ja machte ich auch über Try and Error. Einfach jede Kombination erstellt und geprüft ob es erfolgreich durchläuft. Da musste man sogar am PC kurz auf das Ergebnis warten.
Tag 8 in C64 BASIC:
10 TI$="000000":DIM I$(700),O(700),X(700):PL=0
50 PRINT"LOAD BOOT PROGRAM...":OPEN 2,8,2,"INPUT08,S,R"
60 IF ST<>0 THEN CLOSE 2:GOTO 100
70 GET#2,C1$:GET#2,C2$:GET#2,C3$:I$(PL)=C1$+C2$+C3$:INPUT#2,O(PL):PL=PL+1
80 PRINT PL:PRINT"{UP}";:GOTO 60
100 PRINT"TIME AFTER READING: "TI$:PRINT"EXECUTE PROGRAM..."
110 GOSUB 1000:PRINT"PART 1:";A:PRINT"TIME SO FAR: "TI$
120 PRINT"FIX PROGRAM..."
130 FOR J=0 TO PL-1:I$=I$(J)
140 IF I$="JMP" THEN NI$="NOP":GOTO 170
150 IF I$="NOP" THEN NI$="JMP":GOTO 170
160 GOTO 190
170 PRINT J:PRINT"{UP}";:I$(J)=NI$:GOSUB 1000:I$(J)=I$
180 IF IP=PL THEN PRINT"PART 2:"A:J=PL
190 NEXT
900 PRINT"TOTAL TIME: "TI$:END
1000 REM EXECUTE PROGRAM UNTIL END OR ENDLESS LOOP DETECTED
1010 A=0:IP=0:FOR I=0 TO PL:X(I)=0:NEXT
1020 IF IP=PL OR X(IP) THEN RETURN
1030 IF I$(IP)="ACC" THEN A=A+O(IP):GOTO 1060
1040 IF I$(IP)="JMP" THEN IP=IP+O(IP)-1:GOTO 1060
1050 IF I$(IP)<>"NOP" THEN PRINT"UNKNOWN INSTRUCTION "I$(IP)" @"IP:END
1060 X(IP)=-1:IP=IP+1:GOTO 1020
Alles anzeigen
Tag 6 in Python:
#!/usr/bin/env python3
import sys
from functools import reduce
from operator import and_, or_
import pytest
from more_itertools import split_at
EXAMPLE_LINES = """\
abc
a
b
c
ab
ac
a
a
a
a
b
""".splitlines()
def is_empty_line(line):
return line.strip() == ""
def parse_group(lines):
return [set(line.strip()) for line in lines]
def parse_groups(lines):
return map(parse_group, split_at(lines, is_empty_line))
def count_answers_per_group(groups, combine_answers):
return sum(len(reduce(combine_answers, group)) for group in groups)
def main():
groups = list(parse_groups(sys.stdin))
for combine_answers in [or_, and_]:
print(count_answers_per_group(groups, combine_answers))
@pytest.mark.parametrize("combine_answers,expected", [(or_, 11), (and_, 6)])
def test_example(combine_answers, expected):
assert (
count_answers_per_group(parse_groups(EXAMPLE_LINES), combine_answers)
== expected
)
if __name__ == "__main__":
main()
Alles anzeigen
Hofei Wie langsam ist Dein PC? Und welche ”Kombinationen” meinst Du? Ich denke Du machst da zu viel. Wahrscheinlich sogar viel zu viel. Wie viele ”Kombinationen” hat denn das Beispiel aus der Aufgabe bei Deiner Lösung?
So, da mangels Zeit die Lösungsfindung in einer komplett anders strukturierten Sprache doch etwas länger dauert, habe ich mich entschlossen erstmal bisschen aufs Gas zu drücken und die Lösungen in meinem Täglich-Brot-C# zu implementieren:
=> https://github.com/renao/Advent_of_Code_NET
Um dem Monk in mir gerecht zu werden, habe ich erstmal natürlich die bereits gelösten Aufgaben nachgebaut und stecke gerade an Tag 3 Teil 2 fest.
Ehrlicherweise bin ich mir gerade unsicher, ob mein Weg durch die "Slopes" an einer Stelle einen Gedankenfehler hat oder ob ich irgendwo einen Overflow nicht mitbekomme beim Multiplizieren der Antworten.
Hat jemand mal Lust auf meine (falsche-) Lösung zu schauen bzw. meinen Input mal bei sich durchzujagen?
Dann hätte ich eine richtige Assertion für den Test und könnte mich zumindest daran orientieren
Natürlich ist das Knobeln hier auch Teil der Sache, aber es macht auch mehr Spaß, wenn ich auch mal fix wieder an die aktuellen Aufgaben komme
P.S.: Meine falsche Lösung ist: 8034812640
Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!