4, 8, 15, 16, 23, 42

Ecrivez un programme qui affiche cette suite de nombres à l'infini. Cependant, les numéros ne doivent apparaître nulle part dans votre code source.

Ce qui suit n'est pas un programme Java valide pour générer les numéros, car ceux-ci apparaissent dans son code source:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = 0;;) System.out.println(
            n == 4 ? n = 8 :
            n == 8 ? n = 15 :
            n == 15 ? n = 16 :
            n == 16 ? n = 23 :
            n == 23 ? n = 42 : (n = 4)
        );
    }
}

La définition de "Les numéros ne doivent pas figurer dans votre code source" est la suivante:

• Vous ne devez pas utiliser le chiffre 4.
• Vous ne devez pas utiliser le chiffre 8.
• Vous ne devez pas utiliser le chiffre 1 suivi du chiffre 5.
• Vous ne devez pas utiliser le chiffre 1 suivi du chiffre 6.
• Vous ne devez pas utiliser le chiffre 2 suivi du chiffre 3.

Si votre langue ignore certains caractères qui peuvent être placés entre les chiffres, ce n'est pas une substitution valide. Ainsi, par exemple, si votre langue interprète le littéral de la 1_5manière suivante 15, cela comptera comme le chiffre 1 suivi du chiffre 5.

Des bases alternatives sont incluses dans la restriction, par exemple:

• Binary 100 ne peut pas être utilisé en remplacement de 4.
• Le 10 octal ne peut remplacer le 8.
• La valeur hexadécimale F ne peut pas remplacer 15.

Par conséquent, ce qui suit est un programme Java valide (mais pas très inspiré) pour générer The Numbers car The Numbers n'apparaît pas dans son code source:

class TheNumbers {
    public static void main(String[] args) {
        for(int n = '*';;) {
            System.out.println(n -= '&');
            System.out.println(n *= 2);
            System.out.println(n += 7);
            System.out.println(++n);
            System.out.println(n += 7);
            System.out.println(n += 19);
        }
    }
}

Notez que dans ce programme, '*'et '&'sont substitués aux nombres entiers 42 et 38, sinon les chiffres 4 et 8 apparaissent dans son code source.

La définition de "sort la séquence infiniment" est sujette à interprétation. Ainsi, par exemple, un programme qui génère des glyphes de plus en plus petits jusqu'à ce qu'ils soient "infiniment" petits serait valide.

Félicitations si vous êtes capable de générer la séquence d’une manière qui ne soit pas fondamentalement codée en dur pour chaque nombre.

• Dériver à une formule. Mon impression est qu'il n'y en a pas, mais peut-être qu'il y en a un ou il peut être simulé.
• Correction d'un générateur pseudo-aléatoire pour renvoyer la séquence.

Ceci est un concours de popularité, alors soyez créatif. La réponse avec le plus grand nombre de votes le 26 mars est le gagnant.

Java

J'ai décidé d'ajouter une autre entrée car c'est complètement différent de mon premier (qui ressemblait plus à un exemple).

Ce programme calcule la moyenne d'un tableau saisi par l'utilisateur ...

import java.util.Scanner;

public class Numbers {
    public static double getSum(int[] nums) {
        double sum = 0;
        if(nums.length > 0) {
            for(int i = 0; i <= nums.length; i++) {
                sum += nums[i];
            }
        }

        return sum;
    }

    public static double getAverage(int[] nums) { return getSum(nums) / nums.length; }
    public static long roundAverage(int[] nums) { return Math.round(getAverage(nums)); }

    private static void beginLoop(int[] nums) {
        if(nums == null) {
            return;
        }

        long avg = roundAverage(nums);
        System.out.println("enter nums for average");
        System.out.println("example:");
        System.out.print("array is " + nums[0]);
        for(int i = 1; i <= nums.length; i++) {
            System.out.print(", " + nums[i]);
        }

        System.out.println();
        System.out.println("avg is " + avg);
    }

    private static int[] example = { 1, 2, 7, 9, };

    public static void main(String[] args) {
        boolean done = false;
        while(!done) {
            try {
                int[] nums = example;
                beginLoop(nums);

                nums = getInput();
                if(nums == null) {
                    done = true;
                } else {
                    System.out.println("avg is " + getAverage(nums));
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }

    static int[] getInput() {
        Scanner in = new Scanner(System.in);
        System.out.print("enter length of array to average or 0 to exit: ");
        int length = in.nextInt();
        if(length == 0) {
            return null;

        } else {
            int[] nums = new int[length];
            for(int i = 0; i <= nums.length; i++) {
                System.out.print("enter number for index " + i + ": ");
                nums[i] = in.nextInt();
            }
            return nums;
        }
    }
}

... ou le fait-il?

java.lang.ArrayIndexOutOfBoundsException: 4
    à Numbers.getSum (Numbers.java:8)
    à Numbers.getAverage (Numbers.java:15)
    à Numbers.roundAverage (Numbers.java:16)
    à Numbers.beginLoop (Numbers.java:23)
    à Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    à Numbers.getSum (Numbers.java:8)
    à Numbers.getAverage (Numbers.java:15)
    à Numbers.roundAverage (Numbers.java:16)
    à Numbers.beginLoop (Numbers.java:23)
    à Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    à Numbers.getSum (Numbers.java:8)
    ...

Python

#!/usr/bin/python
lizt = ["SPOI",
        "LERS: Lo",
        "st begins with ",
        "a plane crash on",
        "a desert island and end",
        "s with its viewers stuck in limbo forever."
        ]

while True:
    for item in lizt:
        print len(item)

Edit: Selon la suggestion de nneonneo, le script n’a plus de chiffres.

Perl

Il n'y a rien de caché dans le code source. Nan. Si le code ne fonctionne pas, tapez-le use re "eval";avant (obligatoire dans Perl 5.18).

''=~('('.'?'.('{').(
'`'|'%').('['^'-').(
"\`"| '!').('`'|',')
.'"'. '\\' .'@'.('`'
|'.') .'=' .'('.('^'
^('`'       |"\*")).
','.("\:"& '=').','.
('^'^('`'| ('/'))).(
'^'^("\`"| '+')).','
.('^'^('`'|('/'))).(
'^'^('`'|'(')).','.(
'^'^('`'|',')).('^'^
("\`"|     '-')).','
.('^' ^('`' |'*')).(
'^'^( "\`"| (','))).
(')').     ';'.('['^
','). ('`'| ('(')).(
"\`"| ')'). ('`'|','
).('`'     |'%').'('
.'\\'.'$'.'|'."\=".(
'^'^('`'|'/'))."\)".
'\\'.'{'.'\\'."\$".(
"\["^ '/')       .((
'=')  ).+( '^'^('`'|
'.' ) ).(( (';'))).(
"\`"| '&').     ('`'
|'/') .('['^')') .((
'(')) .''. '\\'. '@'
.+(     '`'     |'.'
).')'.'\\'.'{'.('['^
'(').('`'|',').('`'|
'%').('`'|'%').('['^
'+'). '\\'.     '$'.
'_'.  '-'. '\\'. '$'
.+( ( '[') ^'/').';'
.'\\' .'$'      .''.
('['^ '/') .'='. (((
'\\') )).+ "\$". '_'
.((     ';'     )).+
'\\'.'$'.'_'.'='.'='
.('^'^('`'|'*')).'|'
.'|'.('['^'+').('['^
')'     ).(     '`'|
(( ')')) ) .('`' |((
'.'))).( '['^'/' ).+
(((     (((     '\\'
)) )))).'"'.('{' ^((
(( '[')))) ).''. (((
((       ((     '\\'
))))))).'"'.';'.('['
^'+').('['^')').('`'
|')').('`'|'.').('['
^+ '/').''.     '\\'
.+ '}'. +( "\["^ '+'
). ('[' ^"\)").( '`'
|+       ((     ')')
)).('`' |+ '.').('['
^'/').( (( '{'))^'['
).'\\'. ((       '"'
)).('!'^'+').('\\').
'"'.'\\'.'}'.(('!')^
'+').'"'.'}'.')');$:
='.'#madebyxfix#'.'=
^'~';$~='@'|"\(";#;#

Explication dans le spoiler.

Il s'agit d'un programme Perl simple qui utilise plusieurs opérations sur les bits et évalue l'expression régulière à l'aide de l' opérateur = ~ . La regex commence par (? { Et se termine par }) . En Perl, cela exécute le code tout en évaluant l'expression régulière - cela me permet d'utiliser eval sans l'utiliser réellement. Normalement, cependant, re "eval" est requis, pour des raisons de sécurité, lors de l'évaluation d'expressions régulières à partir de chaînes (certains programmes plus anciens prenaient en fait des expressions régulières de l'utilisateur) - mais il s'avère qu'avant Perl 5.18, un bogue causait des expressions pliées constantes. pour travailler même sans ce pragma - si vous utilisez Perl 5.18, tapez use re "eval";avant le code pour le faire fonctionner. Autre que cela, il n'y a pas grand chose d'autre à ce code.

Brainfuck

Je suis tellement mauvais en art ASCII!

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

Testez-le ici: http://ideone.com/kh3DYI

Unix C

Il y a beaucoup d'endroits pour trouver des constantes numériques.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <fcntl.h>
#include <pwd.h>
#include <netdb.h>

int main(void)
{
  int thenumbers[] = {
    S_IRGRP|S_IXGRP|S_IWOTH,
    ntohs(getservbyname("telnet", "tcp")->s_port),
    exp(M_E)-cos(M_PI),
    SIGTERM,
    CHAR_BIT,
    strlen(getpwuid(EXIT_SUCCESS)->pw_name)
  }, i=sizeof(thenumbers)/sizeof(*thenumbers);
  while(i--)
    printf("%d\n", thenumbers[i]);
  return main();
}

C #

Formule "volée" sur https://oeis.org/A130826 : a est le plus petit nombre tel que deux fois le nombre de diviseurs de (a (n) -n) / 3 donne le n-ème terme du premier différences de la séquence produite par le tamis de Flavius-Josephus.

using System;
using System.Collections.Generic;
using System.Linq;

public static class LostNumberCalculator
{
    public static int GetNumber(int i)
    {
        int a = GetPairwiseDifferences(GetFlaviusJosephusSieveUpTo(100)).ElementAt(i);
        int b = FindSmallestNumberWithNDivisors(a / 2);
        return b * 3 + i + 1;
    }

    public static IEnumerable<int> GetFlaviusJosephusSieveUpTo(int max)
    {
        List<int> numbers = Enumerable.Range(1, max).ToList();

        for (int d = 2; d < max; d++)
        {
            List<int> newNumbers = new List<int>();
            for (int i = 0; i < numbers.Count; i++)
            {
                bool deleteNumber = (i + 1) % d == 0;
                if (!deleteNumber)
                {
                    newNumbers.Add(numbers[i]);
                }
            }
            numbers = newNumbers;
        }

        return numbers;
    }

    public static IEnumerable<int> GetPairwiseDifferences(IEnumerable<int> numbers)
    {
        var list = numbers.ToList();
        for (int i = 0; i < list.Count - 1; i++)
        {
            yield return list[i + 1] - list[i];
        }
    }

    public static int FindSmallestNumberWithNDivisors(int n)
    {
        for (int i = 1; i <= int.MaxValue; i++)
        {
            if (CountDivisors(i) == n)
            {
                return i;
            }
        }
        throw new ArgumentException("n is too large");
    }

    public static int CountDivisors(int number)
    {
        int divisors = 0;
        for (int i = 1; i <= number; i++)
        {
            if (number % i == 0)
            {
                divisors++;
            }
        }
        return divisors;
    }
}

class Program
{
    static void Main(string[] args)
    {
        while (true)
        {
            for (int i = 0; i < 6; i++)
            {
                int n = LostNumberCalculator.GetNumber(i);
                Console.WriteLine(n);
            }
        }
    }
}

C #

En utilisant le fait que toute séquence de N éléments peut être générée par un polynôme N-1 et en entrant les nombres, cela implique beaucoup de bips et de boops. Pour référence, le polynôme que j'ai dérivé est

( -9(X^5) +125(X^4) -585(X^3) +1075(X^2) -446(X) +160 ) / 40

J'ai assigné les facteurs aux variables nommées pour les nombres, pour plus de simplicité;)

Première version:

int BEEP,
// Magic numbers, do not touch.
four = -9,
eight = 125,
fifteen = -117*5, 
sixteen = 1075,
twenty_three = (-1-1337) /3,
forty_two = 320/2;


for(BEEP=0;;BEEP=++BEEP%6)
{
    Console.WriteLine( 0.025* (
        four *BEEP*BEEP*BEEP*BEEP*BEEP+ 
        eight *BEEP*BEEP*BEEP*BEEP+ 
        fifteen *BEEP*BEEP*BEEP+
        sixteen *BEEP*BEEP+
        twenty_three *BEEP+ 
        forty_two ));
}

J'ai aimé l'implication de la tension montante car le nombre de BEEP diminue après chaque nombre.

Ensuite, je me suis dit que je pourrais aussi calculer les facteurs en utilisant bip et bip:

int BEEEP=0, BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP,

four = BOOP*-BOOP,
eight = BLEEP*BLEEP*BLEEP,
fifteen = BOOP*-(BOOP+(BEEP*BLEEP))*BLEEP*BOOP,
sixteen = BLEEP*BLEEP*(BOOP+(BLEEP*BEEP*BEEP*BEEP)),
twenty_three = BEEP*-((BLEEP*BOOP*BLEEP*BOOP)-BEEP),
forty_two = BEEP*BEEP*BEEP*BEEP*BEEP*BLEEP;

Je suis allé un peu à la mer après ça ...

int BEEEP=default(int), BEEP=++BEEEP ,BOOP=++BEEP,BLEEP=++BOOP+BEEP;

for(--BEEEP;;BEEEP=++BEEEP%(BEEP*BOOP))
{
    Console.WriteLine(

    BOOP*(                       (BOOP*-BOOP)*BEEEP    *BEEEP*BEEEP*BEEEP    *BEEEP+(BLEEP*BLEEP*
    BLEEP)                       *BEEEP*      BEEEP*    BEEEP*                     BEEEP+
    (BOOP*                       -(BOOP+      (BEEP*    BLEEP)                    )*BLEEP
    *BOOP)                       *BEEEP*      BEEEP*    BEEEP+(BLEEP*BLEEP        *(BOOP+
    (BLEEP*                       BEEP*        BEEP*                 BEEP)))       *BEEEP*
    BEEEP+                       (BEEP*-(     (BLEEP                 *BOOP*         BLEEP
    *BOOP)                       -BEEP))      *BEEEP+                (BEEP*         BEEP*
    BEEP*BEEP*BEEP*BLEEP))/     (BEEP*((BEEP*BEEP*BEEP  *BEEP*BEEP*BEEP)-(        BEEP+BEEP))));
}

L'utilisation de l'opérateur par défaut en C # pour les types de valeur permet l'initialisation de BEEEP à zéro. De cette façon, aucun littéral numérique n'est utilisé dans le code. L'algorithme de base est le même. mais les facteurs sont calculés en ligne.

ré

Vous n'êtes pas autorisé à utiliser les chiffres 4, 8, 15, 16, 23 ou 42 dans mon code? Pas de problème, alors je n'utiliserai pas de chiffres du tout!

import std.stdio;

void main()
{
    while( true )
    {
        ( ',' - '('  ).writeln;
        ( '/' - '\'' ).writeln;
        ( '/' - ' '  ).writeln;
        ( '_' - 'O'  ).writeln;
        ( '^' - 'G'  ).writeln;
        ( '~' - 'T'  ).writeln;
    }
}

Javascript + HTML

Anti-golf!

<!DOCTYPE html>
<html>
<head>
</head>
<body>
<pre>
/*hereIsTheDataPart~                    Es="5030000307000022
E2000000100000010000                    E5370000507000022200
E0010100001110000005                    E0337001010000102220
E0100010010111005033                    E7001010000102220010
E1010010111~33079900                    E1000111102221000001
E1110111~03037910100                    E0111102220010100001
E0111".replace(/~/g,                    E5);Zfillfillfillfil
Eqw=21;fq=2;fz=fq*2;                    Efl=fz*2;fm=fl*2;fw=
Efm+2; M=Math;functi                    Eon r(n,i,z){return 
Efunction(){l=i||'';                    E;for(m=0;m!=n;m++)l
E+=String.fromCharCo                    Ede(97+M.floor(M.ran
Edom()*26));return l                    E+(z||'')}};kb=r(fm,
E'/*','*'+'/');kc=r(                    Efw,'//');kd=r(20);Z
Eke=r(fw,'/*');kf=r(                    E20);kg=r(fw,'','*'+
E'/');kh=kf;ki=new Z                    EArray(21).join(' ')
E;x=[];for(n=35*ix;n                    E!=s.length;++n){x.Z
Epush(parseInt(s[n])                    E)};oo=function(){oZ
E+=z==1?kb():z==9?kc                    E():z==3?(ee.shift()
E||kd()):z==5?(y==0?                    Eke():(ee.shift()||Z
Ekf())):z==7?(y==(yl                    E-1)?kg():(ee.shift(
E)||kh())):z==0?ki:Z                    Epl.shift();}Ze=mc^2
EZthis=does*nothing;                    EZnor*does+this-haha
EZawkw0rd+space+fi11                    EZrunn1ng/out+of=stf
EZfjsddfkuhkarekhkhk                    777777777777777777*/
0;ix=typeof ix=="number"?(ix+1)%6:1;s=text();ee=[];pl=[];//2
0;q=function(n,m){return s.substr(n,m)};evl="";xl=20;yl=12//
0;while(s.length){c=s[0];m=1;if(c=='\n'){s=q(1);continue;}//
0;if(c=='E'){ev=q(0,xl);i=ev.indexOf('Z');ee.push(ev);//sd//
0;evl+=i==-1?ev.substr(1):ev.substr(1, i-1);}if(c=='0'){//sd
0;pl.push(q(0,xl*3),'','');m=3};s=q(xl*m);}eval(evl);o="";//
0;for(r=0;r!=5;++r){for(y=0;y!=yl;++y){for(n=0;n!=7;++n){//s
0;z=x[n+r*7];oo()}o+="\n"}}setTimeout(function(){text(o);//z
0;(function(){var space=' ____ ',garbage='asfdasr#@%$sdfgk';
0;var filler=space+garbage+space+garbage+space+garbage;//s//
0;})("test",1199119919191,new Date(),"xyz",30/11/1)//asdfsaf
0;eval(text());},1000);//askfdjlkasjhr,kajberksbhfsdmhbkjygk
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
                                        /*1111111111111111*/
</pre>
<script>
window.onload = function () {
setTimeout(function() {
    text = function (txt) { 
        pre = document.getElementsByTagName('pre')[0];
        if(!txt) {
            return pre.innerText;
        }
        pre.innerText = txt;
    }
    eval(text());
}, 1000);
}
</script>
</body>
</html>

L' <pre>élément affiche un numéro dans la séquence. Il contient également tout le code nécessaire pour passer au numéro suivant de la séquence. Donc, le <pre>est évalué, ce qui fait que le texte de la <pre>mise à jour ressemble au numéro suivant dans la séquence. Ce processus se répète indéfiniment.

Ici c'est en action!

C

Mettez vos lunettes de strabisme sur :-)

main(         i){char*s     ="*)2;,5p   7ii*dpi*t1p+"
"={pi       7,i)?1!'p)(a! (ii(**+)(o(,( '(p-7rr)=pp="
"/(('       (^r9e   n%){1 !ii):   a;pin     7,p+"
"{*sp       ;'*p*   op=p) in,**             i+)s"
"pf/=       (t=2/   *,'i% f+)0f7i=*%a       (rpn"
"p(p;       )ri=}   niipp   +}(ipi%*ti(     !{pi"
"+)sa       tp;}*   s;}+%         *n;==     cw-}"
"9{ii       i*(ai   a5n(a +fs;i   *1'7",    *p=s-
1;while(p=('T'^i)?++p:s){ for(i=1;55!=*     p;p++
)i+=(' '!=*   p);printf     ("%d ",i/       2);}}

Haskell, 1 LoC

import Data.Char; main = putStr $ unwords $ map (show . (+)(-ord 'D') . ord) $ cycle "HLST[n" 

J'ai décidé de choisir une doublure lisible pour montrer à quel point Haskell est génial. En outre, j'ai décidé d'éviter tous les chiffres, juste au cas où.

Grâce à une évaluation paresseuse intégrée, Haskell peut manipuler (carte, diviser, joindre, filtrer ...) des listes infiniment longues. Il a même plusieurs composants intégrés pour les créer. Puisqu'une chaîne est juste une liste de caractères, les chaînes infiniment longues ne sont pas non plus un mystère pour Haskell.

Mathematica

Nous pouvons répondre à la question en nous concentrant sur les dénominateurs partiels répétés de la fraction périodique continue montrée ci-dessous. Ils sont ce dont nous avons besoin.

Après tout, ils constituent la séquence non-terminale que nous essayons de produire: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...

Dans Mathematica, on obtient l' irrationnel quadratique correspondant à la fraction continuée périodique en

FromContinuedFraction[{0, {4, 8, 15, 16, 23, 42}}]

où le 0 fait référence à la partie entière implicite.

Nous pouvons vérifier en inversant l'opération:

{0, {4, 8, 15, 16, 23, 42}}

Les 4 et 8 enfreignent l'une des règles du défi. La sous 15- chaîne est une violation supplémentaire. Nous pouvons reformater l'irrationnel quadratique pour satisfaire les règles.

{0, {4, 8, 15, 16, 23, 42}}

Maintenant, nous saisissons la séquence d'intérêt:

Last[c]

{4, 8, 15, 16, 23, 42}

Et imprimez la liste pour toujours…

While[True, Print@Row[ContinuedFraction[(-3220235/5+Sqrt[(10611930613350/25)])/(61630/2)],"\t"]]

C / C ++

En utilisant uniquement les caractères L, O, Set à Tplusieurs reprises dans cet ordre:

int main(){for(;;)printf("%d %d %d %d %d %d\n",

    'L'-     'O'*'S'    &'T','L'  &'O'+'S'*
    'T',    'L'^  'O'  |'S'*        'T'&
    'L',    'O'*  'S'    &'T'/      'L'+
    'O',    'S'^  'T'      &'L',    'O'*
    'S'&'T'   +'L'+    'O'^'S'+     'T')   ;}

Java

Je ne trouve pas de motif dans cette séquence. S'il n'y a pas de motif reconnaissable, nous pourrions aussi bien rassembler un groupe de petits nombres premiers, les mettre dans le RNG intégré de Java et les appeler tous les jours. Je ne vois pas comment cela pourrait mal tourner, mais encore une fois, je suis optimiste :)

import java.util.Random;
public class LostNumbers {
    public static void main(String[] args) {
        long nut=2*((2*5*7)+1)*((2*2*3*((2*2*2*2*11)+3))+5)*
                   ((3*5*((2*3*3)+1)*((2*2*2*2*2*3)+1))+2L);
        int burner=2*2*2*5;
        while(true){
            Random dice = new Random(nut);
            for(int i=0;i<6;i++)
                System.out.print((dice.nextInt(burner)+3) + " "); // cross your fingers!
            System.out.println();
        }
    }
}

Bash one-liner

yes `curl -s "https://oeis.org/search?q=id:A$((130726+100))&fmt=text" |
grep %S | cut -d " " -f 3 | cut -d "," -f 1-6`

Saut de ligne ajouté pour plus de lisibilité. Il utilise le fait que ce sont les six premiers numéros de la séquence OEIS A130826 .

C n'utilisant aucun nombre ni aucune valeur de caractère

s(int x) { return x+x; }
p(int x) { return printf("%d ",x); }
main()
{
    for(;;){
    int a = s(p(s((s==s)+(p==p))));
    int b = a+s(a+p(a+a));
    putchar(b-s(p(b*a-b-s(p(s(s(p(b-(s==s))+p(b)))-(p==p))))));
    }
}

J'aime l'idée d'utiliser la séquence

a[n+5] = a[n] + a[n+2] + a[n+4]

comme dans cette réponse . Trouvé dans la recherche OEIS sous la séquence A122115 .

Si nous suivons la séquence en sens inverse, nous trouverons un quintuple d’initialisation convenable qui ne contient pas 4, 8, 15, 16 ou 23.

Python3:

l = [3053, 937, -1396, -1757, -73]
while l[-1] != 66:
    l.append(l[-5] + l[-3] + l[-1])
while True:
    print(l[-6:-1])

JavaScript

Pas de chiffres du tout est un bon coup. Mais plutôt que d'imprimer la séquence une fois par passage dans la boucle, n'imprimez qu'un numéro par passage.

t = "....A...B......CD......E..................FEDCBA";
b = k = --t.length;
do {
    console.log(p = t.indexOf(t[k]));
} while (k-=!!(p-k)||(k-b));

La partie inférieure de la chaîne code les numéros à imprimer et la partie supérieure de la chaîne code le caractère suivant à rechercher. Lorsque les deux parties se rencontrent (une seule F), les codes réinitialisent le cycle.

Python

b=a=True;b<<=a;c=b<<a;d=c<<a;e=d<<a;f=e<<a
while a: print c,d,e-a,e,e+d-a,f+d+b

Opérateurs binaires et quelques mathématiques simples.

Rubis

Génère les Nombres en incorporant la séquence également mystique 0,, 9, 0, 36, 6, 6, 63 ;
Il ne peut en résulter aucun bien.

(0..1/0.0).each{|i|puts"kw9ygp0".to_i(36)>>i%6*6&63}

C ( 54 50 caractères)

Je poste une réponse au golf parce que jouer au golf le rend amusant.

main(a){while(printf("%d\n","gAELMT"[a++%6]-61));}

Haskell

main = mapM_ (print . round . go) [0..]
  where
    go n = 22 - 19.2*cos t + 6*cos (2*t) - 5.3*cos (3*t) + 0.5*cos (5*t)
      where t = fromInteger (n `mod` 6) / 6 * pi

http://ideone.com/erQfcd

Edit: Ce que j'ai utilisé pour générer les coefficients: https://gist.github.com/ion1/9578025

Edit: J'ai vraiment aimé le programme d'agrif et j'ai fini par écrire un équivalent de Haskell tout en le découvrant. J'ai choisi une base différente pour le nombre magique.

import Data.Fixed
main = mapM_ print (go (369971733/5272566705 :: Rational))
  where go n = d : go m where (d,m) = divMod' (59*n) 1

http://ideone.com/kzL6AK

Edit: J'ai aussi aimé son deuxième programme et j'ai fini par écrire une implémentation Haskell d'irrationnels quadratiques ;-). En utilisant la bibliothèque et le numéro magique d'agrif, ce programme imprimera la séquence.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

main = F.mapM_ print xs
  where (_, xs) = qiToContinuedFraction n
        n = qi (-16101175) 1 265298265333750 770375

Voici comment on pourrait rechercher le nombre magique à l'aide de la bibliothèque:

> continuedFractionToQI (0, Cyc [] 4 [8,15,16,23,42])
qi (-644047) 1 424477224534 30815

La valeur imprimée représente le nombre (−644047 + 1 √424477224534)/30815. Tout ce que vous avez à faire est de trouver des facteurs qui éliminent les séquences de chiffres non autorisées dans les nombres sans modifier la valeur de l'expression.

C #

var magicSeed = -1803706451;
var lottery = new Random(magicSeed);
var hurleysNumbers = new List<int>();
for (int i = 0; i < 6; i++) hurleysNumbers.Add(lottery.Next(43));
while (true) Console.WriteLine(String.Join(",", hurleysNumbers));

J'ai trouvé la graine après avoir écouté une station de radio lors d'un vol au-dessus du Pacifique.

Python

import math

def periodic(x):
    three_cycle = abs(math.sin(math.pi * \
        (x/float(3) + (math.cos(float(2)/float(3)*x*math.pi)-1)/9)))
    two_cycle = abs(math.sin(math.pi * x / float(2)))
    six_cycle = three_cycle + 2*two_cycle
    return round(six_cycle, 2) # Correct for tiny floating point errors

def polynomial(x):
    numerator = (312+100)*(x**5) - 3000*x*(x**3) + (7775+100)*(x**3) - \
        (7955+1000)*(x**2) + (3997+1)*x + 120
    denominator = float(30)
    return float(numerator)/denominator

def print_lost_number(x):
    lost_number = polynomial(periodic(float(x)))
    print(int(lost_number)) # Get rid of ugly .0's at the end

i=0
while (1):
    print_lost_number(i)
    i += 1

Alors que beaucoup de gens utilisaient des modèles issus d'OEIS, j'ai décidé de créer mon propre ensemble de fonctions pour représenter les nombres.

La première fonction que j'ai créée était périodique (). C'est une fonction qui répète tous les six nombres en utilisant les propriétés cycliques des fonctions trig. Ça va comme ça:

periodic(0) = 0
periodic(1) = 5/2
periodic(2) = 1
periodic(3) = 2
periodic(4) = 1/2
periodic(5) = 3
periodic(6) = 0
...

Ensuite, je crée polynôme (). Cela utilise le polynôme suivant:

412x^5-3000x^4+7875x^3-8955x^2+3998x+120
----------------------------------------
                  30

(Dans mon code, certains des coefficients sont représentés sous forme de sommes car ils contiennent les nombres perdus dans l'un de leurs chiffres.)

Ce polynôme convertit la sortie de périodique Period () en son propre nombre perdu, comme ceci:

polynomial(0)   = 4
polynomial(5/2) = 8
polynomial(1)   = 15
polynomial(2)   = 16
polynomial(1/2) = 23
polynomial(3)   = 42

En augmentant constamment et en passant par les deux fonctions, les nombres perdus se répètent à l'infini.

(Remarque: j’utilise beaucoup float () dans le code. C’est pourquoi Python effectue la division en virgule flottante au lieu de dire 2/3 = 0.)

Emacs Lisp 73 caractères

Le meilleur moyen de boucler pour toujours? Une liste cyclique!

(let((a'(?\^D?\^H?\^O?\^P?\^W?*)))(setcdr(last a)a)(while(print(pop a))))

Mais attendez, il y a plus!

? \ ^ D est le bon moyen d’insérer le caractère pour EOT, cependant si je ne faisais que soumettre un fichier, je n’aurais pas besoin du littéral "\ ^ D", je pourrais simplement insérer un '?' suivi d'un caractère EOT réel, ramenant ainsi le nombre réel de caractères nécessaires à: 63

Modifier

J'ai travaillé sur "gel" qui n'est pas encore un langage réel, mais qui est essentiellement une série de macros emacs lisp pour le golf de code. En "gel" ce serait la solution:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))(...)))

et sans attendre:

(m a(~o ?\^D?\^H?\^O?\^P?\^W?*)(@(<^(^ a))))

44 caractères avec une belle entrée de caractère. Serait 34 si ce n'était pas une soumission Web.

Julia

En recherchant un moment, j'ai trouvé un moyen mathématique d'exprimer la séquence par d'autres séquences sans utiliser aucun des nombres (ou des manières délicates de les utiliser):

L(n)=n==0?2:n==1?1:L(n-1)+L(n-2) #Lucas numbers.
O(n)=int(n*(n+1)*(n+2)/6)
S(n)=n in [O(i) for i=1:50]?0:1 #A014306
T(n)=begin k=ifloor(n/2);sum([L(i)*S(n+1-i) for i=1:k]) end #A025097

lost(n)=n>5?lost(n-1)+lost(n-3)+lost(n-5):(n+3)>5?T(n+3):-T(n+3) #A122115

[lost(i-2) for i=5:10]

Sortie:

6-element Array{Int64,1}:
  4
  8
 15
 16
 23
 42

C ++

Un langage propre comme C ++ peut vous permettre de présenter votre source de manière lisible et nette, et présente l'avantage d'être facile à copier à la main avec un minimum d'ambiguïté.

Ici, la solution est atteinte en utilisant uniquement le nombre 1.

#include <iostream>

typedef long int lI;
auto &VV = std::cout;
std::string vv = " ";

int main() {
  for(lI UU; UU --> UU;) {
    lI l1=1l+1l;lI 
    ll=1l << l1;VV 
    << ll << vv;lI 
    Il=ll*l1;VV << 
    Il << vv;VV <<
    ll*ll-1l << vv;
    lI II=ll*ll;VV 
    << II << vv;VV 
    <<(II += Il-1l)
    << vv;VV << l1
    * (II-l1)<< vv;
  }
}

Test: http://ideone.com/fuOdem

Scheme (Guile)

(let l ((x 179531901/2199535975))
  (let* ((b (* x 51)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

http://ideone.com/QBzuBC

On peut soutenir que cela enfreint la règle "ne pas coder les nombres dans d'autres bases", mais je pense que c'est assez obscur pour que cela ne compte pas. Comme preuve de cette obscurité, ces deux nombres magiques en base 51 sont:

26:27:21:9:18 / 6:19:6:19:6:19

Edit : Même astuce, représentation différente. En fait, j'aime davantage celui-ci, car il ne dépend pas d'une base choisie arbitrairement. Cependant, cela nécessite une implémentation de schéma avec une prise en charge de précision infinie pour les irrationnels quadratiques, qui (AFAIK) n'existent pas. Vous pouvez toutefois l'implémenter dans quelque chose comme Mathematica.

(let l ((x (/ (+ -16101175 (sqrt 265298265333750)) 770375)))
  (let* ((b (/ 1 x)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))

PHP

Je pensais qu'il était temps que quelqu'un soumette une réponse php, pas la meilleure mais amusante de toute façon

while(true)
{
    $lost = array(
    "Aaah",
    "Aaaaaaah",
    "Aaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaah",
    "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaah");
    foreach ($lost as $a)
    {
        echo strlen($a).'
        ';
    }
}

les Ahs sont les hurlements des passagers alors que l'avion s'écrase

Perl

#!/usr/bin/perl
use Math::Trig;

$alt = 2600;
$m   = 10 x 2;
$ip  = 1 - pi/100;
@candidates = (
    "Locke",
    "Hugo",
    "Sawyer",
    "Sayid Jarrah",
    "Jack Sh.",
    "Jin-Soo Kwon"
);

@lost = map {map{ $a+=ord; $a-=($a>$alt)?($r=$m,$m=-$ip*$m,$r):$z; }/./g; $a/100 }@candidates;
for(;;) {
    printf "%d\n",$_ for @lost;
}