캔터의 말할 수없는 숫자


58

말할 수없는 숫자는 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 숫자 이상을 인쇄 / 출력하십시오 ...

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

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

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

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


8
솔루션을 확인할 수 있도록 해당 시퀀스의 처음 7 ^ 7 번호를 제공하십시오.
flawr


2
누군가 더 많은 숫자를 생성하고 결과를 비교하려는 경우 : 시퀀스의 첫 7 ^ 77 숫자의 합은 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.

물론, 그 순서에서 1의 수는 22977입니다. 즉, 처음 7 ^ 77에서 무작위로 요소를 무작위로 골라내는 경우 1
Niklas B

1
관심이 있으시다면 여기에 반복되는 숫자의 증가를 보여주는 그래프가 있습니다 : drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

답변:


6

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

1
23 바이트 . 그것은 cuz 7가 소수입니다. 따라서 다른 수표와 잘 맞는 소인수 분해를 통해
나눌 수

당신은 그것의 주요 부분을 게시 할 수 있습니다
Maltysen

1
이 콘테스트를 수상한 것을 축하합니다. 나는 또한 @ Maltysen의 트릭을 좋아합니다!
mschauer

23

파이썬 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

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


상한을 완전히 제거 할 수 없습니까?
mschauer

@ mschauer 고마워요.
PurkkaKoodari

if n%7<1or'7'in`n`else nn%7<1문자열을 확인하는 것보다 빠르며 or단락 되기 때문에 약간 더 빠를 수 있습니다 (동일 바이트 수) . yield[n,next(i)][n%7<1or'7'in`n`]작동하지 않는 것이 너무 나쁩니다 .
mbomb007

@ mbomb007 속도가 문제라고 생각하지 않지만 감사합니다. :)
PurkkaKoodari

10

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

1
say$a[@a]=$_=...내가 실수하지 않으면 2 바이트를 이길 수 있습니다.
Dada

@Dada는 실제로 할당 할 필요가 없으므로 $_5 바이트를 절약합니다. 감사!
가브리엘 베 나미

1
오, 실로, 나는 단지 빠른 모습을 보았고 그 중간에 그 임무를 알아 차리지 못했습니다. 좋은 직업 :)
Dada

"Perl은 쓰기 전용 언어가 될 수 있습니다"라는 문장을 이해 한 것은 지금이 순간뿐입니다.
haneefmubarak

@Grimy 다른 코드를 편집하지 마십시오. 답변을 향상 시키려면 개선 사항을 포함하여 의견을 추가하거나 자신의 답변을 게시하십시오. 당신은 아마 의견으로 OP에 도달하지 않을 것이므로 자신의 답변을 게시하십시오.
ovs

5

PHP, 80 (와후 카) 57 54 바이트

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

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

5

하스켈, 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 바이트.


4

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

3

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

사용할 수 있습니다 incr. TCL과 버전> = 8.6, 만약 incr첫번째 반복에게의 증가 가정 새로운 로부터 변수 01그 변수가 전에 설정되어 있지 않은 경우; 처음 두 set명령을 제거 할 수 있습니다 .
sergiol

나에게 골프를 쳤다 – 나는 필요없는 공백도 제거했다.
sergiol

내가 당신을 위해 내 골프의 제안을 게시 한 사이트를 잃은, 그래서 만들어 내 새 응답
sergiol

3

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

1
for($n=1;;$n++)echo$a[]=!(strpos($n,7)>-1||$n%7==0)?"$n ":array_shift($a)." ";바이트 수를 모르지만 106 바이트보다 훨씬 낮습니다. 사용 해보고 작동하는지 확인하십시오.
Ismael Miguel

도움을 주셔서 감사합니다. 코드의 유일한 수정은 처음 7을 인용하여 두 바이트를 78 바이트 버전에 추가하는 것입니다.
Wahooka

을 수행하여 3 바이트를 절약 할 수 있습니다 for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. 나는 당신이 대체 할 수 있는지 확실하지 않습니다 $n%7==0와 함께 !$n%7하지만 해볼만 한 가치는있다.
Ismael Miguel

1
계속 -6 : $ n = 0은 쓸모가 없습니다. "7"은 7 일 수 있습니다.
Crypto

1
왜 교대? for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 바이트). ++$b-1왜냐하면$a[null] === null
Christoph

3

줄리아, 62 바이트

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

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


3

펄 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

~7대신 말하여 바이트를 절약 할 수있는 것 같습니다 '7'.
Sean

2

실론, 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;
                };
}

2

루비, 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}

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


1
PPCG에 오신 것을 환영합니다! 이것은 7 ^ 7 (즉, 823543)까지 올라가고 숫자 7, 즉 17 을 포함하는 숫자를 설명 합니까?
ETHproductions

확실하지 않았다. 지금 수정했습니다. 그 문제가 너무 쉽다고 생각했습니다 :)
Christopher Lates

훌륭하지만 아직 자격이 있는지 확실하지 않습니다. 뒤에 나오는 숫자 34는 ( 8현재는)이어야 7하지만 7말할 수없는 숫자이므로 프로그램은 세 번째 반복을 시작하고 대신 인쇄해야 1합니다.
ETHproductions

2

Dyalog APL , 39 바이트

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

⍳7*71 2 3 ... 7 7

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

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

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

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

또는

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

i← 할당하다 i

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


이거 좋은데. mask7 * 7에 비트 마스크를 곱하고 시퀀스에서 0을 수정하는 고정 점을 취하면 도움이됩니까?
mschauer

2

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

후에 중괄호가 필요 else합니까?
Zacharý

고마워요 또한 기술적으로 (r=0)대부분의 경우 중괄호가 필요하지 않습니다 . 그러나 일부 컴파일러는 까다 롭습니다. 사양을 확인하기에는 너무 게으르다.
LambdaBeta

2

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로 나눌 수 있는지 또는 숫자를 포함하는지 확인합니다.


-4 바이트 대체 7%in%el(strsplit(c(T,""),""))에 의해 55%in%utf8ToInt(paste(T))? (테스트되지 않음)
JayCe

2

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 덕분에 몇 가지를 놓쳤다는 것을 지적했습니다.


좋은 접근법. 두 가지 말. r % 10-7은 마지막 7 개만 캡처하고 힙을 손상시키지 않습니다. 스택 깊이는 다 항적으로 증가합니다 ... s [99]는 안전합니다.
mschauer

2

자바 스크립트, 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
    }
}

SyntaxError : missing) in
parhetical


1

자바 스크립트 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);

사이트에 오신 것을 환영합니다! 나는 자바 스크립트에 대해 많이 모르지만 다음과 같은 것을 할 수 p=console.log;for(c=0,i=1;i<=Math.pow(7,7);i++)/7/.test(i)||i%7==0?(6==c?c=1:c++,p(c)):p(i);있습니까?
DJMcMayhem

@DrMcMoylex 덕분에 몇 바이트 더 줄었습니다. 여전히 개선의 여지가 있는지 의심의 여지가 없습니다.
Richard Sime

기꺼이 도와 드리겠습니다! 내가 방금 깨달은 또 다른 것은 도전이 다음과 같이 말한 이후에 9e5대신 할 수 있다는 것입니다 Math.pow(7,7).Print/output AT LEAST the first 7^7
DJMcMayhem

네, 닥터 닥! 이것은 나도 비교 연산자에서 등호를 버릴 수있게했습니다.
Richard Sime

예상대로 작동하지 않는 것 같습니다. 간격을 채울 때 카운터를 재설정하는 대신 규칙을 다시 적용해야합니다 (시퀀스의이 부분 참조 :) 34 1 36 **8** 38. 그러나 가치가있는 것을 위해 현재 버전은 더 골프화 될 수 있습니다 for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld

1

펀칭, 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 억)에 도달해야합니다.

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


1

클로저, 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 인덱싱 결과의 첫 번째 요소를 삭제.


1

Perl6, 41 바이트

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


1

자바 스크립트, 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(','))


PS는 다른 몇 가지 (비교 대상 console.log은 70 바이트의) 자바 스크립트 답변
l4m2

1

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

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

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.