我反转了源代码，您否定了输出！

39

您的任务（如果希望接受）是编写一个输出非零数字（可以是整数或浮点数）的程序。棘手的部分是，如果我反转源代码，则输出必须是取反的原始整数。

规则

  • 您必须构建一个完整的程序。也就是说，您的输出必须打印到STDOUT。

  • 两个数字都必须以10为底（禁止以其他任何底数或以科学计数法输出）。

  • 允许输出带有尾部/前导空格的数字。

  • 这是代码高尔夫球，因此每种语言中最短的（原始）代码胜出！

  • 默认漏洞适用。

例

假设您的源代码为，ABC并且其对应的输出为4。如果我CBA改为编写并运行它，则输出必须为-4。

code-golf  source-layout 
— 高放射性
source
6
如果我们可以在位级别而不是字节级别反转，则一个字节-（0x45 = 0b00101101）在Jelly中起作用- -因为它定义了文字-1，所以产生-1，而Ṇ（0xB4 = 0b10110100）因为执行逻辑不而产生1。的隐式输入零。（当然Ṇ效果也不错：p）
— 乔纳森·艾伦
@TwilightSparkle“具有未使用的，空的输入”是否意味着我们可以依靠立即达到EOF的输入函数？
— Borka223
1
@ Borka223不，你可能没有。
— 高度放射性的
@JoKing复制。我将删除它。
— 放射性

Answers:

28

JavaScript（V8），19个字节

print(1)//)1-(tnirp

在线尝试！

与...几乎相同

C＃（Visual C＃交互式编译器），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打印而不是打印

红宝石，8字节

p 1#1- p

在线尝试！

— Arnauld
source
也是C＃Interactive ，Print(1)//)-1(tnirP。（在线尝试！）
— 某人
对于C＃，最短的程序也可能是微不足道的程序：class A{static void Main(){System.Console.Write(1);}}//}};)1-(etirW.elosnoC.metsyS{)(niaM diov citats{A ssalc
— LegionMammal978
这不是一种编程语言，但是您可以1<!--!<1-使用HTML（9字节）来完成操作，这将-1<!--!<1在反向时进行。它与您的答案完全相同。
— Ismael Miguel
在Lua中大致相同：print(1)--)1-(tnirp
— val
1
— 夜间2
12

///，4个字节

9/9-

输出9。

在线尝试！

反转：

-9/9

输出-9。

在线尝试！

之前的所有内容都会/被打印，而其余的内容会被忽略（没有真正使用的斜杠太多，所以我不知道会发生什么，但不会输出任何内容）。

— 史提芬
source
2
+1以使用斜杠。的/开始图案读取处理，并且因此，它后的字符被readed入模式，不输出。
— 高度放射性的
2
我想出了一个/\-//1-聪明的想法。：D
— Tanner Swett
10

空格，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。

在线尝试或反向尝试在线（仅使用空格，制表符和换行符）。

说明：

利用内置的退出程序是一个简短的回文NNN。
常规程序将：

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后跟一个N：二进制数字，其中S=0和T=1

即SSTTSTSN推-10。

— 凯文·克鲁伊森
source
7

Japt，2 个字节

任何单位整数>0来代替的可以使用2如罐A-G，H，I，J或L（10-16，32，64，-1和100，分别地）。

n2

测试 | 倒转

该n方法应用于整数时，将从传递给它的参数中减去该整数，默认为0。向前运行时，该n方法正在隐式的第一个输入上运行，该输入也默认为0。

另外，g也可以使用方法代替n，从而给出从所应用的整数中减去其参数的结果的符号。

— 毛茸茸
source
7

Haskell，无评论，41个字节

转发打印1+换行符：

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

在线尝试！

-1没有换行符的反转打印（可以添加2个字节）：

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

在线尝试！

  • 每个程序的第一行都会打印数字。
    • 对于-1字符串输出，用于避免括号。
    • 使用$!（严格的应用程序）代替空格可以使反向线成为操作符的有效定义!$（$因为重新定义会中断使用，所以不会这样做）。
  • 中间一行确保niam为最后一行定义。
  • 最后一行是operator的定义，!$未使用，但需要正确解析和类型检查。
— ØrjanJohansen
source
7

PHP，15 13字节

一个没有注释滥用的PHP版本。ohce是一个未定义的常量，因此将等于其名称的字符串值。结果，这将尝试打印+1-'ohce'或-1+'ohce'反转。由于'ohce'是非数字值，因此在算术运算中将使用0代替，并且仅1或-1将被打印。

;echo+1-ohce;

在线尝试！

online在线尝试！

— 晚2
source
那很聪明。真好！
— AdmBorkBork
1
男人，这是可悲的，我已经到了相同的答案，因为你3小时后期:(有我给予好评。
— 伊斯梅尔·米格尔
6

Cubix，7 6 5字节

@)O(@

尝试在这里
反转

说明

总结：

  @
) O ( @
  .

展开控制流，我们执行)O(@，将递增，输出，递减和退出。

颠倒和僵化：

  @
( O ) @
  .

展开控制流，我们执行(O)@，以进行递减，输出，递增和退出。

先前版本

@O(.)O@

尝试在这里
反转

不那么短，但是在美学上令人愉悦。

— 助记符
source
不错，可以将其放在1号立方体上的方法！
— 朱塞佩
3
@)O(@5个字节并恢复对称性:)
— MickyT
5

堆猫 -mn，4个字节

:-:_

在线尝试！在页脚中，我包括了所有其他4字节解决方案。（Stack Cats会在第一个换行后忽略所有内容。）

尝试反向！

说明

该-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它做-]或-[还是什么都不是，取决于堆栈顶部的符号。所以...

堆猫 -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。

— 马丁·恩德
source
4

Zsh，12个字节

<<<2 # 2-<<<

在线尝试！

基本的前进，评论，倒车方法。

如果I / O的限制较少，则由于Zsh支持负返回码，因此可能有一个更有趣的11字节解决方案：

return -127

相反，721- nruter退出并返回代码127（未找到命令）。exit -127无法使用，它将被强制转换为u8。 在线尝试！

— 伽玛功能
source
4

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
— 路易斯·门多
source
4

六边形，5字节

1!@!(

在线尝试！

任何有效程序都必须：

  • 有一个终止命令（@或:）。后者仅在存在内存指针移动命令时才与前者不同。同样，此命令不得位于第一个或最后一个字节。
  • 有一个输出命令。（!，;也是可能的，但可能会占用更多字节）
  • 有一个内存操作命令。

因此，一个2字节的程序显然是不可能的。3字节的程序是不可能的，因为第二个字节必须是终止命令，而第一个字节不能是镜像/ IP操作命令，因此只能执行一个字节。

我认为4字节程序是不可能的。这样的程序必须具有a@bc六角形网格的形式

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

因此a必须是IP重定向命令。但是，仅用1个内存操作命令就不可能同时生成正数和负数。

— 用户名
source
+1在另外琐碎最优答案的证明
— 乔金
3

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有一个错误，尽管您缺少程序的强制性主方法，但该错误允许您在枚举内创建代码块以执行某些操作。这将导致错误：

java.lang.NoSuchMethodError：main
线程“主”中的异常

但是仍然会先输出我们想要STDOUT的内容，因此我们可以忽略它。

— 凯文·克鲁伊森
source
3

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

在线尝试！

— 连指手套
source
2
我不知道Go，但是看来您可以删除一些字节。该Println可以Print，而且import "fmt";并不需要空间：import"fmt";。:)
— Kevin Cruijssen
3

视网膜，6个字节

-`<
-

印刷品1。

在线尝试！


-
<`-

印刷品-1。

在线尝试！

说明： 1

-`<
-

这...什么都不做。由于使用`，这是从<到的替代-（使用configuration -，但不执行任何操作），但是输入为空，因此输出也为空。

第二阶段将空的正则表达式与空的输入进行匹配，并计算匹配的数目，恰好为1。输出是隐式的。

说明： -1


-

这次我们用替换空的正则表达式-。实际上，确实会将空输入变成单个输入-。

<`-

在这里，配置实际上做了一些事情：<在执行阶段之前打印阶段的输入，因此我们打印-。然后-在阶段的输入中再次计算连字符1。由于隐式输出，这会在1后面打印a -，从而-1根据需要提供给我们。

— 马丁·恩德
source
3

TEX(MathJax), 4bytes

1%1-

CodeResultForward:1%1-1Backward:-1%1−1

— 纳特
source
3

brainfuck，156个字节

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

在线尝试！/ Bash中的前进/后退验证程序

-1向前和\n1向后打印。

尽管几乎无关紧要，但我认为这是针对此特定固定输出的最佳解决方案。

证明：

  • 该程序不能具有[或]。

    因此，程序必须具有形式<A> . <B> . <C>。

  • 每个,都可以用足够多的替换，<而无需增加+或的数量-。

  • 每个+函数仅在向前或向后程序中都有用，而对两者都不有用。

    证明：+A部分显然仅在前向程序中有用，而+C部分显然仅在后向程序中有用。

    表示shift(P)= <P中的数量-P中的数量>。考虑程序<B> = <D> + <E>，+中间的在向前程序中很有用⟺ shift(E) = 0，同样在向后程序中很有用 ⟺ shift(D) = 0。但是，如果这样，shift(D) = shift(E) = 0则B向前或向后执行的程序将在第二次打印之前向当前单元格添加一个固定值，因为不能这样ord('1') - ord('\n') != ord('1') - ord('-')。

因此，程序至少需要ord('-')+ord('1')+ord('\n')+ord('1') = 153 +s，2 .s以及至少a < >或,因为shift(B) != 0。

— 用户名
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.