diff options
Diffstat (limited to '')
| -rw-r--r-- | 2021/05/README.md | 3 | ||||
| -rw-r--r-- | 2021/05/example | 10 | ||||
| -rw-r--r-- | 2021/05/first.go | 48 | ||||
| -rw-r--r-- | 2021/05/first_v2.go | 60 | ||||
| -rw-r--r-- | 2021/05/go.mod | 3 | ||||
| -rw-r--r-- | 2021/05/input | 500 | ||||
| -rw-r--r-- | 2021/05/line/line.go | 239 | ||||
| -rw-r--r-- | 2021/05/second.go | 61 | ||||
| -rw-r--r-- | 2021/05/second_v2.go | 58 |
9 files changed, 982 insertions, 0 deletions
diff --git a/2021/05/README.md b/2021/05/README.md new file mode 100644 index 0000000..6a4996d --- /dev/null +++ b/2021/05/README.md @@ -0,0 +1,3 @@ +I went a little overboard with a parsing tutorial. + +I wanted to manually write a parser from quite some time now and seized this opportunity. It would have been trivial with just a scanner or even a regex, but hey learning! diff --git a/2021/05/example b/2021/05/example new file mode 100644 index 0000000..b258f68 --- /dev/null +++ b/2021/05/example @@ -0,0 +1,10 @@ +0,9 -> 5,9 +8,0 -> 0,8 +9,4 -> 3,4 +2,2 -> 2,1 +7,0 -> 7,4 +6,4 -> 2,0 +0,9 -> 2,9 +3,4 -> 1,4 +0,0 -> 8,8 +5,5 -> 8,2 diff --git a/2021/05/first.go b/2021/05/first.go new file mode 100644 index 0000000..3bd007b --- /dev/null +++ b/2021/05/first.go @@ -0,0 +1,48 @@ +package main + +import ( + "bufio" + "fmt" + "os" + + "git.adyxax.org/aoc/2021/05/line" +) + +func main() { + matrix := make([][]int, 1000) + for i := 0; i < 1000; i++ { + matrix[i] = make([]int, 1000) + } + + parser := line.NewParser(bufio.NewReader(os.Stdin)) + for { + l, err := parser.Parse() + if err != nil { + break + } + if l.X1 == l.X2 { + if l.Y1 > l.Y2 { + l.Y1, l.Y2 = l.Y2, l.Y1 + } + for i := l.Y1; i <= l.Y2; i++ { + matrix[l.X1][i]++ + } + } else if l.Y1 == l.Y2 { + if l.X1 > l.X2 { + l.X1, l.X2 = l.X2, l.X1 + } + for i := l.X1; i <= l.X2; i++ { + matrix[i][l.Y1]++ + } + } + } + score := 0 + for i := 0; i < 1000; i++ { + for j := 0; j < 1000; j++ { + if matrix[i][j] >= 2 { + score++ + } + } + } + fmt.Println(score) +} diff --git a/2021/05/first_v2.go b/2021/05/first_v2.go new file mode 100644 index 0000000..d99f80b --- /dev/null +++ b/2021/05/first_v2.go @@ -0,0 +1,60 @@ +package main + +import ( + "bufio" + "fmt" + "os" + + "git.adyxax.org/aoc/2021/05/line" +) + +func abs(a int) int { + if a < 0 { + return -a + } + return a +} + +func computeDelta(a, b int) int { + if a < b { + return 1 + } else if a > b { + return -1 + } + return 0 +} + +func main() { + matrix := make([][]int, 1000) + for i := 0; i < 1000; i++ { + matrix[i] = make([]int, 1000) + } + + parser := line.NewParser(bufio.NewReader(os.Stdin)) + for { + l, err := parser.Parse() + if err != nil { + break + } + length := abs(l.X2 - l.X1) + if length == 0 { + length = abs(l.Y2 - l.Y1) + } + dx := computeDelta(l.X1, l.X2) + dy := computeDelta(l.Y1, l.Y2) + if dx == 0 || dy == 0 { + for i := 0; i <= length; i++ { + matrix[l.X1+i*dx][l.Y1+i*dy]++ + } + } + } + score := 0 + for i := 0; i < 1000; i++ { + for j := 0; j < 1000; j++ { + if matrix[i][j] >= 2 { + score++ + } + } + } + fmt.Println(score) +} diff --git a/2021/05/go.mod b/2021/05/go.mod new file mode 100644 index 0000000..81fcab6 --- /dev/null +++ b/2021/05/go.mod @@ -0,0 +1,3 @@ +module git.adyxax.org/aoc/2021/05 + +go 1.17 diff --git a/2021/05/input b/2021/05/input new file mode 100644 index 0000000..527ecf6 --- /dev/null +++ b/2021/05/input @@ -0,0 +1,500 @@ +223,805 -> 223,548 +609,164 -> 609,503 +461,552 -> 796,552 +207,361 -> 207,34 +503,879 -> 503,946 +937,52 -> 937,268 +560,652 -> 118,652 +771,103 -> 85,789 +119,156 -> 947,984 +356,634 -> 607,634 +348,812 -> 873,287 +409,490 -> 726,490 +298,790 -> 298,454 +407,543 -> 820,130 +206,89 -> 591,89 +164,709 -> 976,709 +208,921 -> 208,131 +515,209 -> 515,745 +876,639 -> 281,44 +270,453 -> 727,910 +190,417 -> 190,755 +522,726 -> 903,726 +390,651 -> 603,864 +707,549 -> 926,330 +471,869 -> 471,561 +970,735 -> 401,735 +612,624 -> 612,88 +844,879 -> 844,453 +400,38 -> 400,350 +832,225 -> 984,225 +971,642 -> 42,642 +70,862 -> 447,485 +183,79 -> 183,708 +598,700 -> 598,287 +635,195 -> 39,195 +587,362 -> 349,362 +108,88 -> 965,945 +700,299 -> 165,299 +295,824 -> 785,334 +211,284 -> 390,105 +288,326 -> 672,710 +595,231 -> 595,679 +671,576 -> 813,718 +14,845 -> 784,75 +700,129 -> 43,129 +83,913 -> 889,107 +830,596 -> 322,596 +391,450 -> 391,779 +384,32 -> 384,430 +311,948 -> 938,321 +460,288 -> 460,392 +924,602 -> 924,595 +703,458 -> 703,475 +335,953 -> 335,195 +692,314 -> 927,314 +131,433 -> 131,737 +590,771 -> 965,771 +650,13 -> 963,13 +586,904 -> 658,976 +238,824 -> 782,824 +366,45 -> 691,370 +428,758 -> 201,758 +240,545 -> 30,545 +396,154 -> 332,154 +549,307 -> 233,307 +187,240 -> 851,904 +151,135 -> 937,921 +342,850 -> 342,156 +695,200 -> 695,754 +385,880 -> 893,372 +986,966 -> 813,966 +727,661 -> 727,402 +316,937 -> 316,797 +422,235 -> 422,282 +965,684 -> 882,684 +266,222 -> 419,69 +649,843 -> 635,857 +618,84 -> 126,576 +588,822 -> 588,636 +569,142 -> 569,607 +899,479 -> 488,890 +986,52 -> 369,52 +987,478 -> 551,914 +867,951 -> 973,845 +90,401 -> 304,401 +60,836 -> 798,836 +143,675 -> 686,675 +743,974 -> 743,305 +981,899 -> 551,469 +705,430 -> 493,430 +301,366 -> 823,366 +978,712 -> 617,712 +426,805 -> 426,345 +532,855 -> 532,54 +612,143 -> 612,133 +57,52 -> 955,950 +880,50 -> 16,914 +89,908 -> 89,214 +487,867 -> 586,867 +181,285 -> 181,470 +526,666 -> 86,226 +117,704 -> 117,961 +289,101 -> 983,795 +586,429 -> 442,429 +442,869 -> 734,869 +564,479 -> 564,382 +447,486 -> 62,101 +42,218 -> 509,218 +21,890 -> 843,68 +84,978 -> 921,141 +590,960 -> 590,934 +54,949 -> 967,36 +799,39 -> 767,39 +979,232 -> 979,628 +489,482 -> 339,482 +759,473 -> 290,942 +960,958 -> 32,30 +134,180 -> 134,864 +972,981 -> 13,22 +106,385 -> 11,385 +849,454 -> 447,454 +477,385 -> 955,863 +853,180 -> 922,180 +509,274 -> 751,32 +905,295 -> 779,295 +661,629 -> 104,629 +935,117 -> 93,959 +165,372 -> 746,953 +988,141 -> 122,141 +625,621 -> 625,406 +24,710 -> 465,710 +417,468 -> 851,34 +365,285 -> 572,285 +217,164 -> 217,214 +943,439 -> 465,439 +80,102 -> 80,717 +869,19 -> 54,834 +399,480 -> 399,458 +644,826 -> 644,911 +651,189 -> 651,687 +671,946 -> 332,607 +531,417 -> 657,417 +847,350 -> 847,112 +315,733 -> 871,177 +749,118 -> 692,118 +55,616 -> 55,894 +570,307 -> 633,307 +12,964 -> 883,93 +84,299 -> 84,185 +49,187 -> 903,187 +592,40 -> 842,40 +639,381 -> 802,544 +59,61 -> 836,61 +968,51 -> 266,753 +883,373 -> 883,130 +612,45 -> 406,45 +206,698 -> 206,823 +385,685 -> 385,46 +656,338 -> 73,921 +256,794 -> 365,903 +671,247 -> 248,247 +722,509 -> 635,422 +460,783 -> 615,783 +946,980 -> 946,129 +343,780 -> 343,723 +218,371 -> 218,856 +363,809 -> 143,589 +434,739 -> 889,739 +75,71 -> 975,971 +57,253 -> 582,778 +976,237 -> 976,148 +386,866 -> 386,544 +901,797 -> 901,630 +976,706 -> 195,706 +264,420 -> 272,428 +693,72 -> 693,379 +888,832 -> 888,490 +363,900 -> 363,350 +25,312 -> 25,58 +292,307 -> 481,307 +715,393 -> 976,132 +641,450 -> 96,450 +650,38 -> 432,38 +339,97 -> 476,97 +916,24 -> 13,927 +933,934 -> 34,35 +971,367 -> 971,919 +726,310 -> 477,559 +12,984 -> 986,10 +318,531 -> 318,72 +604,979 -> 12,387 +890,39 -> 890,213 +944,954 -> 33,43 +507,830 -> 284,607 +724,111 -> 724,242 +425,912 -> 425,445 +371,903 -> 371,634 +415,314 -> 415,509 +884,849 -> 884,454 +726,647 -> 447,926 +588,463 -> 588,426 +807,453 -> 807,593 +32,449 -> 975,449 +593,757 -> 593,607 +521,850 -> 521,139 +843,478 -> 843,317 +408,834 -> 408,455 +65,241 -> 864,241 +532,138 -> 613,138 +477,239 -> 477,676 +92,400 -> 92,935 +268,104 -> 300,104 +942,20 -> 93,869 +294,134 -> 695,134 +748,477 -> 748,311 +581,879 -> 481,879 +292,57 -> 874,639 +829,787 -> 944,787 +130,780 -> 442,780 +754,435 -> 956,435 +306,659 -> 306,491 +252,612 -> 646,612 +846,949 -> 846,924 +197,888 -> 145,836 +156,790 -> 151,790 +903,305 -> 671,73 +195,79 -> 195,40 +781,67 -> 781,635 +742,743 -> 742,280 +297,42 -> 618,42 +237,151 -> 156,151 +851,930 -> 47,126 +425,368 -> 659,134 +57,890 -> 898,49 +86,62 -> 86,445 +133,499 -> 133,604 +202,567 -> 872,567 +749,578 -> 749,804 +379,379 -> 147,379 +510,474 -> 510,388 +184,115 -> 738,115 +904,613 -> 550,613 +755,649 -> 755,305 +461,306 -> 461,547 +469,124 -> 542,124 +736,218 -> 736,968 +307,662 -> 307,188 +360,970 -> 58,668 +36,267 -> 214,267 +980,330 -> 22,330 +222,972 -> 222,178 +846,774 -> 714,774 +798,837 -> 789,837 +567,258 -> 567,502 +325,582 -> 325,976 +138,386 -> 138,691 +326,878 -> 326,386 +790,276 -> 811,276 +517,522 -> 81,86 +493,567 -> 406,567 +522,370 -> 13,370 +31,697 -> 607,121 +297,524 -> 297,320 +790,681 -> 753,681 +90,961 -> 901,150 +262,46 -> 262,68 +18,26 -> 977,985 +782,381 -> 956,381 +353,740 -> 353,595 +32,448 -> 941,448 +405,254 -> 686,254 +853,57 -> 297,613 +555,209 -> 439,209 +765,679 -> 142,56 +175,903 -> 175,685 +693,653 -> 845,653 +394,108 -> 394,901 +351,108 -> 335,108 +841,83 -> 841,716 +525,608 -> 525,496 +874,32 -> 874,214 +354,760 -> 44,760 +249,330 -> 864,945 +553,377 -> 553,944 +903,374 -> 335,374 +387,34 -> 387,86 +380,331 -> 380,124 +618,520 -> 797,520 +718,169 -> 703,169 +355,184 -> 851,184 +582,570 -> 582,313 +312,952 -> 312,460 +269,70 -> 269,197 +701,907 -> 701,768 +645,417 -> 645,548 +931,532 -> 367,532 +497,361 -> 497,348 +563,642 -> 976,642 +376,504 -> 376,448 +538,945 -> 538,773 +594,886 -> 594,281 +879,558 -> 192,558 +985,68 -> 66,987 +599,420 -> 599,41 +296,318 -> 296,132 +330,619 -> 302,619 +245,137 -> 918,810 +823,798 -> 556,531 +64,201 -> 723,860 +955,365 -> 955,829 +372,976 -> 255,859 +804,962 -> 168,962 +200,442 -> 200,97 +965,964 -> 870,869 +534,158 -> 128,564 +380,739 -> 577,542 +740,391 -> 740,651 +167,177 -> 619,177 +215,449 -> 215,330 +494,612 -> 19,137 +458,634 -> 458,257 +884,817 -> 393,326 +407,291 -> 19,679 +627,173 -> 627,570 +53,93 -> 552,592 +809,363 -> 119,363 +588,418 -> 588,764 +807,131 -> 807,834 +616,61 -> 514,61 +553,642 -> 236,325 +959,553 -> 683,553 +36,754 -> 36,830 +533,293 -> 144,293 +950,780 -> 396,780 +949,878 -> 14,878 +453,180 -> 989,180 +22,46 -> 670,694 +479,206 -> 479,552 +22,53 -> 599,53 +254,964 -> 884,334 +578,813 -> 100,813 +945,247 -> 778,80 +312,978 -> 312,518 +882,225 -> 882,967 +581,683 -> 293,395 +107,540 -> 534,967 +382,946 -> 28,946 +864,743 -> 246,743 +538,558 -> 733,753 +811,436 -> 814,436 +982,33 -> 65,950 +785,829 -> 945,829 +322,471 -> 346,471 +904,528 -> 904,669 +231,471 -> 772,471 +773,490 -> 669,386 +867,482 -> 417,32 +352,856 -> 352,478 +723,355 -> 619,355 +667,922 -> 667,247 +642,386 -> 241,386 +594,35 -> 594,580 +916,723 -> 793,723 +73,774 -> 269,970 +43,273 -> 148,168 +744,637 -> 825,637 +98,30 -> 98,383 +130,277 -> 802,277 +167,122 -> 672,627 +871,866 -> 564,559 +923,475 -> 539,859 +422,714 -> 422,946 +667,950 -> 667,640 +758,181 -> 12,927 +129,927 -> 129,288 +485,661 -> 402,661 +114,573 -> 974,573 +674,779 -> 851,779 +977,184 -> 977,143 +229,937 -> 229,138 +520,887 -> 520,512 +918,329 -> 918,990 +732,41 -> 521,41 +399,245 -> 883,729 +824,618 -> 356,618 +215,218 -> 845,848 +704,34 -> 307,431 +124,166 -> 696,738 +692,749 -> 839,749 +790,637 -> 790,598 +697,396 -> 669,396 +419,140 -> 113,446 +426,738 -> 171,738 +489,494 -> 190,793 +320,301 -> 320,398 +275,809 -> 275,717 +537,703 -> 465,703 +536,450 -> 560,450 +153,927 -> 914,166 +246,692 -> 485,453 +26,179 -> 26,554 +487,678 -> 487,696 +807,719 -> 224,719 +605,920 -> 899,920 +112,262 -> 112,765 +752,898 -> 752,429 +861,103 -> 861,477 +628,505 -> 628,248 +556,293 -> 556,276 +826,682 -> 273,129 +685,324 -> 685,692 +544,410 -> 544,678 +796,633 -> 796,950 +753,843 -> 753,936 +817,40 -> 817,600 +137,941 -> 677,401 +563,457 -> 599,457 +251,644 -> 251,67 +170,792 -> 805,792 +171,486 -> 171,877 +337,481 -> 268,412 +43,158 -> 44,158 +148,610 -> 863,610 +332,765 -> 202,765 +307,637 -> 334,637 +557,380 -> 231,54 +858,76 -> 150,784 +477,329 -> 319,329 +306,608 -> 306,38 +245,42 -> 245,929 +15,786 -> 745,786 +946,321 -> 841,321 +837,281 -> 837,762 +847,391 -> 847,840 +304,52 -> 304,299 +938,122 -> 877,122 +214,347 -> 862,347 +494,540 -> 751,540 +184,29 -> 913,758 +904,12 -> 15,901 +573,23 -> 158,23 +926,603 -> 643,603 +105,506 -> 518,506 +551,917 -> 983,917 +708,33 -> 831,33 +347,173 -> 218,44 +933,175 -> 933,781 +902,556 -> 902,812 +556,485 -> 252,789 +823,807 -> 368,352 +217,744 -> 217,470 +795,455 -> 795,783 +170,944 -> 926,188 +55,655 -> 258,655 +158,57 -> 959,858 +714,823 -> 714,550 +238,18 -> 388,18 +980,985 -> 12,17 +360,596 -> 770,596 +846,684 -> 220,58 +552,107 -> 552,974 +228,552 -> 354,552 +421,41 -> 421,103 +674,475 -> 912,475 +455,626 -> 455,683 +952,841 -> 946,841 +920,792 -> 381,253 +786,918 -> 786,175 +889,859 -> 889,24 +178,604 -> 573,209 +71,621 -> 550,621 +38,36 -> 922,920 +104,690 -> 575,690 +252,883 -> 894,241 +627,107 -> 417,107 +768,913 -> 13,158 +708,337 -> 708,407 +156,941 -> 156,297 +814,653 -> 814,829 +234,920 -> 896,920 +652,170 -> 128,170 +765,825 -> 347,825 +681,901 -> 681,112 +410,301 -> 979,301 +462,681 -> 462,726 +117,957 -> 117,693 +479,948 -> 698,948 +839,965 -> 97,223 +102,189 -> 102,366 +93,798 -> 819,72 +27,336 -> 27,655 +161,635 -> 527,269 +140,272 -> 140,336 +884,915 -> 41,72 +575,563 -> 155,563 +387,601 -> 387,597 +355,186 -> 782,613 +866,435 -> 816,435 +96,161 -> 764,161 +971,29 -> 21,979 diff --git a/2021/05/line/line.go b/2021/05/line/line.go new file mode 100644 index 0000000..aedf455 --- /dev/null +++ b/2021/05/line/line.go @@ -0,0 +1,239 @@ +package line + +import ( + "bufio" + "bytes" + "fmt" + "io" + "strconv" +) + +type Line struct { + X1, Y1, X2, Y2 int +} + +// Token represents a lexical token. +type Token int + +const ( + // Special tokens + ILLEGAL Token = iota + EOF + WHITESPACE + + // Literals + INT // integers + + // Misc characters + COMMA // , + ARROW // -> +) + +func isWhitespace(ch rune) bool { + return ch == ' ' || ch == '\t' || ch == '\n' +} + +func isDigit(ch rune) bool { + return (ch >= '0' && ch <= '9') +} + +var eof = rune(0) + +// Scanner represents a lexical scanner. +type Scanner struct { + r *bufio.Reader +} + +// NewScanner returns a new instance of Scanner. +func NewScanner(r io.Reader) *Scanner { + return &Scanner{r: bufio.NewReader(r)} +} + +// read reads the next rune from the bufferred reader. +// Returns the rune(0) if an error occurs (or io.EOF is returned). +func (s *Scanner) read() rune { + ch, _, err := s.r.ReadRune() + if err != nil { + return eof + } + return ch +} + +// unread places the previously read rune back on the reader. +func (s *Scanner) unread() { _ = s.r.UnreadRune() } + +// Scan returns the next token and literal value. +func (s *Scanner) Scan() (tok Token, lit string) { + // Read the next rune. + ch := s.read() + + // If we see whitespace then consume all contiguous whitespace. + // If we see a digit then consume as an int. + if isWhitespace(ch) { + return s.scanWhitespace(ch) + } else if isDigit(ch) { + return s.scanInt(ch) + } + + // Otherwise read the individual character. + switch ch { + case eof: + return EOF, "" + case ',': + return COMMA, string(ch) + case '-': + return s.scanArrow(ch) + } + + return ILLEGAL, string(ch) +} + +// scanWhitespace consumes the current rune and all contiguous whitespace. +func (s *Scanner) scanWhitespace(read rune) (tok Token, lit string) { + // Create a buffer and read the current character into it. + var buf bytes.Buffer + buf.WriteRune(read) + + // Read every subsequent whitespace character into the buffer. + // Non-whitespace characters and EOF will cause the loop to exit. + for { + if ch := s.read(); ch == eof { + break + } else if !isWhitespace(ch) { + s.unread() + break + } else { + buf.WriteRune(ch) + } + } + + return WHITESPACE, buf.String() +} + +// scanInt consumes the current rune and all contiguous digit runes. +func (s *Scanner) scanInt(read rune) (tok Token, lit string) { + // Create a buffer and read the current character into it. + var buf bytes.Buffer + buf.WriteRune(read) + + // Read every subsequent ident character into the buffer. + // Non-ident characters and EOF will cause the loop to exit. + for { + if ch := s.read(); ch == eof { + break + } else if !isDigit(ch) { + s.unread() + break + } else { + _, _ = buf.WriteRune(ch) + } + } + + // Otherwise return as a regular identifier. + return INT, buf.String() +} + +func (s *Scanner) scanArrow(read rune) (tok Token, lit string) { + // Create a buffer and read the current character into it. + var buf bytes.Buffer + buf.WriteRune(read) + + // Read every subsequent ident character into the buffer. + // Non-ident characters and EOF will cause the loop to exit. + for { + if ch := s.read(); ch == eof { + break + } else if ch == '>' { + _, _ = buf.WriteRune(ch) + return ARROW, buf.String() + } else { + _, _ = buf.WriteRune(ch) + break + } + } + + // Otherwise return as a regular identifier. + return ILLEGAL, buf.String() +} + +// Parser represents a parser. +type Parser struct { + s *Scanner + buf struct { + tok Token // last read token + lit string // last read literal + n int // buffer size (max=1) + } +} + +// NewParser returns a new instance of Parser. +func NewParser(r io.Reader) *Parser { + return &Parser{s: NewScanner(r)} +} + +// scan returns the next token from the underlying scanner. +// If a token has been unscanned then read that instead. +func (p *Parser) scan() (tok Token, lit string) { + // If we have a token on the buffer, then return it. + if p.buf.n != 0 { + p.buf.n = 0 + return p.buf.tok, p.buf.lit + } + + // Otherwise read the next token from the scanner. + tok, lit = p.s.Scan() + + // Save it to the buffer in case we unscan later. + p.buf.tok, p.buf.lit = tok, lit + + return +} + +// unscan pushes the previously read token back onto the buffer. +func (p *Parser) unscan() { p.buf.n = 1 } + +// scanIgnoreWhitespace scans the next non-whitespace token. +func (p *Parser) scanIgnoreWhitespace() (tok Token, lit string) { + tok, lit = p.scan() + if tok == WHITESPACE { + tok, lit = p.scan() + } + return +} + +func (p *Parser) Parse() (*Line, error) { + l := &Line{} + if tok, lit := p.scanIgnoreWhitespace(); tok != INT { + return nil, fmt.Errorf("found %q, expected INT", lit) + } else { + l.X1, _ = strconv.Atoi(lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != COMMA { + return nil, fmt.Errorf("found %q, expected COMMA", lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != INT { + return nil, fmt.Errorf("found %q, expected INT", lit) + } else { + l.Y1, _ = strconv.Atoi(lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != ARROW { + return nil, fmt.Errorf("found %q, expected ARROW", lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != INT { + return nil, fmt.Errorf("found %q, expected INT", lit) + } else { + l.X2, _ = strconv.Atoi(lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != COMMA { + return nil, fmt.Errorf("found %q, expected COMMA", lit) + } + if tok, lit := p.scanIgnoreWhitespace(); tok != INT { + return nil, fmt.Errorf("found %q, expected INT", lit) + } else { + l.Y2, _ = strconv.Atoi(lit) + } + if tok, lit := p.scan(); tok != WHITESPACE { + return nil, fmt.Errorf("found %q, expected WHITESPACE", lit) + } + return l, nil +} diff --git a/2021/05/second.go b/2021/05/second.go new file mode 100644 index 0000000..c79025a --- /dev/null +++ b/2021/05/second.go @@ -0,0 +1,61 @@ +package main + +import ( + "bufio" + "fmt" + "os" + + "git.adyxax.org/aoc/2021/05/line" +) + +func main() { + matrix := make([][]int, 1000) + for i := 0; i < 1000; i++ { + matrix[i] = make([]int, 1000) + } + + parser := line.NewParser(bufio.NewReader(os.Stdin)) + for { + l, err := parser.Parse() + if err != nil { + break + } + if l.X1 == l.X2 { + if l.Y1 > l.Y2 { + l.Y1, l.Y2 = l.Y2, l.Y1 + } + for i := l.Y1; i <= l.Y2; i++ { + matrix[l.X1][i]++ + } + } else if l.Y1 == l.Y2 { + if l.X1 > l.X2 { + l.X1, l.X2 = l.X2, l.X1 + } + for i := l.X1; i <= l.X2; i++ { + matrix[i][l.Y1]++ + } + } else { + if l.X1 > l.X2 { + l.X1, l.X2, l.Y1, l.Y2 = l.X2, l.X1, l.Y2, l.Y1 + } + if l.Y1 < l.Y2 { + for i := 0; i <= l.X2-l.X1; i++ { + matrix[l.X1+i][l.Y1+i]++ + } + } else { + for i := 0; i <= l.X2-l.X1; i++ { + matrix[l.X1+i][l.Y1-i]++ + } + } + } + } + score := 0 + for i := 0; i < 1000; i++ { + for j := 0; j < 1000; j++ { + if matrix[i][j] >= 2 { + score++ + } + } + } + fmt.Println(score) +} diff --git a/2021/05/second_v2.go b/2021/05/second_v2.go new file mode 100644 index 0000000..7d02a19 --- /dev/null +++ b/2021/05/second_v2.go @@ -0,0 +1,58 @@ +package main + +import ( + "bufio" + "fmt" + "os" + + "git.adyxax.org/aoc/2021/05/line" +) + +func abs(a int) int { + if a < 0 { + return -a + } + return a +} + +func computeDelta(a, b int) int { + if a < b { + return 1 + } else if a > b { + return -1 + } + return 0 +} + +func main() { + matrix := make([][]int, 1000) + for i := 0; i < 1000; i++ { + matrix[i] = make([]int, 1000) + } + + parser := line.NewParser(bufio.NewReader(os.Stdin)) + for { + l, err := parser.Parse() + if err != nil { + break + } + length := abs(l.X2 - l.X1) + if length == 0 { + length = abs(l.Y2 - l.Y1) + } + dx := computeDelta(l.X1, l.X2) + dy := computeDelta(l.Y1, l.Y2) + for i := 0; i <= length; i++ { + matrix[l.X1+i*dx][l.Y1+i*dy]++ + } + } + score := 0 + for i := 0; i < 1000; i++ { + for j := 0; j < 1000; j++ { + if matrix[i][j] >= 2 { + score++ + } + } + } + fmt.Println(score) +} |