La tâche

Créez une fonction / sous-routine qui renvoie 1. Vous pouvez la rendre aussi élaborée que vous le souhaitez, tant qu'elle renvoie 1.

Les règles

L'entrée avec le plus de votes gagne - comme tout concours de popularité. Bonne chance!

Script de golf

1

Il a fallu beaucoup de temps pour optimiser ce code à son plus pur, et j'ose le dire - belle forme. Une telle élégance de la langue ne va pas sans des années de pratique dévouée. Le programme qui, sans Zero-Instruction-Set-Computer, ne peut littéralement plus jamais être compressé. Toute ma carrière de golf de code a conduit à ce moment.

Je suis libre. Je suis vivant.

Je vois le code qui sous-tend l'univers.

C

Deux exemples, utilisant des fonctionnalités de langage obscures telles que «retour fort» ( return!) et l'opérateur «approches» ( -->):

int foo(void) {
    return! 0;
}

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

Brainfuck

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

Ou si vous n'êtes pas amusant lors des fêtes:

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

APL

one ← {⍴⍴⍴⍵}

⍴vous donne les dimensions d'un vecteur. La dimension de cela est toujours unidimensionnelle, donc la dimension de cela est toujours une. Ou:

"Rho, rho, rho de X est
toujours égal à un,
Rho est dimension; rho rho, le rang
APL est amusant!"

(Je n'ai pas écrit ce verset, c'est celui de Stallman.)

Java

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

Cela s'appellera 2 ¹⁰²⁴ fois (ce nombre peut varier sur différentes plateformes) avant de finalement revenir 1. Mais ne retenez pas votre souffle; cela prendra facilement beaucoup plus de temps que l'âge de l'univers.

Poisson

x envoie le compteur de programme dans une direction aléatoire. # est un mur sur lequel le compteur de programmes "rebondit". Cela va littéralement errer sans but jusqu'à ce qu'il trouve le "^", puis imprimer 1 et terminer.

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

Shell Unix (Bourne, POSIX, bash, ksh, csh,…)

expr 0

Cela affiche 0 mais renvoie 1, ce qui peut surprendre les programmeurs habitués à d'autres langages. Vous pouvez désactiver la sortie imprimée et voir le code retour en exécutant expr 0 >/dev/null; echo $?.

Java

C'est l'une de mes questions spécifiques Java préférées.

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

Javascript

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

Explication:

• ![]évalue d' abord à false.
• ~falsedevient alors -1parce que falseest d'abord casté en 0, et ~0 == -1.
• enfin, --1évalue à 1.

Alterner:

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

Alterné fou (chaque ligne fait exactement 80 caractères):

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 et l'église de l'ADT

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

Cela définit l' un vrai One. Il Ones'agit à la fois du type désignant l' unité et du constructeur One, qui est lui-même la fonction nullary qui renvoie la seule vraie et la seule valeur de type One, qui est, voici,One .

Utilisation dans le 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

Le livre complet est désormais en ligne. En le chargeant, vous obtenez les deux testaments: calcul et arithmétique. Cela vous permet d'explorer plus de vérités:

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

Sensationnel

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

Ne contient pas 4

Perl

sub ret1 { print $->$= }

(Malgré les apparences, la fonction n'imprime rien.)

Je sais que les programmeurs Perl aiment dire TMTOWTDI, mais c'est une tâche pour laquelle T vraiment MTOWTDI.

PHP

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

Modifier:

Si vous préférez une version plus longue, voici une alternative (elle n'imprime rien):

<?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 rhétorique

Vous n'avez pas dit que ce devait être un entier 1.

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

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

JavaScript (ECMAScript vraiment)

function one() { return Number.length; }

Il est temps pour du porno spec.

La section 15.7.3 indique que la lengthpropriété du Numberconstructeur est 1(et nous savons qu'un constructeur est un objet fonction comme mentionné en 4.3.4 ), et c'est parce que la section 15.3.5.1 dit:

La valeur de la propriété length est un entier qui indique le nombre «typique» d'arguments attendus par la fonction. Cependant, le langage permet à la fonction d'être invoquée avec un autre nombre d'arguments.

… Et comme le Numbernombre typique d'arguments du constructeur est 1, le lengthde Numberest 1. On pourrait donc dire que la longueur d'un nombre en Javascript est 1.

Perl

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

Ouvrez grand et dites aaaaa .

Le concept créatif était d'accolades imbriquer crochets à l' intérieur des accolades ... aussi profondément que possible, tout en retournant le résultat souhaité, et seulement en utilisant une variable « un » ( $a, @a, %a, @$aet$#$a sont bien sûr toutes les variables différentes).

Bien que cela modifie considérablement son environnement, il reviendra toujours 1lors des appels suivants. Pour comprendre ce qu'il fait, vous pouvez envisager d'exécuter ce code:

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

Tcl

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

Ne fonctionne pas comme vous pourriez le penser.

(5+2-3)/4n'est pas une commande valide, elle renvoie donc une erreur ( return -code 1), catch renvoie ce nombre.

MATHEMATICA

À mon avis, la façon mathématique la plus élégante de renvoyer 1 en utilisant Mathematica:

-Exp[I Pi]

L'identité d'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(){}
}

Peut être ajusté pour revenir tout autre nombre positif nen ajoutant les méthodes printXpour Xde 1 à n dans Splitter. Par exemple, la modification Splitterde

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

Renvoie «2», sans aucun autre changement nécessaire. Les méthodes ajoutées doivent, en dehors du nom, être un doublon exact de print1. Utilise la réflexion pour obtenir le nombre de méthodes dans le séparateur et appelle une fonction avec ce nom.P.getNum, qui est ensuite appelée, lit la trace de la pile et analyse le dernier caractère de la méthode d'appel et l'affiche.

Appel print.getNum() retourne le caractère '1'

Modifier - modifié pour n'utiliser aucun littéral de chaîne / entier / etc.

C #

Cela devrait dépendre de l'architecture matérielle:

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

HOU LA LA!

C #

Fusion de celle-ci (controversée) avec la conjecture Collatz voisine (controversée) :

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

Rubis

Abuser du RNG ...

Random.new(56417).rand(10000)

Génère un nombre "aléatoire" entre 0 et 10000, et parce que j'ai choisi la bonne graine, il se trouve que c'est juste 1.;)

Script que j'ai utilisé pour trouver le numéro:

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 octets

est-ce assez simple?

(+!~~{})

R

Un classique:

TRUE + 0

+ essaie de contraindre son argument à un type commun: ici, en raison de l'ordre de priorité, il contraint à des entiers. La coercition de TRUEà un entier donne 1.

Machine de Turing

Machine de Turing à un état avec B comme symbole vierge, calcule 1 (= 0,111 ... en base 2):

q B 1 R q

(Cela suit la convention de Turing de commencer avec une bande vierge et de préfixer «0» à la séquence infinie générée.)

C

Il inclut même une documentation sur ses paramètres.

    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() s'appellera 111.111.111 fois, renvoyant à chaque fois 1, avant de renvoyer une valeur finale de 1.

Vous pouvez également spécifier le nombre de chiffres. Par exemple, one(3)renverra 1 seulement 111 fois.

Je pourrais ajouter une explication plus tard, mais je n'ai vraiment pas le temps pour le moment.

R

NA ^ 0

Tout nombre au pouvoir 0est 1.