เป้าหมายของความท้าทายนี้คือการเขียนโปรแกรมที่ตรงตามเงื่อนไขต่อไปนี้:

• โปรแกรมไม่ใช่ palindromic หรือเป็นหลัก palindromic (หมายความว่ามันเป็นไปได้ที่จะลบตัวอักษรเพื่อให้เป็น palindrome โดยไม่ต้องเปลี่ยนเอฟเฟกต์ของโปรแกรม)

• โปรแกรมไม่ใช่ส่วนร่วม (หมายความว่าจะไม่สร้างอินพุตดั้งเดิมเมื่อรันบนเอาต์พุต)

• โปรแกรมกลับขั้ว -เป็นสิ่งที่ตรงกันข้ามของโปรแกรมปกติ; ดังนั้นเมื่อโปรแกรมที่กลับด้านทำงานในเอาต์พุตของโปรแกรมปกติมันจะคืนค่าอินพุตดั้งเดิม

สิ่งที่ตรงกันข้ามขั้วหมายความว่าอะไร? มันแตกต่างกันระหว่างภาษา

• สำหรับส่วนใหญ่ที่ไม่ใช่ esolangs นี้หมายถึงการกลับคำสั่งของการดำเนินงานย่อยในการดำเนินงานเดียวกลับคำสั่งของการขัดแย้งและการย้อนกลับเนื้อหาของรายการ / อาร์เรย์ / tuples / tuples / พจนานุกรม / สแต็คคิว / ฯลฯ เป็นการย้อนกลับลำดับของโค้ดบล็อกและบรรทัดแบบสแตนด์อะโลน (แต่ไม่ใช่บรรทัดภายในบล็อก)

ตัวอย่าง:

Haskell : x`mod`y-> y`mod`x; zipWith ((*3).(+)) [1,2,3] [4,5,6]->zipWith ((+).(*3)) [6,5,4] [3,2,1]

Python : 2**3-> 3**2; for x,y in [(1,2),(3,4),(5,6)]->for y,x in [(6,5),(4,3),(2,1)]

• สำหรับภาษาที่มีฟังก์ชั่น 1 ตัวอักษร (เช่น Pyth, APL) เพียงย้อนกลับสตริงคำแนะนำ

• สำหรับ esolangs 1 มิติอย่าง BF กลับคำแนะนำหรือสลับขั้ว สัญญาแลกเปลี่ยนขั้วคือ[]-> {}, +-> -, --> +, >-> <, <-> >, .-> ,และ,-> .(แต่ไม่ใช่ทั้งคู่)

• สำหรับ esolangs 2 มิติเช่น Befunge คุณอาจทำการสะท้อนผ่านแกน x หรือ y หรือแกนทแยงมุม, หมุน 180 องศาหรือทำการรวมกันของการสะท้อนและการหมุน

อนุญาตให้มีการดำเนินการสลับได้ แต่พาลินโดรมิกนั้นไม่ใช่: ใช้ได้2*xแต่x+xไม่ดี คำจำกัดความของการสลับขั้วกลับค่อนข้างหลวม แต่ใช้วิจารณญาณของคุณในสิ่งที่สมเหตุสมผล วัตถุไม่ได้เพื่อหาช่องโหว่ที่ฉลาดที่สุด แต่เพื่อค้นหาทางออกที่ฉลาดที่สุด

นี่คือการประกวดความนิยมดังนั้นช่องโหว่ที่ฉลาดมากอาจได้รับความนิยม แต่พยายามเก็บไว้ในจิตวิญญาณของความท้าทายนี้ ผู้ชนะจะได้รับการประกาศเมื่อมีอย่างน้อย 10 โซลูชันที่มีอย่างน้อย 1 upvote และมีอย่างน้อยหนึ่งโซลูชันที่มี upvotes มากกว่าที่มีการส่งอย่างน้อย 1 upvote หรือใน 1 เดือนแล้วแต่ว่าจะถึงอย่างใดก่อน นี่คือความท้าทายครั้งแรกของฉันดังนั้นพยายามที่จะเป็นธรรมและให้ข้อเสนอแนะที่สร้างสรรค์ แต่ยังแจ้งให้ฉันทราบว่านี่เป็นความท้าทายที่ไม่มีเหตุผลหรือเป็นในทางที่ผิดประเภทหรือไม่ชัดเจน หากคุณมีคำถามเกี่ยวกับภาษาที่ไม่เหมาะสมกับนกพิราบตัวใดตัวหนึ่งที่ฉันตั้งไว้ที่นี่แสดงความคิดเห็นและฉันจะโค้งงอตามความประสงค์ของชุมชนหากมีการโวยวายอย่างชัดเจนสำหรับการชี้แจงหรือการเปลี่ยนแปลงกฎโดยเฉพาะ

UPDATE

เป็นเวลา 1 เดือนนับตั้งแต่การประกวดเริ่มขึ้น (ฉันเพิ่งเกิดขึ้นเพื่อตรวจสอบโดยบังเอิญไม่รู้ว่าฉันตรงเวลา) เช่นนี้เป็นประกวดความนิยมผู้ชนะ (ถล่มทลาย) เป็น Pietu1998-Befunge แม้ว่าส่วนประกอบด้านล่าง (ตัวพลิกข้อความและตัวอักษรด้านหลัง) เป็นทั้งการเรียงตัว แต่ตัวเข้ารหัส / ตัวถอดรหัสไม่ดังนั้นจึงไม่มีปัญหา คะแนนโบนัส (ในใจของฉัน) สำหรับการจัดการเพื่อเขียน "BEFUNGE" ลงตรงกลาง ฉันชอบความแปลกใหม่ของโซลูชัน ThisusของZgarbเนื่องจากภาษานั้นดูเท่ห์ (ถ้าถูก จำกัด ) ขอบคุณทุกคนที่เข้าร่วมและในขณะที่ผู้ชนะได้รับเลือกฉันจะเปิดการแข่งขันนี้อย่างสมบูรณ์และยินดีต้อนรับการส่งในอนาคต

Befunge

โอ้โฮนั่นเป็นงานแม้กับบรรณาธิการที่ฉันทำเพื่อความท้าทายนี้ นี่คือสิ่งที่ฉันได้รับบล็อกที่ดีขนาด 11x12:

v$,g6<6g,$v
v,$ _^_ $,v
1W>v\B\v>L1
~T+:1E1:-O~
+F00-F-02L+
>:|6gUg6|:>
{a@>^N^>@z`
>1+|@G$| +>
:^9< E<  ^1
~>7^@_,#:>:
 xD>65 ^=P~
v,-\+**<  v

มันทำสองสามอย่างน่าเศร้าสำหรับตัวอักษรพิมพ์เล็กเท่านั้น

มันทำอะไร

เมื่อทำงานตามปกติจะทำการเข้ารหัส Caesarบนอินพุต

abcxyz      -> bcdyza
exampletext -> fybnqmfufyu

เมื่อพลิกในแนวนอนมันจะบอกรหัสกลับ นี่คือข้อกำหนดสำหรับความท้าทาย แต่มันไม่ได้จบที่นี่

bcdyza      -> abcxyz
fybnqmfufyu -> exampletext

เมื่อพลิกในแนวตั้งมันจะใส่รหัสด้วยอักษรย้อนกลับ สิ่งนี้ถือได้ว่าเป็นวิธีที่ตรงกันข้ามกับรหัสซีซาร์

abcxyz      -> zyxcba
exampletext -> vcznkovgvcg

ในที่สุดเมื่อหมุน 180 องศาก็จะกลับอินพุต ฉันมีความรู้สึกว่ามันจะต้องย้อนกลับของบางสิ่งบางอย่าง (คำใบ้: อินพุต)

abcxyz      -> zyxcba
exampletext -> txetelpmaxe

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

บล็อกนั้นประกอบด้วยอัลกอริทึมแบบกึ่งทับซ้อนสี่แบบ

เข้ารหัสซีซาร์

v$,g6<
v,$ _^
1 >v\
~ +:1
+ 00-
>:|6g
{a@>^

ตัวถอดรหัส Caesar (พลิกในแนวนอน)

v$,g6<
v,$ _^
1 >v\
~ -:1
+ 20-
>:|6g
`z@>^

รหัสตัวอักษรแบบย้อนกลับ (พลิกในแนวตั้ง)

v,-\+**<
   >65 ^
~>7^
:^9<
>1+|@
   >^

ตัวพลิกข้อความ (หมุน 180 องศา)

v  <
~      
:>:#,_@
1^  <
>+ |$
   >^

Brainfuck, 5

,+.-,

อาจเป็นครั้งแรกที่ Brainfuck จะสร้างคำตอบที่แข่งขันกับความยาวของรหัส อัปยศไม่ใช่คำถามรหัสกอล์ฟ

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

* (หรือเกี่ยวกับการทำสิ่งที่มีประโยชน์กับรหัสทั้งหมดในทั้งสองทิศทาง)

ผลลัพธ์ทั่วไป (อักขระตัวที่สองหากกำหนดถูกละเว้น)

ส่งต่อ: B->C

ย้อนกลับ: B-> AหรือC->B

Marbelous

นี่เป็นวิธีง่ายๆในการเริ่มต้นเรา มันอ่านตัวละครตัวหนึ่งจาก STDIN เพิ่มขึ้นและพิมพ์

--
]]
00
]]
++

ถ้าเราหมุนมันด้วย 180 ° (โดยไม่ต้องสลับวงเล็บปีกกา) หรือสะท้อนมันในแกน x เราก็จะได้

++
]]
00
]]
--

ซึ่งอ่านไบต์จาก STDIN และลดค่าลง

คุณสามารถทดสอบได้ที่นี่

ฉันอาจตรวจสอบโปรแกรม Marbelous ที่ซับซ้อนกว่านี้ แต่ฉันแน่ใจว่า es1024 จะเอาชนะฉันได้ ;)

คำอธิบาย

00หินอ่อนที่มีค่า 0 (ซึ่งเป็นพลบริการ) ]]อุปกรณ์อ่านไบต์จาก STDIN - นั่นคือถ้าหินอ่อนตกผ่านพวกเขาคุ้มค่าหินอ่อนจะถูกเปลี่ยนเป็นไบต์อ่าน ++และ--อุปกรณ์เพียงแค่เพิ่มขึ้นหรือลดลงของมูลค่าของหินอ่อน (สมัย 256) และปล่อยให้มันตกผ่าน เมื่อหินอ่อนหลุดออกจากกระดานไบต์จะถูกเขียนไปยัง STDOUT

ดังนั้นอุปกรณ์ทั้งสองที่อยู่ด้านบนจึงไม่สนใจเพราะการควบคุมไม่เคยไปถึงอุปกรณ์เหล่านั้น

Marbelous

คณะกรรมการนี้จะใช้เวลาหนึ่งอาร์กิวเมนต์ ( x) (101 * x) mod 256และผลตอบแทน

.. @5 .. }0 }0 @1 .. @0 .. @2 .. 
.. /\ Dp << \\ .. &0 >0 &1 .. .. 
!! @3 .. << }0 .. \/ -- \/ .. }0 
@4 .. .. &0 @1 /\ &0 65 &1 /\ @2 
/\ Dp .. @4 .. .. @3 @0 @5 !! \\

การทำมิเรอร์เซลล์ตามแนวแกน y จะส่งผลให้เกิดกระดานที่มีอาร์กิวเมนต์หนึ่งตัว ( y) และส่งคืน(101 * y + 8 * y) mod 256ซึ่งเป็นค่าผกผันของบอร์ดแรก

.. @2 .. @0 .. @1 }0 }0 .. @5 ..
.. .. &1 >0 &0 .. \\ << Dp /\ ..
}0 .. \/ -- \/ .. }0 << .. @3 !!
@2 /\ &1 65 &0 /\ @1 &0 .. .. @4
\\ !! @5 @0 @3 .. .. @4 .. Dp /\

การทดสอบนี้ได้ที่นี่ ควรตรวจสอบบอร์ดรูปทรงกระบอกและห้องสมุดรวม

ตัวอย่างอินพุต / เอาต์พุต :

Original Board:      Mirrored Board:
Input   Output       Input    Output
025     221          221      025
042     146          146      042
226     042          042      226

โปรดทราบว่า Marbelous อนุญาตเฉพาะการส่งจำนวนเต็มบวกเป็นอาร์กิวเมนต์และจำนวนเต็มเหล่านี้จะถูกส่งผ่านไปยังโปรแกรมโมดูโล 256 โดยผู้แปล

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

คำอธิบายสั้น ๆ

คอลัมน์ที่มีเซลล์ (จากบนลงล่าง) @0 >0 -- 65 @0วิ่งเหมือนกันทั้งสองแผงและวนรอบ101ก่อนที่จะไปทางขวา ที่ด้านใดด้านหนึ่งของ>0สาขาเป็นตัวประสานที่แตกต่างกัน; อันไหนที่ถูกเลือกขึ้นอยู่กับว่ากระดานสะท้อนหรือไม่

ในแต่ละด้านในซิงค์กับห่วงศูนย์, การป้อนข้อมูลสรุปซ้ำ ๆ 101*x mod 256จึงได้รับ บนบอร์ดที่กลับด้านสำเนาสองชุดของอินพุตจะถูกเลื่อนไปทางซ้ายสองครั้ง ( input * 4) จากนั้นจะรวมและปล่อยให้ซิงโครไนซ์

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

Dp เพียงพิมพ์ผลลัพธ์เป็นเลขทศนิยม

เธเซอุส

นี่อาจถือเป็นช่องโหว่ แต่ฉันชอบภาษาดังนั้นนี่จะไป โปรแกรมนี้จะกำหนดฟังก์ชั่นfในจำนวนธรรมชาติที่แม3nเพื่อ3n + 1 , 3n + 1เพื่อ3n + 2และ3n + 2เพื่อ3nสำหรับทุกn

data Num = Zero | Succ Num

iso f :: Num <-> Num
  | n                          <-> iter $ Zero, n
  | iter $ m, Succ Succ Succ n <-> iter $ Succ m, n
  | iter $ m, Succ Succ Zero   <-> back $ m, Zero
  | iter $ m, Succ Zero        <-> back $ m, Succ Succ Zero
  | iter $ m, Zero             <-> back $ m, Succ Zero
  | back $ Succ m, n           <-> back $ m, Succ Succ Succ n
  | back $ Zero, n             <-> n
  where iter :: Num * Num
        back :: Num * Num

เธเซอุสเป็นภาษาที่สามารถย้อนกลับได้ซึ่งมีรูปแบบเหมือน Haskell ซึ่งทุกฟังก์ชั่นสามารถย้อนกลับได้ มันคือการทดลองสูงและออกแบบมาเพื่อวัตถุประสงค์ในการวิจัย fรหัสข้างต้นกำหนดประเภทข้อมูลสำหรับตัวเลขธรรมชาติและฟังก์ชั่น ได้รับการป้อนตัวเลขจำนวนคุณรูปแบบการแข่งขันกับมันอยู่ทางด้านซ้ายมือ (มันก็ตรงn) จากนั้นคุณดูที่รูปแบบทางด้านขวา หากรูปแบบนั้นมีป้ายกำกับ (ที่นี่iter) คุณดำเนินการจับคู่รูปแบบกับทางด้านซ้ายมือแล้วนำค่าที่สอดคล้องกันทางด้านขวาอีกครั้ง สิ่งนี้จะทำซ้ำจนกว่าคุณจะมีค่าที่ไม่มีป้ายกำกับทางด้านขวาและนั่นคือผลลัพธ์ของคุณ รูปแบบทางด้านซ้ายและด้านขวาจะต้องครบถ้วนและไม่ทับซ้อนกัน (แยกต่างหากสำหรับแต่ละฉลาก) ตอนนี้เพื่อ "ย้อนกลับขั้ว" ของfฉันทำต่อไปนี้

• สลับค่าสองค่าของทุกป้าย fนี้จะไม่เปลี่ยนความหมายของ
• สลับด้านขวาและซ้ายในร่างกายของฟังก์ชั่น นี้กำหนดฟังก์ชันผกผันของการออกแบบf

ผลลัพธ์:

iso f :: Num <-> Num
  | iter $ n, Zero             <-> n
  | iter $ n, Succ m           <-> iter $ Succ Succ Succ n, m
  | back $ Zero, m             <-> iter $ Succ Succ Zero, m
  | back $ Succ Succ Zero, m   <-> iter $ Succ Zero, m
  | back $ Succ Zero, m        <-> iter $ Zero, m
  | back $ Succ Succ Succ n, m <-> back $ n, Succ m
  | n                          <-> back $ n, Zero
  where iter :: Num * Num
        back :: Num * Num

TR

a b

ตัวอย่าง:

$ echo "apple" | tr a b
bpple
$ echo "bpple" | tr b a
apple

เฉพาะค่าผกผันที่แท้จริงในโดเมนของสตริงที่ไม่มีทั้ง 'a' และ 'b'

อีกคำตอบMarbelous

ด้านขวาดั้งเดิมเลื่อนอินพุตบรรทัดคำสั่ง (ค่า 8 บิต) เพิ่มอันที่นำถ้า 1 หายไปโดยการเลื่อน ( 0000 0001 -> 1000 0000)

{0 ..
~~ ..
>> {0
-2 =0
.. ^0
\/ }0
}0 Sb
<< ..
\\ ..
:Sb
// ..
Sb >>
}0 ..
^7 }0
{0 \/

การหมุนบอร์ดนี้ 180 ° (แต่ปล่อยให้เนื้อหาของแต่ละเซลล์เท่าเดิม) เปลี่ยนโปรแกรมเพื่อให้เลื่อนไปทางซ้าย ( 1000 0000 -> 0000 0001)

\/ {0
}0 ^7
.. }0
>> Sb
.. //
:Sb
.. \\
.. <<
Sb }0
}0 \/
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

คุณสามารถทดสอบได้ที่นี่ (คุณจะต้องเปิด 'แสดงผลเป็นตัวเลขทศนิยม')

คำอธิบาย

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

original:      flipped:
   }0          }0
}0 Sb          .. }0
<< ..          >> Sb
\\ ..          .. //

เหล่านี้คือโต๊ะตรงไปตรงสวยทั้งสองใช้เวลาสองเล่มของท่าน (ซึ่งใช้สถานที่ของ}0เซลล์. ฟีดเดิมรุ่นหนึ่งเป็นอุปกรณ์เปลี่ยนซ้าย<<พลิกทำให้รุ่นในอุปกรณ์การเปลี่ยนแปลงสิทธิ>>เหล่านี้ดำเนินการ bitshift แต่น่าเสียดายที่ทิ้งใด ๆ บิตที่หายไปซึ่งเป็นที่ที่Sbบอร์ดเข้ามาพวกเขาตรวจสอบว่าการเปลี่ยนค่าบิตที่ป้อนนั้นจะส่งผลให้บิตหายไปหรือไม่และส่งคืนค่าที่จะเพิ่มลงในผลลัพธ์เพื่อต่อต้านบิตที่หายไป

นี่คือส่วนที่เกี่ยวข้องของSbบอร์ดดั้งเดิมสำหรับโปรแกรมดั้งเดิม:

}0
^7
{0

อันนี้ง่ายมากอย่างไม่น่าเชื่อ `^ 7 'ตรวจสอบค่าบิตที่สำคัญที่สุด ถ้าอันนี้เป็น 1 การทำการกะซ้ายจะทำให้บิตนี้หายไป ดังนั้นบอร์ดนี้ให้ผลลัพธ์ของบิตนี้เป็นค่า 8 บิตที่จะถูกเพิ่มเข้าไปในผลลัพธ์ของ bitshift

สำหรับเวอร์ชันที่พลิกกลับSbต้องดูที่บิตที่สำคัญน้อยที่สุดและส่งคืน128หรือ0นี่คือความซับซ้อนเล็กน้อย:

}0
^0 ..
=0 -2
{0 >>
.. ~~
.. {0

ถ้าบิตที่สำคัญน้อยที่สุด (เท่าที่ทดสอบโดย^0) เป็น 0 ก็แค่กลับ 0 ถ้ามันเป็นหนึ่งส่งออกจะ^0 1สิ่งนี้จะล้มเหลวในการทดสอบความเสมอภาคด้วย0 =0เหตุนี้จึงถูกผลักไปทางขวา จากนั้นเราลบ 2 -2เพื่อรับ 255 เลื่อน>>ไปทางซ้ายเพื่อรับ 127 และทำการไบนารี่~~เพื่อไม่ให้ได้ 128 (เราสามารถเพิ่มเพียงอันเดียว++เพื่อรับ 128 แต่ความสนุกอยู่ตรงไหน?)