Gần đây tôi đã tạo ra một ngôn ngữ mới gọi là ;#(phát âm là "Dấu chấm phẩy") chỉ có hai lệnh:

; thêm một vào bộ tích lũy

#sửa đổi bộ tích lũy bằng 127, chuyển đổi thành ký tự ASCII và đầu ra mà không có dòng mới. Sau đó, đặt lại bộ tích về 0. Có, 127 là chính xác.

Bất kỳ nhân vật khác được bỏ qua. Nó không có tác dụng đối với người tích lũy và không nên làm gì.

Nhiệm vụ của bạn là tạo ra một trình thông dịch cho ngôn ngữ mạnh mẽ này!

Nó phải là một chương trình đầy đủ hoặc một chức năng sẽ lấy một ;#chương trình làm đầu vào và tạo ra đầu ra chính xác.

Ví dụ

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 lên tới 100

Python 3 , 69 68 byte

-1 byte nhờ @WheatWizard

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

Hãy thử trực tuyến!

JavaScript (ES6), 76 82 80 byte

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

Bản giới thiệu

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

Phiên bản đệ quy, 82 77 byte

Đã lưu 5 byte nhờ Neil

Cái này có khả năng bị sập đối với các đầu vào lớn như ví dụ Fizz Buzz.

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

Võng mạc , 336 63 67 65 66 62 59 byte

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

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

Hãy thử trực tuyến!

Phiên bản có thể đọc được bằng cú pháp thoát giả định :

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

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

Không in byte NUL, vì TIO không cho phép chúng trong mã nguồn. Đồng thời in thêm một dòng mới ở cuối, nhưng tôi đoán nó không thể làm khác được. Trailing newline bị đàn áp nhờ @Leo .

-273 byte (!) Nhờ @ETHproductions .

-2 byte nhờ @ovs .

-3 byte nhờ @Neil . Kiểm tra giải pháp 34 byte tuyệt vời của họ .

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

Hãy thử trực tuyến!

Japt , 18 byte

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

Có một char \ x7f không thể in được sau %#. Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

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

Đây là một sân golf của này câu trả lời trước đó.

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

Hãy thử trực tuyến! Python2

Hãy thử trực tuyến! Python3

Giải trình

Đây là một câu trả lời khá đơn giản, chúng tôi xác định có bao nhiêu ;s giữa mỗi #bản và in chrmod 127. Điều duy nhất có thể hơi lạ một chút là [:-1]. Chúng tôi cần phải bỏ nhóm cuối cùng bởi vì sẽ không có #sau đó.

Ví dụ

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

Sẽ được chia thành

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

Nhưng chúng tôi không muốn cuối cùng ;;;vì không có #nó sau khi in giá trị.

> <> , 35 byte

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

Hãy thử trực tuyến! Thay thế ␡bằng 0x7F ^?hoặc "xóa".

Vòng lặp chính

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

Cái này lấy một ký tự của input ( i), kiểm tra nếu nó nhỏ hơn 0 tức là EOF ( :0() và chấm dứt chương trình nếu nó là ( ?;). Mặt khác, kiểm tra xem đầu vào có bằng #( :'#'=) không. Nếu có, phân nhánh xuống và khởi động lại vòng lặp ( ?v... ^ ... <).

Bộ đếm logic

              ';'=?0
              

Kiểm tra xem đầu vào có bằng ;( ';'=) không. Nếu có, đẩy a 0. Nếu không, không làm gì cả. Điều này khởi động lại vòng lặp chính.

In logic

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

Khi ký tự đầu vào là #, bật đầu vào ra khỏi ngăn xếp ( ~), lấy số lượng thành viên trên ngăn xếp ( l), đẩy 127 ( '␡') và lấy mô-đun ( %). Sau đó, xuất nó dưới dạng một ký tự ( o) và bắt đầu một ngăn xếp mới ( [0). "Số không" này ra khỏi quầy. Sau đó, vòng lặp khởi động lại.

Python 3, 69 byte

Được cải thiện, nhờ @Wheat Wizard, @Uriel

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

Röda , 44 39 38 byte

5 byte được lưu nhờ @fergusq

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

Hãy thử trực tuyến!

Hàm ẩn danh lấy đầu vào từ luồng.

Nếu các nhân vật khác không phải bỏ qua, tôi nhận được điều này:

Röda , 20 byte

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

Ruby, 41 35 34 ký tự

( 40 34 mã 33 ký tự + tùy chọn dòng lệnh 1 ký tự)

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

Nhờ vào:

• Jordan đã đề xuất sử dụng putcđể không cần chuyển đổi rõ ràng với .chr(6 ký tự)
• Kirill L. vì đã tìm dấu ngoặc đơn không cần thiết (1 ký tự)

Chạy mẫu:

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

Hãy thử trực tuyến!

05AB1E , 16 15 14 byte

Mã số:

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

Giải trình:

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

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Thạch , 13 byte

ṣ”#Ṗċ€”;%127Ọ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Mã máy x86 trên 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

Nhận xét lắp ráp:

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 nhờ Adnan

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

Giải trình:

Î                       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

Hãy thử trực tuyến!

Võng mạc , 34 byte

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

Hãy thử trực tuyến! Bao gồm trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 2 byte với một số trợ giúp từ @MartinEnder. Lưu ý: Mã bao gồm không thể in được và sử dụng &#x;mã tạo ra kết quả không chính xác vì trình duyệt sử dụng Windows-1252 thay vì ISO-8859-1. Giải thích: Dòng đầu tiên dọn dẹp đầu vào: ;được thay đổi thành \x80, #để \x7F(do TIO hạn chế) và mọi thứ khác sẽ bị xóa. Sau đó, bất cứ khi nào chúng ta thấy một \x80cái không phải trước một cái khác \x80, chúng ta sẽ xóa nó và tăng dần theo mã của bất kỳ ký tự tiếp theo nào. Điều này được lặp đi lặp lại cho đến khi không còn \x80nhân vật nào nữa . Mã gốc hỗ trợ byte rỗng về cơ bản trừ 1 từ các byte không thể in được, ngoại trừ trong dòng đầu tiên \xFFkhông thay đổi và \x7Ftrở thành\x00. Với các lối thoát cho dễ đọc:

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

R, 97 90 86 84 byte

Một chức năng:

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

Khi R bắt đầu, Fđược định nghĩa là FALSE(số 0).

Ung dung:

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

Đồng bằng 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

Có thể đọc được

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

Hãy thử trực tuyến! (Gợi ý: nhấp vào Footer để thu gọn nó.)

Perl, 25 byte

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

Chạy với perl -043pe(được tính là 4 byte, vì perl -elà tiêu chuẩn).

Giải thích: -043đặt bộ kết thúc dòng thành #(ASCII 043). -plặp đi lặp lại trên các dòng đầu vào của dòng Điên (thực sự là # chuỗi giới hạn, bây giờ). y%;%%đếm số lượng ;trong mỗi dòng trên đường sắt. x/#/đảm bảo rằng chúng tôi không in thêm một ký tự cho các chương trình không kết thúc bằng số # (như bản thử nghiệm thứ ba). %127nên khá rõ ràng $_=là nồi hơi thông thường.

CJam, 27 byte

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

Giải trình:

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

Giải pháp thay thế, 18 byte

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

Giải trình:

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

Ung dung

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

Hãy thử trực tuyến!

Chỉnh sửa: Đã đối xử với bất kỳ char nào khác ngoài ';' như '#'. Thay đổi nó để nó bỏ qua ký tự không hợp lệ.

Thay thế

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

Sử dụng ô tham chiếu tiết kiệm 3 byte

Ung dung

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

Dùng thử trực tuyến

Xử lý.js (phiên bản 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;}}

Hãy thử trực tuyến!

Vì phiên bản xử lý được sử dụng không có bất kỳ phương thức nhập nào, đầu vào được đặt trong n.

Mê cung , 61 47 byte

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

Hãy thử trực tuyến!

Giải trình

Việc thực thi mã bắt đầu ở góc trên cùng bên trái và dấu chấm phẩy đầu tiên loại bỏ số 0 ẩn khỏi ngăn xếp và tiếp tục sang phải.

trái cam

• _36đẩy 36 lên ngăn xếp. Đây là để so sánh đầu vào với#
• } di chuyển đỉnh của ngăn xếp sang ngăn xếp thứ cấp
• , đẩy giá trị nguyên của ký tự trên ngăn xếp
• )tăng ngăn xếp (nếu kết thúc đầu vào, điều này sẽ làm cho ngăn xếp 0 và luồng chương trình sẽ tiến tới @và thoát)
• { di chuyển đỉnh ngăn xếp thứ cấp lên đỉnh ngăn xếp chính
• -pop y, pop x, đẩy x - y. Điều này là để so sánh đầu vào với #(35 in ascii). Nếu đầu vào là #mã sẽ tiếp tục đến phần màu tím (vì đỉnh của ngăn xếp là 0, IP sẽ tiếp tục theo hướng nó đang di chuyển trước đó), nếu không nó sẽ tiếp tục đến phần màu xanh lá cây.

Màu tím

• 127 đẩy 127 lên ngăn xếp
• % pop x, pop y, đẩy x% y
• . bật đỉnh ngăn xếp (bộ tích lũy) và xuất ra dưới dạng ký tự

Từ đây, mã màu xám đưa chúng ta đến góc trên cùng bên trái của chương trình mà không có gì trên ngăn xếp.

màu xanh lá

• _24 đẩy 24 lên ngăn xếp
• -pop x, pop y, đẩy xy. 24 là sự khác biệt giữa #và ;vì vậy điều này kiểm tra nếu đầu vào là ;. Nếu đó là ;mã tiếp tục thẳng về phía ). Nếu không, nó sẽ chuyển sang #chiều cao của ngăn xếp (luôn luôn là số dương, buộc chương trình rẽ phải ở giao lộ tiếp theo và bỏ lỡ mã làm tăng bộ tích lũy)
• ; loại bỏ đỉnh của ngăn xếp
• ) tăng đỉnh của ngăn xếp là số 0 ẩn hoặc nó là số 0 tăng trước đó đóng vai trò là bộ tích lũy cho đầu ra

Từ đây, mã màu xám đưa chúng ta đến góc trên cùng bên trái của chương trình với ngăn xếp chỉ có bộ tích lũy trên đó.

Xám

Báo giá là không-op, _đẩy 0 vào ngăn xếp và ;loại bỏ đỉnh của ngăn xếp. Tất cả điều này chỉ là mã để buộc luồng điều khiển theo đúng cách và loại bỏ bất cứ thứ gì thêm từ đầu ngăn xếp.

MATL , 29 byte

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

Đầu vào là một chuỗi được bao trong các dấu ngoặc đơn.

Hãy thử trực tuyến!

Chương trình FizzBuzz quá dài cho các phiên dịch viên trực tuyến; thấy nó hoạt động ngoại tuyến trong gif này:

Giải trình

Giá trị bộ tích lũy được thực hiện dưới dạng số phần tử trong ngăn xếp. Điều này làm cho chương trình chậm hơn so với nếu giá trị của bộ tích lũy là một số duy nhất trong ngăn xếp, nhưng nó tiết kiệm được một vài 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

Hãy thử trực tuyến!

Giải trình

Chúng tôi chỉ giữ trên ngăn xếp một bộ đếm duy nhất về số lượng ;chúng tôi đã gặp. Khi ngăn xếp trống (ví dụ khi bắt đầu chương trình), đây hoàn toàn là 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

Một phiên bản ngắn hơn, nhưng không kết thúc của chương trình này có thể được tìm thấy ở đây .

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)

Đã thử thực hiện một cách tiếp cận khác với câu trả lời của Shaggy . Ồ tốt

; # + , 59 byte, không lọc

Ngôn ngữ đã được thực hiện sau thử thách này.

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

Hãy thử trực tuyến! Đầu vào được kết thúc bằng một byte null.

Giải trình

Thế hệ giống như từ câu trả lời Generate; # code của tôi . Sự khác biệt duy nhất ở đây là sự lặp lại.

Lặp lại

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

Hãy thử trực tuyến!

Giải trình

(Cảm ơn Quack Quack cho -7 byte!)

Các trphần loại bỏ tất cả các nhân vật không liên quan (tôi có thể đặt này trong sedcho chính xác bytecount tương tự, nhưng sau đó nó không xử lý nhân vật linefeed đúng, vì sedchỉ còn sót lại và dcchỉ dậy cho linefeed đầu tiên với ?)

sedphần còn lại và xây dựng một dcchương trình:

Chuỗi ;trở thành chuỗi của 1(một chữ dài)

#trở thành .ZC7%P(nếu điều này tuân theo một chuỗi 1, .là một dấu thập phân cho một số không. Nhưng nếu nó ở đầu chương trình, hoặc theo sau #một chuỗi khác , thì nó là một chữ 0. Sau đó, nó lấy độ dài của số, sửa đổi nó, và In ASCII tương ứng.)

C, 65 64 60 byte

(-2 nhờ trần nhà)

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