4, 8, 15, 16, 23, 42 [zamknięte]


90

4, 8, 15, 16, 23, 42

Napisz program, który wypisze nieskończoną sekwencję liczb. Numery nie mogą jednak nigdzie pojawiać się w kodzie źródłowym.

Następujący program nie jest prawidłowym programem Java do wyświetlania liczb, ponieważ liczby pojawiają się w kodzie źródłowym:

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

Definicja „Numery nie mogą pojawiać się w kodzie źródłowym” jest następująca:

  • Nie wolno używać cyfry 4.
  • Nie wolno używać cyfry 8.
  • Nie wolno używać cyfry 1, a następnie cyfry 5.
  • Nie wolno używać cyfry 1, a następnie cyfry 6.
  • Nie wolno używać cyfry 2, a następnie cyfry 3.

Jeśli Twój język ignoruje pewne znaki, które można umieścić między cyframi, nie jest to poprawne podstawienie. Na przykład, jeśli twój język interpretuje literał 1_5jako 15, będzie to liczone jako cyfra 1, a następnie cyfra 5.

Alternatywne zasady są objęte ograniczeniem, więc na przykład:

  • Binarne 100 nie może być używane jako zamiennik 4.
  • Octal 10 nie może być stosowany jako zamiennik 8.
  • Szesnastkowy F nie może być stosowany jako zamiennik 15.

Dlatego poniżej przedstawiono poprawny (ale niezbyt zainspirowany) program Java do wyświetlania liczb, ponieważ liczby nie pojawiają się w kodzie źródłowym:

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

Zauważ, że w tym programie '*'i '&'są zastąpione liczbami całkowitymi 42 i 38, ponieważ w przeciwnym razie cyfry 4 i 8 pojawiłyby się w kodzie źródłowym.

Definicja „wyjścia sekwencji w nieskończoność” jest otwarta do interpretacji. Na przykład poprawny byłby program, który wypuszcza glify, które stają się mniejsze, aż stają się „nieskończenie” małe.

Kudos, jeśli jesteś w stanie wygenerować sekwencję w jakiś sposób, który nie jest zasadniczo zakodowany na stałe dla każdej liczby.

To konkurs popularności, więc bądź kreatywny. Odpowiedź z największą liczbą głosów 26 marca jest zwycięzcą.


8
Mogę policzyć 6 głosów negatywnych, ale bez komentarzy: /
Vereos

11
@ Vereos, „To jest głupie pytanie” nie jest zbyt konstruktywne i być może dlatego nikt nie opublikował go w komentarzu.
Peter Taylor

18
Na świecie jest 11 typów ludzi: tych, którzy oglądali Zagubionych , tych, którzy tego nie zrobili, i tych, którzy nie rozumieją binarnych.
skrzypiący kostrzew

7
@PeterTaylor Na pewno, ale nowicjusze w większości nie dostaną tego i opuszczą stronę zamiast próbować poprawić swoje przyszłe pytania. Myślę, że This isn't an interesting question, IMHO, since the solution is pretty trivial. Please post in the sandbox next time.byłoby to o wiele lepsze niż This is a stupid question., ale to tylko moja osobista opinia.
Vereos

3
Zauważam, że pytanie nie zabrania wypisywania innych liczb. Tak więc przynajmniej zgodnie z teorią nieskończonej małpy niefałszowany generator liczb pseudolosowych powinien załatwić sprawę.
kojiro

Odpowiedzi:


233

Jawa

Postanowiłem dodać kolejny wpis, ponieważ jest on zupełnie inny niż mój pierwszy (który bardziej przypominał przykład).

Ten program oblicza średnią z tablicy wprowadzonej przez użytkownika ...

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

... czy to robi?

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

17
To jest świetne! Nie pomyślałbym o czymś takim.
Jordon Biondo

2
Oh piękne ! Świetny pomysł;)
Pierre Arlaud

5
Geniusz! Chociaż wynik jest nieco wyczerpujący, ale sądzę, że ma to związek z wybranym tutaj językiem. ;)
Pieter Witvoet

3
Właśnie wtedy, gdy pomyślałem, że Python „lizt = Lost plot” nie da się pokonać ...
Dave

3
@ justhalf Właściwie to mnie wkurza, to była najlepsza odpowiedź na chwilę. Wygranie własnego pytania nie jest zabawne.
Radiodef,

184

Pyton

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

Edycja: Zgodnie z sugestią Nneonneo, skrypt nie zawiera teraz cyfr.


2
Tak proste, a jednak takie dobre.
Konrad Borowski

4
To, czy otrzymam mój głos, zależy wyłącznie od odpowiedzi na to pytanie: czy pisownia „jaszczurki” jest odniesieniem do „Arzta”? EDYCJA: Kogo żartuję, i tak dostaje mój głos.
Plutor

6
Chciałbym napisać while True:, aby twoja odpowiedź w ogóle nie zawierała cyfr.
nneonneo

2
while True:jest bardziej powszechny.
Martin Ueding

1
Czy to nie psuje zasady „brak alternatywnych zasad”? Zasadniczo jest to tylko tablica liczb base-1 :-)
Daniel

77

Perl

W kodzie źródłowym nic nie jest ukryte. Nie. Jeśli kod nie działa, wpisz use re "eval";go wcześniej (wymagane w Perlu 5.18).

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

Wyjaśnienie w spoilerze.

Jest to prosty program w Perlu, który wykorzystuje wiele operacji bitowych i ocenia wyrażenie regularne za pomocą operatora = ~ . Wyrażenie regularne zaczyna się od (? { I kończy się na }) . W Perlu uruchamia to kod podczas oceny wyrażenia regularnego - pozwala mi to na użycie eval bez jego używania. Zwykle jednak ewaluacja jest wymagana ze względów bezpieczeństwa podczas oceny wyrażeń regularnych z ciągów (niektóre starsze programy faktycznie pobierały wyrażenia regularne od użytkownika) - ale okazuje się, że przed Perlem 5.18 był błąd powodujący stałe składanie wyrażeń pracować nawet bez tej pragmy - jeśli używasz Perla 5.18, wpisz use re "eval";przed kodem, aby działał. Poza tym ten kod nie ma wiele więcej.


9
Zaczynam patrzeć jak ten , ale nadal nie widzę ..
rdurand

69
@xfix „Jest to prosty program w Perlu” - w takim przypadku nie chciałbym widzieć skomplikowanego.
MikeTheLiar

8
Hej, patrz, to szkuner.
roippi

5
@roippi Haha, ty głupi draniu. To nie szkuner, to SAILBOAT!
MikeTheLiar

7
Protip: skopiuj / wklej do Notepad ++ i pomniejsz całkowicie.
MikeTheLiar

55

Brainfuck

Jestem taka zła w sztuce ASCII!

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

Przetestuj tutaj: http://ideone.com/kh3DYI


To naprawdę fajne rozwiązanie :)
gilbertohasnofb

47

Unix C

Istnieje wiele miejsc, w których można znaleźć stałe liczbowe.

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

10
Zaciemnienie tutaj jest całkiem wyjątkowe, ponieważ jest prostą substytucją.
Radiodef

1
Czy nie powoduje przepełnienia stosu z powodu rekurencji?
Ski

@ Skirmantas Zakładam, że wszystkie kompilatory użyją do tego rekursji ogona (np. Zamieniają wywołanie main na jump to main).
Tyilo

44

DO#

Formuła „skradziona” z https://oeis.org/A130826 : a (n) to najmniejsza liczba taka, że ​​dwukrotność liczby dzielników (a (n) -n) / 3 daje n-ty termin w pierwszym różnice w sekwencji wytwarzanej przez sito 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);
            }
        }
    }
}

10
+1 Dla kogoś, kto faktycznie poszedł na oeis.org w celu zbadania formuły pasującej do sekwencji :)
MrPaulch

a(i)=a(i-1)+a(i-3)+a(i-5)naprawdę wydaje się łatwiejszym rozwiązaniem
Cruncher

1
@Cruncher Ta formuła wymaga uprzedniego zdefiniowania pierwszych 5 warunków (w tym 4, 8 i 15), co jest zarówno nudne, jak i niezgodne z zasadami.
Sebastian Negraszus

30

DO#

Wykorzystując fakt, że dowolną sekwencję N elementów można wygenerować przez wielomian N-1, a wprowadzanie liczb wiązało się z wieloma dźwiękami i buczeniami. Dla porównania pochodną wielomianową I jest

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

Dla uproszczenia przypisałem czynniki do zmiennych nazwanych liczbami;)

Pierwsza wersja:

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

Podobało mi się implikowanie rosnącego napięcia, gdy liczba BEEP spada po każdej liczbie.

Potem pomyślałem, że mogę też obliczyć czynniki za pomocą sygnału dźwiękowego i boopsa:

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;

Po tym trochę poszedł za burtę ...

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

Użycie domyślnego operatora w C # dla typów wartości pozwala na inicjalizację BEEEP do zera. W ten sposób w kodzie nie stosuje się literałów numerycznych. Podstawowy algorytm jest taki sam. ale współczynniki są obliczane liniowo.


@ kódfodrász dzięki za sugerowaną edycję!
Rik

6
Widzę tam cyfrę 8, ty zła osoba ty
Thebluefish

@Thebluefish Wstydzę się.
Rik

25

re

Nie mogę używać cyfr 4, 8, 15, 16, 23 lub 42 w moim kodzie? Nie ma problemu, więc w ogóle nie będę używać liczb!

import std.stdio;

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

6
Arytmetyka ASCII jest najlepszą arytmetyką.
Pharap,

2
Więc po C pojawił się język o nazwie D?
cegprakash

@cegprakash A przed C był B
SirPython

24

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>

<pre>Elementem wyświetla numer w sekwencji. Zawiera także cały kod niezbędny do przejścia do następnego numeru w sekwencji. Jest to więc <pre>eval'd, co powoduje, że tekst <pre>aktualizowanej wersji przypomina kolejną liczbę w sekwencji. Ten proces powtarza się bez końca.

Oto jest w akcji!


2
Plus jeden za pomysłowość. Witamy w PPCG!
Jonathan Van Matre

22

do

Załóż okulary zezujące :-)

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

11
Choć może to być ładne, liczę trzy 4si dwa 8s.
Geobits

6
@Geobits Oczywiście potrzebuję nowej pary mrugających okularów! Naprawiono teraz.
piskliwy kostnica

20

Haskell, 1 LoC

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

Zdecydowałem się na czytelny jednowarstwowy, aby pokazać, jak niesamowity jest Haskell. Postanowiłem też unikać wszystkich cyfr, na wszelki wypadek.

Dzięki wbudowanej leniwej analizie Haskell może manipulować (mapować, dzielić, łączyć, filtrować ...) nieskończenie długimi listami. Ma nawet wiele wbudowanych do ich tworzenia. Ponieważ ciąg znaków jest tylko listą znaków, nieskończenie długie ciągi znaków również nie są tajemnicą dla Haskella.


2
Uwielbiam sposób, w jaki Haskell i tym podobne wykonują programowanie funkcjonalne: D
Jwosty

2
fromEnumwygląda ładniej niż Data.Char.ordi jest nieco krótszy
mniip

1
Co ... jak? Czy możesz wytłumaczyć?
Pureferret

1
Właśnie zauważyłem nieszkodliwe postacie na końcu. Zakładam, że mają coś z tym wspólnego?
Pureferret


20

Matematyka

Możemy odpowiedzieć na to pytanie, skupiając się na powtarzających się częściowych mianownikach okresowego ciągłego ułamka pokazanego poniżej. Są tym, czego potrzebujemy.

powtórz por

W końcu zawierają one sekwencję nie kończącą się, którą próbujemy stworzyć: 4, 8, 15, 16, 23, 42, 4, 8, 15, 16, 23, 42 ...


W Mathematica uzyskuje się kwadratową irracjonalność odpowiadającą okresowej ciągłej części przez

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

quad ir 1

gdzie 0 odnosi się do niejawnej części całkowitej.

Możemy to sprawdzić, odwracając operację:

wprowadź opis zdjęcia tutaj

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


4 i 8 naruszają jedną z zasad wyzwania. Podciąg 15stanowi dodatkowe naruszenie. Możemy sformatować kwadratowy irracjonalny, aby spełnić zasady.

do

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


Teraz chwytamy sekwencję zainteresowania:

Last[c]

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

I wydrukuj listę na zawsze ...

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

stół


To jedno fajne rozwiązanie matematyczne. Naprawdę podoba mi się ten
C5H8NNaO4

@ C5H8NNaO4, Thanks, MSG. Zabawnie było to rozgryźć.
DavidC,

1
+1 Edytowałeś, by pozbyć się 16tego ułamka, kiedy pisałem o nim komentarz.
Geobits

@Geobits. Zabawne z tego powodu. Myślałem, że sprawdzę, czy przestrzegam zasad; od tego czasu naprawiłem kilka naruszeń.
DavidC

19

C / C ++

Korzystanie tylko znaki L, O, Si Twielokrotnie w tej kolejności:

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

18

Jawa

Nie mogę znaleźć wzoru w tej sekwencji. Jeśli nie ma rozpoznawalnego wzoru, równie dobrze możemy po prostu zrzucić kilka małych liczb pierwszych, wcisnąć je do wbudowanego RNG Javy i nazwać to dniem. Nie rozumiem, jak to mogło pójść nie tak, ale z drugiej strony jestem optymistą :)

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

1
Minus the while(true): ideone.com/1xaPdO
Tim S.

7
Jest pewien wzór, ale nie jest ... bardzo oczywisty: 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`

Dodano podział linii dla czytelności. (Ab) wykorzystuje fakt, że są to pierwsze sześć liczb OEIS Sekwencja A130826 .


Możesz także potokować awk -F"[ ,]" '/%S/ {for (i=3;i<=9;i++) printf $i" "}'do curl.
fedorqui

1
Możesz usunąć pętlę za pomocą yesi upuścić przekierowanie do za /dev/nullpomocą curl -s. Coś w rodzajuyes $(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: Dzięki, nie wiedziałem o tym yesi curl -s- bezwstydnie dodałem to do mojej odpowiedzi. :-)
Heinzi

13

C bez użycia liczb i bez wartości znaków

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

12

Podoba mi się pomysł użycia sekwencji

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

jak w tej odpowiedzi . Znalazłem go poprzez wyszukiwanie OEIS jako sekwencję A122115 .

Jeśli przejdziemy przez sekwencję w odwrotnej kolejności, znajdziemy odpowiedni pięciokrotność inicjalizacji, która nie zawiera 4, 8, 15, 16 lub 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])

bardzo mądry! Miły.
DavidC,

11

JavaScript

Żadne liczby to dobry ruch. Zamiast drukować sekwencję raz na przejście przez pętlę, drukuj tylko raz liczbę na przejście.

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

Dolna część łańcucha koduje liczby do wydrukowania, a górna część łańcucha koduje następny znak do znalezienia. Tam, gdzie dwie części spotykają się (jedna F), kody resetujące cykl.


11

Pyton

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

Operatory bitowe i prosta matematyka.


10

Rubin

Generuje liczby poprzez osadzenie równie mistycznej sekwencji 0, ∞, 9, 0, 36, 6, 6, 63 ;
Z tego nie może wynikać nic dobrego.

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

Cały kod ruby ​​wygląda tak, jakby powinien po prostu błędu i umrzeć; szokuje mnie do dziś, że którykolwiek z nich w ogóle działa!
alexandercannon

10

C ( 54 50 znaków)

Wysyłam odpowiedź na golfa, ponieważ gra w golfa przynajmniej sprawia przyjemność.

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

Jeśli grasz w golfa, możesz (prawdopodobnie) upuścić a=0;. Jedynym efektem byłoby to, że możesz rozpocząć sekwencję w innym miejscu niż 4 (prawdopodobnie 8). W każdym razie to zepsuje sekwencję, gdy nastąpi aprzepełnienie. Jest to technicznie niezdefiniowane zachowanie, ale prawdopodobnym rezultatem jest to, że wydrukujesz śmieci w połowie czasu.
jerry

Lub po prostu zmień ciąg na „gAELMT” :)
orion

Jasne, chyba że ktoś wywoła twój program z argumentami :) Wciąż jednak drukuje śmieci przez połowę czasu.
jerry

3
Jeśli podasz argumenty programowi, który go nie potrzebuje, zapłacisz cenę :)
orion

1
fornie pomaga, jeśli nie ma inicjalizacji. for(;;)to ta sama liczba znaków, co while(). Zinterpretowałem zasady, aby nowe linie musiały tam być ... Ale mógłbym użyć rekurencji ogona z main ...
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

Edycja: Co użyłem do wygenerowania współczynników: https://gist.github.com/ion1/9578025

Edycja: Naprawdę podobał mi się program Agrif i skończyłem pisać ekwiwalent Haskell, jednocześnie go rozgryzając . Wybrałem inną bazę dla magicznej liczby.

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

Edycja: Podobał mi się również jego drugi program i skończyłem na napisaniu implementacji kwadratowej irracjonalności Haskella ;-). Korzystając z biblioteki i magicznej liczby agriza, program wydrukuje sekwencję.

import qualified Data.Foldable as F
import Numeric.QuadraticIrrational

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

W ten sposób można szukać magicznej liczby za pomocą biblioteki:

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

Wydrukowana wartość oznacza liczbę (−644047 + 1 √424477224534)/30815. Wszystko, co musisz zrobić, to znaleźć czynniki, które pozbywają się niedozwolonych sekwencji cyfr w liczbach, nie zmieniając wartości wyrażenia.


Witamy na stronie =)
Riot

8

DO#

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

Znalazłem ziarno po wysłuchaniu jakiejś stacji radiowej podczas lotu nad Pacyfikiem.


6
W środku są 4 i 8.
zakk

7

Pyton

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

Podczas gdy wiele osób używało wzorców zaczerpniętych z OEIS, postanowiłem stworzyć własny zestaw funkcji do reprezentowania liczb.

Pierwszą funkcją, którą utworzyłem, była periodic (). Jest to funkcja, która powtarza się co sześć liczb wejściowych przy użyciu cyklicznych właściwości funkcji triggera. Wygląda to tak:

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

Następnie tworzę polynomial (). Korzysta z następującego wielomianu:

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

(W moim kodzie niektóre współczynniki są reprezentowane jako sumy, ponieważ zawierają utracone liczby jako jedną z ich cyfr).

Ten wielomian konwertuje dane wyjściowe funkcji periodic () na odpowiednią liczbę utraconą, jak poniżej:

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

Przez ciągłe zwiększanie i i przekazywanie go przez obie funkcje, otrzymuję utracone liczby powtarzające się nieskończenie.

(Uwaga: często używam float () w kodzie. To dlatego Python dokonuje podziału zmiennoprzecinkowego zamiast np. 2/3 = 0.)


1
Łatwe do naprawienia, ale nadal masz 4in polynomial.
Geobits

@Geobits, ups, nie zauważyłem tego. Dzięki.
Andrew Soutar,

6

Emacs Lisp 73 znaków

Najlepszy sposób na zapętlenie na zawsze? Cykliczna lista!

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

Ale czekaj, jest więcej!

? \ ^ D to dobry sposób na wstawienie znaku dla EOT, jednak gdybym tylko przesyłał plik, nie potrzebowałbym dosłownego „\ ^ D”, mógłbym po prostu wstawić znak „?” po którym następuje rzeczywisty znak EOT, co zmniejsza rzeczywistą liczbę potrzebnych znaków do: 63

Edytować

Pracowałem nad „żelem”, który nie jest jeszcze prawdziwym językiem, ale jest w zasadzie serią makr emacs lisp dla kodu golfa. W „żelu” byłoby to rozwiązanie:

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

i bez czekania:

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

44 znaki z ładnym wprowadzaniem postaci. Wyniósłby 34, gdyby nie przesłanie przez Internet.


6

Julia

Badając chwilę, znalazłem matematyczny sposób wyrażenia sekwencji za pomocą innych sekwencji bez użycia żadnej liczby (lub trudnych sposobów ich użycia):

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]

Wynik:

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

6

C ++

Ładny, czysty język, taki jak C ++, pozwala na uporządkowanie źródła w czysty i czytelny sposób, a jego zaletą jest łatwość ręcznego kopiowania przy minimalnej dwuznaczności.

Tutaj rozwiązanie jest osiągane tylko za pomocą cyfry 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


6

System (podstęp)

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

http://ideone.com/QBzuBC

Prawdopodobnie łamie to zasadę „nie koduj liczb w innych bazach”, ale myślę, że jest na tyle niejasne, że się nie liczy. Na dowód tej niejasności te dwie magiczne liczby w bazie 51 to:

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

Edycja : Ta sama sztuczka, inna reprezentacja. Właściwie to jeszcze mi się podoba, ponieważ nie zależy to od arbitralnie wybranej bazy. Wymaga to jednak implementacji schematu z obsługą nieskończonej dokładności dla kwadratowych irracjonalnych, które (AFAIK) nie istnieją. Możesz jednak zaimplementować to w matematyce.

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

Witamy na stronie =)
Riot

+1 dla „wymaga implementacji schematu z obsługą nieskończonej dokładności dla kwadratowych irracjonalnych, które (AFAIK) nie istnieją”.
Lyndon White

6

PHP

Myślałem, że nadszedł czas, aby ktoś przesłał odpowiedź php, nie najlepszą, ale i tak zabawną

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

Ahs to krzyki pasażerów podczas katastrofy samolotu


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;
}
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.