编写一个代码段，一个函数，一个程序……，这些代码以一种乍一看看上去很清楚的方式执行其他操作而被混淆。

例如：写一些加两个数字的代码，但是当您问某人“它做什么？”时，他会告诉您它打印“ Hello，World！”。

规则

• 对于大致了解您使用的语言的人，该代码必须是可读的（出于您的利益，请避免使用内在混淆的语言，例如APL）。
• 该代码必须执行读者最初无法预测的意外操作。
• 当您问不同的读者时，他们对代码的作用必须有相同的（错误的）看法。

评分

• 请在最多10到20秒的时间内阅读其他参赛者的密码，以便对发生的事情有一个很好的了解。
• 在答案中添加注释，说明您认为代码的作用。如果您要提供的答案已经存在，只需+1注释即可。（如果您错过了该答案并添加了其他评论，请放心，它不会被视为另一个答案）。
• 这些点将以这种方式被识别：（maxFalseOpinion- goodGuess）/ totalOpinion（请参见下面的示例）。
• 给其他参赛者打上公平竞赛的评价，不要评论自己的代码。
• 仅添加有用的注释。避免使用“我不知道”和“好人！”，因为评级没有考虑到它们，但是混淆的是代码而不是评级。

评分范例

该代码段将两个数字相加。评论说：

（3）显示“你好，世界！”
（1）减去2个数字。
（2）将两个数字相加。

点的总数是最大意见数（3）-良好猜测的数目（2）除以猜测的总数（3 +1 + 2 = 6）。结果：（3-2）/ 6 = 1/6 = 16.67％。

有关点的更多信息

人们似乎很难找出要点。

这是一个完美的成绩：

printf('Hello World');

注释：
它显示您单击按钮的次数。（17条评论）。
总计：17条评论

得分：（17-0）/ 17 = 1 = 100％

这是一个la脚的得分：

printf('Hello World');

注释：
打印“ Hello World”。（13条评论）。
总计：13条评论

得分：（0-13）/ 13 = -1 = -100％

这是一个不错的分数：

printf('Hello World');

注释：
打印用户名。（2条评论）。
它显示当前时间（15条评论）。
它返回您输入的内容而无需修改。（3条评论）。
它打印“ Hello World”（1条评论）。
总计：21条评论

得分：（15-1）/ 21 = 0.6667 = 66.67％
解释：
15是主要的猜测，是人们最多说的话。1是正确的猜测数。所有评论的总和为21。

Java脚本

var а;
a = 1;
а++;
alert( a );

答：输出1。下面的注释对其进行了很好的解释-这里有两个不同的变量，即-“拉丁文小写字母A”和а-“西里尔小写字母A”。

正确答案为1，有50个人认为它输出了2，总共52个答案，得分为（50-1）/ 52 = 49/52 = 94,23％

C，得分33.3％

#include <stdio.h>
int main(int ac, char **av) {
        const char *arg = av[1];
        #define valid_ch(ch) (ch!='&' && ch!='\\')  // All valid except & and \
        while (*arg)
        {
                if (valid_ch(*arg)) putchar(*arg);
                arg++;
        }
        puts("");
        return 0;
}

跑 ./prog 'Hello & goodbye, world!'

得分

正确答案是H\n（while注释的一部分，这要感谢以结尾的行\，因此没有循环），由6个人给出。
最受欢迎的错误是Hello goodbye, world\n25人犯了。
（25-6）/ 57 = 33.3％。
感谢Olivier Dulac费心计算。

蟒蛇

a = []
for i in range(10):
    a.append(i * ++i)
for a[i] in a: 
    print(a[i])

评分

1. 好的答案：0 1 4 9 16 25 36 49 64 64在一行上打印，每个数字。

2. 说明：尽管没有人得到正确的答案，但我认为这主要是一次失败的尝试，因为没有人犯了我想要的错误。（如果没有其他人做，我将在后面添加一个真实的说明。）

3. 好的答案数：0

4. 错误答案相同的人数：7

5. 答案总数：11

6. 得分： 63,64％（四舍五入到两位小数）

说明

首先，a创建一个列表并用values填充i * ++i。++Python中没有运算符，但是有一个一元运算+符，它对整数不执行任何操作，并且两次应用该操作仍然无效。因此a包含从0到的整数平方9。

我把++注意力分散了，希望大多数选民继续前进，以为他们找到了陷阱，落入了真正的陷阱。它没有解决。一些人认为这++是语法错误，其他人仍然在寻找陷阱。

陷阱 陷阱位于第二个for循环中：

for a[i] in a: 
    print(a[i])

我确信大多数人会认为这会在一行上打印出所有的a[i]，即0 1 4 9 16 25 36 49 64 81每个数字。例如，这就是使用可变标尺所得到的：

for x in a: 
    print(x)

x被分配了中的值a，然后x打印。在第一个版本中，a[i]分配了中的值a，然后a[i]进行打印。区别在于，在我们的例子中，我们有i == 9，因此a[9]每次通过循环都会更改的值。最终a[9]打印时，它的值为a[8]，因此64再次打印。

JavaScript，得分为-100％

我没有发明这个，加里·伯恩哈特做到了，但这是我的最爱之一

alert(Array(16).join("wat?" - 1)+", BATMAN!")

Python，-54.8％

答案：加薪 SyntaxError: not a chance

from __future__ import braces

if (input() > 0) {
print 'You entered a positive number';
}
else {
print 'You didn\'t enter a positive number';
}

• 不错的猜测：24
• 同样的错误猜测：7
• 总猜想：31

说明：

from __future__ import braces是Python中的复活节彩蛋之一。这是一个笑话，它表示Python将来将不再使用花括号来进行作用域定义。

Perl，26.67％

结果：

上面印着“我根本不说话。”

my $num1,$num2 = @_;缺少括号。因此，它等效于my $num1; $num2 = @_;。 $num1没有设置任何东西。

因此$num1永远不会大于零。屏幕上隐藏着的秘密鱼世界的一些错误，是红色鲱鱼，使人们认为他们已经找到了“绝招”。

此外，三元运算符在Perl中是一个l值：1 ? $a = 1 : $b = 2实际上是(1 ? $a = 1 : $b) = 2。($a = 1) = 2评估$a为均值，设置为2。与外观相反，第二个字符串分配给$num1。

如果您想知道的话，//是定义或运算符。如果sub返回一个未定义的值，"Stuff did not happen."则将打印该字符串。但这实际上并没有发生。只是给人们另一个选择。

得分：

正确总数：5

总猜想：30

得分：（13-5）/ 30 = 26.67％

no warnings;
no strict;
no feature;
no 5.16;
no Carp;

sub do_mysterious_stuff
{
    my $num1,$num2 = @_;               

    if ($num1 > 0)
    {                                                                                                                  eval q; $num1="This is a secret fish world. Carp cannot be repressed!" or
       $num1 = "Hello, world!";
    }
    else
    {
        $num2 > 0 ? 
            $num1 = "What's up, world?": 
            $num2 = "I am ambivalent about saying anything at all.";
    }

    return $num1;
}

print do_mysterious_stuff(1,1) //"Stuff did not happen.";

PHP 52％

  $arg = 'T';
  $vehicle = ( ( $arg == 'B' ) ? 'bus' :
               ( $arg == 'A' ) ? 'airplane' :
               ( $arg == 'T' ) ? 'train' :
               ( $arg == 'C' ) ? 'car' :
               ( $arg == 'H' ) ? 'horse' :
               'feet' );
  echo $vehicle;

（从这里逐字复制）

说明和分数

正确的答案是马。这不是花招或技巧。奇怪的是，这就是在PHP中定义三元运算符的方式。
3选择了正确的答案：马，有
16个人选择了除PHP以外在其他任何一种语言上都正确的火车。总共
25个答案，得分为（16-3）/ 25 = 52％

C ++ 28.9％

#include <iostream>

using namespace std;

void print( void ) {
  static int times = 0;

  switch( times ) {
  case 0:
     cout << "Hello";
     break;
  case 1:
     cout << "World";
     break;
  default:
     cout << "Goodbye";
     break;
  }
  times++;
}

int main(int cout, char* argv[]) {

  print();
  cout << '\n';
  print();
}

解

该代码的目的是欺骗用户，使他们认为在文本“ Hello”和“ World”之间将打印换行符。请注意，main的第一个参数名为cout。因为在main的范围内，cout是一个整数，所以<<操作符实际上使用参数'\ n'执行左移操作，而不是打印换行符。那里的打印功能主要是要注意main中的输入参数，但也允许使用std :: cout而不添加名称空间前缀。

得分

由Alvin Wong提供

• 总计38个答案：
• 12个想法HelloWorld（考虑到minitech和zeel相同）
• 23人以为Hello\nworld 3人有其他想法。
• 得分是（23-12）/ 38 = 28.9％

露比100％

display = lambda { puts "Hello, world!" }
display()

正确答案：

打印没有换行符的“ main”。说明：在Ruby中，不能使用常规括号语法调用lambda。而是将display（）解释为所有对象都具有的内置方法：o.display将o.to_s打印到标准输出。在没有对象的情况下调用的方法被解释为“ main”的方法，“ main”是一个包含内核模块的对象。

分数：3个相同的错误答案，没有其他答案。

蟒蛇，-28.13％

x = 0
while x < 10:
    if (x%2)==0: x += 2
else: x += 1

print x

这11是因为退出循环之后执行了else属于的块，所以进行打印while。

• 错误猜测的最大数量：8
• 正确的猜测：17
• 总猜测：8 + 17 + 7 = 32

得分：（8-17）/ 32 = -28.13％

Python：评分：-27％

name = "Robin"
seek = "Seek and find holy grail"
favorite_color = "blue"

from os import *

print "What is your name: %s" % name
print "What is your quest: %s" % seek
print "What is your favorite color: %s" % favorite_color

程序打印：

What is your name: <value of os.name> 
What is your quest: Seek and find holy grail
What is your favorite color: blue

评分：总共意见：22 12正确3 +1 + 6错误[对于Bakuiru的回答，我想说这很接近，但仍然不正确，因为os.name是一个字符串（os.uname是一个函数）]

根据该假设和我对评分系统的理解进行评分：最大错误= 6正确= 12得分=（6-12）/ 22 = -27％

蟒蛇

import sys

class TwoPlusTwoIsFive(object):
  def __bool__(self):
    if 2 + 2 == 5:
      return True
    else:
      return False

two_plus_two_is_five = TwoPlusTwoIsFive()

if two_plus_two_is_five:
  print('{} is company'.format(sys.version[0]))
else:
  print('{} is a crowd'.format(sys.version[0]))

编辑：

得分（8-1）/ 9 == 77.7％

在python 2上正确的输出是'2 is company'在python 3上的'3 is a人群'。

JavaScript，-46.7％

var getResult = function(n, notReadyYet) {
    alert("Calculating results...");
    if (notReadyYet) {
        setTimeout(getResult, 100, n);
    } else {
        sayResult(n);
    }
    return arguments.callee;
}

var sayResult = function(n) {
    if (n >= 10) {
        alert("That's a big number!");
    }
    if (n < 10) {
        alert("That's a small number.");
    }
    return n;
}

(function() {
    var input = parseInt(prompt("Please enter a number:"));
    var result = getResult(input, true);
    return result;
})();

准备就绪时，您可以在此处运行它（首先要猜测！）。如果在JS面板中向下滚动足够远，则会看到带有简短说明的代码。

正确答案：

要求用户输入数字后，它将进入无限循环并显示“正在计算结果...”警报，直到超出最大调用堆栈大小为止（尽管jsfiddle示例将在大约20次后停止）。但是，如果将分号放在sayResult函数的右括号后面，则它将像注释中所述的mgibsonbr一样工作。

得分：

• 好答案：9
• 最受欢迎的错误意见：2
• 答案总数：15

Java脚本

var a = [];
a.push( "Hello" );
a.concat( [ ", ", "world", "!" ] );
alert( a.join("") )

答：它会发出警报Hello。该concat方法不会修改数组-它返回一个数组，该数组包含被调用的数组与提供的任何其他参数的串联。

正确15题，错误26题，总共41题，得分为（26-15）/ 41 = 11/41 = 26.83％

蟒蛇33.3％

def Test():
    False = True
    True = False
    if False:
        return False
    elif True:
        return True
    else:
        return None

a = Test()
print a

注意：假设这是Python 2.x，而不是Python 3。

运行时，此代码产生一个UnboundLocalError: local variable 'True' referenced before assignment。

爪哇

public class Puzzle {

    public static void main(String[] args) {
        String out = "Some ungodly gibberish";
        //char x = \u000a; out = out + " and then some more. ";
        System.out.println(out);
    }
}

第一次尝试代码高尔夫...

好的答案：印刷品Some ungodly gibberish and then some more.和换行符

评分：

• 最大猜数6
• 猜测总数11
• 正确的猜测数5（如果您处于pedanitc模式，则为0）

得分：9％（在学徒模式下为55％）

C＃62.5％

int sum=0;
List<Task> threads = new List<Task>();
for (int i=1; i<=10; i++) {
  Task adder = new Task( ()=> sum += i );
  threads.Add( adder );
  adder.Start();
}
foreach (var t in threads ) { 
  t.Wait();
}
Console.WriteLine("Sum of all numbers in 1..10 is: "+sum);

这是我第一次打高尔夫。

正确的答案是：“介于55和110之间”。那是因为每当执行“ sum + = i”语句时，它将使用i的当前值。该代码甚至可能在for循环完成之后执行，此时i的值为11。这使最高值变为110（并且可以确保在测试中放慢lambda的速度，以确保看到它）。最小的可能值为sum（1..10），即55。

• 好答案：0
• 只有大约好的答案：5
• 选择最受欢迎的答案的次数：5
• 答案总数：8

得分：严格来说，没有人做对，所以得分应该是（5-0）/ 8 = 62.5％。 如果我们愿意将“大约好”视为正确答案，那么分数为（5-5）/ 8 = 0％

Python，-83.3％

答案：a < b如果输入相等，a = b第一个较大且a > b第二个较大，则打印。

a = input()
b = input()
print 'a', '<=>'[cmp(a, b)], 'b'

• 好猜：11
• 同样的错误猜测：1
• 总猜想：12

说明：

cmp(a, b)0如果两个参数相等，1则返回第一个参数，如果第一个参数较大，-1则较小，这就是为什么打印错误的比较符号的原因。

PHP，100％

第一次发布到代码海湾，希望这还不错。

function word_to_num($word) {
 switch ($word) {
  case "one":
   return 1;
  case "two":
   return 2;
  case "three":
   return 3;
  default:
   return "error";
 }
}
function print_word($num) {
 switch ($num) {
  case 1:
   print "hello";
   break;
  case 2:
   print "world";
   break;
  case "error":
  default:
   print " ";
  }
}

$words = array("one", 0, "two");
foreach ($words as $word) {
 $result = word_to_num($word);
 print_word($result);
}

正确的输出是“ hellohelloworld”

得分是（10-0）/ 10 = 1 = 100％

Perl：100％（4-0）/ 4

print (1 + 2) * 3, "\n"; 
#

该程序将打印“ 3”，而无需换行。Perl将此指令解析为

((print (1+2)) * 3, "\n")

因此，只有将(1+2)作为参数传递给print。

C＃

static void Main(string[] args)
{
     Console.WriteLine('H' + 'e' + 'l' + 'l' + 'o');
     Console.ReadLine();
}

CPython的

if 'Hello' + 'World' is 'HelloWorld':
  print 'Hello'
if 'Hello' + 'World!' is 'HelloWorld!':
  print 'World!'

正确的输出是“你好”

得分（14-3）/ 19 == 57.9％

C（评分：4.45％）

良好的猜测：7
错误的猜测的最大值：6 + 2 = 8
总的猜测：6 + 7 + 3 + 2 + 4 = 22

解决方案： ??/是的三部曲\，因此换行符被转义并且该scanf行被注释掉。因此，程序将永远运行并打印Guess a number between 1 and 10:。这些评论是来自莫扎特（via fortune）的引用。

// Why not?/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// What?/
int main(int argc, char** argv)
{
    // Why not?/
    int number;

    // Why should I not send it?/
    srand(time(NULL));

    while(1)
    {
        // Why should I not dispatch it?/
        printf("Guess a number between 1 and 10: ");

        // Why not??/
        scanf("%d", &number);

        // Strange! I don't know why I shouldn't/
        if(number == rand() % 10 + 1)
        {
            // Well, then/
            printf("You guessed right!\n");
            // You will do me this favor./
            exit(0);
        }
    }
}

剧透，如何编译和运行：

gcc test.c -trigraphs

爪哇

public class Test {
    public static void main(String[] args) {
        String fmt = "%s - %04d\n";
        System.out.println(fmt.format("Padded value: ", 0x0c));
    }
}

答案

打印Padded value:（用换行符）。

String的format方法为static，格式作为第一个参数传递。即上面的调用等效于：

        System.out.println(String.format("Padded value: ", 0x0c));

好的答案数：2错误的答案：9

得分：（9-2）/ 11 = 63％

C

#include <stdio.h>
#define SIX  1+5
#define NINE 8+1

int main()
{
    printf("%d\n", SIX * NINE);
}

得分=（3-16）/ 19 == -68.4％

不要忘记你的毛巾。

C ++

#include <cstdio>

int main()
{
    int f;

    f or (f = 0, f < 1000, ++f,
        printf("H ello world !\n"));

    return 0;
}

得分=（1-6）/ 7 = -0.71428571428571 = -71.428571428571％

的JavaScript

var x = 0;
var y = !x * 4;
var z = !y;
alert("Z = "+z);

蟒蛇

def greeting():
  try:
    return 'Hello World'
  finally:
    return 'HELL0 W0RLD'

print greeting().lower()

正确的输出是“ hell0 w0rld”

得分（8-14）/ 22 == -27.3％

R：100％

并非如此，但可能会使某些人感到困惑：

sum(data.frame(rep(1,10),stringAsFactors=TRUE))

您认为结果如何？

编辑：

答案是20，因为丢失的s在stringAsFactors（代替stringsAsFactors），参数不被识别，因此函数创建一个名为新列stringAsFactors。由于矢量循环，该列包含10次TRUE，1总和转换为s，因此总计为20，而不是10。

评论中未给出该答案。给出了3个答案（都10或多或少说了）。因此，我猜得分为100％。

Tcl

受ugoren启发

foreach c [split [lindex $argv 0] {}] {
    # Don't print the invalid chars & and \
    if {$c in "& \\"} {continue}
    puts -nonewline $c
}

抱歉，忘记了示例字符串。好的，以

./charfilter.tcl：“你好，再见，世界！”

编辑 权解决方案：完全不过滤。（6x）
最高错误答案：4x
总答案：10
得分：-0.2