4, 8, 15, 16, 23, 42 [fechado]

90

4, 8, 15, 16, 23, 42

Escreva um programa que produz essa sequência de números infinitamente. No entanto, os números não devem aparecer no seu código-fonte em nenhum lugar.

O seguinte não é um programa Java válido para a saída do The Numbers porque o The Numbers aparece em seu código-fonte:

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

A definição de "Os números não devem aparecer no seu código-fonte" é a seguinte:

  • Você não deve usar o número 4.
  • Você não deve usar o número 8.
  • Você não deve usar o número 1 seguido pelo número 5.
  • Você não deve usar o número 1 seguido pelo número 6.
  • Você não deve usar o número 2 seguido pelo número 3.

Se seu idioma ignora certos caracteres que podem ser colocados entre os números, não é uma substituição válida. Por exemplo, se seu idioma interpreta o literal 1_5como 15, isso contará como o número 1 seguido pelo número 5.

Bases alternativas estão incluídas na restrição, por exemplo:

  • O binário 100 não pode ser usado como um substituto para 4.
  • O Octal 10 não pode ser usado como um substituto para 8.
  • O hexadecimal F não pode ser usado como substituto de 15.

Portanto, a seguir, é um programa Java válido (mas não muito inspirado) para gerar saída do Numbers porque ele não aparece em seu código-fonte:

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

Observe que nesse programa, '*'e '&'são substituídos os números inteiros 42 e 38, porque, caso contrário, os números 4 e 8 apareceriam em seu código-fonte.

A definição de "gera a sequência infinitamente" está aberta à interpretação. Assim, por exemplo, um programa que gera glifos cada vez menores até serem "infinitamente" pequenos seria válido.

Parabéns se você é capaz de gerar a sequência de alguma forma que não é basicamente codificar cada número.

Este é um concurso de popularidade, então seja criativo. A resposta com mais votos em 26 de março é a vencedora.

Radiodef
fonte
8
Posso contar 6
votos negativos,
11
@Vereos, "Esta é uma pergunta estúpida" não é muito construtivo, e pode ser por isso que ninguém postou como comentário.
Peter Taylor
18
Existem 11 tipos de pessoas neste mundo: aqueles que assistiram Lost , aqueles que não assistiram e aqueles que não entendem binário.
Ossifrage melindroso 12/03/14
7
@ PeterTaylor Com certeza, mas os recém-chegados geralmente não conseguem isso e deixam o site em vez de tentar melhorar suas perguntas futuras. Eu acho que This isn't an interesting question, IMHO, since the solution is pretty trivial. Please post in the sandbox next time.seria muito melhor do que isso This is a stupid question., mas essa é apenas a minha opinião pessoal.
Vereos 12/03
3
Percebo que a pergunta não proíbe a saída de outros números. Portanto, pelo menos de acordo com a teoria dos macacos infinitos, um gerador de números pseudo-aleatórios não adulterado deve fazer o truque.
kojiro

Respostas:

233

Java

Decidi adicionar outra entrada, pois ela é completamente diferente da minha primeira (que era mais como um exemplo).

Este programa calcula a média de uma matriz inserida pelo usuário ...

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 faz?

java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    em Numbers.getAverage (Numbers.java:15)
    em Numbers.roundAverage (Numbers.java:16)
    em Numbers.beginLoop (Numbers.java:23)
    em Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    em Numbers.getAverage (Numbers.java:15)
    em Numbers.roundAverage (Numbers.java:16)
    em Numbers.beginLoop (Numbers.java:23)
    em Numbers.main (Numbers.java:42)
java.lang.ArrayIndexOutOfBoundsException: 4
    em Numbers.getSum (Numbers.java:8)
    ...
Radiodef
fonte
17
Isso é ótimo! Eu não teria pensado em algo assim.
22414 Jordon Biondo
2
Uau lindo ! Grande ideia;)
Pierre Arlaud
5
Gênio! Embora a saída seja um pouco detalhada, acho que isso tem a ver com o idioma que você escolheu aqui. ;)
Pieter Witvoet 13/03
3
Quando pensei que o "lizt = Lost plot" do Python não podia ser superado ...
Dave
3
@justhalf Na verdade, me incomoda que esta tenha sido a melhor resposta por um tempo. Não é divertido ganhar minha própria pergunta.
Radiodef
184

Pitão

#!/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)

Editar: Conforme sugestão de nneonneo, o script agora não inclui dígitos.

Kevin
fonte
2
Tão simples e tão bom.
precisa
4
A obtenção ou não do meu voto depende inteiramente da resposta a esta pergunta: a grafia de "lizt" é uma referência "Arzt"? EDIT: Quem eu estou brincando, recebe o meu voto de qualquer maneira.
Plutor
6
Eu escreveria while True:para que sua resposta não contenha nenhum dígito.
nneonneo
2
while True:é mais comum
Martin Ueding 17/03/14
1
Isso não estraga a regra "sem bases alternativas"? Basicamente, é apenas uma matriz de números de base-1 :-)
Daniel
77

Perl

Não há nada oculto no código fonte. Não. Se o código não funcionar, digite use re "eval";antes dele (obrigatório no Perl 5.18).

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

Explicação em spoiler.

Este é um programa Perl simples que utiliza várias operações bit a bit e avalia a expressão regular usando o operador = ~ . O regex começa com (? { E termina com }) . No Perl, isso executa o código enquanto avalia a expressão regular - isso me permite usar eval sem realmente usá-lo. Normalmente, no entanto, antes do código para fazê-lo funcionar. Fora isso, não há muito mais para esse código. re "eval" é necessário, por razões de segurança, ao avaliar expressões regulares de strings (alguns programas mais antigos realmente pegavam expressões regulares do usuário) - mas acontece que antes do Perl 5.18 havia um bug que causava expressões dobradas constantes para trabalhar mesmo sem esse pragma - se você estiver usando o Perl 5.18, digite use re "eval";

Konrad Borowski
fonte
9
Estou começando a olhar como este , mas eu ainda não vejo isso ..
rdurand
69
@xfix "Este é um programa Perl simples " - se for esse o caso, eu odiaria ver um programa complicado.
MikeTheLiar
8
Ei, olha, é uma escuna.
roippi
5
@roippi Haha, seu bastardo idiota. Não é uma escuna, é um barco a vela!
MikeTheLiar
7
Protip: copie / cole no Notepad ++ e reduza o zoom até o fim.
21414 Mike
55

Brainfuck

Eu sou tão ruim em arte ASCII!

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

Teste aqui: http://ideone.com/kh3DYI

Michael M.
fonte
Esta é uma solução muito boa :) #
3011 gilbertohasnofb
47

Unix C

Existem muitos lugares para encontrar constantes numéricas.

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

fonte
10
A ofuscação aqui é bastante suprema por ser simples substituição.
Radiodef 13/03/14
1
Não funciona com excesso de pilha devido à recursão?
Ski
@Skirmantas Presumo que todos os compiladores usarão recursão de cauda para isso (por exemplo, substitua a chamada para main por um salto para main).
Tyilo
44

C #

A fórmula "roubada" de https://oeis.org/A130826 : a (n) é o menor número, de modo que o dobro do número de divisores de (a (n) -n) / 3 fornece o n-ésimo termo no primeiro diferenças da sequência produzida pela peneira 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);
            }
        }
    }
}
Sebastian Negraszus
fonte
10
+1 Para alguém que realmente foi para oeis.org, a fim de pesquisar uma fórmula que se encaixa na seqüência :)
MrPaulch
a(i)=a(i-1)+a(i-3)+a(i-5)realmente parece uma solução mais fácil
Cruncher
1
@Cruncher Essa fórmula exige que você pré-defina os 5 primeiros termos (incluindo 4, 8 e 15), o que é chato e contra as regras.
Sebastian Negraszus 20/03
30

C #

Usar o fato de que qualquer sequência de N elementos pode ser gerada por um polinômio N-1 e inserir os números envolveu muitos bipes e boops. Para referência, o polinômio I derivado é

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

Atribuí os fatores às variáveis ​​nomeadas para os números, por simplicidade;)

Primeira versão:

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

Gostei da implicação do aumento da tensão, à medida que o número de BEEPs diminui após cada número.

Então imaginei que também poderia calcular os fatores usando bipes e boops:

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;

Foi um pouco exagerado depois disso ...

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

O uso do operador padrão em C # para tipos de valor permite a inicialização do BEEEP em zero. Dessa forma, nenhum literal numérico é usado no código. O algoritmo básico é o mesmo. mas os fatores são calculados em linha.

Rik
fonte
@ kódfodrász obrigado pela edição sugerida!
Rik
6
Vejo um numeral 8 em lá, você má pessoa que você
Thebluefish
@Thebluefish Estou com vergonha.
Rik
25

D

Não é permitido usar os números 4, 8, 15, 16, 23 ou 42 no meu código? Não tem problema, então não usarei números!

import std.stdio;

void main()
{
    while( true )
    {
        ( ',' - '('  ).writeln;
        ( '/' - '\'' ).writeln;
        ( '/' - ' '  ).writeln;
        ( '_' - 'O'  ).writeln;
        ( '^' - 'G'  ).writeln;
        ( '~' - 'T'  ).writeln;
    }
}
Tony Ellis
fonte
6
A aritmética ASCII é a melhor aritmética.
Pharap
2
Então, depois de C, veio uma linguagem chamada D?
cegprakash
@cegprakash E antes de C ser B
SirPython 9/15
24

Javascript + HTML

Anti-golfe!

<!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>

O <pre>elemento exibe um número na sequência. Ele também contém todo o código necessário para chegar ao próximo número na sequência. Portanto, o <pre>é avaliado, o que resulta no texto da <pre>atualização para se parecer com o próximo número na sequência. Esse processo se repete indefinidamente.

Aqui está em ação!

sh54
fonte
2
Mais um por engenhosidade. Bem-vindo ao PPCG!
Jonathan Van Matre 13/03
22

C

Coloque seus óculos de sol em :-)

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);}}
ossifrage melindroso
fonte
11
Por mais bonito que seja, conto três 4e dois 8segundos.
Geobits 13/03
6
@ Geobits Eu obviamente preciso de um novo par de óculos de estrabismo! Corrigido agora.
Ossifrage melindroso 13/03/14
20

Haskell, 1 LoC

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

Decidi optar por uma linha legível apenas para mostrar como Haskell é incrível. Além disso, decidi evitar todos os dígitos, apenas por precaução.

Graças à avaliação lenta embutida, o Haskell pode manipular (mapear, dividir, ingressar, filtrar ...) listas infinitamente longas. Ele ainda possui vários recursos internos para criá-los. Como uma string é apenas uma lista de caracteres, infinitamente longas também não são um mistério para Haskell.

John Dvorak
fonte
2
Adoro a maneira como Haskell e similares fazer programação funcional: D
Jwosty
2
fromEnumparece mais agradável do que Data.Char.ord, e é um pouco mais curto
mniip
1
Whuh ... como? Você poderia explicar?
Pureferret 13/03/14
1
Acabei de notar os personagens inócuos no final. Presumo que tenha algo a ver com isso?
Pureferret 13/03/14
20

Mathematica

Podemos responder à pergunta focando nos denominadores parciais repetidos da fração contínua periódica mostrada abaixo. Eles são o que precisamos.

repita cf

Afinal, eles compreendem a sequência não terminante que estamos tentando produzir: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...


Na Mathematica, obtém-se o irracional quadrático correspondente à fração contínua periódica por

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

quad irr 1

onde 0 se refere à parte inteira implícita.

Podemos verificar invertendo a operação:

insira a descrição da imagem aqui

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


Os 4 e 8 violam uma das regras do desafio. A substring 15é uma violação adicional. Podemos reformatar o irracional quadrático para satisfazer as regras.

c

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


Agora pegamos a sequência de interesse:

Last[c]

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

E imprima a lista para sempre ...

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

mesa

DavidC
fonte
Bem, essa é uma boa solução matemática. Eu realmente gosto deste
C5H8NNaO4
@ C5H8NNaO4, Obrigado, MSG. Foi divertido descobrir.
DavidC
1
Você editou para se livrar da 16fração enquanto eu estava digitando um comentário sobre isso.
Geobits 18/03/14
@Geobits. Engraçado sobre isso. Pensei em verificar se cumpri as regras; houve várias violações que eu corrigi desde então.
DavidC
19

C / C ++

Usando apenas os personagens L, O, Se Trepetidamente nessa ordem:

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')   ;}
sam hocevar
fonte
18

Java

Não consigo encontrar um padrão nessa sequência. Se não houver um padrão reconhecível, é melhor juntarmos alguns primos pequenos, enfiá-los no RNG interno do Java e encerrar o dia. Não vejo como isso poderia dar errado, mas, novamente, sou otimista :)

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();
        }
    }
}
Geobits
fonte
1
Menos o while(true): ideone.com/1xaPdO
Tim S.
7
Há um padrão, mas não é ... muito óbvia: oeis.org/A130826 :)
Sebastian Negraszus
14

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`

Quebra de linha adicionada para facilitar a leitura. (Ab) usa o fato de que estes são os seis primeiros números da sequência OEIS A130826 .

Heinzi
fonte
Você também pode canalizar awk -F"[ ,]" '/%S/ {for (i=3;i<=9;i++) printf $i" "}'para curl.
fedorqui
1
Você pode remover o loop completamente yese soltar o redirecionamento para /dev/nullwith curl -s. Algo comoyes $(curl -s "https://oeis.org/search?q=id:A$((130726+100))&t=text" | awk -F"[ ,]" '/%S/ {for (i=3;i<9;i++) printf $i" "}')
Digital Trauma
@DigitalTrauma: Obrigado, eu não sabia yese curl -s- apenas adicionei vergonhosamente isso à minha resposta. :-)
Heinzi 14/03
13

C usando nenhum número e nenhum valor de caractere

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))))));
    }
}
asr
fonte
12

Eu gosto da ideia de usar a sequência

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

como nesta resposta . Foi encontrado através da pesquisa OEIS como sequência A122115 .

Se passarmos pela sequência ao contrário, encontraremos um quíntuplo de inicialização adequado que não contém 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])
bodo
fonte
muito esperto! Agradável.
DavidC
11

Javascript

Nenhum número é uma boa jogada. Mas, em vez de imprimir a sequência uma vez por passagem no loop, imprima apenas uma vez o número por passagem.

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

A parte inferior da sequência codifica os números a serem impressos e a parte superior da sequência codifica o próximo caractere a ser encontrado. Onde as duas partes se encontram (um único F) códigos redefinindo o ciclo.

DocMax
fonte
11

Pitão

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

Operadores bit a bit e algumas contas simples.

grovesNL
fonte
10

Rubi

Gera os números incorporando a sequência igualmente mística 0, ∞, 9, 0, 36, 6, 6, 63 ;
Nada de bom pode vir disso.

(0..1/0.0).each{|i|puts"kw9ygp0".to_i(36)>>i%6*6&63}
daniero
fonte
Todo código ruby ​​parece que deve apenas errar e morrer; me choca até hoje que qualquer coisa funcione!
alexandercannon
10

C ( 54 50 caracteres)

Estou postando uma resposta de golfe, porque o golfe o torna divertido.

main(a){while(printf("%d\n","gAELMT"[a++%6]-61));}
orion
fonte
Se você está jogando golfe, pode (sem dúvida) largar o a=0;. O único efeito seria que você pode iniciar a sequência em outro lugar que não seja 4 (provavelmente 8). De qualquer forma, isso atrapalhará a sequência quando ahouver excesso. É um comportamento tecnicamente indefinido, mas o resultado provável é que você imprimirá o lixo na metade do tempo.
jerry
Ou ciclo apenas a string para "gAELMT" :)
orion
Claro, a menos que alguém invoque seu programa com argumentos :) Ainda imprimindo lixo na metade do tempo.
jerry
3
Se você fornecer argumentos para um programa que não precisa de nenhum, você paga o preço :)
orion
1
fornão ajuda se não houver inicialização. for(;;)é o mesmo número de caracteres que while(). Interpretei as regras para que as novas linhas precisassem estar lá ... Mas eu poderia usar a recursão da cauda com o principal ...
orion
10

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: O que eu usei para gerar os coeficientes: https://gist.github.com/ion1/9578025

Edit: Eu realmente gostei do programa de Agrif e acabei escrevendo um equivalente Haskell enquanto descobri. Eu escolhi uma base diferente para o número mágico.

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: Eu também gostei do seu segundo programa e acabei escrevendo uma implementação Haskell de irracionais quadráticos ;-). Usando a biblioteca e o número mágico do agrif, este programa imprimirá a sequência.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

É assim que se pode procurar o número mágico com a ajuda da biblioteca:

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

O valor impresso representa o número (−644047 + 1 √424477224534)/30815. Tudo o que você precisa fazer é encontrar fatores que se livrem das seqüências de dígitos não permitidas nos números, sem alterar o valor da expressão.

íon
fonte
Bem-vindo ao site =)
Riot
8

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

Encontrei a semente depois de ouvir alguma estação de rádio em um vôo sobre o Pacífico.

Rápido como
fonte
6
Existem 4s e 8s dentro.
Zakk
7

Pitão

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

Enquanto muitas pessoas usavam padrões retirados do OEIS, decidi criar meu próprio conjunto de funções para representar os números.

A primeira função que criei foi periódica (). É uma função que repete a cada seis números de entrada usando as propriedades cíclicas das funções trigonométricas. É assim:

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

Então, eu crio polinomial (). Que usa o seguinte polinômio:

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

(No meu código, alguns dos coeficientes são representados como somas porque contêm os números perdidos como um de seus dígitos.)

Esse polinômio converte a saída de periódico () em seu número perdido apropriado, assim:

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

Ao aumentar constantemente i e passar por ambas as funções, recebo os números perdidos repetindo infinitamente.

(Nota: Eu uso muito float () no código. Isso é para que o Python faça divisão de ponto flutuante em vez de dizer 2/3 = 0.)

Andrew Soutar
fonte
1
Fácil de corrigir, mas você ainda tem um 4em polynomial.
Geobits 13/03
@Geobits whoops, não percebeu isso. Obrigado.
Andrew Soutar
6

Emacs Lisp 73 chars

A melhor maneira de fazer um loop para sempre? Uma lista cíclica!

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

Mas espere, tem mais!

? \ ^ D é a melhor maneira de inserir o caractere para EOT, no entanto, se eu estivesse apenas enviando um arquivo, não precisaria do literal "\ ^ D", apenas poderia inserir um '?' seguido por um caractere EOT real, diminuindo assim o número real de caracteres necessários para: 63

Editar

Eu tenho trabalhado em "gel", que ainda não é uma linguagem real, mas é basicamente uma série de macros emacs lisp para código golf. Em "gel", esta seria a solução:

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

e sem a espera:

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

44 caracteres com boa entrada de caracteres. Seria 34 se não fosse por uma apresentação na web.

Jordon Biondo
fonte
6

Julia

Ao pesquisar um tempo, encontrei uma maneira matemática de expressar a sequência por outras seqüências sem usar nenhum dos números (ou maneiras complicadas de usá-las):

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]

Resultado:

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

C ++

Uma linguagem limpa e agradável como o C ++ pode permitir que você organize sua fonte de maneira organizada e altamente legível, e tem a vantagem de ser fácil de copiar manualmente, com o mínimo de ambiguidade.

Aqui a solução é alcançada usando apenas o número 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;
  }
}

Teste: http://ideone.com/fuOdem

Tumulto
fonte
6

Esquema (Guile)

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

http://ideone.com/QBzuBC

Indiscutivelmente, isso quebra a regra "não codifique os números em outras bases", mas acho que é suficientemente obscuro para não contar. Como evidência dessa obscuridade, esses dois números mágicos na base 51 são:

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

Edit : Mesmo truque, representação diferente. Na verdade, gosto mais deste, uma vez que não depende de uma base escolhida arbitrariamente. No entanto, requer uma implementação de esquema com suporte de precisão infinita para irracionais quadráticos, que (AFAIK) não existe. Você pode implementá-lo em algo como o Mathematica.

(let l ((x (/ (+ -16101175 (sqrt 265298265333750)) 770375)))
  (let* ((b (/ 1 x)) (f (floor b)))
    (format #t "~a " f)
    (l (- b f))))
agrif
fonte
Bem-vindo ao site =)
Riot
+1 para "requer uma implementação de esquema com suporte de precisão infinita para irracionais quadráticos, que (AFAIK) não existe".
Lyndon White
6

PHP

Eu pensei que era hora de alguém enviar uma resposta php, não a melhor, mas a mais divertida de qualquer maneira

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

os Ahs são os gritos dos passageiros enquanto o avião cai

alexandercannon
fonte
5

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;
}
ninjalj
fonte