L'obiettivo

Creare una funzione / subroutine che restituisce 1. È possibile renderla elaborata a piacere, purché restituisca 1.

Le regole

Vince l'ingresso con il maggior numero di voti, proprio come qualsiasi concorso di popolarità. In bocca al lupo!

Golf Script

1

Ci è voluto molto tempo per ottimizzare questo codice nella sua forma più pura, e oso dirlo - bella forma. Tale eleganza del linguaggio non arriva senza anni di pratica dedicata. Il programma che, senza un Zero-Instruction-Set-Computer, non può letteralmente essere più compresso. La mia intera carriera nel campo del golf a codice ha portato a questo momento.

Sono libero. Sono vivo.

Vedo il codice che sta alla base dell'universo.

C

Due esempi, utilizzando funzionalità di linguaggio oscuro come "ritorno forte" ( return!) e l'operatore "approcci" ( -->):

int foo(void) {
    return! 0;
}

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

Brainfuck

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

O se non ti diverti alle feste:

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

APL

one ← {⍴⍴⍴⍵}

⍴ti dà le dimensioni di un vettore. La dimensione di ciò è sempre monodimensionale, quindi la dimensione di quello è sempre una. O:

"Rho, rho, rho di X è
sempre uguale a uno,
Rho è dimensione; rho rho, il grado
APL è divertente!"

(Non ho scritto quel verso, è di Stallman.)

Giava

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

Questo si chiamerà 2 ¹⁰²⁴ volte (questo numero può variare su piattaforme diverse) prima di tornare finalmente 1. Non trattenere il respiro, però; ci vorrà facilmente molto più tempo dell'età dell'universo.

Pesce

x invia il contatore del programma in una direzione casuale. # è un muro su cui il contatore del programma "rimbalza". Questo vagherà letteralmente in giro senza meta fino a quando non trova "^" e quindi stampa 1 e termina.

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

Questa stampa 0 ma restituisce 1, che può essere una sorpresa per i programmatori utilizzati per altre lingue. È possibile disattivare l'output stampato e visualizzare il codice di ritorno eseguendo expr 0 >/dev/null; echo $?.

Giava

Questa è una delle mie domande specifiche preferite su Java.

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

JavaScript

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

Spiegazione:

• prima ![]valuta false.
• poi ~falsediventa -1perché falseviene lanciato per la prima volta 0e ~0 == -1.
• infine, --1valuta 1.

Alternato:

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

Alternativo pazzo (ogni riga è lunga esattamente 80 caratteri):

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 e la chiesa dell'ADT

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

Questo definisce quello vero One. Questo Oneè sia il tipo che indica l' Unità , sia il costruttore One, che è esso stesso la funzione nulla che restituisce quello vero, e solo un valore di tipo One, che è, ecco,One .

Utilizzo nella 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

L'intero Libro dell'Uno è ora online. Caricandolo otterrai entrambi i testamenti: calcolo e aritmetica. Ciò ti consente di esplorare più verità:

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

Non contiene 4

Perl

sub ret1 { print $->$= }

(Nonostante le apparenze, la funzione non stampa nulla.)

Conosco i programmatori Perl come dire TMTOWTDI, ma questo è un compito per il quale T è davvero MTOWTDI.

PHP

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

Modificare:

Se preferisci uno più lungo, ecco un'alternativa (non stampa nulla):

<?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;
}

Retorica Java

Non hai detto che doveva essere un numero intero 1.

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

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

JavaScript (ECMAScript davvero)

function one() { return Number.length; }

Tempo per qualche porno spec.

La sezione 15.7.3 afferma che la lengthproprietà del Numbercostruttore è 1(e sappiamo che un costruttore è un oggetto funzione come menzionato in 4.3.4 ), e questo perché la sezione 15.3.5.1 dice:

Il valore della proprietà length è un numero intero che indica il numero "tipico" di argomenti previsti dalla funzione. Tuttavia, il linguaggio consente di invocare la funzione con qualche altro numero di argomenti.

… E poiché il Numbernumero tipico di argomenti del costruttore è 1, il lengthof Numberè 1. Quindi si potrebbe dire che la lunghezza di un numero in Javascript è 1.

Perl

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

Spalancare e dire aaaaa.

Il concetto creativo era a coppie nido all'interno parentesi graffe all'interno ... più profondamente possibile, pur restituendo il risultato desiderato, e solo utilizzando una variabile "uno" ( $a, @a, %a, @$ae $#$asono ovviamente tutte le variabili diverse).

Sebbene ciò modifichi in modo significativo il suo ambiente, tornerà sempre 1alle chiamate successive. Per avere un'idea di ciò che sta facendo, potresti considerare di eseguire questo codice:

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

Tcl

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

Non funziona come potresti pensare.

(5+2-3)/4non è un comando valido, quindi genera un errore ( return -code 1), catch restituisce questo numero.

MATEMATICA

Secondo me, il modo matematico più elegante per restituire 1 usando Mathematica:

-Exp[I Pi]

L'identità di Eulero.

Giava

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

Possono essere regolati per restituire qualsiasi altro numero positivo naggiungendo i metodi printXper Xda 1 a n in Splitter. Ad esempio, modificando Splitterin

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

Restituirà '2', senza altre modifiche necessarie. I metodi aggiunti dovrebbero, a parte il nome, essere un duplicato esatto di print1. Usa la riflessione per ottenere il numero di metodi nello splitter e chiamare una funzione con quel nome.P.getNum, che viene quindi chiamato, legge la traccia dello stack, analizza l'ultimo carattere nel metodo chiamante e lo visualizza.

La chiamata print.getNum()restituisce il carattere '1'

Modifica: modificato per non utilizzare valori letterali String / interi / etc.

C #

Dovrebbe dipendere dall'architettura hardware:

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

WOW!

C #

Unendo questo (controverso) con la congettura di Collatz vicina (controversa) :

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

Rubino

Abuso dell'RNG ...

Random.new(56417).rand(10000)

Genera un numero "casuale" tra 0 e 10000 e poiché ho scelto il seme giusto, sembra che sia 1.;)

Script che ho usato per trovare il numero:

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 byte

è abbastanza semplice?

(+!~~{})

R

Un classico:

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.