Los números indescriptibles de Cantor

58

Un número indescriptible es un número que es divisible por siete o tiene siete como uno de sus dígitos. Un juego para niños es contar saltando números indescriptibles

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

La versión del juego de Cantor es la secuencia definida rellenando recursivamente la secuencia "1 2 3 4 5 6 () 8 ..." en los espacios () anteriores.

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 al menos los primeros 7 ^ 7 números del juego de números indescriptible de Cantor ...

Si bien la definición se da de forma recursiva, no está obligado a utilizar la recursividad en el código.

Este es el , por lo que gana el programa con el recuento de bytes más corto.

Nota: La suma de números en 1 a 7 ^ 7 es 203511962727. Los últimos 10 números en ese rango son 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

El volcado de Pastebin de los primeros 1000 itera: http://pastebin.com/Ksiu9Svf

mschauer
fuente
8
Proporcione los primeros 7 ^ 7 números de esa secuencia para que podamos verificar nuestras soluciones.
falla
2
Relacionado
Adnan
2
En caso de que alguien quiere generar algunos más números y resultados de la comparación: La suma de los primeros 7 ^ 77 números en la secuencia es 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.
Claro, el número de 1 en esa secuencia es 22977, lo que significa que si elige un elemento de los primeros 7 ^ 77 de manera uniforme al azar, tiene una probabilidad de 2 * 10 ^ -61 de que sea un 1
Niklas B.
1
En caso de que le interese, aquí hay un gráfico que muestra el crecimiento del número de repetidos: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

Respuestas:

6

Pyth , 25 23 22 bytes

Gracias a @Maltysen por -2 bytes

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

Un programa que imprime una secuencia infinita.

Pruébalo en línea! (Salida enjuagada a intervalos y tiempos de espera en 1 minuto)

Cómo 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
TheBikingViking
fuente
1
23 bytes . Funciona porque 7es primo, por lo que la divisibilidad se puede hacer mediante la verificación de la factorización prima, que encaja bien con la otra verificación
Maltysen
puedes publicarlo, la parte principal es tuya
Maltysen
1
Enhorabuena por ganar este concurso. ¡También me gusta el truco de @Maltysen!
mschauer
23

Python 2, 77 75 74 70 bytes

Gracias a @MartinEnder para sugerir el límite de 9e5que Ende r d trabajando después de un cambio.
Gracias a @mschauer por sugerir una secuencia infinita, ahorrando 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 es un generador que produce un flujo infinito de números.

PurkkaKoodari
fuente
¿No podría eliminar el límite superior por completo?
mschauer el
@mschauer Gracias, no pensé en eso.
PurkkaKoodari
if n%7<1or'7'in`n`else npodría ser un poco más rápido (el mismo número de bytes), ya que n%7<1es más rápido que verificar la cadena y orestá en cortocircuito. Es una pena que yield[n,next(i)][n%7<1or'7'in`n`]no funcione.
mbomb007
@ mbomb007 No creo que la velocidad sea un problema aquí, pero gracias. :)
PurkkaKoodari
10

Perl, 47 46 41 39 bytes

Guardado 5 bytes gracias a @Dada

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

¡Pruébelo en línea! TIO Nexus, ¡ahora con soporte Perl! Esto truncará la salida después de cierto punto, pero si tiene instalado Perl, puede ejecutarlo localmente para producir la salida completa.

El código hace uso de un par de peculiaridades extrañas de la sintaxis de Perl, por lo que detallaré cómo funciona a continuación.

Desglose del 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
Gabriel Benamy
fuente
1
say$a[@a]=$_=...ganar 2 bytes si no me equivoco.
Dada
@Dada en realidad ya que eso me ahorra tener que asignar $_, me ahorra 5 bytes. ¡Gracias!
Gabriel Benamy
1
Ah, de hecho, solo eché un vistazo rápido y no noté esa tarea en el medio ... buen trabajo :)
Dada
Es en este momento (¡y solo en este momento!) Que he entendido la afirmación "Perl puede ser un lenguaje de solo escritura".
haneefmubarak
@ Grimy, por favor no edites el código de otros. Si desea mejorar una respuesta, agregue un comentario que incluya la mejora o publique su propia respuesta. Como probablemente no llegue al OP por un comentario, simplemente publique su propia respuesta.
ovs
5

PHP, 80 (Wahooka) 57 54 bytes

Si bien la idea es de Wahooka. Creo que mi versión es lo suficientemente diferente como para que sea una respuesta propia:

for(;;)echo$a[]=strpos(++$n,55)<-$n%7?"$n ":$a[+$b++];
Christoph
fuente
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 es una lista infinita de los números.

Pruébalo en línea!

fcomienza una nueva iteración con 1un índice y qué número elegir de 0. Siempre que haya una brecha, tomamos una nueva iteración y elegimos su ithelemento y continuamos con la iteración actual i+1. Si no hay una brecha, tomamos el número actual xy continuamos sin aumentar i.

Editar: -1 byte gracias a @BMO.

nimi
fuente
4

MATL , 26 25 bytes

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

Pruébalo en línea! con 9e5reemplazado por 9e4, de modo que no se exceda el tiempo de ejecución máximo y el tamaño de salida del compilador en línea.

Cómo funciona

Esto usa iteración en lugar de recursión. (De hecho, MATL no tiene recursividad).

Primero se genera una matriz de números desde 1hasta 9e5(esto es suficiente, porque 9e5excede 7^7). A continuación, los números que son múltiplos de 7o que tengan 7como se identifican dígitos, y reemplazado por 1, 2, ... El proceso se itera hasta que no hay números que necesitan ser reemplazados.

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
fuente
3

Tcl , 121 bytes

La solución trivial con bucle infinito, nada de lujos.

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

Sin golf:

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
fuente
Puedes usar incr. Y si la versión tcl> = 8.6, incrsupone la primera iteración un incremento de una nueva variable de 0a 1si esa variable no se estableció antes; para que puedas deshacerte de las dos primeras setinstrucciones.
sergiol
Golfed by my - Eliminé también algunos espacios en blanco no necesarios.
sergiol
El sitio donde publiqué mis sugerencias de golf para usted las perdió, así que hice una nueva respuesta
sergiol
3

PHP, 106 80 bytes

Gracias Ismael Miguel por la ayuda con la solución ternaria y el código de bucle más corto que se usa por en lugar de por un tiempo

No se pudieron verificar las últimas partes de la secuencia completa debido al tiempo de ejecución máximo de 30 segundos de PhpFiddle. Parece funcionar al menos hasta 1K en función de la salida de muestra proporcionada por el OP.

Golf:

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

Versión original de golf :

$n=1;while(1){if(!(strpos($n,"7")>-1||$n%7==0)){echo$a[]=$n." ";}else{echo$a[]=array_shift($a)." ";}$n++;}
Wahooka
fuente
1
for($n=1;;$n++)echo$a[]=!(strpos($n,7)>-1||$n%7==0)?"$n ":array_shift($a)." ";No sé el recuento de bytes, pero estoy seguro de que es mucho más bajo que 106 bytes. Pruébelo y vea si funciona.
Ismael Miguel
Muy bien, gracias por la ayuda. La única modificación a su código fue poner los primeros 7 entre comillas que agregaron dos bytes a su versión de 78 bytes.
Wahooka
Puede guardar 3 bytes más o menos haciendo esto for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. No estoy seguro de si se puede reemplazar $n%7==0con !$n%7pero vale la pena intentarlo.
Ismael Miguel
1
Sigue adelante -6: $ n = 0 es inútil, "7" puede ser 7.
Cripto
1
¿Por qué cambiar? 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 sofisticado. Utiliza que la secuencia dentro de los huecos es la secuencia misma. Realiza copias de matriz excesivas para guardar algunos bytes.

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

Intentalo

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

Prueba:

$ 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
fuente
Parece que podría guardar un byte diciendo en ~7lugar de '7'.
Sean
2

Ceilán, 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;};}

Esta no es una función, sino una declaración de objeto que implementa una secuencia infinita (Iterable). El objeto se puede imprimir directamente, print(u)genera esto:

{ 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 más, use printAll(u). El siguiente código usa líneas nuevas y también imprime la suma (y los primeros 30 elementos que se muestran arriba):

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

Aquí está la versión no comentada y 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;
                };
}
Paŭlo Ebermann
fuente
2

Rubí, 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}

Primera presentación, estoy seguro de que se puede mejorar :)

Christopher Lates
fuente
1
Bienvenido a PPCG! ¿Esto sube al menos a 7 ^ 7 (es decir, 823543), y tiene en cuenta los números que contienen el dígito 7, es decir, 17?
ETHproductions
Seguro que no. Corregido ahora. Pensé que ese problema era demasiado fácil :)
Christopher Lates
Bien, pero no estoy seguro de que califique todavía. El número después 34(que es 8actualmente) debería ser 7, pero debido a que 7es un número indescriptible, el programa debe comenzar una tercera iteración y, en su lugar, imprimir 1.
ETHproductions
2

Dyalog APL , 39 bytes

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

⍳7*7es 1 2 3 ... 7 7

{ }⍣≡es el operador de punto fijo : aplique una función repetidamente hasta que el resultado se estabilice

A@I⊢B modificar operador - reemplazar los elementos en los índices Ide BlaA

0=7|⍵ máscara de bits para donde el argumento es divisible por 7

'7'∊¨⍕¨⍵ máscara de bits para donde el formato decimal del argumento contiene un 7

o

¿con qué índices es cierta alguna de las máscaras de bits anteriores?

i← asignar a i

⍵⍴⍨⍴i remodelar el argumento a la cantidad de elementos en i

ngn
fuente
Esto es bonito. ¿Ayuda si multiplica ⍳7 * 7 con la máscara de bits y toma el punto fijo de enmendar los ceros en la secuencia?
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 correcto, no me molesté en comprobarlo por completo. Sube a 999999, que aparentemente es lo suficientemente grande.

Versión sin golf:

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

Versión parcialmente golfizada:

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
fuente
¿Necesitas los frenos después else?
Zacharý
Yo no, gracias. Tampoco técnicamente necesito los aparatos ortopédicos la (r=0)mayor parte del tiempo. Pero algunos compiladores son exigentes. Soy demasiado vago para verificar las especificaciones en este momento.
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}

Utiliza la Verdad de R incorporada T(inicializada en TRUE/ 1) para contar los números en la secuencia y el valor Falsy F(inicializado en FALSE/ 0) para contar los indescriptibles. Aparte de eso, el programa simplemente verifica si cada número es divisible por siete o si contiene el número.

Billywob
fuente
-4 bytes reemplazando 7%in%el(strsplit(c(T,""),""))por 55%in%utf8ToInt(paste(T))? (no probado)
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));}

EDITAR: Gracias a @mschauer que señaló que me perdí algunas cosas.

Orión
fuente
Buen enfoque. Dos observaciones r% 10-7 solo captura sietes finales y no corrompe su montón: la profundidad de la pila crece polinomialmente ... s [99] es 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))

Dado que solo hay requisitos mínimos pero no requisitos máximos, esta solución continúa produciéndose indefinidamente.

Para verificar que el algoritmo sea correcto, puede ejecutar el mismo código imprimiendo solo los últimos 10 números y la suma:

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
fuente
SyntaxError: missing) en paréntesis
l4m2
1

Mathematica, 82 bytes

Nest[#2&[i=1,If[Or@@(#==7&)/@IntegerDigits@#,i++,#]&/@#]&,Table[i,{i,7^7}],20]
J. Antonio Perez
fuente
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);

Golfed

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
fuente
Bienvenido al sitio! No sé mucho sobre javascript, pero ¿podrías hacer algo así 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
Gracias @DrMcMoylex, que dejó caer unos pocos bytes más. No dudo que todavía hay margen de mejora.
Richard Sime
Me alegro de poder ayudar! Otra cosa que acabo de 9e5Math.pow(7,7)Print/output AT LEAST the first 7^7
darme
Sí, buen tiro Doc! Esto me permitió eliminar un igual de un operador de comparación también.
Richard Sime
No parece hacer lo que se espera. Al llenar los vacíos, aparentemente tiene que aplicar las reglas nuevamente en lugar de simplemente restablecer un contador (vea esta parte de la secuencia:) 34 1 36 **8** 38. Pero para lo que vale, la versión actual podría ser un poco más golfed: for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld
1

Befunge, 100 o 156 bytes

Esta primera versión es la más portátil de las dos, limitándose a celdas de memoria de 7 bits, que es lo que obtienes en el intérprete de referencia.

"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

La segunda versión solo funciona con intérpretes que tienen celdas de memoria de 32 bits y, por lo tanto, no es estrictamente Befunge estándar, pero eso nos permite almacenar valores más grandes en la memoria sin tener que dividirlos en celdas.

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

En ambos casos, el programa se ejecuta indefinidamente, pero la primera versión se desbordará alrededor de la marca de 2 millones, mientras que la segunda versión debería alcanzar el valor máximo int (alrededor de 2 mil millones).

Puede probarlo en línea , pero deberá eliminar el proceso para evitar que se ejecute para siempre.

James Holderness
fuente
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)))

Reducción básica, haciendo un seguimiento de los contenidos del vector de resultados y cuántos valores se han omitido. El último 0toma el primer elemento del reducido [r s], restdeja caer el primer elemento del resultado indexado a 0.

NikoNyrh
fuente
1

Perl6, 41 bytes

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

Tcl , 64 bytes

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

Pruébalo en línea!

sergiol
fuente
¡bonito! mucho más corto que el mío ...
hdrz
Esto escribe "... 33 34 7 36 8 38 ..." en lugar de "... 33 34 1 36 8 38 ..."
mschauer
@mschauer: Ok, lo arreglaré cuando tenga tiempo ...
sergiol 05 de
@hdrz Probé su solución y tiene el mismo problema que mschauer le contó.
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(','))

l4m2
fuente
ps para comparar con las otras pocas ( console.log) respuestas de JavaScript, son 70 bytes
l4m2
1

Japt , 25 bytes

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

Prueba la suma y los últimos 10 elementos.

Genera las primeras 1,000,000 entradas de la secuencia y las imprime. Un millón es el número más corto 7**7 == 823543en Japt.

La nueva línea final es significativa, ya que activa la asignación implícita a U.

Generar la lista solo toma alrededor de un segundo, pero la salida de toda la matriz probablemente hará que su navegador se cuelgue.

Desempaquetado y cómo 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

Utiliza la propiedad de que la definición recursiva se puede resolver mirando la secuencia ya generada.

Bubbler
fuente