งานของคุณถ้าคุณต้องการที่จะยอมรับมันคือการเขียนโปรแกรมที่ส่งออกจำนวนที่ไม่เป็นศูนย์ (อาจเป็นจำนวนเต็มหรือลอย) ส่วนที่ยุ่งยากคือถ้าฉันย้อนกลับซอร์สโค้ดของคุณผลลัพธ์จะต้องเป็นจำนวนเต็มต้นฉบับเมื่อตะกี้

กฎระเบียบ

• คุณต้องสร้างโปรแกรมเต็มรูปแบบ นั่นคือผลลัพธ์ของคุณจะต้องพิมพ์ไปที่ STDOUT

• ตัวเลขทั้งสองต้องอยู่ในฐาน 10 (ห้ามส่งออกในฐานอื่นหรือด้วยเครื่องหมายทางวิทยาศาสตร์เป็นสิ่งต้องห้าม)

• การส่งออกตัวเลขที่มีช่องว่างต่อท้าย / นำหน้าได้รับอนุญาต

• นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุด (ต้นฉบับ) ในแต่ละภาษาชนะ!

• มีการใช้ช่องโหว่เริ่มต้น

ตัวอย่าง

สมมติว่ารหัสที่มาของคุณและผลผลิตที่สอดคล้องกันของมันคือABC 4ถ้าผมเขียนแทนและเรียกใช้การส่งออกจะต้องมีCBA-4

05AB1E , 2 ไบต์

(1

ลองออนไลน์!

! enilno ti yrT

(       # negate nothing
 1      # push 1 (and implictly output it)

1       # push 1
 (      # negate it (and implictly output it)

JavaScript (V8) , 19 ไบต์

print(1)//)1-(tnirp

ลองออนไลน์!

เกือบเหมือนกับ ...

C # (Visual C # Interactive Compiler)ขนาด 19 ไบต์

Print(1)//)1-(tnirP

ลองออนไลน์!

(ขอบคุณ @someone สำหรับการชี้ให้เห็น)

ยังคงเหมือนเดิมใน ...

Lua , 19 ไบต์

print(1)--)1-(tnirp

ลองออนไลน์!

แต่สั้นลงใน ...

Python 2 , 15 ไบต์

print 1#1-tnirp

ลองออนไลน์!

แม้จะสั้นกว่าใน PHP เพราะมันมีเครื่องมือการพิมพ์มหัศจรรย์: <?=...

PHP , 12 ไบต์

<?=1;#;1-=?<

ลองออนไลน์!

แม้จะสั้นกว่าใน Ruby เพราะคุณสามารถinspectพิมพ์มากกว่า

Ruby , 8 ไบต์

p 1#1- p

ลองออนไลน์!

PowerShell ,  4  3 ไบต์

1-0

ลองออนไลน์! หรือ! enilno ti yrT

ใช้ไบต์โดยใช้การคำนวณทางคณิตศาสตร์แทนรูปแบบตัวเลขความคิดเห็นหมายเลข

เห็นได้ชัดว่าเป็นเช่นเดียวกันกับ jshell (ต่อSam ) และjq (ต่อการผลิต - 1-0และ0-1)

/// , 4 ไบต์

9/9-

9เอาท์พุท

ลองออนไลน์!

ย้อนกลับ

-9/9

-9เอาท์พุท

ลองออนไลน์!

ทุกอย่างก่อนที่/จะพิมพ์ในขณะที่ส่วนที่เหลือจะถูกละเว้น (ไม่ได้ใช้สแลชมากนักดังนั้นฉันจึงไม่ทราบว่าเกิดอะไรขึ้น แต่มันไม่ได้ส่งอะไรเลย)

ไคลน์ 011, 5 ไบต์

1-
@/

ลองออนไลน์!

ย้อนกลับ

/@
-1

ลองออนไลน์!

สิ่งเหล่านี้ใช้ประโยชน์จากโครงสร้างเฉพาะของไคลน์โดยเฉพาะกับระนาบการฉายจริง (แม้ว่าคำตอบแต่ละคำตอบจะต้องการขวด Klein เท่านั้น)

ช่องว่าง 21 ไบต์

S S S T N
T   N
S T N
N
N
T   S N
T   N
T   T   S S 

เพิ่มตัวอักษรS(ช่องว่าง), T(แท็บ) และN(บรรทัดใหม่) เป็นการเน้นเท่านั้น

เอาท์พุท/1-1

ลองออนไลน์หรือลองออนไลน์ย้อนกลับ (พร้อมพื้นที่ว่างเปล่าแท็บและบรรทัดใหม่เท่านั้น)

คำอธิบาย:

ใช้ออกจากโปรแกรม builtin เป็น NNNpalindrome
โปรแกรมปกติจะ:

SSSTN  # Push 1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

โปรแกรมย้อนกลับจะ:

SSTTN  # Push -1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

คำอธิบายเพิ่มเติมเล็กน้อยเกี่ยวกับการกดตัวเลข:

• ครั้งแรกS: เปิดใช้งานการจัดการกองซ้อน
• ที่สองS: กดตัวเลขไปที่สแต็ก
• SหรือT: บวก / ลบตามลำดับ
• บางส่วนS/ Tตามด้วย trailing N: number ใน binary, ที่ไหนS=0และT=1

เช่นดันSSTTSTSN-10

T-SQL, 16 ไบต์

--Forwards:
PRINT 4--4-TNIRP

--Backwards:
PRINT-4--4 TNIRP

เลือก 4 เพราะ 1 ใช้มากเกินไป :)

Japtap , 2 ไบต์

จำนวนเต็มหลักเดียว>0สามารถนำมาใช้ในสถานที่ของ2ที่สามารถA-G, H, I, JหรือL( 10-16, 32, 64, -1และ100ตามลำดับ)

n2

ทดสอบ | ย้อนกลับ

วิธีเมื่อนำไปใช้จำนวนเต็มลบที่จำนวนเต็มจากการโต้แย้งผ่านไปที่เริ่มต้นที่n 0เมื่อรันไปข้างหน้าnเมธอดจะถูกรันบนอินพุตแรกโดยนัยซึ่งเป็นค่าดีฟอลต์0ด้วย

อีกวิธีหนึ่งคือgสามารถใช้วิธีการแทนnซึ่งจะให้สัญญาณของผลของการลบการโต้แย้งจากจำนวนเต็มมันใช้

Haskell ที่ไม่มีความคิดเห็น 41 ไบต์

ส่งต่อพิมพ์1+ บรรทัดใหม่:

main=print$!1
niam=main
"1-"!$rtStup=niam

ลองออนไลน์!

พิมพ์กลับด้าน-1โดยไม่ต้องขึ้นบรรทัดใหม่ (ซึ่งสามารถเพิ่มที่ราคา 2 ไบต์):

main=putStr$!"-1"
niam=main
1!$tnirp=niam

ลองออนไลน์!

• บรรทัดแรกของแต่ละโปรแกรมพิมพ์หมายเลข
  • สำหรับ-1เอาต์พุตสตริงใช้เพื่อหลีกเลี่ยงวงเล็บ
  • การใช้$!(การประยุกต์ใช้อย่างเข้มงวด) แทนของพื้นที่ช่วยให้เส้นตรงกันข้ามจะเป็นความหมายที่ถูกต้องของผู้ประกอบการ!$(เพียง$จะไม่ทำตั้งแต่นิยามใหม่จะแบ่งการใช้งาน)
• เส้นกลางทำให้มั่นใจได้ว่าniamกำหนดไว้สำหรับบรรทัดสุดท้าย
• บรรทัดสุดท้ายคือคำจำกัดความของโอเปอเรเตอร์!$ซึ่งไม่ได้ใช้ แต่จำเป็นต้องแยกวิเคราะห์และพิมพ์ได้อย่างถูกต้อง

PHP , 15 13 ไบต์

เวอร์ชัน PHP โดยไม่มีการแสดงความคิดเห็น ohceเป็นค่าคงที่ที่ไม่ได้กำหนดดังนั้นมันจะเท่ากับค่าสตริงของชื่อ ด้วยเหตุนี้สิ่งนี้จะพยายามพิมพ์+1-'ohce'หรือ-1+'ohce'เมื่อกลับด้าน เนื่องจาก'ohce'เป็นค่าที่ไม่ใช่ตัวเลข 0 จะถูกนำมาใช้แทนในการดำเนินการทางคณิตศาสตร์และจะมีเพียง1หรือ-1จะพิมพ์

;echo+1-ohce;

ลองออนไลน์!

ลองออนไลน์!

Googleขนาด 3 ไบต์

2-1

ลองออนไลน์!
! enilno ti yrT

เยลลี่ 2 ไบต์

NC

ลองออนไลน์!

Negative ผลในการ0แล้วComplement ผลในการ=1-01

CN

ลองออนไลน์! Complement ผลในการ=1-0 egative ผลในการ1N-1

K (ngn / k) , 3 ไบต์

2-1

ลองออนไลน์!

ฉันพลาดอะไรไปรึเปล่า? ดูเหมือนชัดเจนสำหรับภาษา REPL

Cubix , 7 6 5 ไบต์

@)O(@

ลองที่นี่
ย้อนกลับ

คำอธิบาย

Cubified:

  @
) O ( @
  .

การคลายการควบคุมโฟลว์เราดำเนินการ)O(@ซึ่งเพิ่มขึ้นเอาต์พุตลดลงและออก

ย้อนกลับและถูกตัด:

  @
( O ) @
  .

การคลายการควบคุมโฟลว์เราดำเนินการ(O)@ซึ่งการลดลงเอาท์พุตการเพิ่มและออก

รุ่นก่อนหน้า

@O(.)O@

ลองที่นี่
ย้อนกลับ

ไม่สั้น แต่ก็น่าพึงพอใจ

Runic Enchantmentsขนาด 4 ไบต์

1@Z1

ลองออนไลน์! ลองย้อนกลับ!

ฉันไม่สามารถหาวิธีใช้1คำสั่งซ้ำได้แม้จะมีค่าใช้จ่ายเป็นไบต์หรือสองก็ตาม

1@ɩ ใช้งานได้ แต่มีจำนวนไบต์เท่ากัน

APL (Dyalog Unicode) ,  4  3 ไบต์

1-0

ลองออนไลน์!

คำตอบเล็กน้อย พิมพ์1เมื่อเรียกใช้และ¯1เมื่อเรียกใช้ย้อนกลับ

Stack Cats -mnขนาด 4 ไบต์

:-:_

ลองออนไลน์! ในส่วนท้ายฉันได้รวมโซลูชัน 4 ไบต์อื่น ๆ ทั้งหมดแล้ว (Stack Cats จะไม่สนใจทุกสิ่งหลังจาก linefeed แรก)

ลองย้อนกลับ!

คำอธิบาย

การ-nเปิดใช้งานการตั้งค่าสถานะเป็นตัวเลข (และการป้อนข้อมูล แต่เราไม่มี) และโดยทั่วไปการ-mตั้งค่าสถานะเป็นเพียงความสะดวกสบายในการเล่นกอล์ฟซึ่งช่วยให้คุณหลีกเลี่ยงส่วนที่ซ้ำซ้อนของซอร์สโค้ด นี่เป็นเพราะทุกโปรแกรม Stack Cats ต้องมีมิร์เรอร์สมมาตร ด้วยการ-mตั้งค่าสถานะคุณให้ครึ่งแรกเท่านั้น (รวมถึงอักขระกลาง) ดังนั้นโปรแกรมจริงที่นี่คือ:

:-:_:-:

อย่างที่คุณเห็นในลิงค์แรกของ TIO มีวิธีแก้ปัญหา 4 ไบต์มากมาย แต่ฉันเลือกอันนี้เพื่อความเรียบง่าย Stack Cats เป็นแบบสแต็กและโปรแกรมนี้ใช้สแต็กเริ่มต้นเท่านั้น เนื่องจากเราไม่มีอินพุตใด ๆ จึงมีหนึ่ง-1(เครื่องหมาย EOF) ที่ด้านบนของศูนย์อนันต์ คำสั่งทั้งสามในโปรแกรมมีความหมายดังนี้:

:   Swap the top two stack elements.
-   Negate the top stack element (i.e. multiply by -1).
_   Pop a. Peek b. Push b-a.

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

   :   -   :   _   :   -   :

-1   0   0  -1   1   0   0   1
 0  -1  -1   0   0   1   1   0
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

มันจะเปิดออกคำสั่งเพียงแค่นั้นจริงๆจะเป็นอะไรที่นี่_ซึ่งจะเปลี่ยนเครื่องหมาย EOF 1ของเราเป็น เอาท์พุทในตอนท้ายของโปรแกรมเป็นนัยและเครื่องหมาย EOF เป็นตัวเลือกดังนั้นนี่เป็นเพียงแค่พิมพ์ออกมา1เราได้รับ

ตอนนี้ถ้าเราย้อนกลับซอร์สโค้ดเนื่องจากการมิรเรอร์โดยนัยโปรแกรมจริงกลายเป็น:

_:-:-:_

สิ่งนี้แตกต่างอย่างมาก:

   _   :   -   :   -   :   _

-1   1   0   0   1  -1   0  -1
 0   0   1   1   0   0  -1  -1
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

คราวนี้ด้านล่างของสแต็คเป็นยังคงเป็น-1จึงไม่ทำหน้าที่เป็นเครื่องหมาย EOF และเพียง-1บนของมันได้รับการตีพิมพ์

...

ขณะนี้จากทั้งหมดที่กล่าวมาเนื่องจาก Stack Cats มีความสัมพันธ์ที่ไม่เหมือนใครกับรหัสการย้อนกลับฉันรู้สึกว่าการใช้-mนั้นเป็นการโกงเล็กน้อย ปกติแล้วมันจะหมายถึงการบันทึกไบต์โดยการละเว้นส่วนที่ซ้ำซ้อนของซอร์สโค้ด แต่จริงๆแล้วมันทำให้การท้าทายนั้นง่ายขึ้นมากและแม้แต่โปรแกรมแบบเต็มก็จะสั้นลง นี่เป็นเพราะการย้อนกลับโปรแกรมเต็มรูปแบบจะเปลี่ยนโปรแกรมเฉพาะเมื่อมันมีสิ่งใดสิ่งหนึ่ง<>[]ซึ่งหมายความว่าโปรแกรมจะใช้หลายสแต็ค (Stack Cats จริง ๆ แล้วมีเทปของสแต็กซึ่งทั้งหมดยกเว้นตอนแรกจะเต็มเท่านั้น ด้วยศูนย์เริ่มต้นด้วย) ยิ่งไปกว่านั้นการสลับมันก็แค่แลกเปลี่ยน<>และ[]จับคู่ซึ่งยังคงทำให้การประมวลผลสมมาตร วิธีเดียวที่จะทำลายความสมมาตรนั้นคือการใช้Iสิ่งที่ทำ-]หรือ-[หรือไม่มีอะไรขึ้นอยู่กับสัญลักษณ์ของด้านบนของสแต็ก ดังนั้น...

Stack Cats -nขนาด 11 ไบต์

*|]I*:*I[|*

ลองออนไลน์! ส่วนท้ายอีกครั้งรวมถึงทางเลือกอื่น ๆ ทั้งหมดที่นับไบต์เดียวกัน เอาต์พุตเหล่านั้นบางส่วน 1 / -1 และเอาต์พุตบางส่วน 2 / -2 ตามที่ระบุหลังแต่ละโปรแกรม ฉันเลือกอันนี้เพื่ออธิบายแบบสุ่มว่าเป็นอันที่เอาท์พุท 2

ลองย้อนกลับ!

คำอธิบาย

อย่างที่ฉันพูดไปแล้ว แม้ว่าเราใช้-mสัญกรณ์สำหรับสิ่งนี้มันจะมีน้ำหนักเป็น 6 ไบต์แทนที่จะเป็น 4 ด้านบน

คำสั่งที่ใช้ในครั้งนี้:

*   Toggle the least significant bit of the top of the stack.
|   Reverse the longest non-zero of prefix on this stack.
[]  Move one stack to the left/right and take the top of the current stack with you.
I   If the top of the stack is positive, -], if it's negative, -[, otherwise do nothing.
:   Swap the top two stack elements.

โปรแกรมแรกใช้เพียงสองกอง มันค่อนข้างยุ่งที่จะทำในงานศิลปะ ASCII แต่ฉันจะพยายามทำให้ดีที่สุด เครื่องหมายวงเล็บเหลี่ยมระบุว่าสแต็กหัวเทปอยู่ที่ใดและฉันจะใส่คำสั่งระหว่างสถานะสแต็กแต่ละคู่

  [-1]
…   0   0   …
    0   0
    …   …

      *

  [-2]
…   0   0   …
    0   0
    …   …

      | (does nothing)
      ]

      [-2]
…   0   0   …
    0   0
    …   …

      I

   [2]
…   0   0   …
    0   0
    …   …

      *

   [3]
…   0   0   …
    0   0
    …   …

      :

   [0]
…   3   0   …
    0   0
    …   …

      *

   [1]
…   3   0   …
    0   0
    …   …

      I

      [-1]
…   3   0   …
    0   0
    …   …

      [

  [-1]
…   3   0   …
    0   0
    …   …

      |

  [ 3]
…  -1   0   …
    0   0
    …   …

      *

  [ 2]
…  -1   0   …
    0   0
    …   …

ตอนนี้-1ทำหน้าที่เป็นเครื่องหมาย EOF และ2ได้รับการพิมพ์

โปรแกรมอื่น ๆ [ที่เป็นแบบเดียวกันจน Iก็ยังคงแทบจะเหมือนกันทุกทางจนสอง ในทางเทคนิคเราจะอยู่ในสแต็กที่แตกต่างกัน แต่หากไม่มีค่าบนมันพวกมันจะแยกไม่ออก แต่แล้วความแตกต่างระหว่างI[และI]จบลงที่สำคัญ:

    *|[I*:*I

      [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        ]

          [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        | (does nothing)
        *

          [-2]
…   3   0   0   …
    0   0   0
    …   …   …

และในครั้งนี้เราไม่ได้มีเครื่องหมาย EOF -2แต่โปรแกรมยังคงออกผลลัพธ์เป็น

Zsh , 12 ไบต์

<<<2 # 2-<<<

ลองออนไลน์!

ส่งต่อพื้นฐานความคิดเห็นวิธีการย้อนกลับ

หาก I / O มีข้อ จำกัด น้อยกว่าจะสามารถแก้ปัญหา11 ไบต์ได้เนื่องจาก Zsh สนับสนุนโค้ดส่งคืนค่าลบ:

return -127

ย้อนกลับ721- nruterออกจากด้วยรหัส127(ไม่พบคำสั่ง) ไม่สามารถนำมาใช้ก็จะถูกทิ้งไป exit -127 ลองออนไลน์!u8

CJam , 3 ไบต์

W;1

ลองออนไลน์!

• ปกติ
• ย้อนกลับ

พวกเขาทำงานอย่างไร

รุ่นปกติ:

W    e# Push -1
;    e# Delete
1    e# Push 1
     e# Implicit display

เวอร์ชันย้อนกลับ: คุณได้รับแนวคิด

MATL , 3 ไบต์

Nqv

ลองออนไลน์!

• ปกติ
• ย้อนกลับ

พวกเขาทำงานอย่างไร

ปกติ:

N   % Push number of elements in the stack: 0
q   % Subtract 1: gives -1
v   % Concatenate stack contents vertically: leaves -1 as is
    % Implicit display stack contents

ย้อนกลับ

v   % Concatenate stack contents vertically: gives the empty array, []
q   % Subtract 1: leaves [] as is
N   % Push number of elements in the stack: 1
    % Implicit display. [] is not displayed

ภาษา Wolfram (Mathematica) , 21 18 ไบต์

Print@1;tnirP//1-0

ลองออนไลน์!

-3 ขอบคุณMartin Ender

Hexagony 5 ไบต์

1!@!(

ลองออนไลน์!

โปรแกรมที่ถูกต้องจะต้อง:

• มีคำสั่งเลิกจ้าง ( @หรือ:) หลังมีความแตกต่างสำหรับอดีตเมื่อมีคำสั่งการเคลื่อนไหวของตัวชี้หน่วยความจำ นอกจากนี้คำสั่งนี้จะต้องไม่เป็นครั้งแรกหรือไบต์สุดท้าย
• มีคำสั่งส่งออก ( !, ;อาจเป็นไปได้ แต่อาจจะใช้เวลามากขึ้นไบต์)
• มีคำสั่งการจัดการหน่วยความจำ

ดังนั้นโปรแกรม 2 ไบต์จึงเป็นไปไม่ได้เลย โปรแกรม 3 ไบต์ไม่สามารถทำได้เนื่องจากไบต์ที่สองต้องเป็นคำสั่งยุติการทำงานและไบต์แรกจะต้องไม่ใช่คำสั่งการจัดการ Mirror / IP ดังนั้นจึงสามารถเรียกใช้งานได้เพียง 1 ไบต์เท่านั้น

ฉันคิดว่าโปรแกรม 4 ไบต์ไม่สามารถทำได้ โปรแกรมดังกล่าวจะต้องมีรูปแบบที่a@bcมีตารางหกเหลี่ยม

 Forward:       | Backward:
                | 
  c b           |   a @
 @ a .          |  b c .
  . .           |   . .

ดังนั้นaจะต้องเป็นคำสั่งเปลี่ยนเส้นทาง IP อย่างไรก็ตามมันเป็นไปไม่ได้ที่จะสร้างทั้งจำนวนบวกและลบด้วยคำสั่งจัดการหน่วยความจำเพียง 1

Haskell , 28 ไบต์

main=print 1--)1-(tnirp=niam

ลองออนไลน์!

ลองมัน!

รูปสามเหลี่ยมขนาด 4 ไบต์

i%%d

ลองออนไลน์!

เอาท์พุท 1

Ungolfed:

   i
  % %
 d

ย้อนกลับ

d%%i

ลองออนไลน์!

เอาท์พุท -1

Java 5 หรือ 6, 127 67 ไบต์

enum A{A;{System.out.print(9);}}//}};)9-(tnirp.tuo.metsyS{;A{A mune

เอาท์พุท/9-9

ไม่มีคอมไพเลอร์ออนไลน์เนื่องจาก Java 5 หรือ 6 ไม่สามารถใช้ได้ทุกที่

แต่คุณสามารถลองนี้127 ไบต์ Java 8 เทียบเท่า:
ลองออนไลน์หรือลองออนไลน์ตรงกันข้าม

คำอธิบาย:

enum A{                              // Create an enum
 A;                                  //  With a mandatory value
 {                                   //  And in a separate instance code-block:
  System.out.print(9);}}             //   Print 9 to STDOUT
//}};)9-(tnirp.tuo.metsyS{;A{A mune  // Comment and thus a no-op

Java 5 และ 6 มีข้อผิดพลาดที่ช่วยให้คุณสร้างบล็อคโค้ดภายใน enum เพื่อทำบางสิ่งแม้ว่าจะขาดวิธีการหลักในการบังคับของโปรแกรม สิ่งนี้จะทำให้เกิดข้อผิดพลาด:

java.lang.NoSuchMethodError:
ข้อยกเว้นหลักในเธรด "main"

แต่จะยังคงเอาท์พุทสิ่งที่เราต้องการ STDOUT ก่อนเพื่อให้เราสามารถเพิกเฉยได้

Golang , 109 ไบต์

package main;import "fmt";func main(){fmt.Println(1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

และสิ่งที่ตรงกันข้าม:

package main;import "fmt";func main(){fmt.Println(-1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

ลองออนไลน์!

Perl 5 (-p), 12 ไบต์

\$--{}}{++$\

ลองออนไลน์!

! enilno ti yrT

}{หลอกผู้ประกอบการจริงๆมาในสะดวก

Perl 5 (-M5.010), 9 ไบต์

จัดหาให้โดย Nahuel Fouilleul ในความคิดเห็น

say+1-yas

ลองออนไลน์!

! enilno ti yrT

เรติน่า 6 ไบต์

-`<
-

1พิมพ์

ลองออนไลน์!

-
<`-

-1พิมพ์

ลองออนไลน์!

คำอธิบาย: 1

-`<
-

นี่ ... ไม่ทำอะไรเลย เนื่องจาก`นี่เป็นการทดแทนจาก<ถึง-(ด้วยการกำหนดค่า-ซึ่งไม่ทำอะไรเลย) แต่อินพุตว่างเปล่าดังนั้นเอาต์พุตจึงว่างเปล่าเช่นกัน

และขั้นตอนที่สองนี้จับคู่ regex ว่างกับอินพุตว่างและนับจำนวนการแข่งขันซึ่งก็คือ 1 เอาท์พุทเป็นนัย

คำอธิบาย: -1

-

เวลานี้เราแทนที่ regex -ว่างเปล่ากับ -นี้ไม่แน่นอนเปิดการป้อนข้อมูลที่ว่างเปล่าเป็นเดียว

<`-

นี่คือการตั้งค่าที่ไม่จริงบางสิ่งบางอย่างพิมพ์ป้อนข้อมูลขั้นตอนของก่อนที่จะดำเนินขั้นตอนเพื่อให้เราพิมพ์< -แล้ว-นับยัติภังค์ในการป้อนข้อมูลของเวทีซึ่งเป็นอีกครั้งที่ 1. เนื่องจากการส่งออกโดยนัยนี้พิมพ์1หลังจากที่-ให้เรา-1ตามที่ต้องการ

$\Large{\mathbf{\TeX} \left(\text{MathJax}\right)},~4\,\text{bytes}$

1%1-

brainfuck , 156 ไบต์

+++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++<+++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++

ลองออนไลน์! / ตรวจสอบไปข้างหน้า / ย้อนกลับใน Bash

พิมพ์-1ไปข้างหน้าและ\n1ข้างหลัง

แม้จะเป็นเรื่องเล็กน้อย แต่ฉันเชื่อว่านี่เป็นทางออกที่ดีที่สุดสำหรับการส่งออกคงที่นี้โดยเฉพาะ

พิสูจน์:

• โปรแกรมที่ไม่สามารถมีหรือ[]

  <A> . <B> . <C>ดังนั้นโปรแกรมจะต้องมีรูปแบบ

• แต่ละคน,สามารถถูกแทนที่ด้วยจำนวนเพียงพอของ<โดยไม่ต้องเพิ่มจำนวนหรือ+-

• แต่ละโปรแกรม+จะมีประโยชน์ทั้งในโปรแกรมไปข้างหน้าหรือโปรแกรมถอยหลังไม่เคยมีทั้งคู่

  หลักฐาน: +ในส่วน A เห็นได้ชัดว่ามีประโยชน์เฉพาะในโปรแกรมส่งต่อและ+ในส่วน C เห็นได้ชัดว่ามีประโยชน์เฉพาะในโปรแกรมย้อนกลับ

  แสดงว่าshift(P)= จำนวนของ<ใน P - จำนวนของ>ใน P พิจารณาโปรแกรม<B> = <D> + <E>, ที่+อยู่ตรงกลางจะมีประโยชน์ในโปรแกรมไปข้างหน้า$\iff$ shift(E) = 0ในทำนองเดียวกันมันมีประโยชน์ในโปรแกรมย้อนกลับ $\iff$ shift(D) = 0. แต่ถ้าshift(D) = shift(E) = 0แล้วโปรแกรมดำเนินการอย่างใดอย่างหนึ่งไปข้างหน้าหรือข้างหลังจะเพิ่มค่าคงที่จะเซลล์ปัจจุบันก่อนที่จะพิมพ์เป็นครั้งที่สองซึ่งไม่สามารถเป็นกรณีเพราะBord('1') - ord('\n') != ord('1') - ord('-')

ดังนั้นความต้องการโปรแกรมอย่างน้อยord('-')+ord('1')+ord('\n')+ord('1') = 153 +s 2 .s และอย่างน้อย< >หรือเพราะ,shift(B) != 0