Liên quan đến: Tạo một; # trình thông dịch và Tạo; # mã

;# - Hướng dẫn gió lốc

Đây là một ngôn ngữ đơn giản với hai lệnh. Cấu trúc dữ liệu duy nhất của nó là một bộ tích lũy, được khởi tạo thành 0.

1. ; Tăng tích lũy

2. #Tính giá trị của modulo tích lũy 127 và in ký tự ASCII tương ứng. Sau đó, đặt lại bộ tích về 0.

Mã nguồn có thể chứa các ký tự bổ sung (khoảng trắng ASCII + có thể in), nhưng chúng được coi là các nhận xét và không có tác dụng trong việc thực hiện chương trình.

Thử thách

Vì hầu hết các máy tính không được ;#cài đặt sẵn, nên sẽ rất hữu ích khi có một công cụ có thể chuyển đổi ;#mã sang ngôn ngữ khác. Trong thử thách này, bạn sẽ viết một chương trình để thực hiện điều này.

Đầu vào

Một số ;#mã nguồn, được thực hiện thông qua đối số hoặc STDIN. Mã nguồn này có thể chứa (bình luận) các ký tự khác ;hoặc #.

Đầu ra

Mã, trong cùng ngôn ngữ với nội dung gửi của bạn, khi được thực thi, sẽ in / trả về cùng một chuỗi với ;#mã gốc . Mã kết quả này có thể xuất ra một dòng mới sau chuỗi đích, nếu điều đó thuận tiện hơn cho ngôn ngữ của bạn.

Ghi chú

Một điều cần chú ý là các chuỗi thoát, chẳng hạn như mã in dấu gạch chéo ngược hoặc in dấu ngoặc kép. Ngoài ra, hãy tìm ;#mã có thể chứa những thứ trông giống như từ khóa hoặc lệnh trong ngôn ngữ của bạn.

Hạn chế bổ sung

Tất cả các chương trình phải chấm dứt (tôi thường coi đây là mặc định, nhưng ai đó đã hỏi về nó vì vậy tôi nói rõ ở đây).

Ví dụ

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

Python 2 , 76 69 byte

Mã

Đầu vào được bao quanh bởi dấu ngoặc kép.

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

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

Giải trình

Phần đầu tiên của đầu ra về cơ bản được thực hiện bởi đầu vào, sử dụng input('print'). Chúng tôi chia đầu vào trên hashtag và loại bỏ phần tử cuối cùng. Chúng tôi in đại diện của ord (y% 127) , trong đó y là số lần xuất hiện của dấu chấm phẩy. Chúng tôi nối thêm phần ,cuối của bản in để đảm bảo rằng phần này không in một dòng mới.

Điều này sẽ cung cấp mã Python sau cho Hello, World!chương trình:

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

Mà có thể được thử trực tuyến .

Brainfuck , 126 byte

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

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

Chương trình đầu ra sẽ thất bại trong việc triển khai TIO nếu ;#đầu ra vượt quá 65536 ký tự. Tôi cũng đã tạo một phiên bản 130 byte mà đầu ra [+]thay vì <, để tránh vấn đề này:

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

Giải trình

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

Khoảng trắng, 291 byte

NSSTTNNSTNNSTNNSTTNNSSTSNSSNSNSTNTSTTTSSSTSSSTTNTSSTSNSNTSSSSNSSSTTSSSNTSSTNTSSSTNNSNTSNNSSSSSNSNNNSTSSNNSTSTNNSTSTNNSTSNNSTTNNSTSNNSTNNSTSTNNSTTNNSTNNSTNNSNTTNNSSSSTNNSTSSNNSTSNNSTTNNSTSNNSTSSNNSNTSNNSSTNSSSTSTSNTNSSNTNNSSSSNNSTNNSTNNSSNSSSTSSSSSNTNSSNTNNSSSTNNSTSNNSTSNNSSSNSSSTSSTNTNSSNTN

Thay S bằng dấu cách, T bằng tab và N bằng một dòng mới.

Tạo khoảng trắng trong khoảng trắng không phải là điều hiệu quả nhất trên thế giới. Việc tạo bất kỳ loại mã động nào cũng đòi hỏi phải thay đổi bit đáng kể, trong một ngôn ngữ không có thao tác bit, sẽ làm cho kích thước mã phát nổ. Do đó, chương trình này không cố gắng làm điều gì đó thông minh, thay vào đó, chỉ chọn dịch chương trình nguồn từ một sang một. Nó tháo rời như sau:

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

Mã được tạo bởi chương trình trông giống như:

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 byte

Sửa lỗi, bị hỏng nếu không có #ở cuối

Sửa lỗi, thực hiện mod 127

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

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

Hãy thử tạo mã

Giải trình:

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

Trong V, trong chế độ chèn, bất kỳ ký tự ASCII nào cũng có thể được chèn bằng mã bằng cách sử dụng <C-v><Code>. Mã V thay thế tất cả #bằng <C-v>0, trong đó số 0 là bộ tích lũy giả cho mỗi #. Mỗi bộ #đặt lại bộ tích lũy về 0 để có một cái hoạt động tốt. Sau đó, mã thực hiện một gia số cho mỗi dấu chấm phẩy được tìm thấy, chỉ cần tăng số tiếp theo mà nó tìm thấy, đó sẽ là bộ tích lũy tiếp theo. Phần 0này được nối vào cuối để lệnh không bị lỗi trong ;s mà không có phần sau #.

Hexdump:

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

05AB1E , 20 19 18 16 byte

-1 nhờ Adnan
-2 nhờ carusocomputing
-2 nhờ Kevin Cruijssen

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

Hãy thử trực tuyến! (bao gồm đầu ra của mã 05AB1E được thực thi)

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

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

Hãy thử trực tuyến! (bao gồm đầu ra từ việc thực thi mã Python được phiên mã)

Cảm ơn ovs cho nhiều byte!

Giải trình

Chương trình này chuyển mã #; mã bằng cách tách trên #s ( s.split('#')[:-1]), đếm số dấu chấm phẩy trong mỗi mod chunk 127 ( x.count(';')%127for x in ...) và chuyển đổi nó thành ký tự ASCII tương ứng ( chr(...)). Danh sách đó sau đó được nối ( ''.join(...)), được chuyển đổi thành biểu diễn Python của chuỗi (backticks) và được chèn vào chương trình Python của bộ xương để in chuỗi ( "print"+...).

Thạch ,  25 24  16 byte

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

Một chương trình in mã Jelly tương đương đầy đủ (dưới dạng một liên kết đơn, nó trả về một danh sách các danh sách các loại hỗn hợp).

Ví dụ đầu tiên là tại Dùng thử trực tuyến! mang lại chương trình này .

Làm sao?

Đếm các ;s trong mỗi lần chạy giữa #các s lấy mỗi modulo 127 và nối thêm một lệnh vào lệnh thứ tự, nguyên Ọtử đơn nguyên, sau mỗi lần chạy.

Jelly ngầm định chuyển từng giá trị sang STDOUT khi nó chạy qua một chương trình như thế tức là 72Ọ101Ọ108Ọ108Ọ111Ọ44Ọ32Ọ119Ọ111Ọ114Ọ108Ọ100Ọ33Ọsẽ in 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Ọ...)

Một lưu ý liên quan đến đầu vào: Jelly lấy đầu vào chuỗi ở định dạng Python. Chương trình có sản phẩm nào có thể là đầu vào như "", và các chương trình băm chỉ như "#", "##"vv thao tác khác có thể được yêu cầu để chứa những dấu xồ nguợc đầu vào và dấu ngoặc kép.

Về cơ bản , 138 137 byte

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

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

Lưu ý: Bạn có thể cần phải thay thế &6bằng ?6&để nó hoạt động trên TIO. &6là trong đặc tả ngôn ngữ, mặc dù.

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

+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

Chương trình đầu ra:

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 byte

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

Đưa ra một chuỗi đầu vào, xóa tất cả các ký tự không cần thiết, sau đó trả về nguồn của hàm sau:

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

Trường hợp ...đại diện cho ;#nguồn được làm sạch .

C, 98 96 99 98 97 byte

^{+3 byte vì tôi quên C không được giải thích :(}

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

Chạy với:

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

Sẽ in:

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

Thạch , 26 byte

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

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

Và thử mã Jelly ở đây!

ṣ”#Ç€ṙ-      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

Đầu ra Jelly trở thành mã như Ọø‘‘‘‘‘‘‘‘‘‘‘‘‘Ọø‘‘‘‘‘‘‘‘‘‘Ọø, in ra chr (13) + chr (10)

PHP, 72 byte

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

> <>, 106 81 77 byte

Đây là sân golf đầu tiên của tôi trong> <> (cá)! Một ngôn ngữ khá thú vị tôi phải nói. Rất vui!

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

C # 169 byte

Chơi gôn

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

Phiên bản có thể đọc được của con người:

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 byte

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

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

Bị đánh cắp

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 byte

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

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

Cảm thấy một chút quá mệt mỏi để giải thích điều này vào lúc này, nếu bất cứ ai nhìn thấy điều này và tự hỏi làm thế nào nó hoạt động thả một bình luận để nhắc nhở tôi.

MathGolf , 17 byte

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

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

Giải trình

⌡                      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

Vì bất kỳ ký tự nào cũng có thể được đặt trên ngăn xếp (và do đó là đầu ra) bằng cách sử dụng '<char>, điều này sẽ xuất ra một chuỗi các khối mã như vậy.

MATL , 32 28 byte

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

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

Cách tiếp cận hoàn toàn khác nhau dựa trên strsplitchứ không phải là một chương trình kiểu tự động.

      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.

Trên thực tế , 25 byte

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

Hãy thử trực tuyến! (bao gồm đầu ra từ việc thực thi mã thực tế được phiên mã)

Giải trình:

'#@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 byte

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

Fourier, 32 byte

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

Hãy thử nó trên FourIDE!

Đây là một thử thách khá dễ dàng vì Fourier về cơ bản là một siêu bộ của; #:

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

CJam, 14 byte

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

Giải trình:

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 byte

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

Đầu ra:

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

Giải trình:

• ⌽: đảo ngược đầu vào
• {... }: chuyển nó vào chức năng này:
  • ⍵⊂⍨'#'=⍵: phân vùng tại mỗi #trong chuỗi (từ đầu, đó là lý do tại sao nó phải được đảo ngược trước)
  • +/¨';'=: đếm số ;s trong mỗi phân vùng
  • 127|: modulo 127
  • ⌽: đảo ngược lại
  • '⎕UCS',: thêm vào chuỗi ⎕UCS, đó là hàm Unicode.
  • ⍕: biểu diễn chuỗi

Ruby , 47 + 1 = 48 byte

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

+1 byte cho -p.

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

-30 byte nhờ @manatwork !

Pyth, 25 23 24 byte

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

+1 byte nhờ @FryAmTheEggman

Thử nó!

xử lý các ký tự phải được thoát bằng cách chỉ sử dụng chuỗi 1 ký tự.

Đầu ra mẫu:

jk[\"

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

Sử dụng tôi; # thông dịch viên .

C, 150 byte

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

Mở rộng:

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

Đây là một chương trình hoàn chỉnh (nên) chấm dứt, bỏ qua các bình luận và tạo mã đầu ra luôn chính xác. Tôi giả sử EOF = -1

Đã thử nghiệm trên SystemResque-Cd 4.9.6, được biên dịch với gcc 4.9.4

braingasm , 40 byte

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

Gotta nói, đó là ngắn đáng ngạc nhiên.

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

Mã được tạo cho ;là a +, làm tăng ô hiện tại.

Mã được tạo để #chứa một hoạt động modulo thủ công, hướng dẫn

[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 byte

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

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

Về cơ bản thay thế ;bằng 1+, #với #~1+%@và trả trước toàn bộ sự việc bằng một toán tử 0đơn nguyên +bị hỏng ngay bây giờ.

1+ thêm 1 vào mục cuối cùng trong ngăn xếp.

#~1+%@đẩy giá trị char của ~(126), thêm 1 để tạo 127, mô đun với vật phẩm khác trên stack, sau đó bật và in dưới dạng char.

Giải trình

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 byte

Dung dịch:

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

Ví dụ:

Lưu ý rằng cái ,được sử dụng để biểu thị một danh sách (so với nguyên tử) "\""là danh sách của một nguyên tố, thay vì là một nguyên tử.

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

Giải trình:

Lấy chuỗi đầu vào, loại bỏ bất cứ thứ gì không phải là a #hoặc a ;, chia thành các danh sách trên #, đếm số phần tử trong mỗi danh sách, thực hiện mod 127 trên kết quả và chuyển thành chuỗi:

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

Ghi chú:

• Giả sử rằng đầu vào bị chấm dứt bởi a #, nếu không, đoạn cuối cùng sẽ bị bỏ nhầm bởi -1_.
• Có thể ngắn hơn 10 byte nếu đầu vào được đảm bảo chỉ chứa ;#.

Perl 5 , 78 byte

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

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