Eine unaussprechliche Zahl ist eine Zahl, die durch sieben teilbar ist oder sieben als eine ihrer Ziffern hat. Ein Kinderspiel ist es, unaussprechliche Zahlen zu zählen

1 2 3 4 5 6 ( ) 8 9 10 11 12 13 ( ) 15 16 ( ) 18 ...

Cantors Version des Spiels ist die Sequenz, die durch rekursives Einfügen der Sequenz "1 2 3 4 5 6 () 8 ..." in die obigen Lücken () definiert wird.

1 2 3 4 5 6 1 8 9 10 11 12 13 2 15 16 3 18 19 20 4 22 23 24 25 26 5 6 29 30 31 32 33 34 1 36 8 38 ...

Mindestens die ersten 7 ^ 7-Nummern von Cantors unaussprechlichem Zahlenspiel drucken / ausgeben ...

Während die Definition rekursiv angegeben wird, müssen Sie im Code keine Rekursion verwenden.

Das ist Code-Golf , also gewinnt das Programm mit der kürzesten Byteanzahl!

Hinweis: Die Summe der Zahlen in 1 bis 7 ^ 7 ist 203511962727. Die letzten 10 Zahlen in diesem Bereich sind 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Pastebin-Dump der ersten 1000 Iterationen: http://pastebin.com/Ksiu9Svf

Pyth , 25 23 22 Bytes

Danke an @Maltysen für -2 Bytes

.V1=+Y
?}7+PbjbT@Y~hZb

Ein Programm, das einen unendlichen Stream ausgibt.

Probieren Sie es online! (Ausgabe wird in Intervallen gespült und läuft nach 1 Minute ab)

Wie es funktioniert

.V1=+Y
?}7+PbjbT@Y~hZb

Z = 0, Y = []    Implicit variable assignment
.V1              Infinite incrementing for loop with variable b, starting at 1:
   =+Y            Y = Y +
(newline)          (Implicitly print the result of the following:)
?                   If
 }7                  7 is in
    Pb                the prime factorisation of b
   +                  or
      jbT             the digits of b:
         @Y            Index into Y at index
             Z          Z
           ~h          (Increment Z)
                    else:
              b      b

Python 2, 77 75 74 70 Bytes

Dank @MartinEnder für das Vorschlagen der Grenze von 9e5dem Ende _^r nach einer Änderung Arbeits d auf.
Vielen Dank an @mschauer für die Empfehlung eines unendlichen Streams, der 4 Bytes einspart.

def f(n=0):
 i=f()
 while 1:n+=1;yield next(i)if'7'in`n`or n%7<1else n

Dies ist ein Generator, der einen unendlichen Strom von Zahlen liefert.

Perl, 47 46 41 39 Bytes

5 Bytes dank @Dada gespart

say$_=$_%7*!/7/?$_:$a[$b++]for@a=1..1e6

Probieren Sie es online! TIO Nexus, jetzt mit Perl-Unterstützung! Dadurch wird die Ausgabe nach einem bestimmten Zeitpunkt abgeschnitten. Wenn Sie jedoch Perl installiert haben, können Sie es lokal ausführen, um die vollständige Ausgabe zu erhalten.

Der Code verwendet einige seltsame Macken der Perl-Syntax, daher werde ich im Folgenden auf die Funktionsweise eingehen.

Code-Aufschlüsselung:

say$_=$_%7*!/7/?$_:$a[$b++]for@a=1..1e6
                              @a=1..1e6 #Assign the range (1..1,000,000) to the array @a
                           for          #and then loop through this list, with $_ as an alias for the list member.  As an alias, modifying $_ modifies @a.
      $_%7*!/7/?$_:$a[$b++]             #Ternary operation
      $_%7                              #Returns the residue modulo 7...
          *!/7/                         #...and multiplies it by the negation of whether or not there exists a 7 $_
                                        #Since % and * have the same operator precedence, it must be evaluated in this order
                                        #otherwise we would get (!/7/*$_)%7 instead of ($_%7)*!/7/
               ?$_                      #If the result is non-zero (i.e. truthy), then return $_
                  :$a[$b++]             #Otherwise, return the $b-th element of @a, and increment $b
   $_=                                  #Reassign the result back to $_, modifying @a
say                                     #Prints the result of the assignment, separated by newlines

PHP, 80 (Wahooka) 57 54 Bytes

Während die Idee von Wahooka ist. Ich denke, meine Version ist anders genug, um eine eigene Antwort zu geben:

for(;;)echo$a[]=strpos(++$n,55)<-$n%7?"$n ":$a[+$b++];

Haskell, 67 66 Bytes

i#x|mod x 7<1||'7'`elem`show x=f!!i:(i+1)#(x+1)|y<-x+1=x:i#y
f=0#1

f ist eine unendliche Liste der Zahlen.

Probieren Sie es online!

fStartet eine neue Iteration mit 1und gibt einen Index an, für den eine Zahl von 0 ausgewählt werden soll. Wenn eine Lücke vorhanden ist, nehmen wir eine neue Iteration und wählen ihr ithElement aus und setzen die aktuelle Iteration mit fort i+1. Wenn es keine Lücke gibt, nehmen wir die aktuelle Zahl xund fahren fort, ohne zuzunehmen i.

Edit: -1 Byte dank @BMO.

MATL , 26 25 Bytes

9e5:`t7\yFYA!7-A*~s:2M(2M

Probieren Sie es online! wird durch 9e5ersetzt 9e4, damit die maximale Laufzeit und Ausgabegröße des Online-Compilers nicht überschritten wird.

Wie es funktioniert

Dies verwendet Iteration anstelle von Rekursion. (In der Tat hat MATL keine Rekursion).

Zuerst wird ein Array von Zahlen von 1bis 9e5generiert (dies reicht aus, weil es 9e5überschreitet 7^7). Dann Zahlen , die ein Vielfaches von sind 7oder haben 7als Ziffer identifiziert werden , und ersetzt durch 1, 2... Der Prozess wird wiederholt, bis es keine Zahlen, die ersetzt werden müssen.

9e5:       % Generate array of numbers [1 2 ... 9e5]. This array will become the
           % output, after some numbers have been replaced
`          % Do...while
  t        %   Duplicate the array of numbers
  7\       %   Modulo 7. Gives zero for multiples of 7
  y        %   Duplicate the array of numbers
  FYA!     %   Matrix of decimal digits, with a column for each number
  7-       %   Subtract 7 to each entry of that matrix
  A        %   Array that contains "true" for columns that only contain nonzeros;
           %   that is, for numbers that do not have 7 as digit 
  *        %   Multiply. This corresponds to a logical "and" of the two conditions.
           %   A zero indicates that the number at that index needs to be replaced
  ~        %   Logical negate. Each "true" corresponds to a number to be replaced
  s        %   Sum. This is the amount of numbers to be replaced, say n
  :        %   Push array [1 2 ... n]
  2M       %   Push array of logical values again
  (        %   Replace the numbers at the positions indicated by the logical array
           %   by the values [1 2 ... n]
  2M       %   Push n again. This is used as loop condition, so if it is nonzero
           %   the next iteration will be executed. Note that this executes one
           %   too many iterations: the exit condition is that no replacing has
           %   been needed in the current iteration; but then the current iteration 
           %   (which will be the last) was not really necessary. This does not
           %   matter; the last iteration is useless but also harmless
           % End do...while implicitly. Display implicitly

Tcl , 121 Bytes

Die triviale Lösung mit Endlosschleife, nichts Besonderes ..

set r 0;set n 0;while {[set r [expr $r+1]]} {if {![expr $r%7]||(7 in[split $r ""])} {puts [set n [expr $n+1]]} {puts $r}}

Ungolfed:

set r 0
set n 0
while {[set r [expr $r+1]]} {
  if {![expr $r % 7] || (7 in [split $r ""])} {
    puts [set n [expr $n+1]]
  } {
    puts $r
  }
}

PHP, 106 80 Bytes

Vielen Dank an Ismael Miguel für die Hilfe bei der ternären Lösung und der kürzeren Verwendung von Loop-Code für eine Weile.

Die letzten Teile der vollständigen Sequenz konnten aufgrund der maximalen Laufzeit von 30 Sekunden von PhpFiddle nicht überprüft werden. Scheint auf der Grundlage der vom OP bereitgestellten Beispielausgabe mindestens bis zu 1 KB zu funktionieren.

Golf:

for($n=1;;$n++)echo$a[]=!(strpos($n,"7")>-1||$n%7==0)?"$n ":array_shift($a)." ";

Original Golfversion :

$n=1;while(1){if(!(strpos($n,"7")>-1||$n%7==0)){echo$a[]=$n." ";}else{echo$a[]=array_shift($a)." ";}$n++;}

Julia, 62 Bytes

x=[];j=0;for i=1:7^7;x=[x;i%7<1||('7' in "$i")?x[j+=1]:i]end;x

Nichts Besonderes. Verwendet, dass die Sequenz innerhalb der Lücken die Sequenz selbst ist. Erstellt übermäßige Array-Kopien, um einige Bytes zu sparen.

Perl 6 ,  74 57 54  53 Bytes

sub u{my@u;(1..*).map: {if $_%%7||.comb('7') {@u||=u;@u.shift} else {$_}}}

sub u{(1..*).map: {$_%%7||.comb('7')??(@||=u).shift!!$_}}

sub u{map {$_%%7||.comb('7')??(@||=u).shift!!$_},1..*}

sub u{map {$_%%7||.comb(~7)??(@||=u).shift!!$_},1..*}

Versuch es

Erweitert:

sub u{
  map             # for each element transform using:

  { # bare block lambda with implicit parameter ｢$_｣

      $_ %% 7     # if it is divisible by 7
      ||          # or
      .comb(~7)   # contains the number 7 (implicit method call on ｢$_｣)

    ??            # then
      ( @ ||= u ) # store a new instance of the Seq into an unnamed state array if it is empty
                  # ( it is only empty the first time it is seen in this Seq instance )
      .shift      # pull one off of the front

    !!            # else
      $_          # return the value
  },

  1 .. *          # infinite range starting at one ( elements to be mapped over )
}

Prüfung:

$ time perl6 -e'sub u{map {$_%%7||.comb(~7)??(@||=u).shift!!$_},1..*};put 203511962727 == sum u()[^7**7]'
True

real    2m45.744s
user    2m45.416s
sys     0m0.212s

Ceylon, 202 Bytes

object u satisfies{Integer*}{iterator()=>object satisfies Iterator<Integer>{variable value i=0;late Iterator<Integer>n;next()=>if(++i%7<1||'7'in"``i``")then(i<8then(n=iterator())else n).next()else i;};}

Dies ist keine Funktion, sondern eine Objektdeklaration, die eine unendliche Folge (Iterable) implementiert. Das Objekt kann direkt gedruckt werden, print(u)gibt dies aus:

{ 1, 2, 3, 4, 5, 6, 1, 8, 9, 10, 11, 12, 13, 2, 15, 16, 3, 18, 19, 20, 4, 22, 23, 24, 25, 26, 5, 6, 29, 30, ... }

Verwenden Sie, um mehr zu drucken printAll(u). Der folgende Code verwendet Zeilenumbrüche und gibt auch die Summe (und die ersten 30 oben gezeigten Elemente) aus:

shared void run() {
    printAll(u.take(7^7), "\n");
    print(sum({0, * u.take(7^7)}));
    print(u);
}

Hier ist die ungolfed und kommentierte Version:

// Prints cantor's unspeakable numbers.
//
// Question:  http://codegolf.stackexchange.com/q/101231/2338
// My answer: http://codegolf.stackexchange.com/a/101297/2338

// this object u (which is like a singleton class with its single instance)
// implements the Iterable<Integer> interface.
object u satisfies {Integer*} {
    // That interface has just one formal method,
    // `shared formal Iterator<Integer> iterator()`.
    // Lets implement it by ...
    iterator()
    // ... providing for each call ...
            =>
                // ... a new (anonymous) object, which
                // implements the Iterator<Integer> interface.
                object satisfies Iterator<Integer> {
                    // This is the counter (the type `Integer`
                    // is longer than `value`, so we infer it).
                    // We start at 0.
                    variable value i = 0;
                    // This is a nested Iterator. It will be
                    // initialized when first needed, so we don't
                    // get an endless recursion when creating the
                    // first iterator.
                    late Iterator<Integer> n;
                    // `shared formal Integer next()` is the single method
                    // of Iterator which needs to be implemented.
                    next()
                    // each time it is called, the following
                    // expression will be evaluated.
                            =>
                                // increment the counter, then check if it
                                // is an unspeakable number.
                                if (++i % 7 < 1 || '7' in "``i``")
                                then
                                    // if so, take the nested iterator (and the
                                    //  first time, for i == 7, create it first),
                                    // and take its next element.
                                    (i < 8 then (n = iterator()) else n).next()
                                else
                                    // otherwise, just return i.
                                    i;
                };
}

Ruby, 80 Bytes

l=->x{x%7==0||x.to_s[/7/]};a=(1..100);b=a.reject &l p a.map{|x|!l[x]?x:b.shift}

Erste Einreichung, ich bin sicher, es kann verbessert werden :)

Dyalog APL , 39 Bytes

{(⍵⍴⍨⍴i)@(i←⍸('7'∊¨⍕¨⍵)∨0=7|⍵)⊢⍵}⍣≡⍳7*7

⍳7*7ist 1 2 3 ... 7 ⁷

{ }⍣≡ist der Festpunktoperator - Wenden Sie eine Funktion so oft an, bis sich das Ergebnis stabilisiert

A@I⊢B Operator ändern - Ersetzen Sie die Elemente bei Indizes Iin BmitA

0=7|⍵ Bitmaske für den Fall, dass das Argument durch 7 teilbar ist

'7'∊¨⍕¨⍵ Bitmaske, bei der die Dezimalformatierung des Arguments eine 7 enthält

∨ oder

⍸ Bei welchen Indizes ist eine der obigen Bitmasken wahr?

i← zuweisen i

⍵⍴⍨⍴i Verändern Sie das Argument in die Anzahl der Elemente in i

C 157 155 Bytes

int c[999999],r;main(_,p){if(_){p=--_;c[_]=1;for(;;){printf("%d ",c[_]);main(0,++_+1);c[_]=r?_+1:c[p++];}}else!p?r=1:p%7?p%10-7?main(0,p/10):(r=0):(r=0);}

Es sieht richtig aus, ich habe mich nicht darum gekümmert, alles zu überprüfen. Geht bis zu 999999, was anscheinend groß genug ist.

Ungolfed-Version:

int cantor_n[1000000];

int cantor_n_safe(int x) {
    if (!x) return 1;
    if (x % 7 == 0) return 0;
    if (x % 10 == 7) return 0;
    return cantor_n_safe(x / 10);
}

int main(_, prev_index) {
    prev_index = --_;
    cantor_n[_] = 1;
    for(;;) {
        printf("%d ", cantor_n[_]);
        _++;
        if (!cantor_n_safe(_+1)) {
            cantor_n[_] = cantor_n[prev_index++];
        } else {
            cantor_n[_] = _+1;
        }
    }
    return 0;
}

Teilgolf-Version:

int c[999999];int r;
safe(x){ 
    !x?
        r=1:
        x%7?
            x%10-7?
                safe(x/10):
                (r=0):
            (r=0);
}

main(_){
    int p;
    p=--_;
    c[_]=1;
    for(;;){
        printf("%d ",c[_]);
        safe(++_+1);
        if (!r) {
            c[_]=c[p++];
        } else {
            c[_]=_+1;
        }
    }
}

R, 86 Bytes

x=1;while(T<7^7){T=T+1;x[T]=if(!T%%7|7%in%el(strsplit(c(T,""),""))){F=F+1;x[F]}else T}

Verwendet Rs Truthy T(initialisiert auf TRUE/ 1), um die Zahlen in der Sequenz zu zählen, und den Falsy-Wert F(initialisiert auf FALSE/ 0), um die unspeakables zu zählen. Ansonsten prüft das Programm einfach, ob jede Zahl durch sieben teilbar ist oder die Zahl enthält.

C - 115 Bytes

s[99],r;g(x){return x%10-7&&(!x||g(x/10));};f(i){(r=++s[i])%7&&g(r)||f(i+1);}main(){for(;;f(0),printf("%d\n",r));}

EDIT: Danke an @mschauer, der darauf hingewiesen hat, dass ich einige Dinge verpasst habe.

Javascript, 80 Bytes

n=[]
r=l=>(m=n[l]=++n[l]||1,!/7/.test(m)m%7?m:r(l+1))
for(;;)console.log(r(0))

Da es nur minimale, aber keine maximalen Anforderungen gibt, wird diese Lösung weiterhin auf unbestimmte Zeit ausgegeben.

Um zu überprüfen, ob der Algorithmus korrekt ist, können Sie denselben Code ausführen und nur die letzten 10 Zahlen und die Summe drucken:

n = []
r = l => (m = n[l] = ++n[l] || 1, !/7/.test(m) && m % 7 ? m : r(l + 1))
var tot = 0
for (i = 0; i + 1; i++) {
    v = r(0)
    tot += v
        if (i > Math.pow(7, 7) - 11) {
        console.log(v)
    }
    if (i === Math.pow(7, 7) - 1) {
        console.log(tot)
        break
    }
}

Mathematica, 82 Bytes

Nest[#2&[i=1,If[Or@@(#==7&)/@IntegerDigits@#,i++,#]&/@#]&,Table[i,{i,7^7}],20]

JavaScript 81 Bytes

Original (98 Bytes)

for(c=0,i=1;i<=Math.pow(7,7);i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,console.log(c)):console.log(i);

Golf gespielt

p=console.log;for(c=0,i=1;i<9e5;i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,p(c)):p(i);

Befunge, 100 oder 156 Bytes

Diese erste Version ist die portablere der beiden und beschränkt sich auf 7-Bit-Speicherzellen, die Sie im Referenzinterpreter erhalten.

"O":0>\#09#:p#-:#1_v<0$.< 
9\*"~"g9+1:+1::p00:<+3$_^#g01$$<v"~":/"~"p9g00%"~"::+1+g9\*"~"+g
:#15#+5#g+#0%#17#\-#/!#+\#5:#5_^>%00g1+9p"~"/00g2+9p::7%!10>>p#0

Die zweite Version funktioniert nur mit Interpretern, die 32-Bit-Speicherzellen haben, und ist daher nicht der Standard für Befunge. Dadurch können wir jedoch größere Werte im Speicher speichern, ohne sie auf mehrere Zellen aufteilen zu müssen.

"O":0>\#09#:p#-:#1_v<0$.< 
%7::p9g00:+1g9:p00:<+1$_^#g01$$<v01!
:#15#+5#g+#0%#17#\-#/!#+\#5:#5_^>p#0

In beiden Fällen wird das Programm auf unbestimmte Zeit ausgeführt, aber die erste Version überschreitet die 2-Millionen-Marke, während die zweite Version den maximalen int-Wert (ca. 2 Milliarden) erreichen sollte.

Sie können es online testen , aber Sie müssen den Prozess beenden, um zu verhindern, dass er für immer ausgeführt wird.

Clojure, 130 Bytes

#(let[R(range(inc %))](rest((reduce(fn[[r s]i](if(or(=(mod i 7)0)((set(str i))\7))[(assoc r i(r s))(inc s)][r s]))[(vec R)0]R)0)))

Grundlegendes Reduzieren, Verfolgen des Inhalts des Ergebnisvektors und Überspringen von Werten. Das letzte 0nimmt das erste Element des reduzierten [r s], restlöscht das erste Element des 0-indizierten Ergebnisses.

Perl6, 41 Bytes

put {($_=++$)%%7|m/7/??@_[$++]!!$_}…1e6

Tcl , 64 Bytes

while 1 {puts [expr {[incr i]%7&&7ni[split $i ""]?$i:[incr s]}]}

Probieren Sie es online!

JavaScript, 64 Byte

for(f=n=>!/7/.test(m=++n[0])*m%7?m:f(n.t=n.t||[0]);;)alert(f(f))

output=[];index=0;for(f=n=>!/7/.test(m=++n[0])*m%7?m:f(n.t=n.t||[0]);index<100;)output[index++]=f(f);console.log(output.join(','))

Japt , 25 Bytes

[]L³õ@pX%7«/7/tX ?X:UgV°

Testen Sie die Summe und die letzten 10 Elemente.

Erzeugt die ersten 1.000.000 Einträge der Sequenz und druckt sie aus. Eine Million ist die kürzeste Zahl 7**7 == 823543in Japt.

Der abschließende Zeilenumbruch ist signifikant, da er die implizite Zuordnung zu aktiviert U.

Das Generieren der Liste dauert nur etwa eine Sekunde, aber das Ausgeben des gesamten Arrays lässt Ihren Browser wahrscheinlich hängen.

Ausgepackt und wie es funktioniert

[]L³õX{UpX%7&&!/7/tX ?X:UgV++

[]                            Assign empty array to U
  L³õX{                       Map over 1 to 1,000,000 inclusive...
         X%7&&                  If X is not divisible by 7 and
              !/7/tX            X does not have a digit 7
                     ?X:UgV++   then X, otherwise the next element already in U
       Up                       Push it to the end of U

                              Implicit print U

Verwendet die Eigenschaft, dass die rekursive Definition aufgelöst werden kann, indem die bereits generierte Sequenz betrachtet wird.