任务

创建一个返回1的函数/子例程。只要返回1，就可以根据需要进行详细说明。

规则

投票最多的作品将获胜-就像任何知名度竞赛一样。祝好运！

高尔夫脚本

1

花了很长时间将这段代码优化到最纯粹的程度，我敢说它-漂亮的形式。没有多年的实践，这种语言的优雅就不会出现。没有“零指令集计算机”的程序，从字面上就无法进一步压缩。我的整个职业高尔夫生涯一直引领着这一刻。

我自由了。我还活着。

我看到了构成基础的代码。

C

以下两个示例使用了模糊的语言功能，例如“强收益”（return!）和“方法”运算符（-->）：

int foo(void) {
    return! 0;
}

int bar(void) {
    int i=7;
    while (i --> 0);
    return-i;
}

脑干

+++++++
+++++++
    +++
    +++
    +++
    +++
    +++
++++++++++
++++++++++.

或者，如果您在聚会上不开心：

+++++++[->+++++++<]>.

杀伤人员地雷

one ← {⍴⍴⍴⍵}

⍴为您提供矢量的尺寸。那尺寸始终是一维的，这样的尺寸是总是一个。要么：

“ X的Rho，rho，rho
始终等于1，
Rho是维度； rho rho，等级
APL很有趣！”

（我没有写那节经文，是斯托曼的。）

爪哇

public static int funWithOne() {
    try {
        try {
            return funWithOne();
        } finally {
            return funWithOne();
        }
    } catch (Throwable _) {
        return 1;
    }
}

最终返回之前，它会自称为2 ¹⁰²⁴次（此数字在不同平台上可能会有所不同）1。但是不要屏住呼吸；否则很容易花费很多时间比宇宙的年龄。

鱼

x沿随机方向发送程序计数器。＃是程序计数器“反弹”的墙。这实际上会漫无目的地游荡，直到找到“ ^”，然后打印1并完成。

xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxx###xxxxxxxxxxxxxx
xxxxxxxxxx#;#xxxxxxxxxxxxxx
xxxxxxxxxx#n#xxxxxxxxxxxxxx
xxxxxxxxxx#1#xxxxxxxxxxxxxx
xxxxxxxxxx#^#xxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxx

Unix Shell（Bourne，POSIX，bash，ksh，csh等）

expr 0

这将输出 0，但返回 1，这对于习惯于其他语言的程序员可能会感到惊讶。您可以通过运行关闭打印输出并查看返回码expr 0 >/dev/null; echo $?。

爪哇

这是我最喜欢的Java特定问题之一。

public static int ret1() {
    try {
        return 0;
    } finally {
        return 1;
    }
}

的JavaScript

function getOne() {
    return -~![];
}

说明：

• 首先![]评估为false。
• 然后~false成为，-1因为false首先被投射到0和~0 == -1。
• 最后，--1评估为1。

备用：

return +!([][~~{}])

疯狂备用（每行正好是80个字符长）：

this[693741..toString(36)]('acnuftiao nobcbdaterbaurn +abeba!!be'.replace(/b./g,
function(b){return '{}()'.split('')['aecd'.split('').indexOf(b.charAt(1))]})[''+
'replace'](new RegExp('a'+Array(5).join('(.)'),'g'),(a='$')+'4321'.split([]+[]).
join(a)))

的JavaScript

// we all know that OOP == good
function OneManager() {
    // constants == good too
    this.values = {
        ERROR: -1, // value on error
        ONE: 1 // desired value
    }
    this.value = this.values.ERROR // set the value to ERROR
    this.setValue = function(num) {
        if (typeof num !== "number") throw new Error('cannot set value to non-number')
        if (!this.value) this.value = this.values.ERROR // oh noes
        else this.value = num
    }
}
// initialize the one
OneManager.prototype.initializeOne = function() {
    this.setValue(this.values.ONE) // set the value to ONE
    return true // return true for success
}
// get the value
OneManager.prototype.getValue = function() {
    if (this.value == this.values.ERROR) { // if the value is ERROR
        throw new Error('value not initialized')
    } else return this.value // return the value
}

function getOne() {
    var m = new OneManager() // make a OneManager
    var success = m.initializeOne() // initialize the value
    if (success) return m.getValue() // return the value
    else  {
        // there was an error in the initialization
        var retVal = m.values.ERROR // we will return an error
        delete m // maybe it's corrupted
        return retVal // return an error
    }
}

alert(getOne())

Haskell和ADT教堂

data One = One deriving (Eq, Ord, Bounded, Enum, Show, Read)

这定义了一个 true One。这One既是表示Oneness的类型，又是构造函数One，它本身是返回一个 true 的无效函数，并且仅返回type的一个值One，即，One。

用法 ghci REPL中的：

λ: One                  -- One returns the one true One
One
λ: One == One           -- One is equal to itself, as no others are 
True
λ: One < One            -- One is no less than itself
False
λ: minBound :: One      -- One is the least One there is, yet it is all you need
One
λ: maxBound :: One      -- One is as big as the universe of One, it is omnipotent
One
λ: [ One .. One ]       -- One is the beginning, and ending, of all that is One
[One]
λ: show One             -- The textual gospel of One
"One"
λ: read "One" :: One    -- To read the word of One, is to become one with One
One

完整的《一本书》现已上线。加载它会得到两个证明：计算和算术。这使您能够探索更多的真相：

λ: One + One            -- One can only add to its magnificence
One
λ: negate One
*** Exception: One cannot be negated, mortal fool!

λ: One `div` One        -- One is indivisible
One
λ: One `mod` One
*** Exception: Nothing can modulate the power of One

λ: toRational One       -- Ye shall know One as both Numerator and Denominator
1 % 1
λ: toInteger One * 42   -- One multiplies all to wholeness
42
λ: toRational One / 2   -- Even divided, One is on top
1 % 2

Groovy

-"""
int getRandomNumber()
{
    return 4;   //chosen by fair dice roll.
                //guaranteed to be random.
}
""".indexOf(4)

不包含4

佩尔

sub ret1 { print $->$= }

（尽管出现，该函数不会打印任何内容。）

我知道Perl程序员喜欢说TMTOWTDI，但这确实是 MTOWTDI 的任务。

的PHP

<?php
function getOne() {
  return 0 + "one" == 0;
}

编辑：

如果您希望使用更长的打印机，可以使用以下方法（它不会打印任何内容）：

<?php
function getOne() {
    return print('the' + 'integer' + 'between' + 0 and 2);
}

C

float one(void)
{
    const int n = 24; // magic number
    float x = 0.5f;
    float y = x;
    int i;

    for (i = 0; i < n; ++i)
    {
        x *= 0.5f;
        y += x;
    }
    return y;
}

修辞的Java

您没有说它必须是整数1。

float one_F(){
    return FloatFactoryFactory.getInstance(FloatFactoryFactory.
    defaultInstanceDescriptionString).getFactory(Locale.getLocale
    ("en-US")).createBuilder().setString("1.0").getResult();
}

资料来源：http：//bash.org/？946461

JavaScript（实际上是ECMAScript）

function one() { return Number.length; }

时间一些规范色情。

15.7.3节声明构造函数的length属性Number为1（并且我们知道构造函数是4.3.4中提到的函数对象），这是因为15.3.5.1节说：

length属性的值是一个整数，表示该函数期望的“典型”参数数目。但是，该语言允许使用其他一些参数来调用该函数。

…并且由于Number构造函数的典型参数个数为1，因此lengthof Number是1。因此，可以说Javascript中数字的长度为1。

佩尔

sub one{ $a[@a{@a[%a=map{@$a[@a{$a++=>$a}]+++$#$a+$a=>$a}$a]++}+$a] }

张开说aaaaa。

创意概念是内部括号括起来的括号巢牙套......尽可能深入，同时还返回所需的结果，而只能用“一个”变量（$a，@a，%a，@$a和$#$a当然是完全不同的变量）。

尽管这确实会极大地改变其环境，但它将始终1在后续调用中返回。为了了解它在做什么，您可以考虑运行以下代码：

use Data::Dump qw(dump);
for (1..8) {
  one();
  dump(@a);
  dump(%a);
  dump(@$a);
}

Tcl

proc return1 {} {
    catch {(5+2-3)/4}
}

不能像您想象的那样工作。

(5+2-3)/4不是有效的命令，因此会引发错误（return -code 1），catch返回此数字。

数学

我认为，使用Mathematica返回1的最优雅的数学方法是：

-Exp[I Pi]

欧拉身份。

爪哇

public class print {
    public static char getNum() throws Exception{
        String method = print.class.getSimpleName()+Splitter.class.getDeclaredMethods().length;
        return (char)Splitter.class.getMethod(method).invoke(null);
    }
}
class Splitter{
    public static char print1(){
        return P.getNum();
    }
}
class P{
    public static char getNum(){
        String s = Thread.currentThread().getStackTrace()[P.class.getDeclaredMethods().length].getMethodName();
        return s.charAt(s.length()-P.class.getSimpleName().length());
    }
    public void doNothing(){}
}

可以调整到返回任何其他正数n通过添加方法printX为X从1到n到分路器。例如，修改Splitter为

class Splitter{
    public static char print1(){
        return P.getNum();
    }
    public static char print2(){
        return P.getNum();
    }
}

将返回“ 2”，而无需任何其他更改。除名称外，添加的方法应与完全相同print1。使用反射获取拆分器中方法的数量，然后使用该名称调用一个函数。P.getNum然后被调用，读取堆栈跟踪并解析出调用方法中的最后一个字符，并显示它。

呼唤 print.getNum()返回字符“ 1”

编辑-修改为不使用String / integer / etc文字。

C＃

它应取决于硬件体系结构：

return IntPtr.Size / (Environment.Is64BitOperatingSystem ? 8 : 4);

哇！

C＃

将这个（有争议的）与相邻的（有争议的）Collat​​z猜想合并：

public int CollatzOne()
{
    var current = new BigInteger(new Random().Next(1, Int32.MaxValue));
    var history = new[] { new BigInteger(-1), new BigInteger(-1), new BigInteger(-1) };
    do
    {
        history[0] = history[1];
        history[1] = history[2];
        history[2] = current;
        if (current.IsEven)
            current /= 2;
        else
            current = current * 3 + 1;
    } while (current != history[0]);
    return (int)history.Min();
}

红宝石

滥用RNG ...

Random.new(56417).rand(10000)

生成一个介于0和10000之间的“随机”数字，由于我选择了正确的种子，因此恰好是1。

我用来查找数字的脚本：

irb(main):001:0> (1..100000).select{|x|Random.new(x).rand(10000) == 1}
=> [14033, 25845, 35101, 36955, 45334, 56417, 87438, 87460, 99178, 99451]

Javascript 8字节

这够简单吗？

(+!~~{})

[R

经典：

TRUE + 0

+ 尝试将其参数强制转换为通用类型：此处，由于优先顺序，它强制转换为整数。TRUE对整数的强制转换为1。

图灵机

以B为空白符号的单态图灵机计算1（= 0.111 ...以2为底）：

q B 1 R q

（这遵循Turing的惯例，即从空白磁带开始，并在生成的无限序列前加上“ 0”。）

C

它甚至包括有关其参数的文档。

    int
  return_1
(x)     int
       x;{
      /*x
     can
    be:
  any
 val
ue.
***/ return
!x?1:x /x;}

蟒蛇

one = lambda zero = 0o11: zero > 1 and all(one(zero-1) for l in '1111111111') and 1 or one and zero or one()

one() 会调用自己111,111,111次，每次返回1，然后返回最终值1。

您也可以指定位数。例如，one(3)将仅返回111次1。

稍后我可能会添加一个解释，但是我现在真的没有时间。

[R

NA ^ 0

的任何数字0都是1。