Ich habe kürzlich eine neue Sprache namens ;#(ausgesprochen "Semikolon-Hash") erstellt, die nur zwei Befehle enthält:

; füge eins zum Akku hinzu

#Modulieren Sie den Akku um 127, konvertieren Sie ihn in ASCII-Zeichen und geben Sie ihn ohne Zeilenumbruch aus. Danach den Akku auf 0 zurücksetzen. Ja, 127 ist korrekt.

Alle anderen Zeichen werden ignoriert. Es hat keine Auswirkung auf den Akku und sollte nichts tun.

Ihre Aufgabe ist es, einen Dolmetscher für diese mächtige Sprache zu erstellen!

Es sollte entweder ein vollständiges Programm oder eine Funktion sein, die ein ;#Programm als Eingabe verwendet und die richtige Ausgabe erzeugt.

Beispiele

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 bis zu 100

Python 3 , 69 68 Bytes

-1 Byte dank @WheatWizard

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

Probieren Sie es online!

JavaScript (ES6), 76 82 80 Byte

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

Demo

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

Rekursive Version, 82 77 Bytes

5 Bytes gespart dank Neil

Dieser stürzt wahrscheinlich bei großen Eingaben ab, wie z. B. im Fizz Buzz-Beispiel.

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\`¯`

Probieren Sie es online!

Lesbare Version mit hypothetischer Escape-Syntax:

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

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

Druckt keine NUL-Bytes, da TIO sie im Quellcode nicht zulässt. Gibt am Ende auch einen zusätzlichen Zeilenumbruch aus, aber ich schätze, es geht nicht anders. Newline unterdrückt dank @Leo .

-273 (!) Bytes dank @ETHproductions .

-2 Bytes dank @ovs .

-3 Bytes dank @Neil . Schauen Sie sich ihre wunderbare 34-Byte-Lösung an .

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

Probieren Sie es online!

Japt , 18 Bytes

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

Es folgt ein nicht druckbares \ x7f-Zeichen %#. Online testen!

Wie es funktioniert

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

Dies ist ein Golf dieser früheren Antwort.

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

Probieren Sie es online! Python2

Probieren Sie es online! Python3

Erläuterung

Dies ist eine ziemlich einfache Antwort, wir bestimmen, wie viele ;s zwischen jedem stehen #und drucken den chrMod 127. Das einzige, was ein bisschen seltsam sein könnte, ist der [:-1]. Wir müssen die letzte Gruppe fallen lassen, weil es danach keine geben wird #.

Zum Beispiel

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

Wird aufgeteilt in

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

Aber wir wollen nicht das Letzte, ;;;weil es kein hinterher gibt #, um den Wert zu drucken.

> <> , 35 Bytes

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

Probieren Sie es online! Ersetzen Sie ␡durch 0x7F ^?, oder "delete".

Hauptschleife

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

Dies nimmt ein Zeichen von input ( i) an, prüft, ob es kleiner als Null ist, dh EOF (:0( ), und beendet das Programm, wenn es ( ?;) ist. Andernfalls prüfen Sie, ob die Eingabe gleich #( :'#'=) ist. Wenn dies der Fall ist, verzweigen Sie nach unten und starten Sie die Schleife neu ( ?v... ^ ... <).

Zählerlogik

              ';'=?0
              

Überprüfen Sie, ob die Eingabe gleich ;( ';'=) ist. Wenn ja, drücken Sie a 0. Sonst nichts tun. Dies startet die Hauptschleife neu.

Drucklogik

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

Wenn das Eingabezeichen ist #, lassen Sie die Eingabe vom Stapel fallen ( ~), ermitteln Sie die Anzahl der Elemente auf dem Stapel ( l), drücken Sie 127 ( '␡') und nehmen Sie den Modul ( %). Gib es dann als Zeichen aus ( o) und beginne einen neuen Stapel ( [0). Dies "nullt" den Zähler aus. Dann startet die Schleife neu.

Python 3, 69 Bytes

Verbessert dank @Wheat Wizard, @Uriel

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

Röda , 44 39 38 Bytes

5 Bytes gespart dank @fergusq

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

Probieren Sie es online!

Anonyme Funktion, die die Eingabe aus dem Stream übernimmt.

Wenn andere Zeichen nicht ignoriert werden müssen, erhalte ich Folgendes:

Röda , 20 Bytes

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

Ruby, 41 35 34 Zeichen

( 40 34 33 Zeichen Code + 1 Zeichen Befehlszeilenoption)

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

Dank an:

• Jordan für den Vorschlag, putckeine explizite Konvertierung mit .chr(6 Zeichen) zu verwenden
• Kirill L. für das Auffinden der unnötigen Klammer (1 Zeichen)

Probelauf:

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

Probieren Sie es online!

05AB1E , 16 15 14 Bytes

Code:

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

Erläuterung:

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

Verwendet die 05AB1E- Kodierung. Probieren Sie es online!

Gelee , 13 Bytes

ṣ”#Ṗċ€”;%127Ọ

Probieren Sie es online!

Wie es funktioniert

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

x86-Computercode unter 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

Kommentierte Versammlung:

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 dank Adnan

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

Erläuterung:

Î                       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

Probieren Sie es online!

Retina , 34 Bytes

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

Probieren Sie es online! Beinhaltet einen Testfall. Bearbeiten: 2 Bytes mit Hilfe von @MartinEnder gespeichert. Hinweis: Code enthält nicht druckbare Dateien, und die Verwendung von &#x;Codes führt zu falschen Ergebnissen, da der Browser Windows-1252 anstelle von ISO-8859-1 verwendet. Erläuterung: Die erste Zeile bereinigt die Eingabe: ;wird geändert in \x80, #bis . Mit Ausbrüchen zur besseren Lesbarkeit:\x7F (durch TIO Einschränkungen) und alles andere wird gelöscht. Wenn wir dann ein Zeichen sehen \x80, das nicht vor einem anderen steht \x80, löschen wir es und erhöhen zyklisch den Code eines beliebigen nächsten Zeichens. Dies wird solange wiederholt, bis keine \x80Zeichen mehr übrig sind. Ursprünglicher Code, der Null-Bytes unterstützt, subtrahiert grundsätzlich 1 von den nicht druckbaren Bytes, außer in der ersten Zeile, in der \xFFunverändert bleibt und \x7Fwird\x00

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

R 97 90 86 84 Bytes

Eine Funktion:

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

Wenn R startet, Fwird als FALSE(numerisch 0) definiert.

Ungolfed:

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

Plain TeX, 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

Lesbar

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

Probieren Sie es online! (Hinweis: Klicken Sie auf ▼ Footer, um es zu minimieren .)

Perl, 25 Bytes

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

Ausführen mit perl -043pe(wird seitdem als 4 Byte gezähltperl -e Standard ist).

Erläuterung: -043Setzt den Zeilenabschluss auf #(ASCII 043). -piteriert über die Eingabe "Zeilen" (tatsächlich # -begrenzte Zeichenfolgen, jetzt). y%;%%zählt die Anzahl von ;in jeder "Zeile". x/#/stellt sicher, dass für Programme, die nicht mit einem # enden (wie der dritte Testfall), kein zusätzliches Zeichen ausgegeben wird. %127sollte ziemlich offensichtlich sein. $_=ist die übliche Kesselplatte.

CJam, 27 Bytes

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

Erläuterung:

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

Alternative Lösung, 18 Bytes

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

Erläuterung:

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

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

Probieren Sie es online!

Bearbeiten: Behandelte ein anderes Zeichen als ';' wie '#'. Es wurde so geändert, dass ungültige Zeichen ignoriert werden.

Alternative

F #, 107 104 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|_->()]

Die Verwendung einer Referenzzelle spart 3 Bytes

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

Probieren Sie es online aus

Processing.js (Khanacademy-Version), 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;}}

Probieren Sie es online!

Da die verwendete Verarbeitungsversion keine Eingabemethoden hat, wird die Eingabe in n gestellt.

Labyrinth , 61 47 Bytes

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

Probieren Sie es online!

Erläuterung

Die Codeausführung beginnt in der oberen linken Ecke und das erste Semikolon verwirft eine implizite Null vom Stapel und setzt sich nach rechts fort.

Orange

• _36schiebt 36 auf den Stapel. Dies dient zum Vergleichen der Eingabe mit#
• } Verschiebt die Oberseite des Stapels zum Sekundärstapel
• , schiebt den ganzzahligen Wert des Zeichens auf dem Stapel
• )Inkrementiert den Stack (wenn es das Ende der Eingabe ist, wird der Stack auf 0 gesetzt und der Programmfluss geht zum @und zum Ende)
• { Verschiebt die Oberseite des Sekundärstapels an die Oberseite des Primärstapels
• -pop y, pop x, drücke x - y. Dies dient zum Vergleichen der Eingabe mit #(35 in ASCII). Wenn die Eingabe war# , fährt der Code mit dem violetten Bereich fort (da die Oberseite des Stapels 0 ist, fährt die IP in der Richtung fort, in der sie sich zuvor bewegt hat), andernfalls fährt sie mit dem grünen Bereich fort.

Lila

• 127 Drücke 127 auf den Stapel
• % pop x, pop y, drücke x% y
• . Pop der Spitze des Stapels (der Akkumulator) und Ausgabe als Zeichen

Von hier aus führt uns der graue Code in die obere linke Ecke des Programms, ohne dass sich etwas auf dem Stapel befindet.

Grün

• _24 24 auf den Stapel schieben
• -pop x, pop y, push xy. 24 ist der Unterschied zwischen #und ;dies prüft, ob die Eingabe war ;. Wenn ja, geht ;der Code geradeaus weiter in Richtung ). Andernfalls dreht es sich zu dem, #der die Höhe des Stapels verschiebt (immer eine positive Zahl, die das Programm zwingt, an der nächsten Kreuzung nach rechts abzubiegen und den Code zu verpassen, der den Akkumulator inkrementiert).
• ; Werfen Sie die Oberseite des Stapels weg
• ) Inkrementieren Sie die Spitze des Stapels, die entweder eine implizite Null ist oder eine zuvor inkrementierte Null, die als Akkumulator für die Ausgabe fungiert

Von hier aus führt uns der graue Code in die obere linke Ecke des Programms mit dem Stapel, auf dem sich nur der Akku befindet.

Grau

Anführungszeichen sind No-Ops, _drücken eine 0 auf den Stapel und ;verwerfen den oberen Teil des Stapels. All dies ist nur Code, um den Kontrollfluss auf die richtige Art und Weise zu erzwingen und alles Weitere von der Oberseite des Stapels zu verwerfen.

MATL , 29 Bytes

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

Die Eingabe ist eine Zeichenfolge in einfachen Anführungszeichen.

Probieren Sie es online!

Das FizzBuzz-Programm ist für die Online-Dolmetscher zu lang. siehe es funktioniert offline in diesem GIF:

Erläuterung

Der Akkumulatorwert wird als Anzahl der Elemente im Stapel implementiert. Dadurch wird das Programm langsamer, als wenn der Akkumulatorwert eine einzelne Zahl im Stapel wäre, es werden jedoch einige Bytes gespart.

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

Probieren Sie es online!

Erläuterung

Wir behalten auf dem Stapel nur einen einzigen Zähler der Anzahl, auf die ;wir gestoßen sind. Wenn der Stack leer ist (zB beim Start des Programms), ist dies implizit eine 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

Eine kürzere, aber nicht terminierende Version dieses Programms finden Sie hier .

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)

Versuchte einen anderen Ansatz als Shaggys Antwort . Naja.

; # + , 59 Bytes, nicht konkurrierend

Die Sprache wurde nach dieser Herausforderung gemacht.

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

Probieren Sie es online! Die Eingabe wird mit einem Null-Byte abgeschlossen.

Erläuterung

Die Generierung ist die gleiche wie bei meiner Antwort mit dem Code "Generieren; #" . Der einzige Unterschied ist die Iteration.

Wiederholung

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

Probieren Sie es online!

Erläuterung

(Danke Cows Quack für -7 Bytes!)

Der trTeil entfernt alle überflüssigen Zeichen (ich könnte dies sedfür genau das gleiche bytecount eingeben, aber dann wird das Zeilenvorschubzeichen nicht richtig behandelt, da er sedsie einlässt und dcnur bis zum ersten Zeilenvorschub mit einlädt ?).

sedNimmt den Rest und erstellt ein dcProgramm:

Strings of ;werden zu Strings of 1(ein langes Literal)

#wird .ZC7%P(wenn dies auf eine Zeichenfolge von folgt 1, .ist dies ein Dezimalpunkt für ein No-Op. Wenn es sich jedoch am Anfang des Programms befindet oder einem anderen folgt #, ist es ein Literal 0. Dann nimmt es die Länge der Zahl an, modifiziert sie, und druckt das entsprechende ASCII.)

C, 65 64 60 Bytes

(-2 dank ceilingcat)

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