ที่เกี่ยวข้องกับ: สร้าง; # interpreter and Generate; # code

;# - คู่มือลมกรด

นี่เป็นภาษาง่าย ๆ ที่มีสองคำสั่ง โครงสร้างข้อมูลเพียงอย่างเดียวคือแอคคูมูเลเตอร์ซึ่งเริ่มต้นเป็น 0

1. ; เพิ่มการสะสม

2. #คำนวณค่าของตัวสะสม modulo 127 และพิมพ์อักขระ ASCII ที่เกี่ยวข้อง จากนั้นรีเซ็ตตัวสะสมเป็น 0

ซอร์สโค้ดอาจมีอักขระเพิ่มเติม (ASCII ที่พิมพ์ได้ + ช่องว่าง) แต่สิ่งเหล่านี้ถือว่าเป็นความคิดเห็นและไม่มีผลต่อการเรียกใช้โปรแกรม

ท้าทาย

เนื่องจากคอมพิวเตอร์ส่วนใหญ่ไม่มีการ;#ติดตั้งมาล่วงหน้าจึงมีประโยชน์มากที่จะมีเครื่องมือที่สามารถแปลง;#รหัสเป็นภาษาอื่นได้ ในการท้าทายนี้คุณจะต้องเขียนโปรแกรมเพื่อทำสิ่งนี้ให้สำเร็จ

อินพุต

;#ซอร์สโค้ดบางตัวถ่ายผ่านการโต้แย้งหรือ STDIN รหัสแหล่งที่มานี้อาจจะมีตัวอักษร (comment) อื่น ๆ กว่าหรือ;#

เอาท์พุต

รหัสในภาษาเดียวกับการส่งของคุณซึ่งเมื่อดำเนินการจะพิมพ์ / ส่งคืนสตริงเดียวกันกับ;#รหัสต้นฉบับ รหัสผลลัพธ์นี้อาจส่งออกบรรทัดใหม่ต่อท้ายหลังจากสตริงเป้าหมายหากที่สะดวกสำหรับภาษาของคุณ

หมายเหตุ

สิ่งหนึ่งที่ต้องระวังคือ escape sequences เช่นโค้ดที่พิมพ์แบ็กสแลชหรือพิมพ์เครื่องหมายคำพูด ระวัง;#โค้ดที่อาจมีสิ่งที่ดูเหมือนคำหลักหรือคำสั่งในภาษาของคุณ

ข้อ จำกัด เพิ่มเติม

โปรแกรมทั้งหมดจะต้องยุติ (ปกติฉันคิดว่านี่เป็นค่าเริ่มต้น แต่มีคนถามเรื่องนี้ดังนั้นฉันจึงระบุไว้ที่นี่)

ตัวอย่าง

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

Python 2 , 76 69 bytes

รหัส

อินพุตถูกล้อมรอบด้วยเครื่องหมายคำพูด

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

ลองออนไลน์!

คำอธิบาย

input('print')ส่วนแรกของการส่งออกจะกระทำเป็นหลักโดยการป้อนข้อมูลที่ใช้ เราแบ่งอินพุตเป็นแฮชแท็กและละทิ้งองค์ประกอบสุดท้าย เราพิมพ์การแทนของอ๊อก (y% 127)โดยที่yคือจำนวนการปรากฏของอัฒภาค เราต่อท้ายส่วน,ท้ายของการพิมพ์เพื่อให้แน่ใจว่าสิ่งนี้จะไม่พิมพ์บรรทัดใหม่

นี่จะให้รหัส Python ต่อไปนี้สำหรับHello, World!-program:

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

ซึ่งสามารถลองออนไลน์ได้

brainfuck , 126 ไบต์

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

ลองออนไลน์!

โปรแกรมเอาต์พุตจะล้มเหลวในการใช้งาน TIO หาก;#เอาต์พุตเกิน 65536 ตัวอักษร ฉันยังทำรุ่น 130- ไบต์ซึ่งเอาท์พุท[+]แทน<หลีกเลี่ยงปัญหานี้:

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

คำอธิบาย

+++[->+++++<]>[->++++>+++<<]        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.
  ]
,]

ช่องว่าง, 291 ไบต์

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

แทนที่ S โดยเว้นวรรค, T โดยแท็บและ N โดยขึ้นบรรทัดใหม่

การสร้างช่องว่างในช่องว่างไม่ใช่สิ่งที่มีประสิทธิภาพที่สุดในโลก การสร้างรหัสไดนามิกประเภทใด ๆ จำเป็นต้องมีการทวิบิตอย่างมีนัยสำคัญซึ่งในภาษาที่ไม่มีการดำเนินการระดับบิตจะทำให้ขนาดของรหัสที่จะระเบิด ดังนั้นโปรแกรมนี้ไม่ได้พยายามทำอะไรที่ชาญฉลาด แต่เลือกที่จะแปลโปรแกรมต้นทางเป็นหนึ่งแทน มันถอดประกอบดังต่อไปนี้:

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

รหัสที่สร้างโดยโปรแกรมดูเหมือนว่า:

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

แก้ไขข้อผิดพลาดพังถ้าไม่มี#ที่สิ้นสุด

แก้ไขข้อผิดพลาดการใช้งาน mod 127

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

ลองออนไลน์!

ลองสร้างรหัส

คำอธิบาย:

Í;û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

ในวีในโหมดแทรกอักขระ ASCII ใด ๆ <C-v><Code>ที่สามารถเขียนโดยรหัสโดยใช้ รหัส V แทนที่#ด้วยที่ศูนย์เป็นหลอกสะสมต่อ<C-v>0 #แต่ละ#รีเซ็ตตัวสะสมเป็น 0 ดังนั้นมีหนึ่งต่อผลงานออกมาดี จากนั้นรหัสจะเพิ่มขึ้นสำหรับแต่ละอัฒภาคที่พบซึ่งเพิ่มจำนวนถัดไปที่พบซึ่งจะเป็นการสะสมต่อไป 0ถูกผนวกเข้ากับท้ายเพื่อให้การเรียนการสอนไม่ได้ล้มเหลวโดยไม่ต่อไปนี้;#

hexdump:

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

05AB1E , 20 19 18 16 ไบต์

-1 ขอบคุณAdnan
-2 ขอบคุณcarusocomputing
-2 ขอบคุณKevin Cruijssen

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

ลองออนไลน์! (รวมเอาท์พุทของรหัสที่รัน 05AB1E)

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

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

ลองออนไลน์! (รวมเอาท์พุทจากการเรียกใช้งานรหัส Python ที่ transpiled)

ขอบคุณ ovs สำหรับหลาย ๆ ไบต์!

คำอธิบาย

โปรแกรมนี้ transpiles #; โค้ดโดยแยกที่ #s ( s.split('#')[:-1]) นับจำนวนอัฒภาคในแต่ละอันดัดแปลง 127 ( x.count(';')%127for x in ...) และแปลงให้เป็นอักขระ ASCII ตามลำดับ ( chr(...)) รายการนั้นจะถูกต่อกัน ( ''.join(...)) แปลงเป็น Python แทนสตริง (backticks) และแทรกลงในโปรแกรม Python ของ Skeleton สำหรับการพิมพ์สตริง ( "print"+...)

เยลลี่ ,  25 24  16 ไบต์

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

โปรแกรมการพิมพ์รหัส Jelly ที่เทียบเท่าทั้งหมด (เป็นลิงก์แบบ monadic จะส่งคืนรายการของชนิดแบบผสม)

ตัวอย่างแรกคือที่ลองใช้ออนไลน์! ซึ่งทำให้โปรแกรมนี้

อย่างไร?

นับจำนวน;s ในการวิ่งแต่ละครั้งระหว่าง#s จะใช้แต่ละโมดูโล 127 และต่อท้ายคำสั่งแบบ cast to ordinal, monadic Ọatom หลังจากนั้น

เจลลี่จะส่งค่าแต่ละค่าไปยัง STDOUT โดยปริยายเมื่อมันทำงานผ่านโปรแกรมเช่นนั้น72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọจะพิมพ์ออก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Ọ...)

หมายเหตุเกี่ยวกับอินพุต: Jelly รับอินพุตสตริงในรูปแบบ Python โปรแกรมที่ว่างเปล่าอาจจะมีการป้อนข้อมูลเป็น""และโปรแกรมกัญชาเป็นเพียง"#", "##"ฯลฯ การจัดการอื่น ๆ อาจจำเป็นต้องใช้สำหรับการป้อนข้อมูลที่มีเครื่องหมายและคำพูด

Cubically , 138 137 ไบต์

+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})

ลองออนไลน์!

หมายเหตุ: คุณอาจต้องแทนที่&6ด้วย?6&เพื่อให้สามารถทำงานกับ TIO &6อยู่ในสเป็คภาษาแม้ว่า

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

+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

โปรแกรมเอาท์พุท:

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

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

รับสตริงอินพุตลบอักขระที่ไม่จำเป็นทั้งหมดแล้วส่งคืนแหล่งที่มาของฟังก์ชันต่อไปนี้:

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

ในกรณีที่...แสดงให้เห็นถึงการทำความสะอาด;#แหล่งที่มา

C, 98 96 99 98 97 ไบต์

^{+3 ไบต์เพราะฉันลืม C ไม่ได้แปล :(}

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

ทำงานกับ:

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

จะพิมพ์:

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

เยลลี่ 26 ไบต์

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

ลองออนไลน์!

และลองรหัสวุ้นที่นี่!

ṣ”#Ç€ṙ-      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 กลายเป็นรหัสเหมือนỌø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọøซึ่งพิมพ์ chr (13) + chr (10)

PHP, 72 ไบต์

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

> <>, 106 81 77 ไบต์

นี่เป็นสนามกอล์ฟครั้งแรกของฉันใน> <> (ปลา)! ภาษาที่น่าสนใจทีเดียวที่ฉันต้องพูด สนุกมาก!

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

C # 169 ไบต์

แข็งแรงเล่นกอล์ฟ:

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+");");}}

รุ่นที่มนุษย์อ่านได้:

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

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

ลองออนไลน์!

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

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

ลองออนไลน์!

รู้สึกเหนื่อยเกินไปที่จะอธิบายเรื่องนี้ในตอนนี้ถ้าใครเห็นสิ่งนี้และสงสัยว่ามันทำงานอย่างไรส่งความคิดเห็นเพื่อเตือนฉัน

MathGolf , 17 ไบต์

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

ลองออนไลน์!

คำอธิบาย

⌡                      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

เนื่องจากสามารถใส่อักขระใด ๆ ลงบนสแต็ก (และใช้เอาต์พุต) โดยใช้'<char>สิ่งนี้จะส่งลำดับของบล็อกโค้ดดังกล่าว

MATL , 32 28 ไบต์

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

ลองออนไลน์!

วิธีการที่แตกต่างอย่างสิ้นเชิงขึ้นอยู่กับstrsplitมากกว่าโปรแกรมประเภทอัตโนมัติ

      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.

ที่จริงแล้ว 25 ไบต์

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

ลองออนไลน์! (รวมเอาท์พุทจากการดำเนินการรหัสจริง transpiled)

คำอธิบาย:

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

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

ฟูเรียร์ 32 ไบต์

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

ลองใช้กับ FourIDE!

นี่เป็นความท้าทายที่ค่อนข้างง่ายเนื่องจากฟูริเยร์นั้นเป็นรุ่นที่เหนือกว่า #:

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

CJam, 14 ไบต์

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

คำอธิบาย:

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

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

เอาท์พุท:

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

คำอธิบาย:

• ⌽: ย้อนกลับอินพุต
• {... }: ส่งต่อไปยังฟังก์ชันนี้:
  • ⍵⊂⍨'#'=⍵: พาร์ทิชันที่แต่ละ #ในสตริง (จากจุดเริ่มต้นซึ่งเป็นเหตุผลที่มันจะต้องมีการกลับรายการก่อน)
  • +/¨';'=: นับจำนวน;s ในแต่ละพาร์ติชัน
  • 127|: modulo 127
  • ⌽: ย้อนกลับอีกครั้ง
  • '⎕UCS',: เติมสตริง⎕UCSซึ่งเป็นฟังก์ชัน Unicode
  • ⍕: การแทนค่าสตริง

Ruby , 47 + 1 = 48 ไบต์

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

1 -pไบต์สำหรับ

ลองออนไลน์!

-30 ไบต์ขอบคุณ@manatwork !

Pyth, 25 23 24 ไบต์

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

+1 ไบต์ขอบคุณ @FryAmTheEggman

ลองมัน!

จัดการกับตัวละครที่ต้องหลบหนีโดยใช้ 1-char-strings เท่านั้น

ตัวอย่างผลลัพธ์:

jk[\"

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

ใช้ของฉัน; # ล่าม

C, 150 ไบต์

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

ขยาย:

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

มันเป็นโปรแกรมที่สมบูรณ์ที่ (ควร) ยุติละเว้นความคิดเห็นและสร้างรหัสผลลัพธ์ที่ถูกต้องเสมอ ฉันถือว่า EOF = -1

ทดสอบกับ SystemResque-Cd 4.9.6 รวบรวมด้วย gcc 4.9.4

braingasm 40 ไบต์

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

ต้องบอกว่ามันสั้นอย่างน่าประหลาดใจ

,[                                    ,]     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 `;`

รหัสที่สร้างขึ้นสำหรับ;คือ+ซึ่งจะเพิ่มจำนวนเซลล์ปัจจุบัน

รหัสที่สร้างขึ้นสำหรับ#การดำเนินการ modward คู่มือ akward

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

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

ลองออนไลน์!

โดยทั่วไปแทนที่;ด้วย1+, #ด้วย#~1+%@และ pre-pends ทุกสิ่งด้วย0เพราะ+ตัวดำเนินการmonadic ถูกทำลายในขณะนี้

1+ เพิ่ม 1 ไปยังไอเท็มสุดท้ายในสแต็ก

#~1+%@เพิ่มค่าถ่านที่~(126), เพิ่ม 1 เพื่อสร้าง 127, มอดุลัสพร้อมกับไอเท็มอื่น ๆ บนสแต็กจากนั้นป๊อปและพิมพ์เป็นถ่าน

คำอธิบาย

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

วิธีการแก้:

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

ตัวอย่าง:

โปรดทราบว่า,จะใช้เพื่อแสดงรายการ (กับอะตอม) เช่นเดียว"\""กับรายการขององค์ประกอบหนึ่งมากกว่าที่จะเป็นอะตอม

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

คำอธิบาย:

ใช้สตริงป้อนข้อมูลลบสิ่งที่ไม่ใช่ a #หรือ a ;แยกออกเป็นรายการ#นับจำนวนองค์ประกอบในแต่ละรายการดำเนินการ mod 127 กับผลลัพธ์และส่งไปยังสตริง:

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

หมายเหตุ:

• ถือว่าการป้อนข้อมูลที่ถูกยกเลิกโดยมิฉะนั้นก้อนสุดท้ายจะลดลงโดยไม่สมควร#-1_
• อาจจะเป็น 10 ;#ไบต์สั้นถ้าใส่ถูกรับประกันว่าจะมีเพียง

Perl 5 , 78 ไบต์

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

ลองออนไลน์!