ฉันเพิ่งสร้างภาษาใหม่ที่เรียกว่า;#(ออกเสียง "Semicolon Hash") ซึ่งมีเพียงสองคำสั่ง:

; เพิ่มหนึ่งในการสะสม

#modulo ตัวสะสมโดย 127 แปลงเป็นอักขระ ASCII และเอาท์พุทโดยไม่ต้องขึ้นบรรทัดใหม่ หลังจากนี้ให้รีเซ็ตตัวสะสมเป็น 0 ใช่แล้ว 127 ถูกต้อง

อักขระอื่น ๆ จะถูกละเว้น มันไม่มีผลกับตัวสะสมและไม่ควรทำอะไรเลย

งานของคุณคือสร้างล่ามสำหรับภาษาที่ทรงพลังนี้!

ควรเป็นโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่จะใช้;#โปรแกรมเป็นอินพุตและสร้างเอาต์พุตที่ถูกต้อง

ตัวอย่าง

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 มากถึง 100

Python 3 , 69 68 ไบต์

-1 ไบต์ขอบคุณ @WheatWizard

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

ลองออนไลน์!

JavaScript (ES6), 76 82 80 ไบต์

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

การสาธิต

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

เวอร์ชันแบบเรียกซ้ำ82 77 ไบต์

บันทึก 5 ไบต์ขอบคุณ Neil

อันนี้น่าจะผิดพลาดสำหรับอินพุตขนาดใหญ่เช่นตัวอย่าง Fizz Buzz

f=([c,...s],a=0)=>c?c=='#'?String.fromCharCode(a%127)+f(s):f(s,a+(c==';')):""

เรติน่า , 336 63 67 65 66 62 59 59 ไบต์

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

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

ลองออนไลน์!

รุ่นที่อ่านได้โดยใช้ไวยากรณ์ยกเว้นการสมมติ :

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

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

ห้ามพิมพ์ NUL ไบต์เนื่องจาก TIO ไม่อนุญาตให้ใช้ในซอร์สโค้ด พิมพ์บรรทัดใหม่พิเศษในตอนท้ายด้วย แต่ฉันคิดว่ามันไม่สามารถทำได้ ต่อท้ายบรรทัดใหม่ปราบปรามขอบคุณที่@Leo

-273 (!) ไบต์ขอบคุณที่@ETHproductions

-2 ไบต์ขอบคุณที่@ovs

-3 ไบต์ขอบคุณที่@Neil ตรวจสอบของพวกเขาที่ยอดเยี่ยมการแก้ปัญหา 34 ไบต์

Java 8, 100 ไบต์

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

ลองออนไลน์!

Japt , 18 ไบต์

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

มี unprintable \ x7f %#ถ่านหลังจากที่เป็น ทดสอบออนไลน์!

มันทำงานอย่างไร

®   è'; %#   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 ไบต์

นี่คือกอล์ฟนี้คำตอบก่อนหน้านี้

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

ลองออนไลน์! Python2

ลองออนไลน์! Python3

คำอธิบาย

นี่คือคำตอบที่ตรงไปตรงสวยเรากำหนดจำนวน;s อยู่ระหว่างแต่ละ#และพิมพ์chrmod 127 สิ่งเดียวที่อาจจะมีนิด ๆ หน่อย ๆ [:-1]ที่แปลกคือ เราจำเป็นต้องวางกลุ่มสุดท้ายเพราะจะไม่มี#หลังจากนั้น

ตัวอย่างเช่น

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

จะถูกแบ่งออกเป็น

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

แต่เราไม่ต้องการคนสุดท้าย;;;เพราะไม่มี#หลังจากนั้นเพื่อพิมพ์ค่า

> <> , 35 ไบต์

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

ลองออนไลน์! แทนที่␡ด้วย 0x7F ^?หรือ "ลบ"

ห่วงหลัก

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

สิ่งนี้ใช้ลักษณะของอินพุต ( i) ตรวจสอบว่ามันน้อยกว่าศูนย์เช่น EOF ( :0() และยกเลิกโปรแกรมถ้ามันเป็น ( ?;) มิฉะนั้นตรวจสอบว่าอินพุตเท่ากับ#( :'#'=) ถ้าเป็นเช่นนั้นให้แบรนช์ดาวน์และรีสตาร์ทลูป ( ?v... ^ ... <)

ตรรกะเคาน์เตอร์

              ';'=?0
              

ตรวจสอบว่าอินพุตเท่ากับ;( ';'=) 0ถ้าเป็นผลักดัน มิฉะนั้นไม่ทำอะไรเลย นี่เป็นการรีสตาร์ทลูปหลัก

ตรรกะการพิมพ์

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

เมื่ออักขระป้อนเข้า#ปรากฏขึ้นให้ป้อนอินพุตจากสแต็ก ( ~) รับจำนวนสมาชิกในสแต็ก ( l) กด 127 ( '␡') และรับโมดูลัส ( %) จากนั้นเอาท์พุทเป็นอักขระ ( o) และเริ่มสแต็กใหม่ ( [0) "เลขศูนย์" นี้ออกจากเคาน์เตอร์ จากนั้นลูปจะรีสตาร์ท

Python 3, 69 Bytes

ปรับปรุงแล้วขอบคุณ @Wheat Wizard, @Uriel

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

Röda , 44 39 38 ไบต์

บันทึก 5 ไบต์ด้วย @fergusq

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

ลองออนไลน์!

ฟังก์ชั่นนิรนามที่รับอินพุตจากสตรีม

หากตัวละครอื่น ๆ ไม่ควรถูกเพิกเฉยฉันได้รับสิ่งนี้

Röda , 20 ไบต์

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

Ruby, 41 35 34 ตัวอักษร

( 40 34 33 ตัวอักษรรหัส + ตัวเลือกบรรทัดคำสั่ง 1 ตัว)

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

ขอบคุณที่:

• Jordanสำหรับการแนะนำให้ใช้putcไม่จำเป็นต้องมีการแปลงที่ชัดเจนด้วย.chr(6 ตัวอักษร)
• Kirill L.สำหรับค้นหาวงเล็บที่ไม่จำเป็น (1 ตัวอักษร)

วิ่งตัวอย่าง:

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

ลองออนไลน์!

05AB1E , 16 15 14 ไบต์

รหัส:

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

คำอธิบาย:

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

ใช้การเข้ารหัส 05AB1E ลองออนไลน์!

เยลลี่ขนาด 13 ไบต์

ṣ”#Ṗċ€”;%127Ọ

ลองออนไลน์!

มันทำงานอย่างไร

ṣ”#Ṗċ€”;%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 บน MS-DOS - 29 ไบต์

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

ประกอบความเห็น:

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 ไบต์

-2 ไบต์ขอบคุณ Adnan

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

คำอธิบาย:

Î                       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

ลองออนไลน์!

เรติน่า 34 ไบต์

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

ลองออนไลน์! รวมถึงกรณีทดสอบ แก้ไข: บันทึก 2 ไบต์ด้วยความช่วยเหลือจาก @MartinEnder หมายเหตุ: รหัสรวมถึง unprintables และการใช้&#x;รหัสจะสร้างผลลัพธ์ที่ไม่ถูกต้องเนื่องจากเบราว์เซอร์ใช้ Windows-1252 แทน ISO-8859-1 คำอธิบาย: บรรทัดแรกทำความสะอาดการป้อนข้อมูล: ;จะเปลี่ยนไป\x80, #ไป\x7F(เนื่องจากข้อ จำกัด TIO) และทุกสิ่งทุกอย่างจะถูกลบออก จากนั้นเมื่อใดก็ตามที่เราเห็นสิ่ง\x80ที่ไม่ได้อยู่ก่อนหน้า\x80เราจะลบมันและเพิ่มรหัสของตัวละครตัวต่อไป นี่คือการทำซ้ำจนกว่าจะไม่มี\x80ตัวละครเหลืออีก รหัสดั้งเดิมที่รองรับ null null โดยทั่วไปจะลบ 1 จากไบต์ที่ไม่สามารถพิมพ์ได้ยกเว้นในบรรทัดแรกที่\xFFไม่มีการเปลี่ยนแปลงและ\x7Fจะกลายเป็น\x00. ด้วยการหลบหนีเพื่อให้อ่านง่าย:

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

R, 97 90 86 84 ไบต์

ฟังก์ชั่น:

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

เมื่อ R เริ่มต้นFจะถูกกำหนดเป็นFALSE(ตัวเลข0)

Ungolfed:

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

Python ขนาด 82 ไบต์

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

Plain TeX, 156 ไบต์

\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

อ่านง่าย

\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 ไบต์

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

ลองออนไลน์! (คำแนะนำ: คลิก▼ Footerเพื่อยุบ)

Perl, 25 ไบต์

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

เรียกใช้ด้วยperl -043pe(นับเป็น 4 ไบต์เนื่องจากperl -eเป็นมาตรฐาน)

คำอธิบาย: -043ตั้งค่า line-terminator เป็น#(ASCII 043) -pวนซ้ำเหนือเส้น“ input” (จริง ๆ แล้วคือสตริง # -delimited ตอนนี้) y%;%%นับจำนวนของ;ใน“ เส้น” แต่ละอัน x/#/ตรวจสอบให้แน่ใจว่าเราไม่ได้พิมพ์อักขระพิเศษสำหรับโปรแกรมที่ไม่ได้ลงท้ายด้วย # (เช่น testcase ที่สาม) %127ควรจะค่อนข้างชัดเจน $_=เป็นสำเร็จรูปทั่วไป

CJam, 27 ไบต์

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

คำอธิบาย:

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

ทางเลือกโซลูชัน 18 ไบต์

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

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

แก้ไข: ทำการรักษาคนอื่นที่ไม่ใช่ ';' เช่น '#'. เปลี่ยนมันเพื่อไม่สนใจตัวอักษรที่ไม่ถูกต้อง

ทางเลือก

F #, 107 104 ไบต์

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

การใช้เซลล์อ้างอิงช่วยประหยัด 3 ไบต์

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

ลองออนไลน์

กำลังดำเนินการ js (เวอร์ชัน Khanacademy), 118 ไบต์

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

ลองออนไลน์!

เนื่องจากเวอร์ชันของการประมวลผลที่ใช้ไม่มีวิธีการอินพุตใด ๆ จะถูกใส่ใน n

เขาวงกต , 61 47 ไบต์

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

ลองออนไลน์!

คำอธิบาย

การประมวลผลโค้ดเริ่มต้นที่มุมซ้ายบนและเซมิโคลอนแรกทิ้งศูนย์โดยนัยออกจากสแต็กและไปทางขวา

ส้ม

• _36เพิ่ม 36 ลงบนสแต็ก นี่คือการเปรียบเทียบอินพุตกับ#
• } ย้ายด้านบนของสแต็กไปที่สแต็กรอง
• , ผลักดันค่าจำนวนเต็มของตัวละครในกอง
• )เพิ่มสแต็ก (ถ้าเป็นส่วนท้ายของอินพุตสิ่งนี้จะทำให้สแต็ก 0 และการไหลของโปรแกรมจะดำเนินการต่อไป@และออก)
• { ย้ายด้านบนของสแต็กรองไปด้านบนของสแต็กหลัก
• -ป๊อป y, ป๊อป x, กด x - y นี่คือการเปรียบเทียบอินพุตกับ#(35 ใน ascii) หากอินพุตเป็น#รหัสจะดำเนินต่อไปยังส่วนสีม่วง (เนื่องจากด้านบนของสแต็คเป็น 0 IP จะดำเนินการต่อในทิศทางที่มันเคยเคลื่อนที่มาก่อน) มิฉะนั้นจะยังคงอยู่ในส่วนสีเขียว

สีม่วง

• 127 กด 127 ไปที่สแต็ก
• % ป๊อป x, ป๊อป y, กด x% y
• . ป๊อปด้านบนของสแต็ค (สะสม) และเอาท์พุทเป็นตัวละคร

จากที่นี่รหัสสีเทาจะพาเราไปที่มุมซ้ายบนของโปรแกรมโดยที่ไม่มีอะไรมาวางซ้อน

เขียว

• _24 กด 24 ลงบนสแต็ก
• -ป๊อป x, ป๊อป y, กด xy 24 ความแตกต่างระหว่าง#และดังนั้นนี้จะตรวจสอบถ้าใส่เป็น; ;ถ้ามันเป็นรหัสยังคงตรงไปที่; )มิฉะนั้นจะหันไปทาง#ที่เพิ่มความสูงของสแต็ก (เป็นจำนวนบวกเสมอบังคับให้โปรแกรมเลี้ยวขวาที่สี่แยกถัดไปและพลาดรหัสที่เพิ่มการสะสม)
• ; ทิ้งส่วนบนสุดของสแต็ก
• ) เพิ่มค่าสูงสุดของสแต็กซึ่งเป็นศูนย์โดยนัยหรือเป็นศูนย์ที่เพิ่มขึ้นก่อนหน้านี้ซึ่งทำหน้าที่เป็นตัวสะสมสำหรับเอาต์พุต

จากที่นี่รหัสสีเทาจะพาเราไปที่มุมซ้ายบนของโปรแกรมด้วยสแต็คที่มีเพียงตัวสะสมเท่านั้น

สีเทา

_เครื่องหมายอัญประกาศไม่มีการพุชผลัก 0 ไปยังสแต็กและ;ละทิ้งด้านบนของสแต็ก ทั้งหมดนี้เป็นเพียงรหัสเพื่อบังคับให้โฟลว์คอนโทรลในทางที่ถูกต้องและละทิ้งสิ่งพิเศษจากด้านบนของสแต็ก

MATL , 29 ไบต์

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

อินพุตเป็นสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยว

ลองออนไลน์!

โปรแกรม FizzBuzz ยาวเกินไปสำหรับล่ามออนไลน์ เห็นมันทำงานออฟไลน์ใน gif นี้:

คำอธิบาย

มีการใช้งานค่าตัวสะสมเป็นจำนวนองค์ประกอบในสแต็ก สิ่งนี้ทำให้โปรแกรมช้ากว่าหากค่าตัวสะสมเป็นตัวเลขเดียวในสแต็ก แต่จะบันทึกไม่กี่ไบต์

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

อลิซ 22 ไบต์

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

ลองออนไลน์!

คำอธิบาย

เราเก็บไว้ในสแต็คเพียงหนึ่งเคาน์เตอร์จำนวนที่;เราได้พบ เมื่อสแต็กว่างเปล่า (เช่นเมื่อเริ่มต้นโปรแกรม) ค่านี้จะเป็น 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

สั้น แต่ไม่ใช่ยุติรุ่นของโปรแกรมนี้สามารถพบได้ที่นี่

JS (ES6), 97 92 ไบต์

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

พยายามที่จะใช้วิธีการที่แตกต่างกันกว่าคำตอบปุย โอ้ดี

; # + , 59 ไบต์, ไม่ใช่การแข่งขัน

ภาษาถูกสร้างขึ้นหลังจากความท้าทายนี้

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

ลองออนไลน์! อินพุตถูกยกเลิกด้วย null null

คำอธิบาย

รุ่นที่เป็นเช่นเดียวจากฉันสร้าง; ตอบ ความแตกต่างเพียงอย่างเดียวที่นี่คือการทำซ้ำ

การย้ำ

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

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

ลองออนไลน์!

คำอธิบาย

(ขอบคุณ Cows Quack สำหรับ -7 ไบต์!)

trส่วนเอาตัวละครภายนอกทั้งหมด (ฉันสามารถใส่นี้ในsedสำหรับตรง bytecount เดียวกัน แต่แล้วก็ไม่ได้จัดการกับตัวอักษรเลื่อนบรรทัดได้อย่างถูกต้องตั้งแต่sedออกจากพวกเขาและdcเพียงได้รับขึ้นไปเลื่อนบรรทัดแรกที่มี?)

sedใช้เวลาที่เหลือและสร้างdcโปรแกรม:

สตริงการ;กลายเป็นสตริงของ1(ตัวอักษรยาว)

#กลายเป็น.ZC7%P(ถ้าตามหลังสตริง1, .จะเป็นจุดทศนิยมสำหรับ no-op. แต่ถ้ามันอยู่ที่จุดเริ่มต้นของโปรแกรม, หรือตามมาอีกอัน#, มันจะเป็นตัวอักษร0. แล้วมันจะใช้ความยาวของตัวเลข, ดัดแปลงมัน, และพิมพ์ ASCII ที่เกี่ยวข้อง)

C, 65 64 60 ไบต์

(-2 ขอบคุณแมวเพดาน)

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