Baru-baru ini saya membuat bahasa baru yang disebut ;#(dilafalkan "Semicolon Hash") yang hanya memiliki dua perintah:

; tambahkan satu ke akumulator

#modulo akumulator sebesar 127, konversikan ke karakter ASCII dan hasilkan tanpa baris baru. Setelah ini, setel ulang akumulator ke 0. Ya, 127 benar.

Setiap karakter lain diabaikan. Itu tidak berpengaruh pada akumulator dan tidak melakukan apa-apa.

Tugas Anda adalah membuat penerjemah untuk bahasa yang kuat ini!

Ini harus berupa program penuh atau fungsi yang akan mengambil ;#program sebagai input dan menghasilkan output yang benar.

Contohnya

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 hingga 100

Python 3 , 69 68 byte

-1 byte terima kasih kepada @WheatWizard

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

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

Versi rekursif, 82 77 byte

Disimpan 5 byte berkat Neil

Yang ini cenderung macet untuk input besar seperti contoh 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\`¯`

Cobalah online!

Versi yang dapat dibaca menggunakan sintaks hipotetis :

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

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

Tidak mencetak byte NUL, karena TIO tidak mengizinkannya dalam kode sumber. Juga mencetak baris baru ekstra di akhir, tapi saya rasa itu tidak bisa dilakukan sebaliknya. Trailing newline ditekan berkat @Leo .

-273 (!) Bytes berkat @ETHproductions .

-2 byte terima kasih kepada @ovs .

-3 byte terima kasih kepada @Neil . Lihat solusi 34-byte mereka yang luar biasa .

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

Cobalah online!

Japt , 18 byte

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

Ada char yang tidak dapat dicetak setelahnya %#. Uji secara online!

Bagaimana itu bekerja

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

Ini adalah golf dari jawaban sebelumnya ini .

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

Cobalah online! Python2

Cobalah online! Python3

Penjelasan

Ini adalah jawaban yang cukup mudah kami menentukan berapa banyak ;antara masing #- masing dan mencetak chrmod 127. Satu-satunya hal yang mungkin sedikit aneh adalah [:-1]. Kita perlu menghapus grup terakhir karena tidak akan ada #setelahnya.

Sebagai contoh

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

Akan dibagi menjadi

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

Tetapi kami tidak ingin yang terakhir ;;;karena tidak ada #setelah itu untuk mencetak nilai.

> <> , 35 byte

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

Cobalah online! Ganti ␡dengan 0x7F ^?,, atau "hapus".

Loop utama

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

Ini mengambil karakter input ( i), memeriksa apakah kurang dari nol yaitu EOF ( :0() dan mengakhiri program jika ( ?;). Jika tidak, periksa apakah input sama dengan #( :'#'=). Jika ya, cabang ke bawah dan mulai ulang loop ( ?v... ^ ... <).

Logika balasan

              ';'=?0
              

Periksa apakah input sama dengan ;( ';'=). Jika ya, tekan a 0. Kalau tidak, jangan lakukan apa pun. Ini me-restart loop utama.

Logika pencetakan

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

Ketika karakter inputnya #, pop input dari stack ( ~), dapatkan jumlah anggota di stack ( l), tekan 127 ( '␡'), dan ambil modulus ( %). Kemudian, keluarkan sebagai karakter ( o) dan mulai tumpukan baru ( [0). Ini "nol" di luar meja. Kemudian, loop dimulai kembali.

Python 3, 69 Bytes

Lebih baik, terima kasih kepada @Wheat Wizard, @Uriel

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

Röda , 44 39 38 byte

5 byte disimpan berkat @fergusq

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

Cobalah online!

Fungsi anonim yang mengambil input dari aliran.

Jika karakter lain tidak harus diabaikan, saya mengerti:

Röda , 20 byte

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

Ruby, 41 35 34 karakter

( 40 34 33 kode karakter + 1 opsi baris perintah karakter)

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

Terimakasih untuk:

• Jordan untuk menyarankan penggunaan putcagar tidak memerlukan konversi eksplisit dengan .chr(6 karakter)
• Kirill L. untuk menemukan tanda kurung yang tidak perlu (1 karakter)

Contoh dijalankan:

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

Cobalah online!

05AB1E , 16 15 14 byte

Kode:

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

Penjelasan:

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

Menggunakan pengodean 05AB1E. Cobalah online!

Jelly , 13 byte

ṣ”#Ṗċ€”;%127Ọ

Cobalah online!

Bagaimana itu bekerja

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

kode mesin x86 pada 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

Majelis yang dikomentari:

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 terima kasih kepada Adnan

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

Penjelasan:

Î                       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

Cobalah online!

Retina , 34 byte

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

Cobalah online! Termasuk test case. Sunting: Disimpan 2 byte dengan bantuan dari @MartinEnder. Catatan: Kode termasuk unsintables, dan menggunakan &#x;kode menghasilkan hasil yang salah karena browser menggunakan Windows-1252 bukannya ISO-8859-1. Penjelasan: Baris pertama membersihkan input: ;diubah menjadi \x80, #ke \x7F(karena batasan TIO) dan yang lainnya dihapus. Kemudian setiap kali kita melihat \x80yang tidak ada di depan yang lain \x80, kita menghapusnya dan secara siklis menambah kode karakter berikutnya. Ini diulang sampai tidak ada lagi \x80karakter yang tersisa. Kode asli yang mendukung byte nol pada dasarnya mengurangi 1 dari byte yang tidak dapat dicetak, kecuali pada baris pertama di mana \xFFtidak berubah dan \x7Fmenjadi\x00. Dengan lolos untuk kemudahan:

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

R, 97 90 86 84 byte

Sebuah fungsi:

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

Ketika R dimulai, Fdidefinisikan sebagai FALSE(numerik 0).

Tidak Disatukan:

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

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

Dapat dibaca

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

Cobalah online! (Petunjuk: klik ▼ Footer untuk menutupnya.)

Perl, 25 byte

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

Jalankan dengan perl -043pe(dihitung sebagai 4 byte, karena perl -estandar).

Penjelasan: -043mengatur line-terminator ke #(ASCII 043). -piterates di atas input "lines" (sebenarnya string # -delimited, sekarang). y%;%%menghitung jumlah ;di setiap "garis". x/#/memastikan bahwa kami tidak mencetak karakter tambahan untuk program yang tidak diakhiri dengan # (seperti testcase ketiga). %127harus cukup jelas. $_=adalah boilerplate biasa.

CJam, 27 byte

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

Penjelasan:

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

Solusi Alternatif, 18 byte

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

Penjelasan:

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

Tidak disatukan

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

Cobalah online!

Sunting: Memperlakukan arang selain ';' sebagai '#'. Mengubahnya sehingga mengabaikan karakter yang tidak valid.

Alternatif

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

Penggunaan sel referensi menghemat 3 byte

Tidak disatukan

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

Cobalah online

Processing.js (versi 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;}}

Cobalah online!

Karena versi pemrosesan yang digunakan tidak memiliki metode input, input ditempatkan pada n.

Labyrinth , 61 47 byte

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

Cobalah online!

Penjelasan

Eksekusi kode dimulai di sudut kiri atas dan titik koma pertama membuang nol implisit dari tumpukan dan berlanjut ke kanan.

jeruk

• _36mendorong 36 ke tumpukan. Ini untuk membandingkan input dengan#
• } memindahkan bagian atas tumpukan ke tumpukan sekunder
• , mendorong nilai integer karakter pada stack
• )increments stack (jika ini adalah akhir dari input, ini akan membuat stack 0 dan aliran program akan melanjutkan ke @dan keluar)
• { memindahkan bagian atas tumpukan sekunder ke bagian atas tumpukan utama
• -pop y, pop x, tekan x - y. Ini untuk membandingkan input dengan #(35 dalam ascii). Jika inputnya adalah #kode akan melanjutkan ke bagian ungu (karena bagian atas tumpukan adalah 0 IP melanjutkan ke arah itu bergerak sebelumnya), jika tidak maka akan berlanjut ke bagian hijau.

Ungu

• 127 dorong 127 ke tumpukan
• % pop x, pop y, tekan x% y
• . pop bagian atas tumpukan (akumulator) dan output sebagai karakter

Dari sini kode abu-abu membawa kita ke sudut kiri atas program tanpa apa-apa di tumpukan.

hijau

• _24 dorong 24 ke tumpukan
• -pop x, pop y, tekan xy. 24 adalah perbedaan antara #dan ;jadi ini memeriksa apakah inputnya ;. Jika itu ;kode terus lurus menuju ). Kalau tidak, ia akan beralih ke #yang mendorong ketinggian tumpukan (selalu angka positif, memaksa program untuk berbelok ke kanan di persimpangan berikutnya dan kehilangan kode yang menambah akumulator)
• ; buang bagian atas tumpukan
• ) increment bagian atas tumpukan yang merupakan nol implisit atau merupakan nol yang sebelumnya bertambah yang bertindak sebagai akumulator untuk keluaran

Dari sini kode abu-abu membawa kita ke sudut kiri atas program dengan tumpukan dengan hanya akumulator di atasnya.

Abu-abu

Kutipan adalah no-ops, _mendorong 0 ke stack, dan ;membuang bagian atas stack. Semua ini hanya kode untuk memaksa aliran kontrol dengan cara yang benar dan membuang apa pun tambahan dari atas tumpukan.

MATL , 29 byte

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

Input adalah string yang dilampirkan dalam tanda kutip tunggal.

Cobalah online!

Program FizzBuzz terlalu panjang untuk penerjemah online; melihatnya bekerja offline di gif ini:

Penjelasan

Nilai akumulator diimplementasikan sebagai jumlah elemen dalam tumpukan. Ini membuat program lebih lambat daripada jika nilai akumulator adalah angka tunggal dalam stack, tetapi menyimpan beberapa 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

Cobalah online!

Penjelasan

Kami tetap di tumpukan hanya satu penghitung dari berapa banyak yang ;kami temui. Ketika tumpukan kosong (misalnya di awal program) ini secara implisit adalah 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

Versi yang lebih pendek, tetapi tidak berhenti dari program ini dapat ditemukan di sini .

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)

Mencoba mengambil pendekatan yang berbeda dari jawaban Shaggy . Baiklah.

; # + , 59 byte, tidak bersaing

Bahasa dibuat setelah tantangan ini.

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

Cobalah online! Input diakhiri dengan byte nol.

Penjelasan

Generasi ini sama dengan dari jawaban kode # Generate; saya . Satu-satunya perbedaan di sini adalah iterasi.

Perulangan

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

Cobalah online!

Penjelasan

(Terima kasih Sapi Quack untuk -7 byte!)

The trporsi menghapus semua karakter yang asing (saya bisa menempatkan ini dalam seduntuk persis bytecount sama, tapi kemudian tidak menangani karakter linefeed benar, karena sedmeninggalkan mereka dan dchanya bangun untuk linefeed pertama dengan ?)

sedmengambil sisanya dan membangun dcprogram:

Untaian ;menjadi untaian 1(panjang literal)

#menjadi .ZC7%P(jika ini mengikuti string 1, .adalah titik desimal untuk no-op. Tetapi jika itu di awal program, atau mengikuti yang lain #, itu adalah literal 0. Kemudian dibutuhkan panjang angka, mods itu, dan Mencetak ASCII yang sesuai.)

C, 65 64 60 byte

(-2 terima kasih kepada ceilingcat)

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