Buatlah juru bahasa; #

62

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

caird coinheringaahing
sumber
1
Apakah dapat diterima jika juru bahasa tidak menghentikan pelaksanaannya di akhir input tetapi terus mengulang tanpa batas tanpa menghasilkan output tambahan?
Leo
5
Contoh kedua membuat saya bertanya-tanya tentang suatu program untuk menyandikan suatu program untuk menghasilkan keluaran ... kompilasi rekursif!
frarugi87
@ Leo ya itu baik
caird coinheringaahing
1
@iamnotmaynard Semicolon Hash
caird coinheringaahing
2
Mungkin Wink Hash akan lebih mudah untuk mengatakan
James Waldby - jwpat7

Jawaban:

20

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!

ovs
sumber
1
Anda dapat menyimpan byte dengan membalikkan if. Cobalah online!
Wheat Wizard
17

JavaScript (ES6), 76 82 80 byte

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

Demo

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==';')):""
Arnauld
sumber
Saya pikir f(s,a+(c==';'))mungkin menjatuhkan tiga byte dari versi rekursif Anda.
Neil
@ Neil Ini sebenarnya menyimpan 5 byte. :-)
Arnauld
Saya merasa sangat konyol sekarang. Saya awalnya memiliki versi kereta, dan dikurangi 2 byte untuk memperbaiki bug. Tapi saya salah hitung dan versi kereta sebenarnya menyelamatkan 7 byte ...
Neil
12

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 .

eush77
sumber
1
Astaga. Tetapi bisakah Anda tidak menyimpan seribu byte +T`\x01-~`_\x03-\x7f`[^\x01¯]\x01? (termasuk yang tidak diterbitkan sebagai karakter tunggal, tentu saja)
ETHproduksi
@ ETHproductions Tentu saja Anda bisa. Terima kasih! :)
eush77
1
Saat ini huruf terakhir selalu di output, bahkan jika tidak ada trailing #pada input. Anda dapat memperbaikinya dengan mengubah tahap kedua Anda menjadi(;{127}|;+$)
ovs
1
Apakah Anda memerlukan + `di baris ketiga? Saat Anda menghapus seluruh pertandingan, seharusnya tidak ada yang tersisa untuk diganti di iterasi kedua.
Ovs
1
Saya pikir saya bisa melakukan ini dalam 34 byte: T`;#\x01-ÿ`\x80\x7F_ \x80+$(baris kosong) \+T`\x7Fo`\x01-\x80_`\x80[^\x80](menggunakan escapes heksadesimal untuk mewakili unsintables). Output \ x7F bukan nulls.
Neil
12

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!

Mas
sumber
3
Selamat datang di situs ini! :)
DJMcMayhem
Saya menambahkan tautan ke penerjemah online dengan contoh FizzBuzz untuk Anda (teks tautan terlalu panjang untuk ditampung dalam komentar)
Jonathan Allan
Java menggunakan UTF-16 untuk program-programnya . Jadi, ini bukan 100 byte tetapi 100 karakter .
G.Broser mengatakan Reinstate Monica
5
@GeroldBroser Unicode adalah rangkaian karakter: UTF-8 dan UTF-16 adalah dua penyandian dari rangkaian karakter tersebut. Sumber ASCII benar-benar valid sebagai program Java, dan saya punya banyak file sumber Java yang dikodekan dalam ASCII (yang juga valid UTF-8, karenanya juga pengkodean Unicode).
1
Sepenuhnya golf, selama 81 byte sebagai Consumer<char[]>:s->{char i=0;for(int b:s){if(b==59)i++;if(b==35){System.out.print(i%=127);i=0;}}}
Olivier Grégoire
11

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
Produksi ETH
sumber
1
Doh, seharusnya sudah memeriksa jawabannya! Hanya menghabiskan waktu pada ini hanya untuk menemukan Anda akan mengalahkan saya dengan pukulan. q'# ®è'; u# dì¯Jjuga bekerja untuk skor yang sama.
Shaggy
11

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.

Wisaya Gandum
sumber
1
Saya sibuk mencoba mendapatkan semua tes dalam satu tautan TIO. Apakah chr untuk chr kecuali tdan x.
Jonathan Allan
9

> <> , 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.

Conor O'Brien
sumber
3
Buruk> <>. Sangat menyedihkan :0(:(
caird coinheringaahing
9

Python 3, 69 Bytes

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

print(''.join(chr(s.count(';')%127)for s in input().split('#')[:-1]))
MrGeek
sumber
3
Selamat Datang di Programming Puzzles dan Code Golf! Tujuannya di sini adalah untuk membuat kode sesingkat mungkin (dalam byte), jadi Anda harus memasukkan jumlah byte dalam header :).
Adnan
Terima kasih telah menjelaskan, tidak tahu itu. Saya akan mengerjakannya kalau begitu.
MrGeek
2
Anda dapat menghapus ruang setelah :s.
Pavel
1
Saya menghitung 74 byte. tio.run/nexus/…
Dennis
2
Juga, ';'==cmenghemat ruang, tetapi tidak menggunakan ifpernyataan sama sekali akan lebih pendek.
Dennis
9

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}
Kritixi Lithos
sumber
8

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!

manatwork
sumber
Doh. Meskipun saya melakukan C di tahun-tahun awal saya, saya benar-benar lupa putc(). Terima kasih, @Jordan
manatwork
1
Yang mengejutkan saya, Anda dapat benar-benar menjatuhkan tanda kurung setelah menghitung untuk menyimpan byte
Kirill L.
Tangkapan yang bagus, @ KirillL., Terima kasih.
manatwork
7

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!

Adnan
sumber
7

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.
Dennis
sumber
1
Kata semicolaitu tidak ada itu semicolons.
Erik the Outgolfer
@EriktheOutgolfer en.m.wiktionary.org/wiki/semicola
Dennis
Hmm, kata aneh.
Erik the Outgolfer
@EriktheOutgolfer Seseorang di Wiktionary mungkin mencoba membuat jamak Latin valid dalam bahasa Inggris, tetapi ejaan cola dan semicola harus dilarang.
Cœur
7

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
Matteo Italia
sumber
6

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!

Okx
sumber
1
Saya pikir Anda dapat menggantinya i>}dengan +.
Adnan
6

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$
Neil
sumber
Anda dapat menyimpan byte dengan menggabungkan dua tahap terakhir dengan \x80([^\x80]|$)pada tahap terakhir.
Martin Ender
@ MartinEnder Terima kasih! Yang menjengkelkan, \s+T`\x7Fo`\x01-\x80_`\x80(?!\x80).?juga hanya menghemat satu byte.
Neil
Ah, tapi [^\x80]|\x80$menghemat dua byte, saya pikir.
Neil
Ah bagus, ya yang terakhir berhasil. Saya juga sudah mencoba lookahead negatif, tetapi situ menjengkelkan.
Martin Ender
6

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
        }
    }
Sven Hohenstein
sumber
Bukankah ini seharusnya R + pryr?
L3viathan
@ L3viathan Karena pryradalah paket R, itu masih kode R.
Sven Hohenstein
Ini adalah kode R, tetapi membutuhkan instalasi perpustakaan tambahan.
L3viathan
@ L3viathan Apakah menurut Anda jawaban saya tidak valid? Haruskah saya menghindari menggunakan paket tambahan?
Sven Hohenstein
2
@ BLT Tidak ada perbedaan. Menurut pendapat saya, tidak ada masalah untuk menggunakan paket tambahan yang dibuat sebelum tantangan. Ini berlaku untuk semua bahasa. Dalam Python Anda harus menggunakan importsaat dalam R Anda dapat menggunakan ::untuk langsung mengakses fungsi dalam paket. Anda sering dapat melihat penggunaan paket tambahan di sini (misalnya, untuk Python dan Java). Namun, saya mengubah posting saya sebelumnya karena saya tidak ingin terlibat dalam diskusi.
Sven Hohenstein
5

Python, 82 byte

lambda t:''.join(chr(len([g for g in x if g==';'])%127)for x in t.split('#')[:-1])
Uriel
sumber
1
@WheatWizard karena Anda sudah memposting ini sebagai jawaban, saya percaya tindakan yang tepat bagi saya adalah untuk meningkatkannya daripada memperbarui
Uriel
4

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
Uriel
sumber
Bisakah itu mencetak karakter secara simbolis?
eush77
4

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

Dennis
sumber
4

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.

Grimmy
sumber
Yang mengesankan, meskipun ada kesalahan: untuk ;;#;;;itu output # 5 bukannya # 2.
manatwork
Bagaimana Anda mendapatkan hasil ini? echo -n ';;#;;;' | perl -043pe '$_=chr(y%;%%%127)x/#/' | xxdoutput dengan benar 00000000: 02di mesin saya. Jika Anda meninggalkan 043, atau menggunakan codepage #yang bukan ASCII 043, itu akan menjelaskan hasil Anda.
Grimmy
1
Ups. Maaf, saya salah ketik dalam pengujian. Kode Anda berfungsi dengan baik.
manatwork
4

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
Buah Esolanging
sumber
Business Cat Itu tidak mengabaikan karakter yang tidak valid.
Buah Esolanging
mengapa Anda perlu ;menghapus akumulator?
caird coinheringaahing
@RandomUser Jadi tidak pada akhirnya di-output dengan string.
ETHproduksi
4

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

Brunner
sumber
4

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.

Christopher
sumber
Anda dapat secara teknis memalsukan metode input Anda sendiri dengan keyTyped=function(){ ... }: P
ETHproduksi
@ ETHproductions Ini adalah tampilan jijik.
Christopher
@RandomUser yay! Saya telah selesai melakukannya! Saya suka menjawab dalam Memproses (periksa jawaban saya)
Christopher
2
@RandomUser Bukan hanya 1000 rep .. tapi 2 ^ 10 rep (͡ ° ͜ʖ ͡ °)
@Midnightas Ohhh yeah
Christopher
4

Labyrinth , 61 47 byte

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

Cobalah online!

Penjelasan

gambar kode warna dari kode solusi

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.

Robert Hickman
sumber
Karena penasaran, bagaimana Anda menghasilkan gambar penjelasan? Apakah Anda membuatnya sendiri?
Stefnotch
2
@Stefnotch, saya menggunakan editor teks untuk meletakkan tab di antara setiap karakter dan kemudian menempelkan kode ke Microsoft Excel yang menempatkan setiap karakter ke dalam selnya sendiri. Saya memilih semua sel untuk memberi mereka lebar dan tinggi yang sama. Lalu saya menyesuaikan warna dan batas dan mengambil tangkapan layar.
Robert Hickman
3

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:

masukkan deskripsi gambar di sini

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
Luis Mendo
sumber
3

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 .

Leo
sumber
Dikonfirmasi di sini
caird coinheringaahing
Maaf untuk pemformatan yang buruk, saya telah memposting ini dari ponsel saya, saya akan memperbaikinya segera setelah saya mendapatkan pc
Leo
Program harus diakhiri kecuali ditentukan lain dalam tantangan.
Martin Ender
Anda dapat menyimpan byte dengan menggunakan 0x7F literal bukan ~h.
Martin Ender
@ MartinEnder membuatnya berhenti. Saya tidak bisa memasukkan 0x7F ke dalam kode, tapi saya rasa modifikasi alternatif ini lebih menarik :)
Leo
3

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.


sumber
3

; # + , 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
Conor O'Brien
sumber
3

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

Sophia Lechner
sumber
Anda tidak perlu untuk melarikan diri dari ;dalam '...'dan hanya bisa berubah dc -ez?ke dc. Selain itu, alih-alih ;menambahkan 1 ke stack, Anda dapat mengelompokkannya bersama dan mendapatkan panjangnya Zuntuk mencapai tio.run/##S0oszvj/… .
Kritixi Lithos
@Cowsquack Bagus, terima kasih! (dan dc -ez?itu konsekuensi dari membutuhkan nol ekstra untuk memulai program) Tetapi program Anda menambahkan output tambahan stderrbaik dalam kasus berturut-turut #atau input yang tidak berakhir dengan #(dalam kedua kasus, maksud saya setelah karakter asing dihapus) . Saya tidak tahu apakah ada konsensus, tapi saya merasa output ekstra itu membatalkan solusi. Saya mengadaptasi ide Anda, dan akhirnya hanya satu byte lebih dari saran Anda tanpa dcmembuat kesalahan!
Sophia Lechner
Menurut stderr ini dapat diabaikan kecuali tantangan secara eksplisit menyatakan seperti itu, sehingga sangat berguna untuk dc. Juga mencatat bahwa solusi saat ini gagal dengan berturut-turut #s karena Zdari 0yaitu 1, sehingga output 0x01 bukan 0x00 (aku jatuh ke dalam perangkap yang sama juga, tapi browser saya menampilkan unprintables sebagai hexcodes mereka sehingga aku menangkap itu).
Kritixi Lithos
3

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);}
hvd
sumber
Anda harus menginisialisasi cke nol untuk membuat fungsi ini dapat digunakan kembali .
Conor O'Brien
@ ConorO'Brien Diperbaiki. Sayangnya saya tidak berhasil menghasilkan sesuatu yang lebih pendek dari sekadar menambahkan c=0, dan saya tidak ingin menipu dengan menyalin dari jawaban Dennis.
hvd
@ceilingcat Terima kasih lagi, saya bisa melepas tiga byte lagi setelah itu. Ini memang menggunakan trik dalam jawaban Dennis (diperiksa setelah diedit), tetapi kali ini, sudah begitu banyak waktu berlalu sehingga saya lupa semua tentangnya dan muncul sendiri.
hvd