Recientemente creé un nuevo lenguaje llamado ;#(pronunciado "Semicolon Hash") que solo tiene dos comandos:

; agregue uno al acumulador

#module el acumulador por 127, convierta a carácter ASCII y salga sin una nueva línea. Después de esto, restablezca el acumulador a 0. Sí, 127 es correcto.

Cualquier otro personaje es ignorado. No tiene ningún efecto sobre el acumulador y no debe hacer nada.

¡Su tarea es crear un intérprete para este poderoso lenguaje!

Debe ser un programa completo o una función que tome un ;#programa como entrada y produzca la salida correcta.

Ejemplos

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

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

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

Output: Fizz Buzz output
Program: link below

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

Fizz Buzz hasta 100

Python 3 , 69 68 bytes

-1 byte gracias a @WheatWizard

i=0
for c in input():
 i+=c==';'
 if'#'==c:print(end=chr(i%127));i=0

Pruébalo en línea!

JavaScript (ES6), 76 82 80 bytes

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

Manifestación

let f =

s=>s.replace(/./g,c=>c=='#'?String.fromCharCode(a%(a=127)):(a+=(c==';'),''),a=0)

console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;hafh;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;f;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;###ffh#h#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ffea;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#au###h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;h;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;o")))
console.log(JSON.stringify(f(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))

Versión recursiva, 82 77 bytes

Guardado 5 bytes gracias a Neil

Es probable que este bloquee para entradas grandes como el ejemplo de Fizz Buzz.

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""

Retina , 336 63 67 65 66 62 59 bytes

T`;#-ÿ`¯_
;{127}|;+$

(^|¯)
¯
+T`-~`_-`[^¯]
T\`¯`

Pruébalo en línea!

Versión legible con sintaxis de escape hipotética :

T`;#\x01-ÿ`\x01¯_
;{127}|;+$

(^|¯)\x01\x01
¯\x02
+T`\x01-~`_\x03-\x7f`[^\x01¯]\x01
T\`¯`

No imprime bytes NUL, porque TIO no los permite en el código fuente. También imprime una nueva línea adicional al final, pero supongo que no puede hacer otra cosa. Nueva línea final suprimida gracias a @Leo .

-273 (!) Bytes gracias a @ETHproductions .

-2 bytes gracias a @ovs .

-3 bytes gracias a @Neil . Echa un vistazo a su maravillosa solución de 34 bytes .

Java 8, 100 bytes

s->{int i=0;for(byte b:s.getBytes()){if(b==59)i++;if(b==35){System.out.print((char)(i%127));i=0;}}};

Pruébalo en línea!

Japt , 18 bytes

®è'; %# d}'# ë ¯J

Hay un \ x7f char no imprimible después %#. ¡Pruébelo en línea!

Cómo funciona

®   è'; %#   d}'# ë ¯  J
mZ{Zè'; %127 d}'# ë s0,J
                         // Implicit: operate on input string
mZ{           }'#        // Split the input at '#'s, and map each item Z to
   Zè';                  //   the number of semicolons in Z,
        %127             //   mod 127,
             d           //   turned into a character.
m              '#        // Rejoin the list on '#'. At this point the Hello, World! example
                         // would be "H#e#l#l#o#,# #W#o#r#l#d#!#" plus an null byte.
                  ë      // Take every other character. Eliminates the unnecessary '#'s. 
                    ¯J   // Slice off the trailing byte (could be anything if there are
                         // semicolons after the last '#').
                         // Implicit: output result of last expression

Python , 65 bytes

Este es un golf de esta respuesta anterior.

lambda t:''.join(chr(x.count(';')%127)for x in t.split('#')[:-1])

Pruébalo en línea! Python2

Pruébalo en línea! Python3

Explicación

Esta es una respuesta bastante sencilla. Determinamos cuántos ;s hay entre cada uno #e imprimimos el chrmod 127. Lo único que puede ser un poco extraño es el [:-1]. Necesitamos eliminar el último grupo porque no habrá más #después.

Por ejemplo

;;#;;;;#;;;;;#;;;

Se dividirá en

[';;',';;;;',';;;;;',';;;']

Pero no queremos el último ;;;porque no hay #después para imprimir el valor.

> <> , 35 bytes

>i:0(?;:'#'=?v';'=?0
^   [0o%'␡'l~<

Pruébalo en línea! Reemplace ␡con 0x7F, ^?o "eliminar".

Bucle principal

>i:0(?;:'#'=?v      
^            <

Esto toma un carácter de input ( i), comprueba si es menor que cero, es decir, EOF ( :0() y finaliza el programa si es ( ?;). De lo contrario, verifique si la entrada es igual a #( :'#'=). Si es así, bájese y reinicie el bucle ( ?v... ^ ... <).

Contra lógica

              ';'=?0
              

Compruebe si la entrada es igual a ;( ';'=). Si es así, presione a 0. De lo contrario, no hagas nada. Esto reinicia el bucle principal.

Lógica de impresión

>       '#'=?v      
^   [0o%'␡'l~<

Cuando el carácter de entrada es #, retire la entrada de la pila ( ~), obtenga el número de miembros en la pila ( l), presione 127 ( '␡') y tome el módulo ( %). Luego, escríbalo como un carácter ( o) e inicie una nueva pila ( [0). Esto "pone a cero" el contador. Luego, el bucle se reinicia.

Python 3, 69 bytes

Mejorado, gracias a @Wheat Wizard, @Uriel

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))

Röda , 44 39 38 bytes

5 bytes guardados gracias a @fergusq

{(_/`#`)|{|d|d~="[^;]",""chr #d%127}_}

Pruébalo en línea!

Función anónima que toma la entrada de la secuencia.

Si otros personajes no tienen que ser ignorados, obtengo esto:

Röda , 20 bytes

{(_/`#`)|chr #_%127}

Ruby, 41 35 34 caracteres

( 40 34 código de 33 caracteres + opción de línea de comando de 1 carácter)

gsub(/.*?#/){putc$&.count ?;%127}

Gracias a:

• Jordan por sugerir usar putcpara no necesitar conversión explícita con .chr(6 caracteres)
• Kirill L. por encontrar el paréntesis innecesario (1 personaje)

Ejecución de muestra:

bash-4.4$ ruby -ne 'gsub(/.*?#/){putc$&.count ?;%127}' < '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

Pruébalo en línea!

05AB1E , 16 15 14 bytes

Código:

'#¡¨ʒ';¢127%ç?

Explicación:

'#¡              # Split on hashtags
   ¨             # Remove the last element
    ʒ            # For each element (actually a hacky way, since this is a filter)
     ';¢         #   Count the number of occurences of ';'
        127%     #   Modulo by 127
            ç    #   Convert to char
             ?   #   Pop and print without a newline

Utiliza la codificación 05AB1E . Pruébalo en línea!

Jalea , 13 bytes

ṣ”#Ṗċ€”;%127Ọ

Pruébalo en línea!

Cómo funciona

ṣ”#Ṗċ€”;%127Ọ  Main link. Argument: s (string)

ṣ”#            Split s at hashes.
   Ṗ           Pop; remove the last chunk.
    ċ€”;       Count the semicola in each chunk.
        %127   Take the counts modulo 127.
            Ọ  Unordinal; cast integers to characters.

Código de máquina x86 en MS-DOS: 29 bytes

00000000  31 d2 b4 01 cd 21 73 01  c3 3c 3b 75 06 42 80 fa  |1....!s..<;u.B..|
00000010  7f 74 ed 3c 23 75 eb b4  02 cd 21 eb e3           |.t.<#u....!..|
0000001d

Asamblea comentada:

bits 16
org 100h

start:
    xor dx,dx       ; reset dx (used as accumulator)
readch:
    mov ah,1
    int 21h         ; read character
    jnc semicolon
    ret             ; quit if EOF
semicolon:
    cmp al,';'      ; is it a semicolon?
    jne hash        ; if not, skip to next check
    inc dx          ; increment accumulator
    cmp dl,127      ; if we get to 127, reset it; this saves us the
    je start        ; hassle to perform the modulo when handling #
hash:
    cmp al,'#'      ; is it a hash?
    jne readch      ; if not, skip back to character read
    mov ah,2        ; print dl (it was choosen as accumulator exactly
    int 21h         ; because it's the easiest register to print)
    jmp start       ; reset the accumulator and go on reading

05AB1E , 25 21 19 bytes

-2 bytes gracias a Adnan

Îvy';Q+y'#Qi127%ç?0

Explicación:

Î                       Initialise stack with 0 and then push input
 v                      For each character
  y';Q+                 If equal to ';', then increment top of stack
       y'#Qi            If equal to '#', then
            127%        Modulo top of stack with 127
                ç       Convert to character
                 ?      Print without newline
                  0     Push a 0 to initialise the stack for the next print

Pruébalo en línea!

Retina , 34 bytes

T`;#-ÿ`_
\+T`o`-_`[^]|$

Pruébalo en línea! Incluye estuche de prueba. Editar: guardado 2 bytes con ayuda de @MartinEnder. Nota: El código incluye no imprimibles, y el uso de &#x;códigos genera resultados incorrectos ya que el navegador usa Windows-1252 en lugar de ISO-8859-1. Explicación: La primera línea limpia la entrada: ;se cambia a \x80, #a \x7F(debido a las limitaciones de TIO) y se elimina todo lo demás. Luego, cada vez que vemos un \x80que no está antes que otro \x80, lo eliminamos e incrementamos cíclicamente el código de cualquier carácter siguiente. Esto se repite hasta que no quedan más \x80caracteres. El código original que admite bytes nulos básicamente resta 1 de los bytes no imprimibles, excepto en la primera línea donde no \xFFse modifica y se \x7Fconvierte en\x00. Con escapes para la lectura:

T`;#\x00-\xFF`\x7F\x00_
\+T`\x7Eo`\x00-\x7F_`\x7F[^\x7F]|\x7F$

R, 97 90 86 84 bytes

Una función:

function(s)for(i in utf8ToInt(s)){F=F+(i==59);if(i==35){cat(intToUtf8(F%%127));F=0}}

Cuando R comienza, Fse define como FALSE(numérico 0).

Sin golf:

function (s)
    for (i in utf8ToInt(s)) {
        F = F + (i == 59)
        if (i == 35) {
            cat(intToUtf8(F%%127))
            F = 0
        }
    }

Python, 82 bytes

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])

TeX simple, 156 bytes

\newcount\a\def\;{\advance\a by 1\ifnum\a=127\a=0\fi}\def\#{\message{\the\a}\a=0}\catcode`;=13\catcode35=13\let;=\;\let#=\#\loop\read16 to\>\>\iftrue\repeat

Legible

\newcount\a

\def\;{
  \advance\a by 1
  \ifnum \a=127 \a=0 \fi
}
\def\#{
  \message{\the\a}
  \a=0
}

\catcode`;=13
\catcode35=13

\let;=\;
\let#=\#

\loop
  \read16 to \> \>
  \iftrue \repeat

C (gcc) , 58 bytes

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

Pruébalo en línea! (Sugerencia: haga clic en ▼ Pie de página para contraerlo).

Perl, 25 bytes

$_=chr(y%;%%%127)x/#/

Ejecutar con perl -043pe(contado como 4 bytes, ya que perl -ees estándar).

Explicación: -043establece el terminador de línea en #(ASCII 043). -pitera sobre las "líneas" de entrada (en realidad # delimitadas por cadenas, ahora). y%;%%cuenta el número de ;en cada "línea". x/#/se asegura de que no imprimimos un carácter adicional para los programas que no terminan en un # (como el tercer caso de prueba). %127Debería ser bastante obvio. $_=es el habitual repetitivo.

CJam, 27 bytes

0q{";#"#") 127%co0 "S/=~}%;

Explicación:

0                            e# Push 0
 q                           e# Push the input
  {                          e# For each character in the input:
   ";#"#                     e#   Index of character in ";#", -1 if not found
        ") 127%co0 "S/       e#   Push this string, split on spaces
                      =      e#   Array access (-1 is the last element)
                       ~     e#   Execute as CJam code. ")" increments the accumulator,
                             e#     and "127%co0" preforms modulo by 127, converts to character, pops and outputs, and then pushes 0.
                        }%   e# End for
                          ;  e# Delete the accumulator

Solución alternativa, 18 bytes

q'#/);{';e=127%c}%

Explicación:

q                   e# Read the whole input
 '#/                e# Split on '#'
    );              e# Delete the last element
      {             e# For each element:
       ';e=         e#   Count number of ';' in string
           127%     e#   Modulo by 127
               c    e#   Convert to character code
                }%  e# End for

F #, 79 91 93 bytes

let rec r a=function|[]->()|';'::t->r(a+1)t|'#'::t->printf"%c"(char(a%127));r 0 t|_::y->r a y

Sin golf

let rec run acc = function
    | [] -> ()
    | ';'::xs ->
        run (acc + 1) xs
    | '#'::xs ->
        printf "%c" (char(acc % 127))
        run 0 xs
    | x::xs -> run acc xs

Pruébalo en línea!

Editar: estaba tratando cualquier otro carácter que ';' como '#'. Lo cambió para que ignore los caracteres no válidos.

Alternativa

F #, 107104 bytes

let r i=
 let a=ref 0
 [for c in i do c|>function|';'->a:=!a+1|'#'->printf"%c"(!a%127|>char);a:=0|_->()]

El uso de la celda de referencia ahorra 3 bytes

Sin golf

let run i =
    let a = ref 0;
    [for c in i do
        match c with
        | ';' -> a := !a + 1
        | '#' ->
            printf "%c" (char(!a % 127))
            a := 0
        |_->()
    ]

Pruébalo en línea

Processing.js (versión Khanacademy), 118 bytes

var n="",a=0;for(var i=0;i<n.length;i++){if(n[i]===";"){a++;}if(n[i]==="#"){println(String.fromCharCode(a%127));a=0;}}

Pruébalo en línea!

Como la versión de procesamiento utilizada no tiene ningún método de entrada, la entrada se coloca en n.

Laberinto , 61 47 bytes

_36},)@
;    {
; 42_-
"#-  1
_ ; 72
_ ) %
"""".

Pruébalo en línea!

Explicación

La ejecución del código comienza en la esquina superior izquierda y el primer punto y coma descarta un cero implícito de la pila y continúa hacia la derecha.

naranja

• _36empuja 36 en la pila. Esto es para comparar la entrada con#
• } mueve la parte superior de la pila a la pila secundaria
• , empuja el valor entero del personaje en la pila
• )incrementa la pila (si es el final de la entrada, esto hará que la pila sea 0 y el flujo del programa procederá a la @salida)
• { mueve la parte superior de la pila secundaria a la parte superior de la pila primaria
• -pop y, pop x, presione x - y. Esto es para comparar la entrada con #(35 en ascii). Si la entrada fue #el código continuará a la sección púrpura (porque la parte superior de la pila es 0, la IP continúa en la dirección en la que se movía antes), de lo contrario continuará a la sección verde.

Púrpura

• 127 empujar 127 a la pila
• % pop x, pop y, push x% y
• . pop la parte superior de la pila (el acumulador) y la salida como un personaje

Desde aquí, el código gris nos lleva a la esquina superior izquierda del programa sin nada en la pila.

Verde

• _24 empuje 24 en la pila
• -pop x, pop y, presione xy. 24 es la diferencia entre #y ;entonces esto verifica si la entrada fue ;. Si fuera así, ;el código continúa directamente hacia el ). De lo contrario, se convertirá en el #que empuja la altura de la pila (siempre un número positivo, obligando al programa a girar a la derecha en la próxima intersección y perder el código que incrementa el acumulador)
• ; descartar la parte superior de la pila
• ) incremente la parte superior de la pila, que es un cero implícito o es un cero previamente incrementado que actúa como el acumulador para la salida

Desde aquí, el código gris nos lleva a la esquina superior izquierda del programa con la pila con solo el acumulador.

gris

Las cotizaciones no son operacionales, _empujan un 0 a la pila y ;descartan la parte superior de la pila. Todo esto es solo un código para forzar el flujo de control de la manera correcta y descartar cualquier cosa adicional de la parte superior de la pila.

MATL , 29 bytes

';#'&mXz!"@o?T}vn127\c&YD]]vx

La entrada es una cadena entre comillas simples.

Pruébalo en línea!

El programa FizzBuzz es demasiado largo para los intérpretes en línea; verlo trabajando sin conexión en este gif:

Explicación

El valor del acumulador se implementa como el número de elementos en la pila. Esto hace que el programa sea más lento que si el valor del acumulador fuera un solo número en la pila, pero ahorra algunos bytes.

';#'       % Push this string
&m         % Input string (implicit). Pushes row vector array of the same size with 
           % entries 1, 2 or 0 for chars equal to ';', '#' or others, respectively
Xz         % Remove zeros. Gives a column vector
!          % Transpose into a row vector
"          % For each entry
  @        %   Push current entry
  o?       %   If odd
    T      %     Push true. This increases the accumulator (number of stack elements)
  }        %   Else
    v      %     Concatenate stack into a column vector
    n      %     Number of elements
    127\   %     Modulo 127
    c      %     Convert to char
    &YD    %     Display immediately without newline
  ]        %   End
]          % End
vx         % Concatenate stack and delete. This avoids implicit display

Alice , 22 bytes

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

Pruébalo en línea!

Explicación

Mantenemos en la pila solo un contador de cuántos ;nos hemos encontrado. Cuando la pila está vacía (p. Ej. Al inicio del programa) esto es implícitamente un 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

Aquí se puede encontrar una versión más corta pero sin finalización de este programa .

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)

Intenté adoptar un enfoque diferente al de la respuesta de Shaggy . Oh bien.

; # + , 59 bytes, sin competencia

El lenguaje se hizo después de este desafío.

;;;;;~+++++++>~;~++++:>*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)

Pruébalo en línea! La entrada termina con un byte nulo.

Explicación

La generación es la misma que la de mi Generar; # respuesta de código . La única diferencia aquí es la iteración.

Iteración

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   take input while != 0
  ~                                    swap
   <                                   read value from memory (;)
    :                                  move forward to the accumulator memory spot (AMS)
     -                                 flip Δ
      +                                subtract two accumulators into A
       !                               flip A (0 -> 1, else -> 0)
        (     (;))                     if A is nonzero, or, if A == ';'
         <                             read from AMS
          -;-                          increment
             >                         write to AMS
                  ::                   move to cell 0 (#)
                    <                  read value from memory (#)
                     +                 subtract two accumulators into A
                      -                flip Δ
                       ::              move to AMS
                         !(   )        if A == '#'
                           <           read from AMS
                            #          output mod 127, and clear
                             >         write to AMS
                               -:-     move back to initial cell

Bash + coreutils, 46 39 bytes

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

Pruébalo en línea!

Explicación

(¡Gracias Cows Quack por -7 bytes!)

La trparte elimina todos los caracteres extraños (podría poner esto en sedexactamente el mismo bytecount, pero luego no maneja el carácter de salto de línea correctamente, ya que los seddeja adentro y dcsolo llega hasta el primer salto de línea con ?)

sedtoma el resto y construye un dcprograma:

Cadenas de ;convertirse en cadenas de 1(un literal largo)

#se convierte en .ZC7%P(si esto sigue una cadena de 1, el .es un punto decimal para un no-op. Pero si está al comienzo del programa, o después de otro #, es un literal 0. Luego toma la longitud del número, lo modifica, e Imprime el ASCII correspondiente.)

C, 65 64 60 bytes

(-2 gracias a ceilingcat)

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