말할 수없는 숫자는 7로 나눌 수 있거나 7을 숫자 중 하나로 갖는 숫자입니다. 어린이 게임은 말할 수없는 숫자를 건너 뛰는 것을 세는 것입니다.

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

Cantor 버전의 게임은 "1 2 3 4 5 6 () 8 ..."시퀀스를 위의 간격 ()에 재귀 적으로 채워서 정의한 시퀀스입니다.

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

Cantor의 말할 수없는 숫자 게임의 첫 7 ^ 7 숫자 이상을 인쇄 / 출력하십시오 ...

정의는 재귀 적으로 제공되지만 코드에서 재귀를 사용할 의무는 없습니다.

이것은 code-golf 이므로 가장 짧은 바이트 수를 가진 프로그램이 승리합니다!

참고 : 1 ~ 7 ^ 7의 숫자의 합은 203511962727입니다. 해당 범위의 마지막 10 개 숫자는 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565입니다.

처음 1000 번의 Pastebin 덤프 : http://pastebin.com/Ksiu9Svf

Pyth , 25 23 22 바이트

-2 바이트에 대한 @Maltysen 덕분에

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

무한 스트림을 인쇄하는 프로그램입니다.

온라인으로 사용해보십시오! (간격으로 출력이 플러시되고 1 분에 시간이 초과 됨)

작동 원리

.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

파이썬 2, 77 75 74 70 바이트

감사 한계 제안한 @MartinEnder하는 9e5엔데에있는 _^R은 변경 후 작업을 닫 거라고.
무한 스트림을 제안하여 4 바이트를 절약 한 @mschauer에게 감사드립니다.

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

이것은 무한한 수의 스트림을 생성하는 생성기입니다.

Perl, 47 46 41 39 바이트

@Dada 덕분에 5 바이트 절약

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

온라인으로 사용해보십시오! Perl을 지원하는 TIO Nexus! 특정 지점 이후에 출력이 잘리지 만 Perl을 설치 한 경우 로컬로 실행하여 전체 출력을 생성 할 수 있습니다.

이 코드는 Perl 구문의 이상한 두 가지 단점을 사용하므로 아래에서 작동 방식을 자세히 살펴 보겠습니다.

코드 분석 :

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 (와후 카) 57 54 바이트

아이디어는 Wahooka에서 온 것입니다. 내 버전이 자체 답변이 될만큼 충분히 다르다고 생각합니다.

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

하스켈, 67 66 바이트

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 숫자의 무한 목록입니다.

온라인으로 사용해보십시오!

f와 새로운 반복을 시작 1하고 우리는 새로운 반복으로 데리고 그것의 선택 간격있을 때마다 인덱스는 숫자 0의 선택하는 ith요소와 현재 반복을 계속 i+1. 간격이 없으면 현재 숫자를 가져 와서 x증가시키지 않고 진행합니다 i.

편집 : @ BMO 덕분에 -1 바이트.

MATL , 26 25 바이트

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

온라인으로 사용해보십시오! 에 9e5의해 교체 9e4시간과 온라인 컴파일러의 출력 크기를 실행하는 최대를 초과하지 않도록.

작동 원리

재귀 대신 반복을 사용합니다. 실제로 MATL에는 재귀가 없습니다.

에서 1까지 의 숫자 배열 9e5이 먼저 생성됩니다 ( 9e5초과하면 되므로 충분합니다 7^7). 그런 다음,의 배수 인 숫자 7또는이 7숫자로는 식별 및로 대체 1, 2교체 할 필요가없는 번호가 없을 때까지 ...이 과정이 반복된다.

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 바이트

무한 루프를 사용하는 사소한 해결책.

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

언 골프 드 :

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 바이트

삼항 솔루션에 대한 도움과 잠시 동안 대신 사용하는 짧은 루프 코드에 대해 Ismael Miguel에게 감사드립니다.

PhpFiddle의 30 초 최대 런타임으로 인해 전체 시퀀스의 마지막 부분을 확인할 수 없습니다. OP에서 제공하는 샘플 출력에 따라 최대 1K까지 작동하는 것 같습니다.

골프:

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

오리지널 골프 버전 :

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

줄리아, 62 바이트

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

멋진 것은 없습니다. 간격 내의 시퀀스가 ​​시퀀스 자체임을 사용합니다. 일부 바이트를 저장하기 위해 과도한 배열 사본을 만듭니다.

펄 6 ,  74 57 54  53 바이트

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

시도 해봐

넓히는:

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

테스트:

$ 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

실론, 202 바이트

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

이것은 함수가 아니라 무한 시퀀스 (Iterable)를 구현하는 객체 선언입니다. 객체를 직접 인쇄하여 다음을 print(u)출력 할 수 있습니다 .

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

더 인쇄하려면을 사용하십시오 printAll(u). 다음 코드는 줄 바꿈을 사용하고 합계와 위에 표시된 처음 30 개 요소를 인쇄합니다.

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

ungolfed 및 주석이 달린 버전은 다음과 같습니다.

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

루비, 80 바이트

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}

첫 제출, 나는 그것이 향상 될 수 있다고 확신합니다 :)

Dyalog APL , 39 바이트

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

⍳7*71 2 3 ... 7 ⁷

{ }⍣≡는 IS 고정 소수점 연산자 - 결과가 안정 될 때까지 반복하는 기능을 적용

A@I⊢B 개정 연산자 - 인덱스의 요소를 교체 I에서 B와A

0=7|⍵ 인수를 7로 나눌 수있는 비트 마스크

'7'∊¨⍕¨⍵ 인수의 십진 형식화에 7이 포함 된 비트 마스크

∨ 또는

⍸ 위의 비트 마스크 중 어느 인덱스가 참입니까?

i← 할당하다 i

⍵⍴⍨⍴i 인수를 요소 수로 변경 i

C 157155 바이트

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

옳아 보인다, 나는 완전히 확인하는 것을 귀찮게하지 않았다. 충분히 큰 999999까지 올라갑니다.

언 골프 버전 :

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

부분적으로 골프 버전 :

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 바이트

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}

R의 Truthy 내장 T( TRUE/로 초기화 됨 1)을 사용하여 시퀀스의 숫자를 계산하고 Falsy 값 F( FALSE/로 초기화 됨 0)을 사용하여 말할 수없는 수를 계산합니다. 그 외에 프로그램은 단순히 각 숫자를 7로 나눌 수 있는지 또는 숫자를 포함하는지 확인합니다.

C-115 바이트

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

편집 : @mschauer 덕분에 몇 가지를 놓쳤다는 것을 지적했습니다.

자바 스크립트, 80 바이트

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

최소 요구 사항 만 있지만 최대 요구 사항은 아니기 때문에이 솔루션은 계속 무한정 출력됩니다.

알고리즘이 올바른지 확인하려면 마지막 10 개의 숫자와 합계 만 인쇄하는 동일한 코드를 실행할 수 있습니다.

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

수학, 82 바이트

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

자바 스크립트 81 바이트

원본 (98 바이트)

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

골프

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

펀칭, 100 또는 156 바이트

이 첫 번째 버전은 두 가지 중 더 이식성이 뛰어나 7 비트 메모리 셀로 제한되며 이는 참조 인터프리터에서 얻는 것입니다.

"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

두 번째 버전은 32 비트 메모리 셀이있는 인터프리터에서만 작동하므로 표준 Befunge는 아니지만 셀을 통해 분할하지 않고도 더 큰 값을 메모리에 저장할 수 있습니다.

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

두 경우 모두 프로그램은 무기한으로 실행되지만 첫 번째 버전은 약 2 백만 마크가 넘치며 두 번째 버전은 최대 int 값 (약 20 억)에 도달해야합니다.

온라인으로 시도 할 수 있지만 프로세스가 영원히 실행되지 않도록 프로세스를 종료해야합니다.

클로저, 130 바이트

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

기본 감소, 결과 벡터의 내용 및 건너 뛴 값 수를 추적합니다. 마지막으로는 0감소 제의 요소를 가져 [r s], rest0 인덱싱 결과의 첫 번째 요소를 삭제.

Perl6, 41 바이트

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

Tcl , 64 바이트

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

온라인으로 사용해보십시오!

자바 스크립트, 64 바이트

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 바이트

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

합계 와 마지막 10 개 요소를 테스트하십시오 .

시퀀스의 처음 1,000,000 개 항목을 생성하고 인쇄합니다. 7**7 == 823543Japt에서 가장 짧은 숫자는 백만입니다 .

후행 줄 바꿈은에 대한 암시 적 할당을 활성화하므로 중요합니다 U.

목록을 생성하는 데 약 1 초 정도 걸리지 만 전체 배열을 출력하면 브라우저가 중단 될 수 있습니다.

포장 풀기 및 작동 방식

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

이미 생성 된 시퀀스를보고 재귀 정의를 확인할 수있는 속성을 사용합니다.