Os números indizíveis do Cantor


58

Um número indizível é um número que é divisível por sete ou tem sete como um de seus dígitos. Um jogo infantil é contar pulando números indizíveis

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

A versão do jogo de Cantor é a sequência definida pelo preenchimento recursivo da sequência "1 2 3 4 5 6 () 8 ..." nas lacunas () acima.

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

Imprima / imprima pelo menos os primeiros 7 ^ 7 números do jogo de números indizível da Cantor ...

Embora a definição seja dada recursivamente, você não é obrigado a usar recursão no código.

Isso é , então o programa com a menor contagem de bytes vence!

Nota: A soma dos números de 1 a 7 ^ 7 é 203511962727. Os últimos 10 números desse intervalo são 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Despejo de Pastebin das primeiras 1000 iterações: http://pastebin.com/Ksiu9Svf


8
Forneça os primeiros 7 ^ 7 números dessa sequência para que possamos verificar nossas soluções.
flawr


2
No caso de qualquer um quer para gerar mais alguns números e comparar resultados: A soma dos primeiros 7 ^ 77 números na sequência é 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.

Claro, o número de 1s nessa sequência é 22977, o que significa que, se você escolher um elemento dos primeiros 7 ^ 77 uniformemente aleatoriamente, você tem 2 * 10 ^ -61 de chance de ser um 1
Niklas B.

11
Caso você esteja interessado, aqui está um gráfico que mostra o crescimento do número de repetidos: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

Respostas:


6

Pitão , 25 23 22 bytes

Obrigado a @Maltysen por -2 bytes

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

Um programa que imprime um fluxo infinito.

Experimente online! (Saída nivelada em intervalos e tempo limite em 1 min)

Como funciona

.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

11
23 bytes . Ele funciona porque 7é primo, então divisibilidade é pode ser feito através da verificação da fatoração nobre, que se encaixa bem com o outro cheque
Maltysen

você pode publicá-lo, a parte principal dele
Maltysen 27/11

11
Parabéns por vencer este concurso. Eu também gosto do truque de @Maltysen!
mschauer

23

Python 2, 77 75 74 70 bytes

Graças a @MartinEnder para sugerir o limite de 9e5que ende r d a trabalhar depois de uma mudança.
Agradecemos a @mschauer por sugerir um fluxo infinito, economizando 4 bytes.

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

Este é um gerador que gera um fluxo infinito de números.


Você não conseguiu remover completamente o limite superior?
27416 mschauer

@mschauer Obrigado, não pensei nisso.
PurkkaKoodari

if n%7<1or'7'in`n`else npode ser um pouco mais rápido (mesma contagem de bytes), já que n%7<1é mais rápido que a verificação da string e orestá em curto-circuito. É uma pena que yield[n,next(i)][n%7<1or'7'in`n`]não funcione.
mbomb007

@ mbomb007 Acho que a velocidade não é um problema aqui, mas obrigado. :)
PurkkaKoodari

10

Perl, 47 46 41 39 bytes

Guardado 5 bytes graças a @Dada

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

Experimente Online! TIO Nexus, agora com suporte a Perl! Isso truncará a saída após um certo ponto, mas se você tiver o Perl instalado, poderá executá-lo localmente para produzir a saída completa.

O código utiliza algumas peculiaridades estranhas da sintaxe do Perl, então vou detalhar como funciona abaixo.

Repartição do código:

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

11
say$a[@a]=$_=...ganhar 2 bytes se não me engano.
Dada

@ Dad, na verdade, uma vez que isso me poupa de ter que atribuir a $_, me salva 5 bytes. Obrigado!
Gabriel Benamy

11
Oh, na verdade, eu só tinha um olhar rápido e não percebeu que a atribuição no meio .. bom trabalho :)
Dada

É neste momento (e somente neste momento!) Que entendi a afirmação "Perl pode ser a linguagem somente de gravação".
haneefmubarak

@ Grimy, por favor, não edite código de outras pessoas. Se você deseja melhorar uma resposta, adicione um comentário, incluindo a melhoria, ou publique sua própria resposta. Como você provavelmente não alcançará o OP por um comentário, basta postar sua própria resposta.
ovs 24/10

5

PHP, 80 (Wahooka) 57 54 bytes

Enquanto a ideia é de Wahooka. Eu acho que minha versão é diferente o suficiente para torná-la uma resposta própria:

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

5

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 é uma lista infinita dos números.

Experimente online!

finicia uma nova iteração com 1e um índice cujo número deve ser igual a 0. Sempre que houver uma lacuna, fazemos uma nova iteração e selecionamos seu ithelemento e continuamos com a iteração atual i+1. Se não houver diferença, pegamos o número atual xe continuamos sem aumentar i.

Edit: -1 byte graças ao @BMO.


4

MATL , 26 25 bytes

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

Experimente online! é 9e5substituído por 9e4, para que o tempo máximo de execução e o tamanho da saída do compilador online não sejam excedidos.

Como funciona

Isso usa iteração em vez de recursão. (De fato, o MATL não tem recursão).

Uma matriz de números de 1a 9e5é gerada primeiro (isso é suficiente, porque 9e5excede 7^7). Então, números que são múltiplos de 7ou têm 7como dígitos são identificados e substituídos por 1, 2, ... O processo é iterativo até que não haja números que precisam ser substituídos.

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 bytes

A solução trivial usando loop infinito, nada chique ..

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

Você pode usar incr. E se tcl version> = 8.6, incrassume na primeira iteração um incremento de uma nova variável de 0para 1se essa variável não tiver sido definida anteriormente; para que você possa se livrar das duas primeiras setinstruções.
Sergiol 28/05

jogado por mim - também removi alguns espaços em branco não necessários.
Sergiol

O site em que publiquei minhas sugestões de golfe para você as perdeu, então fiz uma nova resposta
sergiol

3

PHP, 106 80 bytes

Obrigado Ismael Miguel pela ajuda com a solução ternária e o código de loop mais curto usando for, em vez de enquanto.

Não foi possível verificar as últimas partes da sequência completa devido ao tempo de execução máximo de 30 segundos do PhpFiddle. Parece funcionar pelo menos até 1K com base na saída de amostra fornecida pelo OP.

Golfe:

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

Versão original do golfe :

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

11
for($n=1;;$n++)echo$a[]=!(strpos($n,7)>-1||$n%7==0)?"$n ":array_shift($a)." ";Não conheço a contagem de bytes, mas tenho certeza que é muito menor que 106 bytes. Experimente e veja se funciona.
Ismael Miguel

Muito bom, obrigado pela ajuda. A única modificação no seu código foi colocar os 7 primeiros entre aspas que adicionaram dois bytes à sua versão de 78 bytes.
Wahooka

Você pode salvar 3 bytes ou mais fazendo isso for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. Eu não tenho certeza se você pode substituir $n%7==0com !$n%7mas vale a pena uma tentativa.
Ismael Miguel

11
Continue indo -6: $ n = 0 é inútil, "7" pode ser 7.
Crypto

11
por que mudar? for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 bytes). ++$b-1porque$a[null] === null
Christoph

3

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

Nada chique. Usa que a sequência dentro das lacunas é a própria sequência. Faz cópias excessivas da matriz para salvar alguns bytes.


3

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

Tente

Expandido:

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

Teste:

$ 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

Parece que você pode salvar um byte dizendo em ~7vez de '7'.
29416 Sean

2

Ceilão, 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;};}

Isso não é uma função, mas uma declaração de objeto implementando uma sequência infinita (Iterable). O objeto pode ser impresso diretamente, print(u)produz o seguinte:

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

Para imprimir mais, use printAll(u). O código a seguir usa novas linhas e também imprime a soma (e os 30 primeiros elementos mostrados acima):

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

Aqui está a versão não-gasta e comentada:

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

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}

Primeira submissão, tenho certeza de que pode ser melhorada :)


11
Bem-vindo ao PPCG! Isso vai até pelo menos 7 ^ 7 (ou seja, 823543) e conta com números que contêm o dígito 7, ou seja, 17?
ETHproductions

Com certeza não. Corrigido agora. Pensei que o problema era um pouco :) muito fácil
Christopher Lates

Legal, mas ainda não tenho certeza. O número após 34(que está 8atualmente) deve ser 7, mas como 7é um número indizível, o programa deve iniciar uma terceira iteração e, em vez disso, imprimir 1.
ETHproductions

2

Dyalog APL , 39 bytes

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

⍳7*7é 1 2 3 ... 7 7

{ }⍣≡é o operador de ponto fixo - aplique uma função repetidamente até o resultado estabilizar

A@I⊢B alterar operador - substituir os elementos em índices Iem BcomA

0=7|⍵ bitmask para onde o argumento é divisível por 7

'7'∊¨⍕¨⍵ máscara de bits para onde a formatação decimal do argumento contém um 7

ou

em que índices é verdade uma das máscaras de bits acima?

i← atribuir a i

⍵⍴⍨⍴i remodelar o argumento para o número de elementos em i


Isso é legal. Ajuda se você multiplicar *7 * 7 com a máscara de bit e usar o ponto de correção para alterar os zeros na sequência?
mschauer

2

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

Parece certo, eu não me incomodei em verificar completamente. Vai até 999999, que é aparentemente grande o suficiente.

Versão não destruída:

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

Versão parcialmente golfada:

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

Você precisa do aparelho depois else?
Zachary

Eu não, obrigado. Eu também tecnicamente não preciso do aparelho na (r=0)maioria das vezes. Mas alguns compiladores são exigentes. Estou com preguiça de verificar as especificações agora.
LambdaBeta

2

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}

Usa Truthy embutido de R T(inicializado em TRUE/ 1) para contar os números na sequência e o valor de Falsy F(inicializado em FALSE/ 0) para contar os indizíveis. Fora isso, o programa simplesmente verifica se cada número é divisível por sete ou contém o número.


-4 bytes substituindo 7%in%el(strsplit(c(T,""),""))por 55%in%utf8ToInt(paste(T))? (não testada)
jayce

2

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: Obrigado a @mschauer, que apontou que perdi algumas coisas.


Boa abordagem. Duas observações. r% 10-7 captura apenas setes finais e não corrompe sua pilha: a profundidade da pilha cresce polinomialmente ... s [99] é seguro.
mschauer

2

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

Como há apenas um requisito mínimo, mas não um requisito máximo, esta solução continua a ser produzida indefinidamente.

Para verificar se o algoritmo está correto, você pode executar o mesmo código imprimindo apenas os últimos 10 números e a soma:

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


1

Mathematica, 82 bytes

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

1

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

Golfe

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

Bem vindo ao site! Eu não sei muito sobre javascript, mas você poderia fazer algo assim 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

Obrigado @DrMcMoylex, que deixou cair mais alguns bytes. Não duvido que ainda haja espaço para melhorias.
Richard Sime 28/11

Ainda bem que pude ajudar! Uma outra coisa que eu só percebi, é que você poderia fazer 9e5em vez de Math.pow(7,7), uma vez que o desafio disse:Print/output AT LEAST the first 7^7
DJMcMayhem

Sim, bom tiro Doc! Isso me permitiu remover um igual de um operador de comparação também.
Richard Sime 28/11

Parece não fazer o que é esperado. Ao preencher as lacunas, você aparentemente precisa aplicar as regras novamente, em vez de apenas redefinir um contador (consulte esta parte da sequência:) 34 1 36 **8** 38. Mas para o que vale a pena, a versão atual poderia ser golfed um pouco mais: for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld

1

Befunge, 100 ou 156 bytes

Essa primeira versão é a mais portátil das duas, limitando-se às células de memória de 7 bits, que é o que você obtém no intérprete de referência.

"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

A segunda versão funciona apenas com intérpretes que possuem células de memória de 32 bits e, portanto, não é estritamente padrão do Befunge, mas que permite armazenar valores maiores na memória sem precisar dividi-los pelas células.

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

Nos dois casos, o programa é executado indefinidamente, mas a primeira versão ultrapassa a marca de 2 milhões, enquanto a segunda versão deve atingir o valor máximo int (cerca de 2 bilhões).

Você pode experimentá-lo on-line , mas precisará interromper o processo para impedir que ele seja executado para sempre.


1

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

Redução básica, mantendo o controle do conteúdo do vetor de resultado e quantos valores foram ignorados. O último 0recebe o primeiro elemento do reduzido [r s]e restdescarta o primeiro elemento do resultado indexado em 0.


1

Perl6, 41 bytes

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

1

Tcl , 64 bytes

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

Experimente online!


legais! muito mais curto que o meu ...
hdrz 26/05

Isto escreve "... 33 34 7 36 8 38 ..." em vez de "... 33 34 1 36 8 38 ..." #
mschauer

@mschauer: Ok, vou corrigi-lo quando eu tiver tempo ...
sergiol

@hdrz Tentei sua solução e ela tem o mesmo problema que o mschauer falou!
sergiol

1

JavaScript, 64 bytes

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 para comparar com os outros poucos ( console.log) JavaScript respostas, é 70 bytes
l4m2

1

Japt , 25 bytes

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

Teste a soma e os últimos 10 elementos.

Gera as primeiras 1.000.000 entradas da sequência e as imprime. Um milhão é o número mais curto do 7**7 == 823543Japão.

A nova linha à direita é significativa, pois ativa a atribuição implícita para U.

A geração da lista leva apenas um segundo, mas a saída de toda a matriz provavelmente fará o navegador travar.

Descompactado e como funciona

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

Usa a propriedade que a definição recursiva pode ser resolvida observando a sequência já gerada.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.