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

Answer 1

Red, 70 bytes

a: #""parse ask""[any[";"(a: a + 1)|"#"(prin a % 127 a: #"")| skip]]()

Try it locally in interpreter.

Answer 2

Golfscript, 39 29 25 24 bytes

'#'/);{';'/,(127%}%'':n+

Try it online!

Explanation:

'#'/);                   # Splits the input with '#' and discards the last part. 
                  %      # For each splited string, executes the preceding block: 
      {';'/,(127%}       # Splits the string with ';' and counts how many splits were made(which is equal to the number of ';'s). Then, mods that number with 127. 
                   '':n+ # Turns every calculated numbers into characters. 

Note: The final :n isn't needed if a trailing newline is allowed. Also, there was a bug in the 29-bytes version that it couldn't handle the input without '#'. Luckily, I could fix that bug and golf my code at the same time.

Answer 3

Rockstar, 208 168 152 148 bytes

listen to S
cut S
O's ""
N's 0
while S
roll S in C
let N be+C's ";"
if C's "#"
let M be N/127
turn down M
cast N-M*127 in N
let O be+N
N's 0


say O

Try it here (Code will need to be pasted in)

listen to S           :Read input string into variable S
cut S                 :Split into an array
O's ""                :Initialise O as an empty string
N's 0                 :Initialise N as 0
while S               :While S is not empty
roll S in C           :  Pop the first element of S into variable C
let N be+C's ";"      :  Increment N by C===";", implicitly casting from Boolean to integer
if C's "#"            :  If C==="#" then
let M be N/127        :    Initialise M as N/127
turn down M           :    Floor M
cast N-M*127 in N     :    Get the character at codepoint N-M*127 and assign it to N
let O be+N            :    Append N to O
N's 0                 :    Reset N to 0
                      :  End if
                      :End while loop
say O                 :Output O

---

If we need to be able to handle newlines in the input then we'll need this 169 byte version as each line in Rockstar is a separate input.

listen to S
O's ""
N's 0
while S
cut S
while S
roll S in C
let N be+C's ";"
if C's "#"
let M be N/127
turn down M
cast N-M*127 in N
let O be+N
N's 0


listen to S

say O

Answer 4

Alice, 22 bytes

I!?';-n+?h$'@u%?'#-n$O

Try it online!

Explanation

We keep on the stack only a single counter of how many ; we have encountered. When the stack is empty (e.g. at the start of the program) this is implicitly a 0.

I!?';-n+?h$'@u%?'#-n$O
I                      Push codepoint of next char from input
 !?                    store it on the tape and reload it right away
   ';-n+               add 1 to the counter if this char is a semicolon,
                       0 otherwise
        ?h$'           If the input char was -1 (EOF) execute the next command,
                       otherwise push its codepoint
            @          Terminate the program (or push 64)
             u         Set all bits up to the most significant as equal to 1
                       this turns 64 (1000000b) into 127 (1111111b)
              %        Compute modulo
               ?       reload the input char from the tape
                '#-n$O if it is a hash, pop the counter and print
                       the corresponding character
                       wrap back to the start of the line

A shorter, but non-terminating version of this program can be found here.

Answer 5

JS (ES6), 97 92 bytes

c=>(a=0,y="",c.split``.map(x=>x=="#"?(a%=127,y+=String.fromCharCode(a),a=0):x==";"?a++:0),y)

Tried to take a different approach than Shaggy's answer. Oh well.

Answer 6

Bash + coreutils, 46 39 bytes

tr -dc \;#|sed 'y/;/1/;s/#/.ZC7%P/g'|dc

Try it online!

Explanation

(Thanks Cows Quack for -7 bytes!)

The tr portion removes all extraneous characters (I could put this in the sed for exactly the same bytecount, but then it doesn't handle the linefeed character correctly, since sed leaves them in and dc only gets up to the first linefeed with ?)

sed takes the rest and builds a dc program:

Strings of ; become strings of 1 (a long literal)

# becomes .ZC7%P (if this follows a string of 1, the . is a decimal point for a no-op. But if it's at the beginning of the program, or following another #, it's a literal 0. Then it takes the length of the number, mods it, and Prints the corresponding ASCII.)

Answer 7

C, 65 64 60 bytes

(-2 thanks to ceilingcat)

c;f(char*s){for(c=0;*s;s++)c+=*s-35?*s==59:-putchar(c%127);}

Answer 8

asm2bf, 74 bytes

Try it online!

Golfed code:

@l
in r1
ceqr1,.;
cadr2,1
ceqr1,.#
cjz%d
modr2,127
outr2
clrr2
@d
jnzr1,%l

Commented code:

; Wrap everything in a loop.
@l
; Read a character from stdin.
    in  r1
; if r1 = ';', set the condition flag.
    ceq r1,.;
; if condition flag is set, add 1 to r2
; r2 is used as an accumulator.
    cad r2,1
; if r1 = '#', set the condition flag.
    ceq r1,.#
; if condition flag is not set, jump to d
    cjz %d
; display acc%127 and clear it.
    mod r2,127
    out r2
    clr r2
@d
; loop if didn't hit an EOF
    jnz r1, %l

Answer 9

Add++, 31 bytes

D,g,@,59C€=Bs127%
L^,"#"$t€gbUp

Try it online!

How it works

D,g,@,		; Define a helper function g that takes one argument, S
	59C	; Push a ';' character
	€=	; Over each character in S, is it ';'?
	Bs	; Sum
	127%	; Mod 127

L^,		; Define the main lambda with one argument, P
		; The ^ flag tells the output to convert numbers to code points and concatenate
	"#"	; Push a '#' character
	$t	; Split P on '#' characters
	€g	; Run g over each section
	bU	; Splat to the stack
	p	; Remove the last one

Answer 10

Vim, ⁵⁸ 68 bytes

@cairdcoinheringaahing and @kops pointed out a few issues, +10 bytes to fix them.

:%j
:s/[^;#]//g
:s/#/x/g
A <Esc>^qqcfx<C-r>=nr2char(len("<C-r>"<BS>")%127)
<Esc>l@qq@qD

Try it online!

Explanation:

:%j                                                # Delete all newlines
:s/[^;#]//g                                        # Delete all unnecessary characters
:s/#/x/g                                           # Replace all '#' with 'x'
A <Esc>^                                           # Append ' ' to the line
        qq                                         # Define macro q:
          cfx                                      #   Cut from here through next 'x'
             <C-r>=nr2char(len("<C-r>"<BS>")%127)  #   Convert (length_of_the_cut_string % 127) to a character
<Esc>l                                             #   Exit insert mode and move to next ';'
      @q                                           #   Call macro q
        q@q                                        # End the macro and run it
           D                                       # Delete any remaining characters

Answer 11

APL (Dyalog Unicode), 26 bytes

Anonymous tacit prefix function.

⎕UCS 127|1⊥¨';'='#'(⌽=⊂⊢)⌽

Try it online!

⌽ reverse the argument

'#'(…) apply the following tacit function with hash as left argument:

 ⊢ the right argument (the ;# code)

 ⊂ partitioned by…

 = the equality (where there are hashes)

 ⌽ reverse that

';'= equality to semicolon

1⊥¨ sum each (lit. evaluate each as unary)

127| division remainder when divided by 127

⎕UCS Convert to corresponding Unicode character

Answer 12

Subleq, 29 18 binary words

-11 from various changes explained below

-1 35 -1
1 35 12
0 28 9
35 35 0
28 -1 15
28 28 9

Changes

Old       New 
-1 25 3  | -1 35 -1 'combined first two line to read character and exit if null;
24 25 -1 |          'changed address to 35 so it could be used for the comparison to "#"
26 25 15 | 1 35 12  'changed addresses of data and comparison
27 28 12 | 0 28 9   'increment 28: using 0: instead of another address containing -1
25 25 0  | 35 35 0  'changed address from 25 to 35
28 -1 18 | 28 -1 15 'no changes except for address in the 3rd argument (which isn't used)
28 28 21 | 28 28 9  'changed to goto line that sets 35: = 0 to eliminate duplicate next line
25 25 0  |          'deleted
0 0 35 -1 0 |       'eliminated initialization data because the two non-zero items are
                    'elsewhere and 0 values (28: and 35:) do not need to be initialized

Original

-1 25 3     
24 25 -1    
26 25 15    
27 28 12    
25 25 0     
28 -1 18    
28 28 21    
25 25 0     
0 0 35 -1 0 

Explanation

-1 25 3     ' move next char in input to 25:
24 25 -1    ' 25: = 25: - 24:(0) if 25: <= 0 exit (if input empty exit)
26 25 15    ' 25: = 25: - 26:(35) if 25: <= 0 goto 15: (if input = "#" goto 15)
27 28 12    ' increment 28: by 1
25 25 0     ' 25: = 0 goto 0
28 -1 18    ' output 28:
28 28 21    ' 28: = 0
25 25 0     ' 25: = 0 goto  0
0 0 35 -1 0 ' values for 24: - 28:

Subleq emulator

Answer 13

C, 96 bytes

This is my first golf attempt!

i;a;main(z,s)char**s;{while(s[1][i])switch(s[1][i++]){case 35:putchar(a%127);a=-1;case 59:++a;}}

Answer 14

Befunge-98, 38 bytes

v+1$>';-!#;_
>~:;|-#';#:_@
^   >$' %,

Try it online!

Note that the input is terminated with a null byte and there is an unprintable (ASCII 127) on the third line after '

Answer 15

Perl 6, 49 bytes

{S:g/(<-[#]>*)(\#)?/{chr($0.comb(';')%127)x?$1}/}

Answer 16

C (gcc), 66 bytes

a;f(char*c){for(a=0;*c;a+=*c==59,a=*c++==35&&putchar(a%127)?0:a);}

Try it online!

Answer 17

QBIC, 48 66 57 bytes

[_l;||D=_sA,a,1|┘b=b-(D=@;`)~D=@#`|b=b%127?chr$(b)';`┘b=0

Explanation:

[    |           FOR
 _l;|              the length of the cmd line arg A$
 D=_sA,a,1|      Take the next character out of the string as D$
┘                Syntactic linebreak
b=b-(D=@;`)      If D$ == ";", this yields -1. Subtracting this from ACC reverses the sign
~D=@#`|          And if D$ == "#"
b=b%127          Do the Modulo-print thingy
?chr$(b)';`
┘b=0             And reset the acc

Answer 18

Go, 104 102 bytes

Yeeeeaaaaaaaaaah, Go.

import."fmt"
func f(c string){i:=0;for _,r:=range c{if';'==r{i++};if'#'==r{Print(string(i%127));i=0}}}

Try it online!

Answer 19

Pyth, 16 bytes

smC%/d\;127Pcw\#

Try it!

explanation

smC%/d\;127Pcw\#
            cw\#    ## split the input on '#'
           P        ## remove the last element (everything after the last #)
 m                  ## map over this list of strings (variable: d)
    /d\;            ## count the semicolons
   %    127         ## modulo 127
  C                 ## the character with that number
s                   ## concat the list of characters

imperative version I did for fun: J0FHwIqH\;=+J1)IqH\#pC%J127=J0

Answer 20

C#, 110 108 103 101 98 bytes

-2 bytes by removing braces, where unnecessary

-5 bytes by removing else, from else if

-2 bytes, thanks to TheLethalCoder

-3 bytes, thanks to Andrew Piliser

a=>{var b=0;var d="";foreach(var c in a){if(c==59)b++;if(c==35){d+=(char)(b%127);b=0;}}return d;};

Anonymous function, returns the output.

Answer 21

Chip, 179 bytes

 HGFEDCB
,\\///\/A
`--v~.
   |z^.
 ,\#xZ<
a^xx/'`.
 ,\#xZ~<
b^xx/' |
 ,\#xZ~<
c^xx/' |
 ,\#xZ~<
d^xx/' |
 ,\#xZ~<
e^xx/' |
 ,\#xZ~<
f^xx/' |
 ,\#xZ~'
g^x-/'HGFEDCB
S÷^---\\/\\\/A

^{(UTF8, so ÷ is \xc3\xb7)}

Try it online!

The upper block with A-H and the slashes is detecting the semicolon character, and the similar lower block is detecting the hash. If other bogus characters needn't be handled, the whole thing would be somewhere around 133 bytes.

The middle block does the following:

Z's are the registers, one for each of the seven bits.

The half-adders # allow for incrementing by 1 in case of a semicolon. If not a semicolon, increment by 0.

If we get a hash, send the current register values to a-g, which outputs the desired character, and then reset the values to zero with the switches \.

If the registers are 0b1111110 (126), as determined by the right two columns, the next increment results in zero due to the switches /.

Answer 22

R, 66 bytes

intToUtf8(nchar(gsub("[^;]","",el(strsplit(scan(,""),"#"))))%%127)

Test:

> intToUtf8(nchar(gsub("[^;]","",el(strsplit(scan(,""),"#"))))%%127)
1: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;... <truncated>
2: 
Read 1 item
[1] "Hello, World!"

Answer 23

Common Lisp, 89 bytes

(do((a 0))(())(case(read-char)(#\;(incf a))(#\#(princ(code-char(mod a 127)))(setf a 0))))

Try it online!.

This is an actual interpreter.

Answer 24

Cubix, 53 bytes

#..Wc.@n.!0i?\?;u...'u;.'\.U;.\w;;U.;).;'%o;c;.!;.U;

Contains one non-printable character, DEL, which is ASCII 127. If the accumulator is 0 and an ignored character is read in, an additional 0 is added to the stack so this runs the risk of stack overflow.

Try it online! and Watch it online

Cubified:

      # . .
      W c .
      @ n .
! 0 i ? \ ? ; u . . . '
u ; . ' \ . U ; . \ w ;
; U . ; ) . ; '   % o ;
      c ; .
      ! ; .
      U ; .

Answer 25

JavaScript (ES6), 91 85 bytes

ETH beat me to the punch with a variation on the Japt solution I was working on (that'll learn me to check the answers first!) so here's the JS solution I was using as the basis for it:

s=>s.split`#`.slice(0,-1).map(x=>String.fromCharCode(--x.split`;`.length%127)).join``

• Saved 6 bytes thanks to [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions

---

Try it

f=
s=>s.split`#`.slice(0,-1).map(x=>String.fromCharCode(--x.split`;`.length%127)).join``
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value=";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")

<input id=i><pre id=o>

Answer 26

SNOBOL4 (CSNOBOL4), 182 167 bytes

	S =INPUT
R	S NOTANY(';#') =	:S(R)
K	K =
T	S LEN(1) . C REM . S	:F(O)
	K =IDENT(C,';') K + 1	:S(T)
	&ALPHABET LEN(REMDR(K,127)) LEN(1) . A
	Y =Y A	:(K)
O	OUTPUT =Y
END

Try it online!

Due to size limitations in this implementation of SNOBOL, it can only read in lines of 1024 characters at a time, discarding the rest. So it only manages to print Hello, Worl. Ah well.

	S =INPUT				;*read input
R	S NOTANY(';#') =Y	:S(R)		;*recursively remove non ;# characters
K	K =0					;*counter
T	EQ(SIZE(S)) :S(O)			;*if string is empty, goto output
	S LEN(1) . C REM . S			;*set C to the first char, the REMainder to S
	K =IDENT(C,';') K + 1	:S(T)		;*if C is identical to ';', increment C and goto T
	&ALPHABET LEN(REMDR(K,127)) LEN(1) . A	;*get the K % 127th character, set it to A
	Y =Y A	:(K)				;*append A to Y
O	OUTPUT =Y				;*output Y
END

Answer 27

Haskell, 66 bytes

f s|(a,_:b)<-span(/='#')s=toEnum(mod(sum[1|';'<-a])127):f b|1<3=[]

Try it online!

• f takes a string s as input and looks for the first # with (a,_:b)<-span(/='#')s, which splits s in the part a before the first # and b everything after.
• sum[1|';'<-a] counts the number of ; in a which is converted into the corresponding character by toEnum after taking it modulo 127.
• f b recursively processes the rest of the string.
• The pattern match (a,_:b)<-span(/='#')s fails if no # exists anymore, in which case in the second pattern guard 1<3=[] the empty list is returned.

Answer 28

PowerShell, 67 65

-join$(switch("$input"|% t*y){';'{$a++}'#'{[char]($a%127);$a=0}})

Fairly straightforward with not many surprising twists.

• 2018-09-06: Shorter way of converting the string to a character array.

Answer 29

Shakespeare Programming Language, 447 439 404 bytes

,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ajax:Open mind.Ford:Am I as big as the sum ofa pig twice twice the sum ofa pig a big big big big cat?If soyou be the sum ofyou a cat.Be you worse the sum ofa pig twice the cube ofa big big cat?If notyou zero.Am I as big as the sum ofa cat twice the sum ofa cat a big big big big cat?If soSpeak thy.If soYou zero.Am I nicer zero?If soLet usAct I.

Try it online!

-35 bytes thanks to Joe King!

Answer 30

F# (.NET Core), 71 bytes

Seq.fold(fun a->function|';'->a+1|'#'->printf"%c"(a%127|>char);0|_->a)0

Try it online!