Di recente ho creato una nuova lingua chiamata ;#(pronunciata "Punto e virgola") che ha solo due comandi:

; aggiungine uno all'accumulatore

#modulo l'accumulatore per 127, converti in carattere ASCII e output senza una nuova riga. Successivamente, ripristinare l'accumulatore su 0. Sì, 127 è corretto.

Qualsiasi altro personaggio viene ignorato. Non ha alcun effetto sull'accumulatore e non dovrebbe fare nulla.

Il tuo compito è creare un interprete per questo linguaggio potente!

Dovrebbe essere un programma completo o una funzione che prenderà un ;#programma come input e produrrà l'output corretto.

Esempi

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 fino a 100

Python 3 , 69 68 byte

-1 byte grazie a @WheatWizard

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

Provalo online!

JavaScript (ES6), 76 82 80 byte

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

dimostrazione

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(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#")))

Versione ricorsiva, 82 77 byte

5 byte salvati grazie a Neil

È probabile che questo si blocchi per input di grandi dimensioni come nell'esempio 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 byte

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

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

Provalo online!

Versione leggibile usando un'ipotetica sintassi di escape:

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

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

Non stampa byte NUL, perché TIO non li consente nel codice sorgente. Stampa anche una nuova riga alla fine, ma immagino che non possa fare diversamente. Newline finale soppressa grazie a @Leo .

-273 (!) Byte grazie a @ETHproductions .

-2 byte grazie a @ovs .

-3 byte grazie a @Neil . Dai un'occhiata alla loro meravigliosa soluzione a 34 byte .

Java 8, 100 byte

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

Provalo online!

Japt , 18 byte

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

Dopo c'è un carattere \ x7f non stampabile %#. Provalo online!

Come funziona

®   è'; %#   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 byte

Questo è un golf di questa risposta precedente.

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

Provalo online! python2

Provalo online! python3

Spiegazione

Questa è una risposta piuttosto semplice, determiniamo quanti ;s sono tra ciascuno #e stampiamo la chrmod 127. L'unica cosa che potrebbe essere un po 'strana è la [:-1]. Dobbiamo eliminare l'ultimo gruppo perché non ci sarà più #dopo.

Per esempio

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

Sarà suddiviso in

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

Ma non vogliamo l'ultimo ;;;perché non c'è nessun #dopo per stampare il valore.

> <> , 35 byte

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

Provalo online! Sostituisci ␡con 0x7F ^?o "elimina".

Anello principale

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

Questo prende un carattere di input ( i), controlla se è minore di zero, cioè EOF ( :0() e termina il programma se è ( ?;). Altrimenti, controlla se l'ingresso è uguale a #( :'#'=). In tal caso, diramare verso il basso e riavviare il ciclo ( ?v... ^ ... <).

Contro logica

              ';'=?0
              

Controlla se l'ingresso è uguale a ;( ';'=). In tal caso, premere a 0. Altrimenti, non fare nulla. Questo riavvia il ciclo principale.

Logica di stampa

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

Quando il carattere di input è #, ~fai uscire l'input dallo stack ( ), ottieni il numero di membri sullo stack ( l), premi 127 ( '␡') e prendi il modulo ( %). Quindi, emettilo come carattere ( o) e avvia un nuovo stack ( [0). Questo "azzera" il contatore. Quindi, il ciclo si riavvia.

Python 3, 69 byte

Migliorato, grazie a @Wheat Wizard, @Uriel

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

Röda , 44 39 38 byte

5 byte salvati grazie a @fergusq

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

Provalo online!

Funzione anonima che accetta l'input dal flusso.

Se non è necessario ignorare altri personaggi, ottengo questo:

Röda , 20 byte

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

Rubino, 41 35 34 caratteri

( 40 34 33 caratteri codice + 1 carattere opzione riga di comando)

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

Grazie a:

• Giordania per aver suggerito di usare putcper non aver bisogno di una conversione esplicita con .chr(6 caratteri)
• Kirill L. per aver trovato la parentesi non necessaria (1 carattere)

Esecuzione di esempio:

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

Provalo online!

05AB1E , 16 15 14 byte

Codice:

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

Spiegazione:

'#¡              # 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

Utilizza la codifica 05AB1E . Provalo online!

Gelatina , 13 byte

ṣ”#Ṗċ€”;%127Ọ

Provalo online!

Come funziona

ṣ”#Ṗċ€”;%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.

codice macchina x86 su MS-DOS - 29 byte

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

Assemblaggio commentato:

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 byte

-2 byte grazie ad Adnan

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

Spiegazione:

Î                       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

Provalo online!

Retina , 34 byte

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

Provalo online! Include test case. Modifica: salvato 2 byte con l'aiuto di @MartinEnder. Nota: il codice include non stampabili e l'utilizzo di &#x;codici genera risultati errati poiché il browser utilizza Windows-1252 anziché ISO-8859-1. Spiegazione: La prima riga pulisce l'input: ;viene modificato in \x80, #in \x7F(a causa delle limitazioni del TIO) e tutto il resto viene eliminato. Quindi ogni volta che vediamo un \x80non prima di un altro \x80, lo eliminiamo e incrementiamo ciclicamente il codice di ogni carattere successivo. Questo è ripetuto fino a quando non ce ne sono più . Con fughe per la leggibilità:\x80 caratteri. Il codice originale che supporta byte nulli sottrae sostanzialmente 1 dai byte non stampabili, tranne nella prima riga dove \xFFè invariato e \x7Fdiventa\x00

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

R, 97 90 86 84 byte

Una funzione:

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

All'avvio di R, Fviene definito come FALSE(numerico 0).

Ungolfed:

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

Python, 82 byte

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

TeX semplice, 156 byte

\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

Leggibile

\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 byte

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

Provalo online! (Suggerimento: fai clic su ▼ Piè di pagina per comprimerlo.)

Perl, 25 byte

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

Esegui con perl -043pe(contato come 4 byte, poiché perl -eè standard).

Spiegazione: -043imposta il terminatore di linea su #(ASCII 043). -pscorre le "linee" di input (in realtà stringhe # -delimate, ora). y%;%%conta il numero di ;in ogni "linea". x/#/si assicura che non stampiamo un carattere aggiuntivo per i programmi che non finiscono con un # (come il terzo testcase). %127dovrebbe essere abbastanza ovvio. $_=è la solita caldaia.

CJam, 27 byte

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

Spiegazione:

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

Soluzione alternativa, 18 byte

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

Spiegazione:

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 byte

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

Ungolfed

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

Provalo online!

Modifica: stava trattando qualsiasi altro carattere diverso da ';' come '#'. Modificato in modo che ignori i caratteri non validi.

Alternativa

F #, 107 104 byte

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

L'uso della cella di riferimento consente di risparmiare 3 byte

Ungolfed

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
        |_->()
    ]

Provalo online

Processing.js (versione Khanacademy), 118 byte

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;}}

Provalo online!

Poiché la versione di elaborazione utilizzata non ha alcun metodo di input, l'input viene inserito in n.

Labyrinth , 61 47 byte

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

Provalo online!

Spiegazione

L'esecuzione del codice inizia nell'angolo in alto a sinistra e il primo punto e virgola scarta uno zero implicito dallo stack e continua verso destra.

arancia

• _36spinge 36 nella pila. Questo serve per confrontare l'input con#
• } sposta la parte superiore della pila nella pila secondaria
• , spinge il valore intero del personaggio nello stack
• )incrementa lo stack (se è la fine dell'input, questo renderà lo stack 0 e il flusso del programma procederà @all'uscita e uscirà )
• { sposta la parte superiore della pila secondaria nella parte superiore della pila principale
• -pop y, pop x, premi x - y. Questo serve per confrontare l'input con #(35 in ascii). Se l'input era #il codice continuerà alla sezione viola (poiché la parte superiore dello stack è 0, l'IP continua nella direzione in cui si stava muovendo prima), altrimenti continuerà alla sezione verde.

Viola

• 127 spingere 127 nello stack
• % pop x, pop y, premi x% y
• . pop la parte superiore della pila (l'accumulatore) e l'output come personaggio

Da qui il codice grigio ci porta nell'angolo in alto a sinistra del programma senza nulla in pila.

verde

• _24 spingere 24 sulla pila
• -pop x, pop y, premi xy. 24 è la differenza tra #e ;quindi questo controlla se l'input era ;. Se fosse ;il codice continua dritto verso ). Altrimenti passerà al valore #che spinge l'altezza dello stack (sempre un numero positivo, costringendo il programma a girare a destra al prossimo incrocio e perdere il codice che aumenta l'accumulatore)
• ; scartare la parte superiore della pila
• ) incrementare la parte superiore dello stack che è uno zero implicito oppure è uno zero precedentemente incrementato che funge da accumulatore per l'output

Da qui il codice grigio ci porta nell'angolo in alto a sinistra del programma con lo stack con solo l'accumulatore su di esso.

Grigio

Le virgolette sono no-op, _inserisce uno 0 nello stack e ;scarta la parte superiore dello stack. Tutto questo è solo un codice per forzare il flusso di controllo nel modo giusto e scartare qualsiasi cosa in più dalla cima dello stack.

MATL , 29 byte

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

L'input è una stringa racchiusa tra virgolette singole.

Provalo online!

Il programma FizzBuzz è troppo lungo per gli interpreti online; vederlo funzionare offline in questo gif:

Spiegazione

Il valore dell'accumulatore viene implementato come numero di elementi nello stack. Ciò rende il programma più lento rispetto a se il valore dell'accumulatore fosse un singolo numero nello stack, ma salva alcuni byte.

';#'       % 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 byte

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

Provalo online!

Spiegazione

Manteniamo in pila solo un singolo contatore di quanti ;ne abbiamo incontrati. Quando lo stack è vuoto (ad es. All'inizio del programma), questo è implicitamente uno 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

Una versione più breve ma non terminante di questo programma è disponibile qui .

JS (ES6), 97 92 byte

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

Ho cercato di adottare un approccio diverso rispetto alla risposta di Shaggy . Oh bene.

; # + , 59 byte, non competitivo

La lingua è stata creata dopo questa sfida.

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

Provalo online! L'input termina con un byte nullo.

Spiegazione

La generazione è la stessa di Generate; # codice risposta . L'unica differenza qui è l'iterazione.

Iterazione

*(~<:-+!(<-;->(;))::<+-::!(<#>)-:-*)
*(                                *)   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 byte

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

Provalo online!

Spiegazione

(Grazie Cows Quack per -7 byte!)

La trporzione rimuove tutti i caratteri estranei (potrei inserirlo sedesattamente nello stesso byte, ma poi non gestisce correttamente il carattere di avanzamento riga, dal momento sedche li lascia entrare e dcarriva solo al primo avanzamento riga ?)

sedprende il resto e costruisce un dcprogramma:

Stringhe di ;diventano stringhe di 1(un lungo letterale)

#diventa .ZC7%P(se segue una stringa di 1, .è un punto decimale per un no-op. Ma se è all'inizio del programma, o seguendo un altro #, è un valore letterale 0. Quindi prende la lunghezza del numero, lo modifica, e stampa l'ASCII corrispondente.)

C, 65 64 60 byte

(-2 grazie a ceilingcat)

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