Kısa bir süre önce ;#sadece iki komuttan oluşan ("noktalı virgül hasarı" olarak adlandırılan) adı verilen yeni bir dil oluşturdum :

; aküye bir tane ekle

#akümülatörü 127'ye kadar olan modulo, ASCII karakterine dönüştürür ve yeni bir satır olmadan çıktı verir . Bundan sonra akümülatörü 0'a sıfırlayın. Evet, 127 doğrudur.

Başka herhangi bir karakter göz ardı edilir. Akümülatör üzerinde etkisi yoktur ve hiçbir şey yapmamalıdır.

Görevin bu güçlü dil için bir tercüman yaratmak!

Tam bir program veya bir ;#programı girdi olarak alacak ve doğru çıktıyı üreten bir işlev olmalıdır .

Örnekler

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 100'e Kadar Buzz

Python 3 , 69 68 bayt

@WheatWizard sayesinde -1 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 76 82 80 bayt

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

gösteri

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

Özyinelemeli sürümü, 82 77 bayt

Neil sayesinde 5 bayt kaydedildi

Bunun Fizz Buzz örneği gibi büyük girdiler için çökmesi olasıdır.

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 bayt

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

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

Çevrimiçi deneyin!

Varsayımsal kaçış sözdizimini kullanan okunabilir sürüm :

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

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

NUL bayt yazdırmaz, çünkü TIO kaynak koduna izin vermez. Ayrıca sonunda fazladan bir yeni satır yazdırıyor, ancak başka türlü yapamayacağını tahmin ediyorum. Sondaki satır @Leo sayesinde bastırıldı .

-273 (!) Bayt @ETHproductions sayesinde .

@Ovs sayesinde -2 bayt .

@Neil sayesinde -3 bayt . Harika 34 baytlık çözümünü inceleyin .

Java 8, 100 bayt

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

Çevrimiçi deneyin!

Japt , 18 bayt

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

Bundan sonra yazdırılamaz bir karakter var %#. Çevrimiçi test edin!

Nasıl çalışır

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

Bu bir golf olan bu erken cevap.

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

Çevrimiçi deneyin! Python2

Çevrimiçi deneyin! Python3

açıklama

Bu, ;ikisi arasında kaç tane olduğunu belirlediğimiz #ve chrmod 127'i basacağımızın oldukça basit bir cevabı. Bu biraz garip olabilecek tek şey [:-1]. Son grubu bırakmalıyız çünkü #ondan sonra olmayacak .

Örneğin

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

Bölünecek

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

Ama sonuncuyu istemiyoruz, ;;;çünkü #değeri basacak bir şey yok .

> <> , 35 bayt

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

Çevrimiçi deneyin! ␡0x7F ile değiştirin ^?veya "delete".

Ana döngü

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

Bu, input ( i) karakterini alır , sıfırdan küçük olup olmadığını kontrol eder, yani EOF ( :0() ve programı ( ?;) ise sonlandırır . Aksi takdirde, girişin #( :'#'=) değerine eşit olup olmadığını kontrol edin . Öyleyse, aşağı dalın ve döngüyü yeniden başlatın ( ?v... ^ ... <).

Sayaç mantığı

              ';'=?0
              

Girişin ;( ';'=) değerine eşit olup olmadığını kontrol edin . Öyleyse, a düğmesine basın 0. Aksi takdirde, hiçbir şey yapmayın. Bu ana döngüyü yeniden başlatır.

Yazdırma mantığı

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

Giriş karakteri olduğunda #, girişi yığından ( ~) çıkarın, yığındaki üye sayısını ( l) alın, 127 ( '␡') düğmesine basın ve ( %) modülünü alın . Ardından, bir karakter ( o) olarak çıktı alın ve yeni bir yığın ( [0) başlatın . Bu "sıfırlar" sayacı dışarı. Ardından, döngü yeniden başlatılır.

Python 3, 69 Bayt

@Wheat Wizard, @Uriel sayesinde geliştirildi

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

Röda , 44 39 38 bayt

@Fergusq sayesinde 5 bayt kurtarıldı

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

Çevrimiçi deneyin!

Girdiyi akıştan alan adsız işlev.

Diğer karakterlerin göz ardı edilmesi gerekmiyorsa, şunu anlıyorum:

Röda , 20 bayt

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

Ruby, 41 35 34 karakter

( 40 34 33 karakter kod + 1 karakter komut satırı seçeneği)

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

Sayesinde:

• Jordan (6 karakter) putcile açıkça dönüştürmeye gerek duymamanızı önerdiğinden.chr
• Gereksiz parantezi bulmak için Kirill L. (1 karakter)

Örnek çalışma:

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

Çevrimiçi deneyin!

05AB1E , 16 15 14 bayt

Kod:

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

Açıklama:

'#¡              # 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 kodlamasını kullanır . Çevrimiçi deneyin!

Jöle , 13 bayt

ṣ”#Ṗċ€”;%127Ọ

Çevrimiçi deneyin!

Nasıl çalışır

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

-86 MS-DOS makine kodu - 29 bayt

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

Yorum yapılan montaj:

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 bayt

Adnan sayesinde -2 bayt

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

Açıklama:

Î                       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

Çevrimiçi deneyin!

Retina , 34 bayt

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

Çevrimiçi deneyin! Test durumu içerir. Düzenleme: @ Martininder'den yardım alarak 2 bayt kaydedildi. Not: Kod yazdırılamayan &#x;kodlar içeriyor ve tarayıcı ISO-8859-1 yerine Windows-1252 kullandığı için kodların kullanılması yanlış sonuçlar veriyor. Açıklama: İlk satır girişi temizler: ;değiştirildiğinde \x80, #hiç \x7F(nedeniyle TIO için sınırlamalar) ve her şey silinir. Sonra ne zaman bir \x80başkasının olmadığı bir şey \x80gördüğümüzde onu siler ve sonraki karakterlerin kodlarını döngüsel olarak artırırız. Bu, daha fazla \x80karakter kalmayana kadar yinelenir . Nerede boş bayt destekler Orijinal kod temelde ilk satırda hariç, basılamaz bayt dan 1 çıkarır \xFFdeğişmez ve \x7Folur\x00. Okunabilirlik için kaçar:

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

R, 97 90 86 84 bayt

Bir işlev:

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

R başladığında, (sayısal ) Folarak tanımlanır .FALSE0

Ungolfed:

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

Python, 82 bayt

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

Düz TeX, 156 bayt

\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

Okunabilir

\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 bayt

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

Çevrimiçi deneyin! (İpucu: Daraltmak için ▼ Altbilgi öğesini tıklayın .)

Perl, 25 bayt

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

Çalıştır perl -043pe( perl -estandart olduğundan 4 bayt olarak sayılır ).

Açıklama: -043satır sonlandırıcısını #(ASCII 043) olarak ayarlar . -p“lines” girişi üzerinden yinelenir (aslında # -delimited dizeleri, şimdi). Her bir “satırdaki” y%;%%sayısını sayar ;. x/#/# ile bitmeyen programlar için fazladan bir karakter basmadığımızdan emin olur (üçüncü test çantası gibi). %127oldukça açık olmalı. $_=olağan kazan olduğunu.

CJam, 27 bayt

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

Açıklama:

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

Alternatif Çözüm, 18 bayt

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

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Düzenleme: ';' gibi '#'. Geçersiz karakterleri görmezden gelmesi için değiştirildi.

Alternatif

F #, 107 104 bayt

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

Referans hücre kullanımı 3 bayt kaydeder

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

Çevrimiçi deneyin

Processing.js (Khanacademy versiyonu), 118 bayt

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

Çevrimiçi deneyin!

Kullanılan işlem versiyonunda herhangi bir giriş yöntemi bulunmadığından, giriş n'ye yerleştirilir.

Labirent , 61 47 bayt

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

Çevrimiçi deneyin!

açıklama

Kod yürütme sol üst köşede başlar ve ilk noktalı virgül yığında kapalı bir sıfırı atar ve sağa devam eder.

Portakal

• _3636'yı istifin üzerine iter. Bu, girişi karşılaştırmak içindir.#
• } yığının üst kısmını ikincil yığına taşır
• , karakterin tamsayı değerini yığında iter
• )yığını artırır (girişin sonu ise, bu yığını 0 yapar ve programın akışı devam eder @ve çıkar)
• { ikincil yığının tepesini birincil yığının tepesine taşır
• -pop y, pop x, x - y tuşlarına basın. Bu, girişi #(ascii'de 35) ile karşılaştırmak içindir . Girdi, #kod mor bölüme devam ederse (yığının üstü 0 olduğu için IP daha önce hareket ettiği yönde devam eder), aksi takdirde yeşil bölüme devam eder.

Mor

• 127 127 yığını istiflemek
• % pop x, pop y, x% y'ye bas
• . yığının üstünü (akümülatör) çıkar ve karakter olarak çıktı al

Buradan gri kod bizi programın sol üst köşesine götürecek ve yığında hiçbir şey kalmayacak.

Yeşil

• _24 24'ü istifin üzerine itin
• -pop x, pop y, xy tuşlarına basın. 24 #ve arasındaki fark budur ve ;bu da giriş olup olmadığını kontrol eder ;. Olursa ;kod doğrudan doğru devam eder ). Aksi halde #, yığının yüksekliğini zorlayana dönecektir (her zaman pozitif bir sayı, programı sonraki kavşakta sağa dönmeye zorlamak ve akümülatörü artıran kodu kaçırmak)
• ; yığının üstünü atın
• ) Yığın sıfırı sıfır olan ya da çıktı için akümülatör olarak görev yapan önceden arttırılmış sıfır olan yığının üstünü artırmak

Buradan itibaren gri kod bizi programın sol üst köşesine, üzerinde sadece akümülatör bulunan istiflere götürür.

Gri

Tırnaklar çalışmaz, _yığına 0 ;atar ve yığının üstünü atar. Bunların hepsi kontrol akışını doğru şekilde zorlamak ve yığının tepesinden fazla olan herhangi bir şeyi atmak için yapılan koddur.

MATL , 29 bayt

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

Giriş, tek tırnak içine alınmış bir dizedir.

Çevrimiçi deneyin!

FizzBuzz programı çevrimiçi tercümanlar için çok uzun; Bu gif çevrimdışı çalışıyor görmek:

açıklama

Akümülatör değeri, yığındaki elemanların sayısı olarak uygulanır. Bu, programı, biriktirici değerinin yığında tek bir sayı olmasından daha yavaş hale getirir, ancak birkaç bayttan tasarruf eder.

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

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

Çevrimiçi deneyin!

açıklama

Yığında ;, karşılaştığımızın yalnızca bir sayacı tutarız . Yığın boşken (örneğin programın başlangıcında) bu tam olarak 0 olur.

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

Bu programın daha kısa fakat sonlandırılmayan bir versiyonunu burada bulabilirsiniz .

JS (ES6), 97 92 bayt

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

Shaggy'nin cevabından farklı bir yaklaşım benimsemeye çalıştı . Oh iyi.

; # + , 59 bayt, rekabetçi olmayan

Dil bu mücadeleden sonra yapıldı.

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

Çevrimiçi deneyin! Giriş boş bir bayt ile sonlandırıldı.

açıklama

Nesil benim Generate; # kod cevap aynıdır . Buradaki tek fark, yinelemedir.

tekrarlama

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

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

Çevrimiçi deneyin!

açıklama

(Teşekkürler İnekler -7 bayt için Quack!)

Bu trkısım tüm yabancı karakterleri kaldırır (bunu sedtam olarak aynı bytecount için koyabilirdim, ancak daha sonra satır beslemesi karakterini doğru işlemez, çünkü sedbunları içeri bırakır ve dcyalnızca ilk satır beslemesine çıkar ?)

sedGerisini alır ve bir dcprogram oluşturur :

Dizeleri ;haline gelir 1(uzun bir değişmez)

#olur .ZC7%P(eğer bu bir dizgiyi takip ederse 1, .no-op için bir ondalık sayıdır. Fakat programın başında veya bir başkasını takip #ederse, değişmezdir 0. O zaman sayının uzunluğunu alır, değiştirir, ve İlgili ASCII'yi yazdırır.)

C 65 64 60 bayt

(-2 ceilingcat sayesinde)

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