这项挑战的目的是编写一个满足以下条件的程序：

• 该程序不是回文的，或者实质上不是回文的（意味着可以删除字符以使其成为回文，而无需更改程序的效果）。

• 该程序不是对合（意味着在其输出上运行时不会产生其原始输入）

• 所述逆极性程序是正常的程序的逆; 因此，当反向程序在普通程序的输出上运行时，它将返回原始输入。

什么是反向极性是什么意思？嗯，这在语言之间是不同的。

• 对于大多数非esolang语言，这意味着在单个操作中反转子操作的顺序，反转参数的顺序，以及反转硬编码列表/数组/元组/字典/堆栈/队列/等的内容颠倒代码块和独立行的顺序（但不改变块内的行）

例子：

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），只需反转指令字符串

• 对于BF等一维esolang，请颠倒说明或交换极性。极性交换是[]-> {}，+-> -，--> +，>-> <，<-> >，.-> ,和,-> .（但不能同时使用）

• 对于像Befunge这样的二维esolang，您可以在x轴或y轴或对角线上执行反射，旋转180度，或者将反射和旋转结合起来

允许交换运算，但回文运算则不允许：2*x很好，但是x+x很糟糕。极性反转的定义很松散，但要根据判断来判断。目的不是找到最聪明的漏洞，而是找到最聪明的解决方案。

这是一次人气竞赛，因此非常聪明的漏洞可能很流行，但请尽量避免这种挑战。一旦至少有10个解决方案的至少1个投票，并且至少有1个解决方案的投票数大于至少1个投票的提交数，则将宣布获胜者；或在1个月内（以先到者为准）。这是我面临的第一个挑战，因此请尽量公平并给我建设性的反馈，但也要让我知道这是一个不合理的挑战，还是以某种方式被错误归类或模棱两可。如果您对某种语言所提出的疑问不适合我在此处提出的任何建议，请发表评论，如果强烈要求特定的澄清或规则更改，我会屈服于社区的意愿。

更新

距比赛开始已经整整1个月了（我只是偶然地检查了一下，不知道自己确实准时参加了比赛）。由于这是一场人气竞赛，因此优胜者（以压倒性优势）是 Pietu1998-Befunge。即使最下面的部分（文本反向器和反向字母）都是对合，编码器/解码器也不是，因此在那里没有问题。（在我心中）奖励点，用于设法在中间写下“ BEFUNGE”。我个人喜欢Zgarb的Theseus解决方案的新颖性，因为该语言看起来很酷（如果受限制的话）。感谢大家的参与，当选出优胜者时，我将完全开放这场比赛，并欢迎以后提交。

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@>^

凯撒密码解码器（水平翻转）

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

马氏

这是一个简单的开始。它从STDIN读取一个字符，递增并打印。

--
]]
00
]]
++

如果将其旋转180°（不带括号），或在x轴上镜像，我们将得到

++
]]
00
]]
--

它从STDIN读取一个字节并将其减1。

您可以在这里进行测试。

我可能会研究一些更复杂的Marbelous程序，但是我敢肯定es1024将击败我。;）

说明

的00是具有0值（这是任意的）的大理石。该]]设备从STDIN读取字节-也就是说，如果一个大理石落下通过他们，大理石的值被改变到读取字节。该++和--设备简单递增或递减一个大理石的值（MOD 256），让它落空。当大理石从板上掉下来时，该字节将写入STDOUT。

因此，最顶部的两个设备将被忽略，因为控制流永远不会到达它们。

马氏

该板采用一个参数（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 只需将结果打印为十进制数即可。

us修斯

这可能被认为是一个漏洞，但是我喜欢这种语言，所以去吧。该程序定义了一个函数f上自然数映射3N至3N + 1，N + 1至N + 2，和3N + 2至3N，对于每Ñ。

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

us修斯是一种具有类似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单元格。原始版本将一个版本输入到左移位设备中<<，翻转后的版本将其放入右移位设备中，>>虽然执行位移位，但不幸的是丢弃了任何一个）丢失的位：Sb板子进入的地方，他们检查将所馈送的值进行位移位是否会导致丢失位，并返回要添加到结果中的值以抵消丢失的位。

这是Sb原始程序板中原始程序的相关部分：

}0
^7
{0

这非常容易，`^ 7'检查最高有效位的值。如果此位为1，则执行左移将导致该位丢失。因此，该板将输出该位的值作为8位值，以将其添加到移位结果中。

对于翻转版本，Sb必须查看最低有效位并返回128or 0，这有点复杂：

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

如果最低有效位（由检验^0）为0，则仅返回0。如果为1，^0将输出1。这将使相等性测试失败0 =0，因此将其推向右侧。然后，我们减去2 -2得到255，向左移位>>得到127，然后执行二进制运算而不~~得到128（我们也可以简单地加一个++得到128，但是这样做的乐趣在哪里？）