Add $p=";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"; to actually enjoy this tasty script. ($p is the input variable)

PowerShell, 98 bytes

[char[]]$p|%{if($_-eq';'){$o++}elseif($_-eq'#'){Write-Host -NoNewLine ([char]($o%127));[int]$o=0}} 

Try it online!

JavaScript (ES6), 71 Bytes

p=>([...p].map(v=>v==";"?i++:b+=String.fromCharCode(i,i=0),i=0,b=""),b) 

This can probably be golfed, but I think the concept passing extra arguments to functions is one of the reasons why JavaScript is one of the more interesting languages to golf in.

java, 86 95 bytes

this is a lambda expression assignable to a Consumer<String>

s->{for(String t:s.split("#|[^#]*\\Z"))System.out.print((char)(t.split(";",-1).length-1%127));} 

Explanation:

• split the input using # as the delimiter and ignore everything after the last match
• for each substring, count the number of ;'s and output the count as a char

Ly, 44 bytes

0<i[[";"=[pp>1+<2$]p"#"=[pp>(127)%o0<2$]]i]; 

Try it online!

This submission does not work with the latest version of the Ly interpreter.
A version that does work, for 43 bytes:

ir[[";"=[pp>1+<2$]p"#"=[pp>(127)%o<2$]pp]]; 

Try it online!

MaybeLater, 99 bytes

s=read()wheni is*{if((S=s[i])!=u){if(S==";")a++if(S=="#"){writechra%127a=0}when0secondpass i++}}i=0 

Ungolfed & Commented

input_string=read() // Read the input from STDIN when index is *{ // When index updates... if((this_char=input_string[index])!=undefined){ // If it's not undefined (So we've iterated onto another entry)... if(this_char==";") // If this character is a ; accumulator++ // Increment the accumulator (Which defaults to 0) if(this_char=="#"){ // If it's # however write(chr(accumulator%127)) // Write the character value of the accumlator % 127, and reset the accumulator. accumulator=0 } when 0 second pass // When 0 seconds pass, to prevent stack overflow, increment the index. Which loops. index++ } } // Start off the index. index = 0 

Try it online!

Pyth, 18 bytes

My misunderstanding works anyways... hmm?

Jcw"#"VtlJpC/@JN"; 

Explanation:

Jcw"#" Split the input by "#" and store it in J VtlJ For the length of J - 1... p Print without newline... C/@JN"; Character from charcode (length of ';'s at the Nth position in J) 

Try it online!

Clojure, 69 bytes

#(reduce(fn[a c](case c\;(inc a)\#(do(print(char(mod a 127)))0)a))0%) 

A simple reduction over the code. Alters the accumulator accordingly for each character that's read.

(defn interpret [code] (reduce (fn [acc chr] (case chr \; (inc acc) \# (do (print (char (mod acc 127))) ; Print the char, 0) ; then reset the accumulator acc)) ; An ignored character; don't do anything 0 ; The initial accumulator code)) 

Kotlin, 105 bytes

Submission

fun d(l:String):String=l.split("#").map{(it.length%127).toChar()}.joinToString("").removeSuffix("\u0000") 

TryItOnline

Link

Explanation

• It splits the string into ; chunks
• Then it changes them into characters
• It joins them into a string
• Then it removes the null byte from the end

Ahead, 26 bytes

r o%721$< ~>j@i:'#=n';=+~ 

Try it online!

Noether, 42 bytes

I~sL(si/~c{";"=}{!a}c{"#"=}{a127MBP0~a}!i) 

Try it online!

Clojure, 65 bytes

(fn[c](map #(char(mod((frequencies %)\;)127))(re-seq #"[^#]+"c))) 

Splits the code by '#', counts the number of ';', and turns the number (mod 127) into its ascii value

Try it online!

Swift, 117 bytes

func f(i:String){var a=0;for c in i{if c==";" {a+=1}else{print(Character(UnicodeScalar(a%127)!),terminator:"");a=0}}} 

Expanded out:

func f(i: String) { var a = 0 for c in i { if c==";" { a += 1 } else { print(Character(UnicodeScalar(a%127)!),terminator:"") a=0 } } } 

Run it online

Pascal (FPC), 134 133 122 bytes

var c:char;a:word;begin repeat read(c);if c='#'then begin write(chr(a mod 127));a:=0 end;if c=';'then Inc(a)until eof end. 

Try it online!

Assumes non-empty input.

Haskell, 73 bytes

f[]a="" f(c:s)a|c==';'=f s(a+1)|c=='#'=toEnum(a`mod`127):f s 0|0<1=f s a 

Forth (gforth), 77 bytes

: f 0 tuck do over i + c@ '# - ?dup if 24 = - else 127 mod emit 0 then loop ; 

Try it online!

Code Explanation

: f \ start a new word definition 0 tuck \ put 0 on the top of the stack and stick a copy behind the second stack item do \ begin a counted loop from 0 to string length - 1 over i + \ get the address of the next character c@ '# - \ get the next character's ascii value and subtract ascii # (35) ?dup \ if result is not 0, duplicate if \ if result is true (not 0) 24 = - \ check if result = 24, and subtract -1 from accumulator if it is (0 otherwise) else \ else (if result was equal to 35) 127 mod \ get accumulator mod 127 emit 0 \ output accumulator and replace with 0 then \ end if loop \ end loop ; \ end word definition 

VBA (Excel) 103 Bytes

Function a(b) For Each c In Split(b,"#") a=a &Chr((Len(c)-Len(Replace(c,";","")))Mod 127) Next End Function 

Un-golfed With Comments:

Function fromSemiHash(myString) 'SemiHash is how I think it should be pronounced :D 'For each string in myString split by hashes For Each littleString In Split(myString,"#") 'Append the char from((the length of everything minus length of everything but ;'s) mod 127) toSemiHash = toSemiHash & Chr((Len(littleString) - Len( Replace( littleString , ";" ,""))) Mod 127) Next littleString End Function 

PHP, 84 bytes

First attempt 144 133 bytes

I was able to remove 11 by using all ternary conditions, this required adding some ( ) to cement in the operation order. PHP has a weird thing with that.

function f($s,$i,$c,$r){echo''==($a=$s[$i])?$r:('#'==$a?f($s,++$i,0,$r.=chr($c%127)):(';'==$a?f($s,++$i,++$c,$r):f($s,++$i,$c,$r)));} 

Test it like this:

error_reporting(0); $strings =[';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#', ';;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#', ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o', ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#' ]; foreach($strings as $s){ f($s,0,0,''); echo "\n"; } function f($s,$i,$c,$r){echo''==($a=$s[$i])?$r:('#'==$a?f($s,++$i,0,$r.=chr($c%127)):(';'==$a?f($s,++$i,++$c,$r):f($s,++$i,$c,$r)));} 

Output

Hello, World! ;# 2d����{��� ! 

Sandbox

Notes/Explanation

This is a recursive function. Most of the space savings comes from using ternary conditionals,short variable names and grouping some of the setters into the aforementioned conditions. It takes 4 input arguments and sets 1 local variable:

Arguments/Variables

$s - the ;# string to parse.

$i - the iterator, to keep track of the current position in the string, starts at 0.

$c - the register keeps the count of ; prior to #, starts at 0.

$r - the results, the output of the parser, starts as an empty string.

Expanded version:

function f($s,$i,$c,$r){ if( '' == ( $a = $s[$i] ) ){ echo $r; }else{ if( '#' == $a ){ f( $s, ++$i, 0, $r.=chr( $c % 127 )); }else{ if( ';' == $a ){ f( $s, ++$i, ++$c, $r); }else{ f( $s, ++$i, $c, $r); } } } } 

Update attempt 2, 77 84 Bytes (PHP < 7)

Had to add aomw to fix a bug with it having an empty element in the array at the end.

 function f($s){foreach(split('#',$s)as$a)echo!$a?'':chr(substr_count($a,';')%127);} 

You can change split to explode to make it compatible with PHP7, but add 2 bytes. Test it the same as above, produces the same output.

Sandbox2

Expanded version:

function f($s){ $array = split('#',$s) foreach($array as $a){ if(!$a){ echo ''; }else{ $count = substr_count($a,';'); echo chr($count%127); } } } 

It's shorter, simpler, and should be faster. The key to this one was substr_count which I already know about but didn't think of right away, as I was a bit rushed for time on the first attempt. After thinking about it some, I came up with this and almost cut it in half. Not bad!

Basically it splits it on the # and then counts the occurrences of ; in each array item and outputs the character that generates.

Cheers!

Kotlin, 77 bytes

{Regex(";*#").findAll(it).fold(""){a,v->a+((v.value.length-1)%127).toChar()}} 

Try it online!

Whitespace, 119 bytes

[S S S N _Push_0][N S S N _Create_Label_LOOP][S N S _Duplicate_top][S N S _Duplicate_top][T N T S _Read_STDIN_as_character][T T T _Retrieve][S N S _Duplicate_input][S S S T S S S T T N _Push_35][T S S T _Subtract][N T S S N _If_0_Jump_to_Label_PRINT_CHAR][S S S T T T S T T N _Push_59][T S S T _Subtract][N T S T N _If_0_Jump_to_Label_INCREASE][N S N N _Jump_to_Label_LOOP][N S S S N _Create_Label_PRINT_CHAR][S N N _Discard_top][S S S T T T T T T T N _Push_127][T S T T _Modulo][T N S S _Print_as_character][S S S N _Push_0][N S N N _Jump_to_Label_LOOP][N S S T N _Create_Label_INCREASE][S S S T N _Push_1][T S S S _Add][N S N N _Jump_to_Label_LOOP] 

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Pseudo-code:

Integer i = 0 Label LOOP: Character c = STDIN as character If(c == '#'): Jump to Label PRINT_CHAR If(c == ';'): Jump to Label INCREASE Jump to Label LOOP Label PRINT_CHAR: i = i modulo-127 Print i as character to STDOUT i = 0 Jump to Label LOOP Label INCREASE: i = i + 1 Jump to Label LOOP 

Rutger, 170 bytes

a=0; f=Each[Array[$Argv]]; f=f[@c]; f=f[{p=Add[$a];s=Equal[";"];h=Equal["#"];a=p[s[$c]]];i=If[{h[$c];}];i=i[{m=Modulo[$a];a=0;PrintEnd[Char[m[127]]];}];Do[$i];}]; Do[$f]; 

Try it online!

Man, Rutger is verbose

How it works

accumulator = 0; each = Each[Array[$Argv]]; // Read a string from argv, cast to list and create an each loop each = each[@char]; // Iterate over each character each = each[{ 	plus = Add[$accumulator]; // Partial function to add a value to the accumulator 	semicolon = Equal[";"]; // Comparison function to ";" 	hash = Equal["#"]; // Comparison function to "#" 	accumulator = plus[semicolon[$char]]; // Add 1 to $accumulator if $char is a semicolon 	if = If[{ 		hash[$char]; // If $char is a hash 	}]; 	if = if[{ 		mod = Modulo[$accumulator]; // Partial function to mod the accumulator 		accumulator = 0; // Reset the accumulator to 0 		PrintEnd[Char[mod[127]]]; // Print, without a trailing newline, the accumulator, mod 127, converted to char 	}]; 	Do[$if]; // Run the if statement }]; Do[$each]; // Run the each loop 

Thunno 2 J, 13 bytes

'#/ṫı';c127%C 

Attempt This Online!

Port of Adnan's 05AB1E answer.

Explanation

'#/ṫı';c127%C # Implicit input '#/ # Split on "#" ṫ # Remove the last item ı # Map over the list: ';c # Count of ";"s 127% # Mod 127 C # Convert to character # Implicit output, joined