İlgili: Yapmak : bir # # tercüman ve Oluştur; # kod

;# - Bir Kasırga Kılavuzu

Bu, iki komutlu basit bir dildir. Tek veri yapısı 0 ile ilklendirilen bir akümülatördür.

1. ; Akümülatörü arttırın

2. #Akümülatör modulo 127'nin değerini hesaplayın ve karşılık gelen ASCII karakterini yazdırın. Ardından akümülatörü 0'a sıfırlayın.

Kaynak kod ek karakterler içerebilir (yazdırılabilir ASCII + boşluk), ancak bunlar yorum olarak kabul edilir ve programın çalışması üzerinde etkisi yoktur.

Meydan okuma

Çoğu bilgisayar ;#önceden yüklenmiş olarak gelmediğinden , ;#kodu farklı bir dile dönüştürebilecek bir araca sahip olmak çok yararlı olacaktır . Bu zorlukla, bunu başarmak için bir program yazmalısınız.

Giriş

Bazı ;#kaynak kodlar, argüman veya STDIN üzerinden alınır. Bu kaynak kodu, ;veya dışındaki (yorum) karakterleri içerebilir #.

Çıktı

Kod, gönderiminizle aynı dilde, yürütüldüğünde, orijinal ;#kodla aynı dizeyi yazdırır / döndürür . Bu sonuç kodu, diliniz için daha uygunsa, hedef dizgeden sonra takip eden bir yeni satır verebilir.

notlar

Dikkat edilmesi gereken noktalardan biri, ters eğik çizgileri basan veya alıntı işaretlerini basan kod gibi kaçış dizileridir. Ayrıca ;#, kendi dilinizde anahtar kelimeler veya komutlar gibi görünen öğeleri içerebilecek kodu arayın.

Ek kısıtlamalar

Tüm programlar sonlandırılmalıdır (Normalde bunu varsayılan olarak kabul ediyorum, ancak birisi sordu bu yüzden burada belirtiyorum).

Örnekler

input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (python): print(";#")
input: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
output (element): \'`

Python 2 , 76 69 bayt

kod

Giriş, tırnak işaretleri ile çevrilidir.

for y in input('print').split("#")[:-1]:print`chr(y.count(";")%127)`,

Çevrimiçi deneyin!

açıklama

Çıktının ilk kısmı esasen girdi kullanılarak yapılır input('print'). Girdiyi hashtag'lere bölerek son elemanı atarız. Ord (y% 127) ifadesini yazdırıyoruz , burada y , noktalı virgül oluşumlarının sayısıdır. Bunun ,yeni bir satır yazdırmayacağından emin olmak için baskının sonuna eklenir .

Bu, Hello, World!-program için aşağıdaki Python kodunu verir :

print'H' 'e' 'l' 'l' 'o' ',' ' ' 'W' 'o' 'r' 'l' 'd' '!'

Hangi çevrimiçi denenebilir .

brainfuck , 126 bayt

+++[->+++++<]>[->++++>+++<<],[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<--.++>]<+.-<.<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

Çevrimiçi deneyin!

Çıkış ;#65536 karakterini geçerse , çıkış programı TIO uygulamasında başarısız olur . Ben de çıktılar bir 130 bayt versiyonu yapılmış [+]yerine <bu sorunu kaçınarak,:

++[------>++>+<<]>+++++<,[+<++++++[-<++++>>------<]>[<]<<[>>>>>[--<.>]<+++.---<.>.<++.--<<<<]>[->>-<<]>>[[-]<]>[>>++++[-->]<[<]],]

açıklama

+++[->+++++<]>[->++++>+++<<]        initialize tape with 60 and 45
,[                                  for each input byte:
  +<++++++[-<++++>>------<]         subtract 35 (#) from byte
  >[<]<<[                           if byte was #
         >>>>>[--<--.++>]           output + (43) a number of times equal to accumulator
         <+.-<.<<<<                 output . (46) and < (60)
  ]
  >[->>-<<]>>                       subtract 24 from what's left of byte
  [[-]<]                            check difference and clear if nonzero
  >[                                if byte was originally 59 (;)
   >>++++[-->]<[<]                  add 4 to accumulator cell, then subtract 2 if nonzero. Since BF cells are mod 256, this creates an accumulator mod 127.
  ]
,]

Boşluk, 291 bayt

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

S'yi boşlukla, T'yi sekmeyle ve N'yi yeni satırla değiştir.

Beyaz uzayda boşluk yaratmak, dünyadaki en etkili şey değil. Herhangi bir dinamik kod türünün üretilmesi, bitsel işlemleri olmayan bir dilde kod boyutunun patlamasına neden olacak şekilde önemli bir bit bükme gerektirir. Bu nedenle, bu program akıllıca bir şey yapmaya kalkışmaz, sadece kaynak programı bire bir çevirmeyi tercih eder. Aşağıdakileri parçalara ayırır:

early:
    call S
    call S
    call N
start:
    push  0
    dup
    ichr
    get
    push  35
    sub
    dup
    jz    hash
    push  24
    sub
    jz    semi
    jmp   start
hash:
    pop
    call SSS
    call TTT
    call TTT
    call T
    call N
    call T
    call S
    call TTT
    call N
    call S
    call S
    jmp   early
semi:
    call SSS
    call T
    call N
    call T
    call SSS
    jmp   start
N:
    push 10
    pchr
    ret
SSS:
    call S
    call S
S:
    push 32
    pchr
    ret
TTT:
    call T
    call T
T:
    push 9
    pchr
    ret

Program tarafından oluşturulan kod şöyle görünür:

push  0
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  1
add
push  127
mod
pchr
push  0
push  1
add
...

V , 19 20 28 bayt

Bugfix, kırdı #sonunda olmazsa

Bugfix, uygulandı mod 127

Í;û127}
éiA0Í#/0
ò/;
x

Çevrimiçi deneyin!

Oluşturulan Kodu Deneyin

Açıklama:

Í;û127}                            ' Delete runs of 127 `;`s (mod 127)
éi                                 ' Insert an `i` in front of input
  A<C-v><esc>0<esc>                ' Append <esc>0 to input
                   Í#/<C-v><C-v>0  ' Replace all `#` with `<C-v>0`
ò                                  ' Recursively
 /;                                ' Go to the next `;`
<C-a>                              ' Increment the next number come across

V modunda, ekleme modunda, herhangi bir ASCII karakteri kullanılarak kod kullanılarak eklenebilir <C-v><Code>. V kodu , sıfırın başına bir taklit-akümülatör olduğu #ile değiştirir . Her biri akümülatörü 0'a ayarlar, böylece her biri için bir tane olması yeterlidir. Daha sonra kod, bulunan her bir noktalı virgül için bir artış yapar; bu, bulduğu bir sonraki sayıyı artırır; bu, sonraki akümülatör olur. Bu , sonuna kadar eklenir, böylece komut takip etmeden s için başarısız olmaz .<C-v>0##0;#

HexDump:

00000000: e969 4116 1b30 1bcd 232f 1616 300a f22f  .iA..0..#/..0../
00000010: 3b0a 7801                                ;.x.

05AB1E , 20 19 18 16 bayt

-1 Adnan
-2'ye teşekkürler, carusocomputing
-2'ye teşekkürler Kevin Cruijssen'e teşekkürler

'#¡¨vy';¢ƵQ%„çJJ

Çevrimiçi deneyin! (yürütülen 05AB1E kodunun çıktısını içerir)

'#¡              # Split on #
   ¨             # remove the last element
    vy           # For each...
      ';¢        #   count the number of ;s
         ƵQ%     #   Mod by 127
            „çJ  #   Push çJ („çJ should work, but it doesn't for some reason)
               J # Join stack and output implicitly

Python 2,75 bayt

lambda s:"print"+`''.join(chr(x.count(';')%127)for x in s.split('#')[:-1])`

Çevrimiçi deneyin! (transpiled Python kodunu çalıştırmanın çıktılarını içerir)

Çok sayıda bayt için ovs için teşekkürler!

açıklama

Bu program # transpiles; #s ( s.split('#')[:-1]) öğesine bölünerek, her bir yığın modundaki 127 ( x.count(';')%127for x in ...) noktalı virgüllerin sayısını sayarak ve ilgili ASCII karakterine ( chr(...)) dönüştürerek kodlayın . Bu liste daha sonra birleştirilir ( ''.join(...)), dizenin Python temsiline dönüştürülür (backticks) ve dizeleri ( "print"+...) yazdırmak için iskelet Python programına eklenir .

Jöle ,  25 24  16 bayt

ṣ”#Ṗċ€”;%127;€”Ọ

Tam program yazdırma eşdeğeri Jelly kodu (monadik bir bağlantı olarak karışık tür listelerinin bir listesini döndürür).

İlk örnek çevrimiçi deneyin! hangi bu programı verir .

Nasıl?

;S arasındaki her çalışmada s'yi sayar #, her modulo 127'yi alır ve herden Ọsonra monadik atomu sıralı bir öğretim ekler .

Jöle, her bir değeri, STDOUT'a, yani böyle bir programdan geçerken, yani 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọbasılacağı gibi iletir Hello, world!.

ṣ”#Ṗċ€”;%127;€”Ọ - Main link: list of characters
 ”#              - literal '#'
ṣ                - split the result at #s
   Ṗ             - pop (remove the last result, list of trailing non-# characters)
      ”;         - literal ';'
    ċ€           - count for €ach
        %127     - modulo 127 (vectorises)
              ”Ọ - literal 'Ọ' (Jelly's cast to ordinal monadic atom)
            ;€   - concatenate for €ach - making a list of lists like [[72,'Ọ],[101,'Ọ'],...]
                 - implicit print (this smashes, printing something like: 72Ọ101Ọ...)

Girdi ile ilgili bir not: Jelly Python formatında dize girişi alır. Boş bir program olarak girdi olabilir ""ve aynı karma salt programları "#", "##"vb Diğer manipülasyon girişi içeren ters eğik ve teklifler için gerekli olabilir.

Kübik olarak , 138 137 bayt

+1/1+54@6:5+1/1+5@6/1+52@6:4/1+5@6:1/1+54@6:4/1+5@6:5+2/1+4@6(~-61/1=7&6+5/1+51=7?6{+3/1+5@6}:5+3/1+3=7?6{+52@6:5+1@6-1@6+1@6:5+2/1+4@6})

Çevrimiçi deneyin!

Not: değiştirmeniz gerekebilir &6ile ?6&bu TIO üzerinde çalışmak için. &6olsa da, dilde spec.

Nasıl çalışır

+1/1+54@6        Output 'R'
:5+1/1+5@6       Output '3'
/1+52@6          Output 'D'
:4/1+5@6         Output '1'
:1/1+54@6        Output 'R'
:4/1+5@6         Output '1'
:5+2/1+4@6       Output '+'
(                Loop indefinitely
  ~                Get next character
  -61/1=7&6        If input is -1 (EOF), exit program
  +5/1+51=7?6{     If input is `;`
    +3/1+5@6         Output '0'
  }                End if
  :5+3/1+3=7?6{   If input is '#'
    +52@6            Output '@'
    :5+1@6           Output '6'
    -1@6             Output '-'
    +1@6             Output '6'
    :5+2/1+4@6       Output '+'
  }                End if
)                End loop

Çıkış programı:

R3D1R1           Set top face to 1
+00...           Add top face to notepad, aka increment notepad
@6               Output notepad as character
-6               Set notepad to 0
...

JavaScript (ES6), 101 bayt

s=>`_=>'${s.replace(/[^#;]/g,``)}'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))`

Bir giriş dizesi verildiğinde, tüm gereksiz karakterleri siler, ardından aşağıdaki işlevin kaynağını döndürür:

_=>'...'.replace(/;*(#|$)/g,(l,c)=>c&&String.fromCharCode(~-l.length%127))

...Temizlenmiş ;#kaynağı nerede gösterir .

C, 98 96 99 98 97 bayt

^{+3 byte çünkü C'nin yorumlanmadığını unuttum :(}

c,a;f(){printf("f(){puts(\"");for(;~c;c=getchar())c==59?a++:c==35?a=!printf(&a):a;puts("\");}");}

İle çalışan:

echo ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#" | ./a.out

Yazdıracak:

f(){puts("Hello, World!");}

Jöle , 26 bayt

”‘x
f”;L%127Ç;“Ọø”
ṣ”#Ç€ṙ-

Çevrimiçi deneyin!

Ve Jelly kodunu burada dene!

ṣ”#Ç€ṙ-      Main link, input is a string of ";;;;;;#lala;;;;;;;;;#"
ṣ”#          Split input on char #
   ǀ        Call helper link 1 for each segment
     ṙ-      Rotate returns 1 to the right (SPLIT introduces an empty element which is moved up front)

f”;L%127Ç;“Ọø”  Helper link 1, determines the number of increments
f”;             Throw out all but semicolons
   L%127        Take the count mod 127
        Ç       Call helper 2
         ;“Ọø”  Add a Jelly link that prints characters and splits print statements

”‘x             Helper 2, receives the count of ;'s
”‘              Return the character ‘ (Jelly's increment command
  x             Once for each ; in the input

Jelly çıkışı Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, chr (13) + chr (10) 'u basan bir kod gibi olur

PHP, 72 bayt

for(;~$c=$argn[$i++];)echo[Z=>'$n++;',B=>'echo~$n=~chr($n%127);'][a^$c];

> <>, 106 81 77 bayt

Bu benim ilk golf'üm> <> (fish)! Söylemem gereken oldukça ilginç bir dil. Çok eğlenceli!

0n01.
>i:1+?!v:";"=?v"#"=?v
^ ;o";"<   .37<
^oo"1+"
^oooooooo'"~"1+%o0' <

C # 169 Bayt

golfed:

class P{static int Main(string[] args){var r="Console.Write(";foreach(var y in args[0].Split('#')){r+=(char)(-1+y.Split(';').Length%127);}System.Console.Write(r+");");}}

İnsan tarafından okunabilir versiyonu:

class P
{
    static int Main(string[] args)
    {
        var r="Console.Write(\"";
        foreach (var y in args[0].Split('#'))
        {
            r +=(char)(-1+y.Split(';').Length% 127);
        }
        System.Console.Write(r+"\");");
    }
}

Haskell , 106 102 bayt

';'!(x:a)=x+1:a;'#'!a=0:a;_!a=a;h s="main=putStr"++(show$""++(toEnum.(`mod`127)<$>init(foldr(!)[0]s)))

Çevrimiçi deneyin!

Ungolfed

step ';' (x:acc) = x+1:acc
step '#' acc = 0:acc
step _ acc = acc;

semicolonHash s = toEnum . (`mod` 127) <$> init (foldr step [0] s)

toHaskell s = "main = putStr " ++ (show $ "" ++ semicolonHash s)

Brachylog , 33 bayt

{";"∧"+₁"|"#"∧"%₁₂₇g~ạw0"}ˢ;"0"↔c

Çevrimiçi deneyin!

Şu an bunu açıklamak için biraz yorgun hissetmek, herhangi biri bunu görür ve nasıl çalıştığını merak ediyorsa, bana hatırlatmak için bir yorum bırak.

MathGolf , 17 bayt

⌡(¶{gÉ'8=£♣(%$''\

Çevrimiçi deneyin!

açıklama

⌡                      decrement twice
 (                     decrement
                       this transforms ";;;#;;#" -> "888 88 "
  ¶                    split string on spaces
   {                   foreach...
    gÉ                 filter using next 3 characters
      '8               push single character "8"
        =              pop(a, b), push(a==b)
                       this filters out all non-";"
         £             length of array/string with pop
          ♣            push 128
           (           decrement
            %          modulo
             $         pop(a), push ord(a) or char(a) (gets character with code)
              ''       push single character "'"
                \      swap top elements

Herhangi bir karakter kullanılarak yığına (ve dolayısıyla çıktının) herhangi bir karakter konabileceğinden '<char>, bu, bu tür kod bloklarının bir sırasını verecektir.

MATL , 32 28 bayt

35lF4$Yb"@g59=z]xv127\!&D99h

Çevrimiçi deneyin!

strsplitOtomat tipi bir programdan ziyade tamamen farklı bir yaklaşım .

      Yb % strsplit
    4$   %  with 4 inputs, namely:
35       %   Split on '#'
  lF     %   Do not (F) collapse delimiters (l).
         %   And of course the implicit program input.

"@g    ] % Loop over strings, convert each to a normal char array
   59=z  % How many equal to 59 ';'?

xv!127\  % Delete last element, concatenate and flip to horizontal, mod 127
&D       % Convert to MATL representation
  99h    % Append a 'c' to output ASCII.

Aslında , 25 bayt

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o

Çevrimiçi deneyin! (transpiled Aslında kodunu çalıştırmanın çıktılarını içerir)

Açıklama:

'#@s⌠';@c7╙D@%⌡MdX$"♂cΣ"o
'#@s                       split on "#"
    ⌠';@c7╙D@%⌡M           for each chunk:
     ';@c                    count ";"s
         7╙D@%               mod by 127 (2**7-1)
                dX         discard last value
                  $        stringify
                   "♂cΣ"o  append "♂cΣ":
                    ♂c       convert each value to an ASCII character
                      Σ      concatenate

shortC , 48 bayt

c,a;AR"AP\"");O;~c;c=G)c==59?a++:c==35?a=!R&a):a

Fourier, 32 bayt

$(I~S{59}{`^`}S{35}{`%127a0`}&i)

FourIDE'da dene!

Fourier temelde bir süperset olduğundan, bu oldukça kolay bir zorluktu

;# command > Fourier equivalent
; > ^ (Increment the accumulator)
# > %127a0 (Modulo accumulator by 127, output corresponding code point and set accumulator to zero)

CJam, 14 bayt

q'#/);';fe=:c`

Açıklama:

q               e# Read input
 '#/            e# Split on '#'
    );          e# Delete last element
      ';fe=     e# Count occurrences of ';' in each
           :c   e# Convert each to character (code point)
             `  e# Escape

APL, 31 bayt

{⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽

Çıktı:

      ({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
⎕UCS 59 35
      ⍝ evaluate the output
      ⍎({⍕'⎕UCS',⌽127|+/¨';'=⍵⊂⍨'#'=⍵}⌽) ';;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#'
;#

Açıklama:

• ⌽: girişi ters çevir
• {...} : bu işleve ilet:
  • ⍵⊂⍨'#'=⍵: her birinde bölüm # dizedeki (baştan itibaren, bu nedenle ilk önce ters çevrilmesi gerekti)
  • +/¨';'=: saymak ; her bölümdeki s
  • 127|: modulo 127
  • ⌽: tekrar ters çevirin
  • '⎕UCS',: dizgiyi hazırla ⎕UCS Unicode işlevi olan .
  • ⍕: string gösterimi

Ruby , 47 + 1 = 48 bayt

$_=gsub(/.*?#/){"$><<#{$&.count(?;)%127}.chr;"}

İçin +1 bayt -p.

Çevrimiçi deneyin!

@Manatwork sayesinde -30 bayt !

Pyth, 25 23 24 bayt

j\\+"jk["mC%/d\;127Pcw\#

@FryAmTheEggman sayesinde +1 bayt

Dene!

Yalnızca 1 karakterli dizgelerden kaçmak zorunda kalan karakterleri işler.

Örnek çıktılar:

jk[\"

jk[\H\e\l\l\o\,\ \W\o\r\l\d\!

Benim #; tercüman kullanır .

C, 150 bayt

#include<stdio.h>
c;n=0;main(){puts("#include<stdio.h>\nmain(){");while(~(c=getchar()))c-35?c-59?:n++:(printf("putchar(%d);",n%127)&(n=0));puts("}");}

Expanded:

#include<stdio.h>
c;
n=0;
main(){
        puts("#include<stdio.h>\nmain(){");
        while( ~(
            c=getchar()
        ))
                c-35?
                        c-59?
                                :
                                n++
                        :
                        ( printf("putchar(%d);",n%127)
                        &(n=0))
                ;
        puts("}");
}

Bu, sonlandırmak, yorumları yok saymak ve her zaman doğru çıktı kodunu üretmek için gereken eksiksiz bir programdır. EOF = -1 olduğunu varsayıyorum

Gcc 4.9.4 ile derlenmiş SystemResque-Cd 4.9.6 üzerinde test edilmiştir.

beyin fırtınası , 40 bayt

,[35-z["[127-s[127+.>]]<0*".]24-z[43.],]

Söylemeliyim ki, bu şaşırtıcı derecede kısa.

,[                                    ,]     Read a byte until end of input
  35-                                          Subtract 35.
     z[                     ]                  If the result is zero,
       "[127-s[127+.>]]<0*".                     print the code for `#`.
                             24-               Subtract 24.
                                z[   ]         If the result is zero,
                                  43.            print the code for `;`

İçin oluşturulan kod ;a,+ , geçerli hücreyi artıran .

Oluşturulan kod #bir akward, manuel modulo işlemi içeriyor

[127-s[127+.>]]<0*
[             ]       While current cell is not zero
 127-                   Subtract 127
     s[      ]          If result is negative
       127+.              Add 127 again and print current cell
            >             Step to next cell to break the loop
               <0*      Step back to first cell and clear it

Braingolf , 55 bayt

V#0VR&,l1-MvMR[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]Rv&@

Çevrimiçi deneyin!

Temelde değiştirir ;ile 1+, #birlikte #~1+%@bir ile her şeyi ve ön pends 0çünkü monadic +operatörü şu anda bozuldu.

1+ yığındaki son öğeye 1 ekler.

#~1+%@, ~(126) ' nın char değerini iter, 127 yapmak için 1 ekler, yığın üzerinde diğer öğeyle modüle eder, sonra char olarak basar ve yazdırır.

açıklama

V#0VR&,l1-MvMR                         Implicit input of each char to stack
[R.#;e"+1"MM|.##e"@%+1~#"MMMMMM|$_vv]
Rv&@

V#0                                    Create stack2, push char value of 0
   VR                                  Create stack3, return to stack1
     &,                                Reverse stack
       l1-                             Push length of stack - 1
          MvMR                         Move length to stack2, switch to stack 2
                                       Move length to stack3, switch back to stack1
[R................................vv]  Do-While loop, will run l times
                                       where l is length of input
  .#;                                  Duplicate last item and push char value of semicolon
     e                                 Pop last 2 items, if they are equal..
      "+1"                             ..Push char values of +1 in that order
          MM                           ..Move last 2 items to stack2
            |                          endif
             .##                       Duplicate last item and push char value of hash
                e                      Pop last 2 items, if they are equal..
                 "@%+1~#"              ..Push char values of @%+1~# in that order
                         MMMMMM        ..Move last 6 chars to stack2
                               |       endif
                                $_     Silently pop last item
Rv                                     Switch to stack2
  &@                                   Greedy char print, print every item in stack as char

q / kdb +, 42 bayt

Çözüm:

{-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}

Örnekler:

Bunun, bir atom olmak yerine bir elementin listesi ,olarak bir listeyi (atoma karşı) belirtmek için kullanıldığını unutmayın "\"".

q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
";#"
q){-1_"c"$mod[;127](#:)@/:"#"vs x inter"#;"}";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#"
,"\""

Açıklama:

Giriş dizesini alın, a #veya a olmayan bir şeyi kaldırın ;, listeye bölün #, her listedeki öğelerin sayısını sayın, sonuçta mod 127 uygulayın ve bir dizgiye yayınlayın:

{-1_"c"$mod[;127]count each"#"vs x inter"#;"} / ungolfed
{                                           } / lambda function
                                 x inter"#;"  / intersection of input and ';#' to clear out any 'comments'
                           "#"vs              / split string on hash
                 count each                   / length of each sub-list
        mod[;127]                             / 127 modulo result (vectorised)
    "c"$                                      / cast back to string
 -1_                                          / drop last character (assuming terminated string)

Notlar:

• Girdilerin a ile sonlandırıldığını varsayalım #, aksi takdirde son öbek hatalı tarafından düşürülür -1_.
• Girdi yalnızca içerdiği garanti edildi ise 10 bayt daha kısa olabilir ;#.

Perl 5 , 78 bayt

say"say''",map{$_=chr y/;//%127;$_.=$_ if/\\|'/;",'$_'"}(join$",<>)=~/[^#]*#/g

Çevrimiçi deneyin!