J'ai récemment créé un nouveau langage appelé ;#(prononcé "Semicolon Hash") qui n'a que deux commandes:

; ajouter un à l'accumulateur

#modulez l'accumulateur par 127, convertissez-le en caractère ASCII et sortez-le sans nouvelle ligne. Après cela, réinitialisez l'accumulateur à 0. Oui, 127 est correct.

Tout autre caractère est ignoré. Cela n'a aucun effet sur l'accumulateur et ne devrait rien faire.

Votre tâche est de créer un interprète pour ce langage puissant!

Ce doit être soit un programme complet, soit une fonction qui prend un ;#programme en entrée et produit le résultat correct.

Exemples

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 jusqu'à 100

Python 3 , 69 68 octets

-1 octet grâce à @WheatWizard

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

Essayez-le en ligne!

JavaScript (ES6), 76 82 80 octets

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

Démo

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

Version récursive, 82 77 octets

5 octets sauvés grâce à Neil

Celui-ci est susceptible de planter pour des entrées de grande taille telles que l'exemple 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 octets

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

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

Essayez-le en ligne!

Version lisible utilisant une syntaxe d'échappement hypothétique :

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

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

N'imprime pas les octets NUL, car TIO ne les autorise pas dans le code source. Imprime également une nouvelle ligne à la fin, mais je suppose que cela ne peut pas être fait autrement. Le retour à la ligne est supprimé grâce à @Leo .

-273 (!) Octets grâce à @ETHproductions .

-2 octets grâce à @ovs .

-3 octets grâce à @Neil . Découvrez leur merveilleuse solution à 34 octets .

Java 8, 100 octets

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

Essayez-le en ligne!

Japt , 18 octets

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

Il y a un caractère \ x7f non imprimable après %#. Testez-le en ligne!

Comment ça fonctionne

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

Ceci est un golf de cette réponse précédente.

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

Essayez-le en ligne! Python2

Essayez-le en ligne! Python3

Explication

C’est une réponse assez simple: nous déterminons le nombre de ;s entre chaque #impression et imprimons le chrmod 127. La seule chose qui pourrait être un peu étrange est le [:-1]. Nous devons supprimer le dernier groupe car il n'y aura pas de #suite.

Par exemple

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

Sera divisé en

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

Mais nous ne voulons pas le dernier ;;;car il n’ya pas d’ #après pour imprimer la valeur.

> <> , 35 octets

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

Essayez-le en ligne! Remplacez ␡par 0x7F, ^?ou "supprimer".

Boucle principale

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

Cela prend un caractère de input ( i), vérifie si sa valeur est inférieure à zéro, c'est-à-dire EOF ( :0() et termine le programme s'il est ( ?;). Sinon, vérifiez si l'entrée est égale à #( :'#'=). Si c'est le cas, relâchez la boucle et redémarrez la boucle ( ?v... ^ ... <).

Contre-logique

              ';'=?0
              

Vérifiez si l'entrée est égale à ;( ';'=). Si c'est le cas, appuyez sur a 0. Sinon, ne faites rien. Cela redémarre la boucle principale.

Logique d'impression

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

Lorsque le caractère saisi est #, supprimez-le de la pile ( ~), obtenez le nombre de membres de la pile ( l), appuyez sur 127 ( '␡') et prenez le module ( %). Ensuite, affichez-le sous forme de caractère ( o) et démarrez une nouvelle pile ( [0). Ceci "zéros" sur le comptoir. Ensuite, la boucle redémarre.

Python 3, 69 octets

Amélioré, grâce à @Wheat Wizard, @Uriel

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

Röda , 44 39 38 octets

5 octets sauvegardés grâce à @fergusq

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

Essayez-le en ligne!

Fonction anonyme qui prend l'entrée du flux.

Si les autres personnages ne doivent pas être ignorés, j'obtiens ceci:

Röda , 20 octets

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

Ruby, 41 35 34 caractères

( 40 34 33 caractères code + option de ligne de commande de 1 caractère)

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

Grâce à:

• Jordan pour avoir suggéré de putcne pas utiliser de conversion explicite avec .chr(6 caractères)
• Kirill L. pour avoir trouvé la parenthèse inutile (1 caractère)

Échantillon échantillon:

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

Essayez-le en ligne!

05AB1E , 16 15 14 octets

Code:

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

Explication:

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

Utilise le codage 05AB1E . Essayez-le en ligne!

Gelée , 13 octets

ṣ”#Ṗċ€”;%127Ọ

Essayez-le en ligne!

Comment ça fonctionne

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

Code machine x86 sous MS-DOS - 29 octets

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

Assemblée commentée:

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 octets

-2 octets grâce à Adnan

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

Explication:

Î                       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

Essayez-le en ligne!

Retina , 34 octets

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

Essayez-le en ligne! Comprend un cas de test. Edit: 2 octets enregistrés avec l’aide de @MartinEnder. Remarque: Le code inclut les articles non imprimables et l'utilisation de &#x;codes génère des résultats incorrects car le navigateur utilise Windows-1252 au lieu de ISO-8859-1. Explication: La première ligne nettoie l'entrée: ;est changé \x80, #à \x7F( en raison des limitations TIO) et tout le reste est supprimé. Ensuite, chaque fois que nous voyons un élément différent d'un \x80autre \x80, nous le supprimons et incrémentons de manière cyclique le code de tout caractère suivant. Ceci est itéré jusqu'à ce qu'il ne reste plus de \x80caractères. Le code original qui prend en charge les octets nuls soustrait fondamentalement 1 des octets non imprimables, sauf dans la première ligne où \xFFest inchangé et \x7Fdevient\x00. Avec échappées pour plus de lisibilité:

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

R, 97 90 86 84 octets

Une fonction:

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

Lorsque R commence, Fest défini comme FALSE(numérique 0).

Ungolfed:

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

Python, 82 octets

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

Plain TeX, 156 octets

\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

Lisible

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

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

Essayez-le en ligne! (Indice: cliquez sur ▼ Pied de page pour le réduire.)

Perl, 25 octets

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

Run with perl -043pe(compte comme 4 octets, car perl -eest standard).

Explanation: -043définit le terminateur de ligne sur #(ASCII 043). -pitère sur les «lignes» d'entrée (en fait # chaînes délimitées, maintenant). y%;%%compte le nombre de ;dans chaque "ligne". x/#/s'assure que nous n'imprimons pas de caractère supplémentaire pour les programmes qui ne se terminent pas par # (comme le troisième cas de test). %127devrait être assez évident. $_=est le passe-partout habituel.

CJam, 27 octets

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

Explication:

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

Solution alternative, 18 octets

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

Explication:

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 octets

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

Essayez-le en ligne!

Edit: traitait tout autre caractère que ';' comme '#'. Changé pour ignorer les caractères invalides.

Alternative

F #, 107 104 octets

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'utilisation de la cellule de référence enregistre 3 octets

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

Essayez-le en ligne

Processing.js (version de Khanacademy), 118 octets

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

Essayez-le en ligne!

Comme la version de traitement utilisée ne comporte aucune méthode de saisie, l'entrée est placée dans n.

Labyrinthe , 61 à 47 octets

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

Essayez-le en ligne!

Explication

L'exécution du code commence dans le coin supérieur gauche et le premier point-virgule supprime un zéro implicite de la pile et continue vers la droite.

Orange

• _36pousse 36 sur la pile. Ceci est pour comparer l'entrée avec#
• } déplace le haut de la pile vers la pile secondaire
• , pousse la valeur entière du caractère sur la pile
• )incrémente la pile (si c'est la fin de l'entrée, cela fera la pile 0 et le déroulement du programme ira à la @sortie)
• { déplace le haut de la pile secondaire vers le haut de la pile principale
• -pop y, pop x, appuyez sur x - y. C'est pour comparer l'entrée avec #(35 en ascii). Si l'entrée était #le code continuera à la section violette (parce que le haut de la pile est 0, l'adresse IP continue dans la direction dans laquelle elle se déplaçait auparavant), sinon elle passera à la section verte.

Violet

• 127 poussez 127 à la pile
• % pop x, pop y, pousse x% y
• . faire apparaître le haut de la pile (l'accumulateur) et le sortir sous forme de caractère

De là, le code gris nous amène dans le coin supérieur gauche du programme avec rien sur la pile.

vert

• _24 poussez 24 sur la pile
• -pop x, pop y, appuyez sur xy. 24 est la différence entre #et ;donc ceci vérifie si l'entrée a été ;. Si c'était ;le code continue tout droit vers le ). Sinon, il se tournera vers le #qui pousse la hauteur de la pile (toujours un nombre positif, obligeant le programme à tourner à droite à la prochaine intersection et à manquer le code qui incrémente l'accumulateur)
• ; jeter le haut de la pile
• ) incrémenter le haut de la pile qui est soit un zéro implicite, soit un zéro précédemment incrémenté servant d’accumulateur pour la sortie

De là, le code gris nous mène dans le coin supérieur gauche du programme avec la pile contenant uniquement l'accumulateur.

gris

Les guillemets ne sont pas des opérations, _poussent un 0 sur la pile et ;rejettent le haut de la pile. Tout ceci n’est que du code pour forcer le flux de contrôle de la bonne manière et éliminer tout élément supplémentaire du haut de la pile.

MATL , 29 octets

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

L'entrée est une chaîne entre guillemets simples.

Essayez-le en ligne!

Le programme FizzBuzz est trop long pour les interprètes en ligne. le voir travailler hors ligne dans ce gif:

Explication

La valeur de l'accumulateur est implémentée en tant que nombre d'éléments dans la pile. Cela rend le programme plus lent que si la valeur de l'accumulateur était un nombre unique dans la pile, il enregistre quelques octets.

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

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

Essayez-le en ligne!

Explication

Nous ne conservons sur la pile qu'un seul compteur du nombre que ;nous avons rencontré. Lorsque la pile est vide (par exemple au début du programme), il s'agit implicitement d'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

Une version plus courte mais non-terminante de ce programme est disponible ici .

JS (ES6), 97 92 octets

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

J'ai essayé d'adopter une approche différente de celle de Shaggy . Tant pis.

; # + , 59 octets, sans compétition

La langue a été faite après ce défi.

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

Essayez-le en ligne! L'entrée se termine par un octet nul.

Explication

La génération est la même que celle de ma réponse Generate; # code . La seule différence ici est l'itération.

Itération

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

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

Essayez-le en ligne!

Explication

(Merci Cocks Quack pour -7 octets!)

La trpartie supprime tous les caractères superflus (je pourrais mettre cela dans sedexactement le même décompte, mais elle ne gérera pas le caractère de saut de ligne correctement, car les sedlaisse dedans et n'atteint dcque le premier saut de ligne avec ?)

sedprend le reste et construit un dcprogramme:

Les chaînes de ;deviennent des chaînes de 1(un long littéral)

#devient .ZC7%P(si cela suit une chaîne de 1, le .est un point décimal pour un non-op. Mais si c'est au début du programme, ou après un autre #, c'est un littéral 0. Ensuite, il prend la longueur du nombre, le modifie, et imprime l’ASCII correspondant.)

C 65 64 60 octets

(-2 grâce à ceilingcat)

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