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 é código-golfe , 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

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

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.

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

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

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.

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

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

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

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.

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

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

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

Dyalog APL , 39 bytes

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

⍳7*7é 1 2 3 ... 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

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

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.

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.

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

Mathematica, 82 bytes

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

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

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.

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.

Perl6, 41 bytes

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

Tcl , 64 bytes

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

Experimente online!

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

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.