Niewymowne liczby Cantora

58

Niewypowiedziana liczba to liczba, która jest podzielna przez siedem lub ma siedem jako jedną z jej cyfr. Gra dla dzieci polega na pomijaniu niewypowiedzianych liczb

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

Wersja gry Cantora to sekwencja zdefiniowana przez rekurencyjne wypełnianie sekwencji „1 2 3 4 5 6 () 8 ...” w powyższych lukach ().

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

Wydrukuj / wydrukuj przynajmniej pierwsze 7 ^ 7 liczb nieopisanej gry liczbowej Cantora ...

Chociaż definicja jest podana rekurencyjnie, nie ma obowiązku używania rekurencji w kodzie.

To jest , więc wygrywa program z najkrótszą liczbą bajtów!

Uwaga: Suma liczb od 1 do 7 ^ 7 wynosi 203511962727. Ostatnie 10 liczb w tym zakresie to 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Zrzut zrzutu 1000 pierwszych iteracji: http://pastebin.com/Ksiu9Svf

mschauer
źródło
8
Podaj pierwsze 7 ^ 7 liczb tej sekwencji, abyśmy mogli sprawdzić nasze rozwiązania.
flawr
2
Powiązane
Adnan
2
W przypadku, gdy ktoś chce generować jeszcze kilka numerów i porównać wyniki: Suma pierwszych 7 ^ 77 liczb w kolejności jest 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.
Jasne, liczba 1 w tej sekwencji wynosi 22977, co oznacza, że ​​jeśli wybierzesz losowo element z pierwszych 7 ^ 77 równomiernie, masz szansę 2 * 10 ^ -61 na 1
Niklas B.
1
Jeśli jesteś zainteresowany, oto wykres pokazujący wzrost liczby powtarzających się: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/...
Niklas B.,

Odpowiedzi:

6

Pyth , 25 23 22 bajtów

Dzięki @Maltysen za -2 bajty

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

Program, który drukuje nieskończony strumień.

Wypróbuj online! (Wydajność jest płukana w odstępach czasu i kończy się co 1 minutę)

Jak to działa

.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
TheBikingViking
źródło
1
23 bajty . Działa, ponieważ 7jest liczbą pierwszą, więc podzielności można dokonać poprzez sprawdzenie faktoryzacji
liczby
możesz go opublikować, jego główna część
Maltysen
1
Gratulujemy wygranej w tym konkursie. Lubię też sztuczkę @Maltysen!
mschauer
23

Python 2, 77 75 74 70 bajtów

Dzięki @MartinEnder za sugerowanie limitu 9e5który Ende r d aż po zmianie pracy.
Dzięki @mschauer za zasugerowanie nieskończonego strumienia, oszczędzającego 4 bajty.

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

Jest to generator, który daje nieskończony strumień liczb.

PurkkaKoodari
źródło
Czy nie możesz całkowicie usunąć górnej granicy?
mschauer
@mschauer Dzięki, nie myślałem o tym.
PurkkaKoodari
if n%7<1or'7'in`n`else nmoże być nieco szybszy (ta sama liczba bajtów), ponieważ n%7<1jest szybszy niż sprawdzanie łańcucha i orpowoduje zwarcie. Szkoda, że yield[n,next(i)][n%7<1or'7'in`n`]to nie zadziała.
mbomb007
@ mbomb007 Nie sądzę, że prędkość jest tutaj problemem, ale dzięki. :)
PurkkaKoodari
10

Perl, 47 46 41 39 bajtów

Zaoszczędź 5 bajtów dzięki @Dada

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

Wypróbuj online! TIO Nexus, teraz z obsługą Perla! Spowoduje to obcięcie wyniku po pewnym momencie, ale jeśli masz zainstalowany Perl, możesz uruchomić go lokalnie, aby uzyskać pełne wyjście.

Kod wykorzystuje kilka dziwnych dziwactw składni Perla, więc opiszę poniżej, jak to działa.

Podział kodu:

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
Gabriel Benamy
źródło
1
say$a[@a]=$_=...wygrać 2 bajty, jeśli się nie mylę.
Dada
@Dada faktycznie, ponieważ to oszczędza mi konieczności przypisywania $_, oszczędza mi 5 bajtów. Dzięki!
Gabriel Benamy
1
Och, rzeczywiście, właśnie rzuciłem okiem i nie zauważyłem tego zadania w środku .. dobra robota :)
Dada
Właśnie w tym momencie (i tylko w tej chwili!) Zrozumiałem stwierdzenie „Perl może być językiem tylko do zapisu”.
haneefmubarak
@Grimy, proszę, nie edytuj kodu innych osób. Jeśli chcesz poprawić odpowiedź, dodaj komentarz zawierający poprawkę lub opublikuj własną odpowiedź. Ponieważ prawdopodobnie nie dotrzesz do PO komentarzem, po prostu opublikuj swoją odpowiedź.
ovs
5

PHP, 80 (Wahooka) 57 54 bajtów

Chociaż pomysł pochodzi od Wahooka. Myślę, że moja wersja jest na tyle inna, że ​​stanowi własną odpowiedź:

for(;;)echo$a[]=strpos(++$n,55)<-$n%7?"$n ":$a[+$b++];
Christoph
źródło
5

Haskell, 67 66 bajtów

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 to nieskończona lista liczb.

Wypróbuj online!

frozpoczyna nową iterację od 1oraz indeks, którego liczbę należy wybrać na 0. Za każdym razem, gdy jest przerwa, bierzemy nową iterację, wybierz jej ithelement i kontynuujemy bieżącą iterację i+1. Jeśli nie ma przerwy, bierzemy bieżący numer xi kontynuujemy bez zwiększania i.

Edycja: -1 bajt dzięki @BMO.

nimi
źródło
4

MATL , 26 25 bajtów

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

Wypróbuj online! z 9e5zastąpionym przez 9e4, aby maksymalny czas działania i wielkość wyjściowa kompilatora online nie zostały przekroczone.

Jak to działa

Używa iteracji zamiast rekurencji. (W rzeczywistości MATL nie ma rekurencji).

Najpierw generowana jest tablica liczb od 1do 9e5(to wystarczy, ponieważ 9e5przekracza 7^7). Następnie, numery, które są wielokrotnością 7lub mają 7jako cyfry są identyfikowane i zastąpione 1, 2... Proces powtórzyć dopóki nie istnieją żadne numery, które muszą zostać wymienione.

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
Luis Mendo
źródło
3

Tcl , 121 bajtów

Trywialne rozwiązanie wykorzystujące nieskończoną pętlę, nic szczególnego ..

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

Nie golfowany:

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
  }
}
hdrz
źródło
Możesz użyć incr. A jeśli wersja tcl> = 8,6, incrzakłada pierwszą iterację przyrost nowej zmiennej od 0do, 1jeśli ta zmienna nie była wcześniej ustawiana; dzięki czemu możesz pozbyć się pierwszych dwóch setinstrukcji.
sergiol
grałem w golfa - usunąłem również trochę niepotrzebnej białej przestrzeni.
sergiol
Witryna, w której zamieściłem dla ciebie moje sugestie dotyczące gry w golfa, je zgubiło, więc udzieliłem nowej odpowiedzi
sergiol
3

PHP, 106 80 bajtów

Dziękujemy Ismael Miguel za pomoc w rozwiązaniu trójskładnikowym i krótszym kodzie pętli używającym zamiast zamiast.

Nie można zweryfikować ostatnich części pełnej sekwencji z powodu maksymalnego czasu działania PhpFiddle wynoszącego 30 sekund. Wydaje się, że działa co najmniej do 1 K na podstawie danych wyjściowych dostarczonych przez PO.

Golf:

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

Oryginalna wersja gry w golfa :

$n=1;while(1){if(!(strpos($n,"7")>-1||$n%7==0)){echo$a[]=$n." ";}else{echo$a[]=array_shift($a)." ";}$n++;}
Wahooka
źródło
1
for($n=1;;$n++)echo$a[]=!(strpos($n,7)>-1||$n%7==0)?"$n ":array_shift($a)." ";Nie znam liczby bajtów, ale jestem pewien, że jest ona dużo mniejsza niż 106 bajtów. Wypróbuj i sprawdź, czy to działa.
Ismael Miguel
Bardzo miło, dziękuję za pomoc. Jedyną modyfikacją twojego kodu było umieszczenie pierwszych 7 w cudzysłowie, co dodało dwa bajty do twojej 78-bajtowej wersji.
Wahooka
Możesz w ten sposób zapisać 3 bajty for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. Nie jestem pewien, czy można zastąpić $n%7==0z !$n%7ale warto spróbować.
Ismael Miguel
1
Kontynuuj -6: $ n = 0 jest bezużyteczne, „7” może być 7.
Crypto
1
dlaczego przesunąć for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 bajtów). ++$b-1ponieważ$a[null] === null
Christoph
3

Julia, 62 bajty

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

Nic fajnego. Używa, że ​​sekwencją w przerwach jest sama sekwencja. Wykonuje nadmierne kopie tablic, aby zaoszczędzić niektóre bajty.

mschauer
źródło
3

Perl 6 ,  74 57 54  53 bajtów

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

Spróbuj

Rozszerzony:

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

Test:

$ 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
Brad Gilbert b2gills
źródło
Wygląda na to, że możesz zapisać bajt, mówiąc ~7zamiast '7'.
Sean
2

Cejlon, 202 bajty

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

To nie jest funkcja, ale deklaracja obiektu implementująca nieskończoną sekwencję (Iterable). Obiekt można wydrukować bezpośrednio, print(u)generując to:

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

Aby wydrukować więcej, użyj printAll(u). Poniższy kod wykorzystuje znaki nowej linii, a także drukuje sumę (i pierwszych 30 elementów pokazanych powyżej):

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

Oto nieposkromiona i skomentowana wersja:

// 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;
                };
}
Paŭlo Ebermann
źródło
2

Rubinowy, 80 bajtów

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}

Pierwsze zgłoszenie, jestem pewien, że można to poprawić :)

Christopher Lates
źródło
1
Witamy w PPCG! Czy to sięga co najmniej 7 ^ 7 (tj. 823543) i czy uwzględnia liczby zawierające cyfrę 7, tj. 17?
ETHproductions
Z pewnością nie. Naprawiono teraz. Myślałem, że ten problem był trochę zbyt łatwy :)
Christopher Lates
Fajnie, ale nie jestem pewien, czy to się kwalifikuje. Liczba po 34(która jest 8obecnie) powinna być 7, ale ponieważ 7jest to niewymowna liczba, program powinien rozpocząć trzecią iterację i zamiast tego wydrukować 1.
ETHprodukcje
2

Dyalog APL , 39 bajtów

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

⍳7*7wynosi 1 2 3 ... 7 7

{ }⍣≡jest operatorem punktu stałego - stosuj funkcję wielokrotnie, aż wynik się ustabilizuje

A@I⊢B zmienić operatora - wymienić elementy dla indeksów Iw BzA

0=7|⍵ maska ​​bitowa, dla której argument można podzielić przez 7

'7'∊¨⍕¨⍵ maska ​​bitowa, dla której format dziesiętny argumentu zawiera 7

lub

przy jakich indeksach jest prawdą jedna z powyższych mas bitowych?

i← Przypisać do i

⍵⍴⍨⍴i przekształć argument na liczbę elementów w i

ngn
źródło
To jest miłe. Czy to pomaga, jeśli pomnożysz ⍳7 * 7 przez maskę bitów i weźmiesz stały punkt zmiany zer w sekwencji?
mschauer
2

C 157 155 bajtów

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

Wygląda dobrze, nie zadałem sobie trudu, aby w pełni sprawdzić. Podnosi do 999999, który jest najwyraźniej wystarczająco duży.

Wersja bez golfa:

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

Wersja częściowo golfowa:

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;
        }
    }
}
LambdaBeta
źródło
Czy potrzebujesz później aparatów ortodontycznych else?
Zacharý
Nie, dziękuję. Przez (r=0)większość czasu nie potrzebuję też aparatów ortodontycznych . Ale niektóre kompilatory są wybredne. Jestem zbyt leniwy, by teraz sprawdzić specyfikację.
LambdaBeta
2

R, 86 bajtów

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}

Korzysta z wbudowanej Prawdy R T(inicjowanej do TRUE/ 1) do zliczania liczb w sekwencji oraz wartości Falsy F(inicjowanej do FALSE/ 0) do zliczania niewymownych. Poza tym program sprawdza po prostu, czy każdą liczbę można podzielić przez siedem, czy też zawiera liczbę.

Billywob
źródło
-4 bajty zastępowane 7%in%el(strsplit(c(T,""),""))przez 55%in%utf8ToInt(paste(T))? (nie testowano)
JayCe
2

C - 115 bajtów

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

EDYCJA: Podziękowania dla @mschauer, który zauważył, że coś mi umknęło.

orion
źródło
Niezłe podejście. Dwie uwagi. r% 10-7 przechwytuje tylko siódemki i nie uszkadza twojego sterty: głębokość stosu rośnie wielomianowo ... s [99] jest bezpieczny.
mschauer
2

JavaScript, 80 bajtów

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

Ponieważ są tylko minimalne wymagania, ale nie wymagania maksymalne, to rozwiązanie działa w nieskończoność.

Aby sprawdzić, czy algorytm jest poprawny, możesz wykonać ten sam kod, drukując tylko 10 ostatnich liczb i sumę:

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
    }
}
Sullof
źródło
Błąd składni
1

Mathematica, 82 bajty

Nest[#2&[i=1,If[Or@@(#==7&)/@IntegerDigits@#,i++,#]&/@#]&,Table[i,{i,7^7}],20]
J. Antonio Perez
źródło
1

JavaScript 81 bajtów

Oryginalny (98 bajtów)

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

Grał w golfa

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);
Richard Sime
źródło
Witamy na stronie! Nie wiem dużo o javascript, ale czy mógłbyś zrobić coś takiego 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
Dzięki @DrMcMoylex, że spadło kilka dodatkowych bajtów. Nie wątpię, że jest jeszcze miejsce na poprawę.
Richard Sime,
Cieszę się, że mogłem pomóc! Jeszcze jedno zdałem sobie sprawę, to można zrobić 9e5zamiast Math.pow(7,7), ponieważ wyzwaniem powiedział:Print/output AT LEAST the first 7^7
DJMcMayhem
Tak, niezły strzał Doc! To pozwoliło mi również upuścić równe z operatora porównania.
Richard Sime,
Wydaje się, że nie spełnia oczekiwań. Wypełniając luki, najwyraźniej musisz ponownie zastosować reguły, a nie po prostu zresetować licznik (zobacz tę część sekwencji:) 34 1 36 **8** 38. Ale za to, co warte, obecna wersja może być grałem trochę więcej: for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld
1

Befunge, 100 lub 156 bajtów

Ta pierwsza wersja jest bardziej przenośna z tych dwóch, ograniczając się do 7-bitowych komórek pamięci, co dostajesz w interpretera referencyjnym.

"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

Druga wersja działa tylko z interpretatorami, które mają 32-bitowe komórki pamięci, a zatem nie jest ściśle standardowym Befunge, ale pozwala nam przechowywać większe wartości w pamięci bez konieczności dzielenia ich na komórki.

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

W obu przypadkach program działa w nieskończoność, ale pierwsza wersja przepełni się wokół znaku 2 milionów, podczas gdy druga wersja powinna osiągnąć maksymalną wartość int (około 2 miliardów).

Możesz wypróbować online , ale musisz zabić proces, aby nie mógł działać wiecznie.

James Holderness
źródło
1

Clojure, 130 bajtów

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

Podstawowe zmniejszanie, śledzenie zawartości wektora wynikowego i liczby wartości, które zostały pominięte. Ostatni 0bierze pierwszy element zredukowanego [r s], restupuszcza pierwszy element wyniku o indeksie 0.

NikoNyrh
źródło
1

Perl6, 41 bajtów

put {($_=++$)%%7|m/7/??@_[$++]!!$_}…1e6
Ponury
źródło
1

Tcl , 64 bajty

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

Wypróbuj online!

sergiol
źródło
miły! znacznie krótszy niż mój…
hdrz
To pisze „... 33 34 7 36 8 38 ...” zamiast „... 33 34 1 36 8 38 ...”
mschauer
@mschauer: Ok, naprawię to, kiedy będę miał czas ...
sergiol
@hdrz Wypróbowałem twoje rozwiązanie i ma ten sam problem, o którym mówił mschauer!
sergiol
1

JavaScript, 64 bajty

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(','))

l4m2
źródło
ps do porównania z innymi kilkoma ( console.log) odpowiedziami na JavaScript, to 70 bajtów
l4m2
1

Japt , 25 bajtów

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

Sprawdź sumę i ostatnie 10 elementów.

Generuje pierwsze 1 000 000 wpisów sekwencji i drukuje je. Milion to najkrótsza liczba 7**7 == 823543w Japt.

Końcowy znak nowej linii jest znaczący, ponieważ aktywuje ukryte przypisanie do U.

Wygenerowanie listy zajmuje tylko około sekundy, ale wygenerowanie całej tablicy prawdopodobnie spowoduje zawieszenie się przeglądarki.

Rozpakowane i jak to działa

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

Wykorzystuje właściwość, że definicję rekurencyjną można rozwiązać, patrząc na już wygenerowaną sekwencję.

Bubbler
źródło