From 74bc598c44eded1e881339d55ade3991e29bd10f Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Tue, 1 Dec 2020 01:16:23 -0800 Subject: 7316 --- apps/advent2020/1a.mu | 13 +++ apps/advent2020/1b.mu | 13 +++ html/apps/advent2020/1a.mu.html | 181 ++++++++++++++++++---------------- html/apps/advent2020/1b.mu.html | 213 +++++++++++++++++++++------------------- 4 files changed, 236 insertions(+), 184 deletions(-) diff --git a/apps/advent2020/1a.mu b/apps/advent2020/1a.mu index 45bb5bd2..05aa58bf 100644 --- a/apps/advent2020/1a.mu +++ b/apps/advent2020/1a.mu @@ -1,3 +1,16 @@ +# https://adventofcode.com/2020/day/1 +# +# To run (on Linux): +# $ git clone https://github.com/akkartik/mu +# $ cd mu +# $ ./translate_mu apps/advent2020/1a.mu +# $ ./a.elf < input +# found +# 1353 667 +# 902451 +# +# You'll need to register to download the 'input' file for yourself. + fn main -> _/ebx: int { # data structure var numbers-storage: (array int 0x100) # 256 ints diff --git a/apps/advent2020/1b.mu b/apps/advent2020/1b.mu index 14119172..aa2d21f1 100644 --- a/apps/advent2020/1b.mu +++ b/apps/advent2020/1b.mu @@ -1,3 +1,16 @@ +# https://adventofcode.com/2020/day/1 +# +# To run (on Linux): +# $ git clone https://github.com/akkartik/mu +# $ cd mu +# $ ./translate_mu apps/advent2020/1b.mu +# $ ./a.elf < input +# found +# 143 407 1470 +# 85555470 +# +# You'll need to register to download the 'input' file for yourself. + fn main -> _/ebx: int { # data structure var numbers-storage: (array int 0x100) # 256 ints diff --git a/html/apps/advent2020/1a.mu.html b/html/apps/advent2020/1a.mu.html index 537d752c..64bf44e5 100644 --- a/html/apps/advent2020/1a.mu.html +++ b/html/apps/advent2020/1a.mu.html @@ -57,90 +57,103 @@ if ('onhashchange' in window) { https://github.com/akkartik/mu/blob/master/apps/advent2020/1a.mu

- 1 fn main -> _/ebx: int {
- 2   # data structure
- 3   var numbers-storage: (array int 0x100)  # 256 ints
- 4   var numbers/esi: (addr array int) <- address numbers-storage
- 5   var numbers-index/ecx: int <- copy 0
- 6   # phase 1: parse each line from stdin and add it to numbers
- 7   {
- 8     var line-storage: (stream byte 0x100)  # 256 bytes
- 9     var line/edx: (addr stream byte) <- address line-storage
-10     {
-11 #?       print-string 0, "== iter\n"
-12       # read line from stdin
-13       clear-stream line
-14       read-line-from-real-keyboard line
-15       # if line is empty (not even a newline), quit
-16       var done?/eax: boolean <- stream-empty? line
-17       compare done?, 0  # false
-18       break-if-!=
-19 #?       print-stream-to-real-screen line
-20       # convert line to int and append it to numbers
-21       var n/eax: int <- parse-decimal-int-from-stream line
-22 #?       print-int32-decimal 0, n
-23 #?       print-string 0, "\n"
-24       var dest/ebx: (addr int) <- index numbers, numbers-index
-25       copy-to *dest, n
-26       numbers-index <- increment
-27 #?       print-string 0, "== "
-28 #?       print-int32-decimal 0, numbers-index
-29 #?       print-string 0, "\n"
-30       loop
-31     }
-32   }
-33   # phase 2: for each number in the array, check if 2020-it is in the rest of
-34   # the array
-35   var i/eax: int <- copy 0
-36   {
-37     compare i, numbers-index
-38     break-if->=
-39     var src/ebx: (addr int) <- index numbers, i
-40 #?     print-int32-decimal 0, *src
-41 #?     print-string 0, "\n"
-42     var target/ecx: int <- copy 0x7e4  # 2020
-43     target <- subtract *src
-44     {
-45       var found?/eax: boolean <- find-after numbers, i, target
-46       compare found?, 0  # false
-47       break-if-=
-48       print-string 0, "found\n"
-49       print-int32-decimal 0, *src
-50       print-string 0, " "
-51       print-int32-decimal 0, target
-52       print-string 0, "\n"
-53       target <- multiply *src
-54       print-int32-decimal 0, target
-55       print-string 0, "\n"
-56       return 0  # success
-57     }
-58     i <- increment
-59     loop
-60   }
-61   return 1  # not found
-62 }
-63 
-64 fn find-after _numbers: (addr array int), start: int, _target: int -> _/eax: boolean {
-65   var numbers/esi: (addr array int) <- copy _numbers
-66   var target/edi: int <- copy _target
-67   var len/ecx: int <- length numbers
-68   var i/eax: int <- copy start
-69   i <- increment
-70   {
-71     compare i, len
-72     break-if->=
-73     var src/edx: (addr int) <- index numbers, i
-74     # if *src == target, return true
-75     compare *src, target
-76     {
-77       break-if-!=
-78       return 1  # true
-79     }
-80     i <- increment
-81     loop
-82   }
-83   return 0  # false
-84 }
+ 1 # https://adventofcode.com/2020/day/1
+ 2 #
+ 3 # To run (on Linux):
+ 4 #   $ git clone https://github.com/akkartik/mu
+ 5 #   $ cd mu
+ 6 #   $ ./translate_mu apps/advent2020/1a.mu
+ 7 #   $ ./a.elf < input
+ 8 #   found
+ 9 #   1353 667
+10 #   902451
+11 #
+12 # You'll need to register to download the 'input' file for yourself.
+13 
+14 fn main -> _/ebx: int {
+15   # data structure
+16   var numbers-storage: (array int 0x100)  # 256 ints
+17   var numbers/esi: (addr array int) <- address numbers-storage
+18   var numbers-index/ecx: int <- copy 0
+19   # phase 1: parse each line from stdin and add it to numbers
+20   {
+21     var line-storage: (stream byte 0x100)  # 256 bytes
+22     var line/edx: (addr stream byte) <- address line-storage
+23     {
+24 #?       print-string 0, "== iter\n"
+25       # read line from stdin
+26       clear-stream line
+27       read-line-from-real-keyboard line
+28       # if line is empty (not even a newline), quit
+29       var done?/eax: boolean <- stream-empty? line
+30       compare done?, 0  # false
+31       break-if-!=
+32 #?       print-stream-to-real-screen line
+33       # convert line to int and append it to numbers
+34       var n/eax: int <- parse-decimal-int-from-stream line
+35 #?       print-int32-decimal 0, n
+36 #?       print-string 0, "\n"
+37       var dest/ebx: (addr int) <- index numbers, numbers-index
+38       copy-to *dest, n
+39       numbers-index <- increment
+40 #?       print-string 0, "== "
+41 #?       print-int32-decimal 0, numbers-index
+42 #?       print-string 0, "\n"
+43       loop
+44     }
+45   }
+46   # phase 2: for each number in the array, check if 2020-it is in the rest of
+47   # the array
+48   var i/eax: int <- copy 0
+49   {
+50     compare i, numbers-index
+51     break-if->=
+52     var src/ebx: (addr int) <- index numbers, i
+53 #?     print-int32-decimal 0, *src
+54 #?     print-string 0, "\n"
+55     var target/ecx: int <- copy 0x7e4  # 2020
+56     target <- subtract *src
+57     {
+58       var found?/eax: boolean <- find-after numbers, i, target
+59       compare found?, 0  # false
+60       break-if-=
+61       print-string 0, "found\n"
+62       print-int32-decimal 0, *src
+63       print-string 0, " "
+64       print-int32-decimal 0, target
+65       print-string 0, "\n"
+66       target <- multiply *src
+67       print-int32-decimal 0, target
+68       print-string 0, "\n"
+69       return 0  # success
+70     }
+71     i <- increment
+72     loop
+73   }
+74   return 1  # not found
+75 }
+76 
+77 fn find-after _numbers: (addr array int), start: int, _target: int -> _/eax: boolean {
+78   var numbers/esi: (addr array int) <- copy _numbers
+79   var target/edi: int <- copy _target
+80   var len/ecx: int <- length numbers
+81   var i/eax: int <- copy start
+82   i <- increment
+83   {
+84     compare i, len
+85     break-if->=
+86     var src/edx: (addr int) <- index numbers, i
+87     # if *src == target, return true
+88     compare *src, target
+89     {
+90       break-if-!=
+91       return 1  # true
+92     }
+93     i <- increment
+94     loop
+95   }
+96   return 0  # false
+97 }

diff --git a/html/apps/advent2020/1b.mu.html b/html/apps/advent2020/1b.mu.html index 69b2346d..c7ac42b1 100644 --- a/html/apps/advent2020/1b.mu.html +++ b/html/apps/advent2020/1b.mu.html @@ -57,106 +57,119 @@ if ('onhashchange' in window) { https://github.com/akkartik/mu/blob/master/apps/advent2020/1b.mu

-  1 fn main -> _/ebx: int {
-  2   # data structure
-  3   var numbers-storage: (array int 0x100)  # 256 ints
-  4   var numbers/esi: (addr array int) <- address numbers-storage
-  5   var numbers-index/ecx: int <- copy 0
-  6   # phase 1: parse each line from stdin and add it to numbers
-  7   {
-  8     var line-storage: (stream byte 0x100)  # 256 bytes
-  9     var line/edx: (addr stream byte) <- address line-storage
- 10     {
- 11 #?       print-string 0, "== iter\n"
- 12       # read line from stdin
- 13       clear-stream line
- 14       read-line-from-real-keyboard line
- 15       # if line is empty (not even a newline), quit
- 16       var done?/eax: boolean <- stream-empty? line
- 17       compare done?, 0  # false
- 18       break-if-!=
- 19 #?       print-stream-to-real-screen line
- 20       # convert line to int and append it to numbers
- 21       var n/eax: int <- parse-decimal-int-from-stream line
- 22 #?       print-int32-decimal 0, n
- 23 #?       print-string 0, "\n"
- 24       var dest/ebx: (addr int) <- index numbers, numbers-index
- 25       copy-to *dest, n
- 26       numbers-index <- increment
- 27 #?       print-string 0, "== "
- 28 #?       print-int32-decimal 0, numbers-index
- 29 #?       print-string 0, "\n"
- 30       loop
- 31     }
- 32   }
- 33   # phase 2: for every pair of distinct numbers, check if the rest of the
- 34   # array has 2020-it
- 35   var i/edi: int <- copy 0
- 36   {
- 37     compare i, numbers-index
- 38     break-if->=
- 39     # for j from i+1 to end
- 40     var j/edx: int <- copy i
- 41     j <- increment
- 42     {
- 43       compare j, numbers-index
- 44       break-if->=
- 45       {
- 46         compare i, j
- 47         break-if-=
- 48         var target/ebx: int <- copy 0x7e4  # 2020
- 49         var src/edi: (addr int) <- index numbers, i
- 50         target <- subtract *src
- 51         var src2/ecx: (addr int) <- index numbers, j
- 52         target <- subtract *src2
- 53         {
- 54           var found?/eax: boolean <- find-after numbers, j, target
- 55           compare found?, 0  # false
- 56           break-if-=
- 57           print-string 0, "found\n"
- 58           print-int32-decimal 0, *src
- 59           print-string 0, " "
- 60           print-int32-decimal 0, *src2
- 61           print-string 0, " "
- 62           print-int32-decimal 0, target
- 63           print-string 0, "\n"
- 64           target <- multiply *src
- 65           target <- multiply *src2
- 66           print-int32-decimal 0, target
- 67           print-string 0, "\n"
- 68           return 0  # success
- 69         }
- 70       }
- 71       j <- increment
- 72       loop
- 73     }
- 74     i <- increment
- 75     loop
- 76   }
- 77   return 1  # not found
- 78 }
- 79 
- 80 fn find-after _numbers: (addr array int), start: int, _target: int -> _/eax: boolean {
- 81   var numbers/esi: (addr array int) <- copy _numbers
- 82   var target/edi: int <- copy _target
- 83   var len/ecx: int <- length numbers
- 84   var i/eax: int <- copy start
- 85   i <- increment
- 86   {
- 87     compare i, len
- 88     break-if->=
- 89     var src/edx: (addr int) <- index numbers, i
- 90     # if *src == target, return true
- 91     compare *src, target
- 92     {
- 93       break-if-!=
- 94       return 1  # true
- 95     }
- 96     i <- increment
- 97     loop
- 98   }
- 99   return 0  # false
-100 }
+  1 # https://adventofcode.com/2020/day/1
+  2 #
+  3 # To run (on Linux):
+  4 #   $ git clone https://github.com/akkartik/mu
+  5 #   $ cd mu
+  6 #   $ ./translate_mu apps/advent2020/1b.mu
+  7 #   $ ./a.elf < input
+  8 #   found
+  9 #   143 407 1470
+ 10 #   85555470
+ 11 #
+ 12 # You'll need to register to download the 'input' file for yourself.
+ 13 
+ 14 fn main -> _/ebx: int {
+ 15   # data structure
+ 16   var numbers-storage: (array int 0x100)  # 256 ints
+ 17   var numbers/esi: (addr array int) <- address numbers-storage
+ 18   var numbers-index/ecx: int <- copy 0
+ 19   # phase 1: parse each line from stdin and add it to numbers
+ 20   {
+ 21     var line-storage: (stream byte 0x100)  # 256 bytes
+ 22     var line/edx: (addr stream byte) <- address line-storage
+ 23     {
+ 24 #?       print-string 0, "== iter\n"
+ 25       # read line from stdin
+ 26       clear-stream line
+ 27       read-line-from-real-keyboard line
+ 28       # if line is empty (not even a newline), quit
+ 29       var done?/eax: boolean <- stream-empty? line
+ 30       compare done?, 0  # false
+ 31       break-if-!=
+ 32 #?       print-stream-to-real-screen line
+ 33       # convert line to int and append it to numbers
+ 34       var n/eax: int <- parse-decimal-int-from-stream line
+ 35 #?       print-int32-decimal 0, n
+ 36 #?       print-string 0, "\n"
+ 37       var dest/ebx: (addr int) <- index numbers, numbers-index
+ 38       copy-to *dest, n
+ 39       numbers-index <- increment
+ 40 #?       print-string 0, "== "
+ 41 #?       print-int32-decimal 0, numbers-index
+ 42 #?       print-string 0, "\n"
+ 43       loop
+ 44     }
+ 45   }
+ 46   # phase 2: for every pair of distinct numbers, check if the rest of the
+ 47   # array has 2020-it
+ 48   var i/edi: int <- copy 0
+ 49   {
+ 50     compare i, numbers-index
+ 51     break-if->=
+ 52     # for j from i+1 to end
+ 53     var j/edx: int <- copy i
+ 54     j <- increment
+ 55     {
+ 56       compare j, numbers-index
+ 57       break-if->=
+ 58       {
+ 59         compare i, j
+ 60         break-if-=
+ 61         var target/ebx: int <- copy 0x7e4  # 2020
+ 62         var src/edi: (addr int) <- index numbers, i
+ 63         target <- subtract *src
+ 64         var src2/ecx: (addr int) <- index numbers, j
+ 65         target <- subtract *src2
+ 66         {
+ 67           var found?/eax: boolean <- find-after numbers, j, target
+ 68           compare found?, 0  # false
+ 69           break-if-=
+ 70           print-string 0, "found\n"
+ 71           print-int32-decimal 0, *src
+ 72           print-string 0, " "
+ 73           print-int32-decimal 0, *src2
+ 74           print-string 0, " "
+ 75           print-int32-decimal 0, target
+ 76           print-string 0, "\n"
+ 77           target <- multiply *src
+ 78           target <- multiply *src2
+ 79           print-int32-decimal 0, target
+ 80           print-string 0, "\n"
+ 81           return 0  # success
+ 82         }
+ 83       }
+ 84       j <- increment
+ 85       loop
+ 86     }
+ 87     i <- increment
+ 88     loop
+ 89   }
+ 90   return 1  # not found
+ 91 }
+ 92 
+ 93 fn find-after _numbers: (addr array int), start: int, _target: int -> _/eax: boolean {
+ 94   var numbers/esi: (addr array int) <- copy _numbers
+ 95   var target/edi: int <- copy _target
+ 96   var len/ecx: int <- length numbers
+ 97   var i/eax: int <- copy start
+ 98   i <- increment
+ 99   {
+100     compare i, len
+101     break-if->=
+102     var src/edx: (addr int) <- index numbers, i
+103     # if *src == target, return true
+104     compare *src, target
+105     {
+106       break-if-!=
+107       return 1  # true
+108     }
+109     i <- increment
+110     loop
+111   }
+112   return 0  # false
+113 }

-- cgit 1.4.1-2-gfad0