Angka yang tak terkatakan adalah angka yang dapat dibagi oleh tujuh atau memiliki tujuh sebagai salah satu digit. Gim anak-anak adalah untuk menghitung lompatan angka yang tak terkatakan

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

Versi permainan dari Cantor adalah urutan yang ditentukan dengan secara berulang mengisi urutan "1 2 3 4 5 6 () 8 ..." ke dalam celah () di atas.

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

Cetak / hasilkan setidaknya 7 ^ 7 angka pertama dari permainan angka Cantor yang tak terkatakan ...

Meskipun definisi diberikan secara rekursif, Anda tidak wajib menggunakan rekursi dalam kode.

Ini adalah kode-golf , sehingga program dengan jumlah byte terpendek akan menang!

Catatan: Jumlah angka dalam 1 hingga 7 ^ 7 adalah 203511962727. 10 angka terakhir dalam kisaran itu adalah 823534 823535 221563 108068 823538 823539 823540 823540 823542 823542 221565.

Dump pastebin dari 1000 iterates pertama: http://pastebin.com/Ksiu9Svf

Pyth , 25 23 22 byte

Berkat @Maltysen untuk -2 byte

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

Program yang mencetak aliran tanpa batas.

Cobalah online! (Output memerah pada interval dan waktu habis pada 1 menit)

Bagaimana itu bekerja

.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 byte

Berkat @MartinEnder untuk menyarankan batas 9e5yang ende _^r d up kerja setelah perubahan.
Terima kasih kepada @mschauer karena menyarankan aliran tanpa batas, menghemat 4 byte.

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

Ini adalah generator yang menghasilkan aliran angka yang tak terbatas.

Perl, 47 46 41 39 byte

Disimpan 5 byte berkat @Dada

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

Cobalah secara Online! TIO Nexus, sekarang dengan dukungan Perl! Ini akan memotong output setelah titik tertentu, tetapi jika Anda telah menginstal Perl, Anda dapat menjalankannya secara lokal untuk menghasilkan output penuh.

Kode menggunakan beberapa quirks aneh sintaks Perl, jadi saya akan memecah cara kerjanya di bawah ini.

Rincian kode:

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 byte

Sedangkan idenya adalah dari Wahooka. Saya pikir versi saya cukup berbeda untuk membuatnya menjadi jawaban sendiri:

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

Haskell, 67 66 byte

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 adalah daftar angka yang tak terbatas.

Cobalah online!

fmemulai iterasi baru dengan 1dan indeks yang angka untuk memilih 0. Setiap kali ada kesenjangan kita mengambil iterasi baru pilih ithelemen itu dan melanjutkan iterasi saat ini dengan i+1. Jika tidak ada kesenjangan, kami mengambil nomor saat ini xdan melanjutkan tanpa meningkat i.

Sunting: -1 byte terima kasih kepada @BMO.

MATL , 26 25 byte

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

Cobalah online! dengan 9e5diganti oleh 9e4, sehingga waktu berjalan maksimum dan ukuran output dari kompiler online tidak terlampaui.

Bagaimana itu bekerja

Ini menggunakan iterasi bukan rekursi. (Faktanya, MATL tidak memiliki rekursi).

Array angka dari 1ke 9e5pertama kali dihasilkan (ini sudah cukup, karena 9e5melebihi 7^7). Kemudian, angka yang merupakan kelipatan dari 7atau memiliki 7sebagai digit diidentifikasi, dan digantikan oleh 1, 2, ... Proses ini iterasi sampai tidak ada nomor yang perlu diganti.

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

Solusi sepele menggunakan loop tak terbatas, tidak ada yang mewah ..

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

Tidak Disatukan:

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 byte

Terima kasih Ismael Miguel untuk bantuan dengan solusi ternary dan menggunakan kode loop yang lebih pendek untuk sementara.

Tidak dapat memverifikasi bagian terakhir dari urutan penuh karena runtime maks 30 detik PhpFiddle. Tampaknya bekerja setidaknya hingga 1K berdasarkan pada sampel sampel yang disediakan oleh OP.

Golf:

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

Versi golf asli :

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

Julia, 62 byte

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

Tidak ada yang mewah. Menggunakan bahwa urutan dalam celah adalah urutan itu sendiri. Membuat salinan array berlebihan untuk menyimpan beberapa byte.

Perl 6 ,  74 57 54  53 byte

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..*}

Cobalah

Diperluas:

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

Uji:

$ 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 byte

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

Ini bukan fungsi, tetapi deklarasi objek yang menerapkan urutan infinite (Iterable). Objek dapat dicetak langsung, print(u)menghasilkan ini:

{ 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, ... }

Untuk mencetak lebih banyak, gunakan printAll(u). Kode berikut menggunakan baris baru, dan juga mencetak jumlah (dan 30 elemen pertama yang ditunjukkan di atas):

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

Ini adalah versi yang tidak diklik dan dikomentari:

// 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 byte

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}

Pengajuan pertama, saya yakin ini bisa ditingkatkan :)

Dyalog APL , 39 byte

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

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

{ }⍣≡adalah operator titik tetap - menerapkan fungsi berulang kali hingga hasilnya stabil

A@I⊢B mengubah Operator - menggantikan elemen di indeks Idi BdenganA

0=7|⍵ bitmask untuk tempat argumen habis dibagi 7

'7'∊¨⍕¨⍵ bitmask untuk tempat format desimal argumen berisi 7

∨ atau

⍸ pada indeks apa salah satu dari bitmasks di atas benar?

i← menetapkan ke i

⍵⍴⍨⍴i membentuk kembali argumen ke sejumlah elemen di 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);}

Kelihatannya benar, saya tidak repot-repot memeriksa sepenuhnya. Naik hingga 999999 yang tampaknya cukup besar.

Versi tidak disatukan:

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

Versi yang sebagian golf:

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 byte

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}

Menggunakan R's Truthy built-in T(diinisialisasi ke TRUE/ 1) untuk menghitung angka dalam urutan dan nilai Falsy F(diinisialisasi ke FALSE/ 0) untuk menghitung yang tak terkatakan. Selain itu, program ini hanya memeriksa apakah setiap angka dapat dibagi oleh tujuh atau berisi nomor.

C - 115 byte

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: Terima kasih kepada @mschauer yang menunjukkan bahwa saya melewatkan beberapa hal.

Javascript, 80 byte

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

Karena hanya ada persyaratan minimum tetapi bukan persyaratan maksimum, solusi ini terus menghasilkan tanpa batas waktu.

Untuk memverifikasi bahwa algoritme itu benar, Anda dapat menjalankan pencetakan kode yang sama hanya dengan 10 angka terakhir dan jumlahnya:

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 byte

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

JavaScript 81 byte

Asli (98 byte)

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

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 atau 156 byte

Versi pertama ini adalah yang lebih portabel dari keduanya, membatasi dirinya pada sel memori 7-bit, yang adalah apa yang Anda dapatkan dalam penerjemah referensi.

"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

Versi kedua hanya bekerja dengan interpreter yang memiliki sel memori 32-bit, dan karenanya Befunge tidak sepenuhnya standar, tetapi itu memungkinkan kita menyimpan nilai yang lebih besar dalam memori tanpa harus membaginya di sel.

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

Dalam kedua kasus program berjalan tanpa batas, tetapi versi pertama akan meluap sekitar tanda 2 juta, sedangkan versi kedua harus mencapai nilai maksimum int (sekitar 2 miliar).

Anda dapat mencobanya secara online , tetapi Anda harus mematikan proses untuk mencegahnya agar tidak berjalan selamanya.

Clojure, 130 byte

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

Basic kurangi, catat konten vektor hasil dan berapa banyak nilai yang dilewati. Yang terakhir 0mengambil elemen pertama dari pengurangan [r s], restmenjatuhkan elemen pertama dari hasil 0-diindeks.

Perl6, 41 byte

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

Tcl , 64 byte

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

Cobalah 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 byte

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

Uji jumlah dan 10 elemen terakhir.

Menghasilkan 1.000.000 entri pertama dari urutan dan mencetaknya. Satu juta adalah angka terpendek 7**7 == 823543di Japt.

Trailing newline signifikan, karena mengaktifkan penugasan implisit untuk U.

Membuat daftar hanya membutuhkan waktu sekitar satu detik, tetapi mengeluarkan seluruh array kemungkinan akan membuat browser Anda hang.

Dibongkar & Cara kerjanya

[]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

Menggunakan properti yang definisi rekursif dapat diselesaikan dengan melihat urutan yang sudah dibuat.