Make a ;# interpreter

Question

I recently created a new language called ;# (pronounced "Semicolon Hash") which only has two commands:

; add one to the accumulator

# modulo the accumulator by 127, convert to ASCII character and output without a newline. After this, reset the accumulator to 0. Yes, 127 is correct.

Any other character is ignored. It has no effect on the accumulator and should do nothing.

Your task is to create an interpreter for this powerful language!

It should be either a full program or a function that will take a ;# program as input and produce the correct output.

Examples

Output: Hello, World!
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: ;#
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Output: 2 d����{���
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o

Output: Fizz Buzz output
Program: link below

Output: !
Program: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Fizz Buzz up to 100

Is it acceptable if an interpreter doesn't terminate its execution at the end of the input but instead keeps looping indefinitely without producing extra output? — Leo, May 22, 2017 at 9:26
The second example makes me wonder about a program to encode a program to produce an output... recursive compilation! — frarugi87, May 22, 2017 at 9:29

recursive · Accepted Answer · 2018-10-11 22:25:41Z

2

Stax, 12 bytes

î╟°♪ƒ▌○«*G<╠

Run and debug it

answered Oct 11, 2018 at 22:25

recursive

10.4k19 silver badges36 bronze badges

Add a comment |

Popov · Accepted Answer · 2020-01-23 10:26:09Z

APL, 41 bytes/chars

{⎕AV[⍋⎕NXLATE 0][127|≢¨⌽⊂⍨⌽2=⍵(⊢⍳∩)';#']}

Explanation:

vector of ASCII characters

{⎕AV[⍋⎕NXLATE 0]                          }

select elements from that vector

{                 [                         ]}

keep only characters from the stream belonging to the set ';#'

{                 [               ⍵(  ∩)';#']}

find position of each character of the stream in the set ';#'

{                 [               ⍵(⊢⍳ )';#']}

0 where there's ';' and 1 where there's '#'

{                 [             2=          ]}

reverse the stream, partition beginning at every 1, reverse back; note that trailing ';'s get discarded this way

{                 [       ⌽⊂⍨⌽            ]}

length of each partition modulo 127

{                 [127|≢¨                   ]}

\$\begingroup\$ tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v//Ud/… \$\endgroup\$
– Popov
Jan 23, 2020 at 10:26 — Popov, Jan 23, 2020 at 10:26

mrFoobles · Accepted Answer · 2020-01-23 11:11:11Z

2

Haskell, 70 bytes

(-7 thanks to BWO)

n#(o:p)|o==';'=(n+1)#p|o=='#'=toEnum(mod n 127):0#p|1>0=n#p
_#p=p
(0#)

Try it online!

edited Jan 23, 2020 at 11:11

user85052

answered Aug 11, 2018 at 15:11

mrFoobles

413 bronze badges

\$\begingroup\$ Huh, I always thought you had to use a space to call a function. \$\endgroup\$
– mrFoobles
Aug 12, 2018 at 16:00
2

\$\begingroup\$ n#(o:p)|o=='#'=toEnum(mod n 127):0#p|o/=';'=n#p|w<-n+1=w#p works for 69 bytes. \$\endgroup\$
– ovs
Aug 12, 2018 at 17:22

Add a comment |

Yaroslav Gaponov · Accepted Answer · 2020-05-16 21:28:11Z

2

JavaScript (V8), 77 bytes

p=>([...p].map(e=>e==';'?i++:(s+=String.fromCharCode(i%127),i=0),i=0,s=''),s)

Try it online!

JavaScript (V8), 77 bytes

p=>([...p].map(e=>i+=e==';'?1:(s+=String.fromCharCode(i%127),-i),i=0,s=''),s)

Try it online!

edited May 16, 2020 at 21:28

answered May 16, 2020 at 21:18

Yaroslav Gaponov

4312 silver badges8 bronze badges

Add a comment |

lyxal · Accepted Answer · 2020-05-17 01:11:56Z

2

Keg, `-ir`, `-lp`, 18 bytes

0&(¦\;⑹|\#⑻\ø%,0⑾™

Try it online!

answered May 17, 2020 at 1:11

lyxal

32.3k2 gold badges56 silver badges138 bronze badges

Add a comment |

Wasif · Accepted Answer · 2021-04-10 04:13:53Z

2

VBScript, 109 bytes

a=0
For i=0 to len(s)
x=Mid(s,i,1)
if x=";" then a=a+1
if x="#" then wscript.stdout.write chr(a mod 127)
next

answered Apr 10, 2021 at 4:13

Wasif

12.3k1 gold badge16 silver badges46 bronze badges

Add a comment |

Pedro Maimere · Accepted Answer · 2021-05-07 14:12:54Z

2

GNU AWK, 43 bytes

BEGIN{FS=";";RS="#"}RT{printf"%c",NF-1%127}

Try it online!

A different approach to this answer, golfing 14 bytes. Works only on GNU AWK (gawk).

BEGIN{FS=";";RS="#"}    ; are fields' and # are records' separators

RT{                     This skips the last ; sequence without a #
   printf"%c",NF-1%127  Prints the number of fields (i.e., semicolons) minus 1,
  }                     converted to ASCII, of course

edited May 7, 2021 at 14:12

answered May 7, 2021 at 1:17

Pedro Maimere

9101 gold badge5 silver badges10 bronze badges

1

\$\begingroup\$ As RT is GNU Awk extension, there isn't much reason anyway in testing with other Awk implementation. \$\endgroup\$
– manatwork
May 7, 2021 at 1:28
\$\begingroup\$ @manatwork yep, you are right. Thanks for pointing that out. \$\endgroup\$
– Pedro Maimere
May 7, 2021 at 14:12

Add a comment |

Yelp · Accepted Answer · 2021-05-10 12:34:45Z

2

C (gcc), 72 67 bytes

-5 thanks to @ceilingcat

a;main(i){for(;i=getchar()-10;a=i-49?i-25?a:0*putchar(a%127):a+1);}

Try it online!

Took longer than I should have for this one.

edited May 10, 2021 at 12:34

answered Apr 30, 2021 at 21:24

Yelp

3111 silver badge3 bronze badges

Add a comment |

bluswimmer · Accepted Answer · 2023-05-19 00:00:34Z

2

Lua, 95 bytes

s=...n=0load(s:gsub('[^#;]',''):gsub('.',{[';']='n=n+1',['#']='io.write(s.char(n%127))n=0'}))()

Try it online!

Removes all non # or ; characters, replaces the remaining characters with their respective Lua instructions, and then runs it.

edited May 19 at 0:00

answered May 18 at 23:34

bluswimmer

8211 silver badge5 bronze badges

Add a comment |

MD XF · Accepted Answer · 2017-05-21 23:21:06Z

C, 74 72 70 bytes

a;f(char*s){for(;*s;s++){if(*s==59)a++;if(*s==35)putchar(a%127),a=0;}}

Test cases:

Output: Hello, World!
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");

Output: ;#
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");

Output: 2d{ (unprintable characters here; should have 4 `\000` bytes between the `d` and the `{` and 3 after the `{`)
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o");

Output: !
f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#");

MD XF · Accepted Answer · 2017-05-22 00:04:25Z

1

shortC, 51 bytes

a;f(C*s){O;*s;s++){F*s==59)a++;F*s==35)Pa%127),a=0;

answered May 22, 2017 at 0:04

MD XF

13.8k4 gold badges64 silver badges103 bronze badges

Add a comment |

Leaky Nun · Accepted Answer · 2017-05-22 05:09:52Z

1

J, 29 bytes

[:u:127|[:+/"1[:';'&=;.1'#',]

Try it online!

answered May 22, 2017 at 5:09

Leaky Nun

49.6k6 gold badges107 silver badges281 bronze badges

\$\begingroup\$ The third test case outputs 2┴d{I, but I think it might be because of J's alphabet a. \$\endgroup\$
– miles
May 23, 2017 at 2:33

Add a comment |

VolAnd · Accepted Answer · 2017-05-22 06:14:40Z

1

C, 56 54 bytes

a;f(char*s){a+=*s-35?*s==59:-putch(a%127);*s&&f(s+1);}

Solution is based on Dennis's one ("C (gcc), 58 bytes"), but with elimination of two characters a=

Two more symbols can be taken off with substitution putchar with putch

edited May 22, 2017 at 6:14

answered May 22, 2017 at 6:08

VolAnd

2963 silver badges8 bronze badges

1

\$\begingroup\$ a= is required to make the function reusable; since a is global, it has to be reset to 0. \$\endgroup\$
– Dennis
May 23, 2017 at 4:08
\$\begingroup\$ putch is not standard C. \$\endgroup\$
– MD XF
May 23, 2017 at 21:19

Add a comment |

Leaky Nun · Accepted Answer · 2017-05-22 06:26:08Z

1

Cheddar, 57 bytes

@.split("#").head(-1).map(s->@"(s.count(";")%127)).join()

Try it online!

answered May 22, 2017 at 6:26

Leaky Nun

49.6k6 gold badges107 silver badges281 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

Aceto, 38 31 bytes

The program reads and processes one character at a time, so it will work with infinite ;# programs. Run with -F if you want immediate results (because buffering), but it works without it if the program is long enough.

  Ox%-12
  =_cpF7
d'#'O
,;=|xIO

, reads a character. We duplicate it and compare it with ;. If it's equal, we mirror to the right side (=|), drop (x) the duplicate, Increment the value on the stack (implicitly zero), and go back to the Origin.

If it's not equal, we compare the copy with #. If that is equal, we mirror upwards (=_; somewhere in empty space above, but the next non-nop we read will be the 2). We push a 2 and a 7, compute 2^7 (F), and substract 1 (1-). We then do a modulo operation (%) convert it to a character, print it (without a newline) and go back to the Origin.

If it's none of those characters, we drop the value on the stack (x) and go back to the Origin.

manatwork · Accepted Answer · 2017-05-22 08:28:56Z

1

Gema, 63 characters

\A=@set{a;0}
\;=@incr{a}
\#=@int-char{@mod{$a;127}}@set{a;0}
?=

Sample run:

bash-4.4$ gema '\A=@set{a;0};\;=@incr{a};\#=@int-char{@mod{$a;127}}@set{a;0};?=' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013

answered May 22, 2017 at 8:28

manatwork

20k5 gold badges46 silver badges78 bronze badges

\$\begingroup\$ I do so love Gema answers. \$\endgroup\$
– Jordan
May 24, 2017 at 2:01

Add a comment |

Jörg Hülsermann · Accepted Answer · 2017-05-22 14:04:59Z

1

PHP, 61 Bytes

for(;~$c=a^$argn[$i++];)$n+=$c^r?$c==Z:-$n*print chr($n%127);

Try it online!

PHP, 68 Bytes

for(;a&$c=$argn[$i++];)$c!=";"?$c!="#"?:$n=1-print chr($n%127):++$n;

Try it online!

edited May 22, 2017 at 14:04

answered May 21, 2017 at 22:43

Jörg Hülsermann

13.3k3 gold badges14 silver badges36 bronze badges

2

\$\begingroup\$ Doesn't work with 0. Fixed and slightly golfed: for(;~$c=a^$argn[$i++];)$c^r?$n+=$c==Z:print~$n=~chr($n%127);. \$\endgroup\$
– user63956
May 22, 2017 at 6:10
\$\begingroup\$ @user63956 It tooks a long time to understand how this works. Nice Thank You \$\endgroup\$
– Jörg Hülsermann
May 22, 2017 at 10:21
1

\$\begingroup\$ Yields warnings A non-numeric value encountered in PHP 7.1. Use $n+=$c^r?$c==Z:-$n*print chr($n%127); (same length) to fix. \$\endgroup\$
– Titus
May 22, 2017 at 13:47
\$\begingroup\$ @Titus Done Thank You \$\endgroup\$
– Jörg Hülsermann
May 22, 2017 at 14:05

Add a comment |

NikoNyrh · Accepted Answer · 2017-05-22 15:31:40Z

1

Clojure, 71 bytes

#(for[i(re-seq #"[^#]*#"%)](print(char(mod(count(filter #{\;}i))127))))

Splits into chunks by regex, counts how many ;s there are in each chunk.

answered May 22, 2017 at 15:31

NikoNyrh

2,6319 silver badges8 bronze badges

Add a comment |

Mayube · Accepted Answer · 2017-05-22 15:41:57Z

Haxe, 145 136 bytes

function(s){var a=0;for(i in 0...s.length){var c=s.charAt(i);if(c==';')a++;else if(c=='#'){Sys.print(String.fromCharCode(a%127));a=0;}}}

-9 bytes thanks to Haxe's "inline function" (lambda) feature

Don't think I've ever seen an answer given in Haxe before, probably because it's not very golfy, and not that well known.

The code's really quite self-explanatory, here's the un-golfed version:

function(s) {
    var a=0;
    for(i in 0...s.length) {
        var c=s.charAt(i);
        if(c==';') {
            a++;
        }
        else if(c=='#') {
            Sys.print(String.fromCharCode(a%127));
            a=0;
        }
    }
}

Community · Accepted Answer · 2020-06-17 09:04:33Z

1

Rust, 109 bytes

Rust was not created for golfing...

fn f(s:&str){let mut a=0u8;for c in s.chars(){if c==';'{a+=1;}if c=='#'{a%=127;print!("{}",a as char);a=0;}}}

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered May 22, 2017 at 16:22

Peter Lenkefi

1,64910 silver badges21 bronze badges

Add a comment |

manatwork · Accepted Answer · 2017-05-23 14:20:45Z

1

jq, 54 characters

(49 characters code + 5 characters command line options)

[scan(".*?#")|gsub("[^;]";"")|length%127]|implode

Sample run:

bash-4.4$ jq -Rrj '[scan(".*?#")|gsub("[^;]";"")|length%127]|implode' < '2d{.;#' | od -tad1
0000000    2  etb    d  nul  nul  nul  nul    {  nul  nul  nul
          50   23  100    0    0    0    0  123    0    0    0
0000013

On-line test

answered May 23, 2017 at 14:20

manatwork

20k5 gold badges46 silver badges78 bronze badges

Add a comment |

user61980user61980 · Accepted Answer · 2017-05-24 00:21:37Z

Mathematica, 81 bytes

StringReplace[a=0;#,{";":>(a++;""),"#":>FromCharacterCode@Mod[a,a=0;127],_:>""}]&

Pure function expecting a string argument.

Explanation

The basic evaluation procedure (it can be more complicated) for an expression in Mathematica is to evaluate the head of the epxression, then evaluate each of its arguments in order, then apply any definitions, then evaluate the entire expression again until nothing changes.

So first we evaluate StringReplace (no-op). The first argument is a=0;#, which sets the accumulator a to 0 and returns the first argument (denoted #) to the function. The second argument is a list of string replacement rules, which are applied in order starting at the beginning of the string.

If we encounter the substring ";", we replace it with (a++;""). Since we used :> instead of ->, this replacement expression is only evaluated whenever we actually find a match for ";". It (post-)increments a and returns the empty string, so finding a match for ";" effectively increments the accumulator and deletes the semicolon. In the case of a match, we move to the next position in the string, otherwise we check the next rule in the list.

If we encounter the substring "#", we replace it with FromCharacterCode@Mod[a,a=0;127]. FromCharacterCode does what you expect, but Mod[a,a=0;127] can be tricky if you don't understand Mathematica's evaluation procedure. We evaluate Mod (no-op), then evaluate the first argument a to get the value of the accumulator. When we evaluate the second argument a=0;127, we reset the accumulator to 0 and return 127. Thus we end up with Mod[<a>,127], where <a> is whatever the value of a was before the expression started evaluating. The only way I can think of to get this to work by resetting the accumulator after calculating the modulus without introducing additional variables is something like "#":>Reap[Sow[FromCharacterCode[Mod[a,127]]];a=0][[2,1,1]]. Introducing another variable I could do something like "#":>(b=a;a=0;FromCharacterCode[b~Mod~127]).

If we reach the last replacement rule, we replace any single character _ with the empty string "".

\$\begingroup\$ No builtin this time? \$\endgroup\$
– caird coinheringaahin g ♦
May 24, 2017 at 6:18 — caird coinheringaahin g, May 24, 2017 at 6:18

tomsmeding · Accepted Answer · 2017-05-24 07:07:20Z

1

Rip, 33 chars

0gDiW[D';EI[Pi0]'#EI[27pdMo0]gDi]

Got around to testing this, and this works with the given examples.

edited May 24, 2017 at 7:07

answered May 22, 2017 at 21:46

tomsmeding

2,04416 silver badges20 bronze badges

Add a comment |

hyper-neutrino · Accepted Answer · 2017-08-15 20:49:30Z

1

Proton, 66 bytes

a=>''.join(map(len+((%)&127)+chr,a.rstrip(';').split('\#'))[to-1])

Try it online!

answered Aug 15, 2017 at 20:49

hyper-neutrino♦

41.3k5 gold badges65 silver badges221 bronze badges

\$\begingroup\$ This is the one of the first challenges you found to answer? :P \$\endgroup\$
– totallyhuman
Aug 17, 2017 at 19:45
\$\begingroup\$ @totallyhuman hey why not :P \$\endgroup\$
– hyper-neutrino ♦
Aug 17, 2017 at 19:57

Add a comment |

brhfl · Accepted Answer · 2017-12-15 22:14:33Z

Bash + coreutils + dc, 93 bytes

tr ';#' '69'|tr -dc '69'|dc -e '?0sa[10~rdZ1<P]dsPx[6=Ala127%P0sa]sR[la1+saq]sA[lRxz0<M]dsMx'

Try it online!

First time submitting a multi-utility answer, so if I botched that let me know - but just treating it as bash seems the least generous in terms of byte count anyway.

I thought this would be fun to do in dc, but obviously dc does not really care for strings, so the first thing to do was use tr to translate it into a new dialect, 69 which is just ;# only... well, sixes and nines. After doing that, we also use tr to delete everything that isn't a 6 or a 9 so that we don't have to account for errant characters in dc.

With a giant number input into dc, we can make an interpreter. 0sa clears the accumulator, a. [10~rdZ1<P]dsPx uses the divide-returning-both-quotient-and-remainder command, ~ to break our big number into a stack full of individual commands. Jump to the end, the main macro [lRxz0<M]dsMx executes macro R until the stack is empty. Macro R is [6=Ala127%P0sa]sR, which tests if the top-of-stack is a 6 and runs macro A if so. Macro A has a quit command in it, which essentially makes the rest of R an else statement. This does the mod 127, Print ASCII, and reset accumulator a to zero operations. Meanwhile, macro A is just a simple increment operation for the accumulator: [la1+saq]sA.

You can try just the dc portion online!

JoshM · Accepted Answer · 2018-08-11 00:23:59Z

1

Coconut, 59 bytes

t->''.join(map(x->chr(x.count(';')%127),t.split('#')[:-1]))

Try it online!

answered Aug 11, 2018 at 0:23

JoshM

4473 silver badges12 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

brainfuck, 201 bytes

+[>>,[>+>+<<-]>>>----[>+<----]>----[-<<->>]+<<[>>-<<[-]]>>[-<<<[-]<<+[->>+>+<<<]>>>>>--[<+>--]<[-<->]<[[-]<[->>+<<]>][-]<[-]>>[-<<<<+>>>>]>]<<<[>--[>--<+++++++]>-[<+>-]<[-<->]<[[-]-]+[[-]<<.[-]>>]]<<<]

Try it online! As a note, this will take 60 seconds to finish because the program will never halt, so it will stop after the Tio 60 second timeout.

How it works

This works differently than the given algorithm. Instead of using mod it just wraps to 0 after counting 127 semicolons.

+[                              'while true
    >>,                         'read input
    [>+>+<<-]                   
    >>>----[>+<----]>----       
    [-<<->>]+<<[>>-<<[-]]>>     'if(input == ';')
    [                       
        -<<<[-]<<+              'increment counter 
        [->>+>+<<<]
        >>>>>--[<+>--]<
        [-<->]  
        <[                      'if(counter == 127) counter = 0
            [-]<[->>+<<]>
        ]
        [-]<[-]                 
        >>[-<<<<+>>>>]>
    ]
    <<<[                        'if(input != 59)
        >--[>--<+++++++]>-      
        [<+>-]          
        <[-<->]     
        <[                      'if(input == '#')
            [-]-                
        ]
        +[                      
            [-]                 
            <<.[-]>>            'print counter as ascii and clear tape
        ]
    ]
    <<<         
]

Rustem B. · Accepted Answer · 2018-09-04 12:37:30Z

1

Julia 1.0, 90 62 bytes

i(s)=print.(Char.(count.(==(';'),split(s,"#")[1:end-1]).%127))

Try it online!

edited Sep 4, 2018 at 12:37

answered Sep 1, 2018 at 21:19

Rustem B.

513 bronze badges

Add a comment |

mazzy · Accepted Answer · 2018-09-06 12:42:47Z

Powershell, 67 bytes

C# 7572 + 18 = 9390 Bytes

using System.Linq;
s=>string.Join("",s.Split('#').Select(p=>(char)(p.Count(c=>c==59)%127)))

-3 Bytes thanks to @Charlie

Ungolfed full program with test cases

using System.Linq;

class P
{
    static void Main()
    {
        System.Func<string, string> f =
            s => string.Join("",                  //6. Combine results with empty string as separator
                s.Split('#')                      //1. Split the input by #
                    .Select(                      //2. For each part
                        p => (char)(              //5. Convert to character
                            p.Count(c => c == 59) //3. Count of all ;
                            % 127)                //4. Mod 127
                    ));

        System.Console.WriteLine(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"));
        System.Console.WriteLine(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"));
        System.Console.WriteLine(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o"));
        System.Console.WriteLine(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"));
    }    
}

I've just come up with this same answer by myself, only to see that you posted it before. You can save 3 bytes using Count instead of Sum. Note that the last ; does not count. — Charlie, Sep 6, 2018 at 9:13
s.Split('#') gives an extra letter in the second example. Note that last substring has not # at end. — mazzy, Sep 6, 2018 at 13:12
I made the same solution and then I found yours. You can save 6 bytes if you won't join the string, but create an array of chars with ToArray(). — Jirka Picek, Jan 23, 2020 at 10:11

Make a ;# interpreter

Examples

139 Answers 139

Stax, 12 bytes

APL, 41 bytes/chars

Haskell, 70 bytes

JavaScript (V8), 77 bytes

JavaScript (V8), 77 bytes

Keg, -ir, -lp, 18 bytes

VBScript, 109 bytes

GNU AWK, 43 bytes

C (gcc), 72 67 bytes

Lua, 95 bytes

C, 74 72 70 bytes

shortC, 51 bytes

J, 29 bytes

C, 56 54 bytes

Cheddar, 57 bytes

Aceto, 38 31 bytes

Gema, 63 characters

PHP, 61 Bytes

PHP, 68 Bytes

Clojure, 71 bytes

Haxe, 145 136 bytes

Rust, 109 bytes

jq, 54 characters

Mathematica, 81 bytes

Explanation

Rip, 33 chars

Proton, 66 bytes

Bash + coreutils + dc, 93 bytes

Coconut, 59 bytes

brainfuck, 201 bytes

How it works

Julia 1.0, 90 62 bytes

Powershell, 67 bytes

C# 7572 + 18 = 9390 Bytes

Ungolfed full program with test cases

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged code-golfinterpreter or ask your own question.

Linked

Related

Hot Network Questions

Keg, `-ir`, `-lp`, 18 bytes

Not the answer you're looking for? Browse other questions tagged
code-golf
interpreter
or ask your own question.