La tarea

Cree una función / subrutina que devuelva 1. Puede hacerlo tan elaborado como desee, siempre que devuelva 1.

Las normas

La entrada con más votos positivos gana, al igual que cualquier concurso de popularidad. ¡Buena suerte!

Guión de golf

1

Tomó mucho tiempo optimizar este código en su forma más pura, y me atrevo a decirlo: una forma hermosa. Tal elegancia del lenguaje no viene sin años de práctica dedicada. El programa que, sin una Computadora de Conjunto de Instrucción Cero, literalmente nunca puede ser comprimido más. Toda mi carrera en el código de golf me ha llevado a este momento.

Soy libre. Estoy vivo.

Veo el código que subyace al universo.

do

Dos ejemplos, utilizando características de lenguaje oscuro como "retorno fuerte" ( return!) y el operador "enfoques" ( -->):

int foo(void) {
    return! 0;
}

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

Brainfuck

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

O si no eres divertido en las fiestas:

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

APL

one ← {⍴⍴⍴⍵}

⍴te da las dimensiones de un vector. La dimensión de eso siempre es unidimensional, por lo que la dimensión de eso siempre es una. O:

"Rho, rho, rho de X
Siempre es igual a uno,
Rho es dimensión; rho rho, ¡el rango
APL es divertido!"

(No escribí ese verso, es de Stallman).

Java

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

Esto se llamará a sí mismo 2 ¹⁰²⁴ veces (este número puede variar en diferentes plataformas) antes de regresar finalmente 1. Sin embargo, no aguantes la respiración; fácilmente tomará mucho más tiempo que la edad del universo.

Pez

x envía el contador del programa en una dirección aleatoria. # es un muro que el contador del programa "rebota". Esto literalmente vagará sin rumbo hasta que encuentre el "^" y luego imprima 1 y termine.

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

Esto imprime 0 pero devuelve 1, lo que puede sorprender a los programadores acostumbrados a otros idiomas. Puede desactivar la salida impresa y ver el código de retorno ejecutando expr 0 >/dev/null; echo $?.

Java

Esta es una de mis preguntas específicas favoritas de Java.

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

JavaScript

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

Explicación:

• primero ![]evalúa a false.
• luego se ~falseconvierte en -1porque falsese lanza primero a 0, y ~0 == -1.
• finalmente, --1evalúa a 1.

Alterno:

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

Alternativa loca (cada línea tiene exactamente 80 caracteres de longitud):

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 y la Iglesia de la ADT

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

Esto define el uno verdadero One. Este Onees tanto el tipo que denota Oneness como el constructor One, que es en sí mismo la función nular que devuelve el único verdadero, y solo un valor de tipo One, que es, he aquí,One .

Uso en el ghciREPL:

λ: 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

El Libro de uno completo ahora está en línea. Al cargarlo obtienes ambos testamentos: Computación y Aritmética. Esto le permite explorar más verdades:

λ: 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

Maravilloso

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

No contiene 4

Perl

sub ret1 { print $->$= }

(A pesar de las apariencias, la función no imprime nada).

Sé que a los programadores de Perl les gusta decir TMTOWTDI, pero esta es una tarea para la que T realmente MTOWTDI.

PHP

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

Editar:

Si prefiere uno más largo, aquí hay una alternativa (no imprime nada):

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

do

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 retórica

No dijiste que tenía que ser un número entero 1.

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

Fuente: http://bash.org/?946461

JavaScript (ECMAScript realmente)

function one() { return Number.length; }

Tiempo para algunas especificaciones porno.

La Sección 15.7.3 establece que la lengthpropiedad del Numberconstructor es 1(y sabemos que un constructor es un objeto de función como se menciona en 4.3.4 ), y eso se debe a que la sección 15.3.5.1 dice:

El valor de la propiedad de longitud es un número entero que indica el número "típico" de argumentos esperados por la función. Sin embargo, el lenguaje permite invocar la función con algún otro número de argumentos.

... y dado que el Numbernúmero típico de argumentos del constructor es 1, el lengthde Numberes 1. Entonces se podría decir que la longitud de un número en Javascript es 1.

Perl

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

Abrir de par en par y decir aaaaa.

El concepto creativo fue a los aparatos de nido dentro de los paréntesis dentro de llaves ... lo más profundamente posible, sin dejar de devolver el resultado deseado, y sólo con un "uno" variable ( $a, @a, %a, @$ay $#$a, por supuesto, todas las variables diferentes).

Aunque esto modifica significativamente su entorno, siempre regresará 1en llamadas posteriores. Para tener una idea de lo que está haciendo, puede considerar ejecutar este código:

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

Tcl

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

No funciona como podrías pensar.

(5+2-3)/4no es un comando válido, por lo que arroja un error ( return -code 1), catch devuelve este número.

MATEMÁTICA

En mi opinión, la forma matemática más elegante para devolver 1 usando Mathematica:

-Exp[I Pi]

La identidad de Euler.

Java

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(){}
}

Puede ser ajustado para devolver cualquier otro número positivo nmediante la adición de los métodos printXpara Xde 1 a n en Splitter. Por ejemplo, modificando Splittera

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

Will return '2', without any other changes necessary. The added methods should, apart from the name, be an exact duplicate of print1. Uses reflection to get the number of methods in splitter, and call a function with that name. P.getNum, which is then called, reads the stack trace and parses out the last character in the calling method, and displays it.

Calling print.getNum() return the character '1'

Edit - modified to use no String/integer/etc literals.

C#

It should depend on hardware architecture:

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

WOW!

C#

Merging this (controversial) one with the neighboring (controversial) Collatz Conjecture:

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();
}

Ruby

Abusing the RNG...

Random.new(56417).rand(10000)

Generates a "random" number between 0 and 10000, and because I picked the right seed it just so happens to be 1. ;)

Script I used to find the number:

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 bytes

is this simple enough?

(+!~~{})

R

A classic:

TRUE + 0

+ tries to coerce its argument to a common type: here, because of the order of precedence, it coerces to integers. The coercion of TRUE to an integer gives 1.

Turing Machine

Single-state Turing machine with B as the blank symbol, computes 1 (= 0.111... in base 2):

q B 1 R q

(This follows Turing's convention of starting with a blank tape, and prefixing '0.' to the generated infinite sequence.)

C

It even includes documentation on its parameters.

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

Python

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

one() will call itself 111,111,111 times, each time returning 1, before returning a final value of 1.

You can also specify the number of digits. For example, one(3) will return 1 only 111 times.

I might add an explanation later, but I really don't have time at the moment.

R

NA ^ 0

Any number to the power of 0 is 1.