I numeri indicibili di Cantor


58

Un numero indicibile è un numero che è divisibile per sette o ha sette come una delle sue cifre. Un gioco per bambini è contare saltando numeri indicibili

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

La versione di Cantor del gioco è la sequenza definita riempiendo ricorsivamente la sequenza "1 2 3 4 5 6 () 8 ..." negli spazi vuoti () sopra.

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

Stampa / stampa almeno i primi 7 ^ 7 numeri dell'indicibile gioco numerico di Cantor ...

Mentre la definizione viene data in modo ricorsivo, non sei obbligato a utilizzare la ricorsione nel codice.

Questo è , quindi vince il programma con il numero di byte più breve!

Nota: la somma dei numeri da 1 a 7 ^ 7 è 203511962727. Gli ultimi 10 numeri in quell'intervallo sono 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Dump di Pastebin dei primi 1000 iterati: http://pastebin.com/Ksiu9Svf


8
Fornisci i primi 7 ^ 7 numeri di quella sequenza in modo da poter verificare le nostre soluzioni.
Flawr,


2
Nel caso in cui qualcuno vuole generare alcuni più numeri e risultati confrontare: la somma dei primi 7 ^ 77 numeri della sequenza è 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.

Certo, il numero di 1 in quella sequenza è 22977, il che significa che se scegli un elemento tra i primi 7 ^ 77 uniformemente a caso, hai una possibilità 2 * 10 ^ -61 che sia un 1
Niklas B.

1
Se sei interessato, ecco un grafico che mostra la crescita del numero di quelli ripetuti: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

Risposte:


6

Pyth , 25 23 22 byte

Grazie a @Maltysen per -2 byte

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

Un programma che stampa un flusso infinito.

Provalo online! (Uscita scaricata a intervalli e timeout a 1 minuto)

Come funziona

.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 byte . Funziona 7perché è primo, quindi si può fare la divisibilità controllando la scomposizione in
fattori

puoi pubblicarlo, la parte principale è tua
Maltysen,

1
Congratulazioni per aver vinto questo concorso. Mi piace anche il trucco di @Maltysen!
mschauer,

23

Python 2, 77 75 74 70 byte

Grazie a @MartinEnder per suggerire il limite di 9e5cui ende r d a lavorare dopo un cambio.
Grazie a @mschauer per aver suggerito un flusso infinito, risparmiando 4 byte.

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

Questo è un generatore che produce un flusso infinito di numeri.


Non potresti rimuovere del tutto il limite superiore?
mschauer,

@mschauer Grazie, non ci ho pensato.
PurkkaKoodari,

if n%7<1or'7'in`n`else npotrebbe essere leggermente più veloce (stesso conteggio byte), poiché n%7<1è più veloce del controllo della stringa e orpresenta un corto circuito. Peccato che yield[n,next(i)][n%7<1or'7'in`n`]non funzionerà.
mbomb007,

@ mbomb007 Non credo che la velocità sia un problema qui, ma grazie. :)
PurkkaKoodari,

10

Perl, 47 46 41 39 byte

5 byte salvati grazie a @Dada

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

Provalo online! TIO Nexus, ora con supporto Perl! Questo troncerà l'output dopo un certo punto, ma se hai installato Perl, puoi eseguirlo localmente per produrre l'output completo.

Il codice utilizza un paio di strane stranezze della sintassi di Perl, quindi analizzerò come funziona di seguito.

Analisi del codice:

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]=$_=...per vincere 2 byte se non sbaglio.
Dada,

@Dada in realtà dal momento che mi salva da dover assegnare $_, mi fa risparmiare 5 byte. Grazie!
Gabriel Benamy,

1
Oh, in effetti, ho appena dato una rapida occhiata e non ho notato quell'incarico nel mezzo .. buon lavoro :)
Dada,

È in questo momento (e solo in questo momento!) Che ho capito l'affermazione "Perl può essere piuttosto il linguaggio di sola scrittura".
Haneefmubarak,

@Grimy, per favore, non modificare il codice degli altri. Se vuoi migliorare una risposta aggiungi un commento incluso il miglioramento o pubblica la tua risposta. Dato che probabilmente non raggiungerai l'OP con un commento, pubblica semplicemente la tua risposta.
Ovs

5

PHP, 80 (Wahooka) 57 54 byte

Mentre l'idea viene da Wahooka. Penso che la mia versione sia abbastanza diversa da renderla una risposta personale:

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

5

Haskell, 67 66 byte

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 è un elenco infinito di numeri.

Provalo online!

finizia una nuova iterazione con 1e un indice quale numero scegliere di 0. Ogni volta che c'è un gap prendiamo una nuova iterazione, prendiamo un ithelemento e continuiamo con l'iterazione corrente i+1. Se non c'è spazio vuoto, prendiamo il numero corrente xe proseguiamo senza aumentare i.

Modifica: -1 byte grazie a @BMO.


4

MATL , 26 25 byte

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

Provalo online! con 9e5sostituito da 9e4, in modo da non superare il tempo di esecuzione massimo e la dimensione di output del compilatore online.

Come funziona

Questo utilizza l'iterazione invece della ricorsione. (In effetti, MATL non ha ricorsione).

Viene prima generata una matrice di numeri da 1a 9e5(questo è sufficiente, perché 9e5supera 7^7). Poi, numeri che sono multipli di 7o hanno 7come cifre sono identificate, e sostituito da 1, 2... Il processo viene iterato finché non ci sono numeri che devono essere sostituiti.

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 byte

La banale soluzione che utilizza un loop infinito, niente di speciale ..

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

È possibile utilizzare incr. E se tcl versione> = 8.6, incrassume la prima iterazione un incremento di una nuova variabile da 0a 1se quella variabile non era stata impostata prima; così puoi sbarazzarti delle prime due setistruzioni.
sergiol,

ho giocato a golf - ho rimosso anche alcuni spazi bianchi non necessari.
sergiol,

Il sito in cui ho pubblicato i miei suggerimenti sul golf per te li ha persi, quindi ho fatto una mia nuova risposta
sergiol

3

PHP, 106 80 byte

Grazie Ismael Miguel per l'aiuto con la soluzione ternaria e il codice di ciclo più breve usando per invece di while.

Impossibile verificare le ultime parti dell'intera sequenza a causa della durata massima di 30 secondi di PhpFiddle. Sembra funzionare almeno fino a 1K in base all'output di esempio fornito dall'OP.

Golf:

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

Versione da golf originale :

$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)." ";Non conosco il conteggio dei byte, ma sono sicuro che è molto inferiore a 106 byte. Provalo e vedi se funziona.
Ismael Miguel,

Molto gentile, grazie per l'aiuto. L'unica modifica al codice è stata quella di inserire i primi 7 tra virgolette che hanno aggiunto due byte alla versione di 78 byte.
Wahooka,

È possibile salvare 3 byte circa for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. Non sono sicuro di poterlo sostituire $n%7==0con, !$n%7ma vale la pena provare.
Ismael Miguel,

1
Continua -6: $ n = 0 è inutile, "7" può essere 7.
Crypto

1
perché cambiare? for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 byte). ++$b-1perché$a[null] === null
Christoph,

3

Julia, 62 byte

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

Nulla di bello. Usa che la sequenza all'interno delle lacune è la sequenza stessa. Esegue copie di array eccessive per salvare alcuni byte.


3

Perl 6 ,  74 57 54  53 byte

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

Provalo

Allargato:

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

Sembra che potresti salvare un byte dicendo ~7invece di '7'.
Sean,

2

Ceylon, 202 byte

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

Questa non è una funzione, ma una dichiarazione di oggetto che implementa una sequenza infinita (Iterable). L'oggetto può essere stampato direttamente, print(u)genera questo:

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

Per stampare di più, utilizzare printAll(u). Il codice seguente utilizza le nuove righe e stampa anche la somma (e i primi 30 elementi mostrati sopra):

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

Ecco la versione ungolf e commentata:

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

Rubino, 80 byte

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}

Primo invio, sono sicuro che può essere migliorato :)


1
Benvenuti in PPCG! Questo arriva ad almeno 7 ^ 7 (cioè 823543) e tiene conto dei numeri che contengono la cifra 7, cioè 17?
ETHproductions

Di certo no. Riparato ora. Pensavo che quel problema fosse un po 'troppo semplice :)
Christopher Lates,

Bello, ma non sono ancora sicuro che si qualifichi. Il numero dopo 34(che è 8attualmente) dovrebbe essere 7, ma poiché 7è un numero indicibile, il programma dovrebbe iniziare una terza iterazione e invece stampare 1.
ETHproductions

2

Dyalog APL , 39 byte

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

⍳7*7è 1 2 3 ... 7 7

{ }⍣≡è l' operatore in virgola fissa : applicare ripetutamente una funzione fino a quando il risultato non si stabilizza

A@I⊢B modificare operatore - sostituire gli elementi a indici Iin BconA

0=7|⍵ maschera di bit per cui l'argomento è divisibile per 7

'7'∊¨⍕¨⍵ maschera di bit per cui la formattazione decimale dell'argomento contiene un 7

o

a quali indici è vera una delle maschere di cui sopra?

i← assegnato a i

⍵⍴⍨⍴i rimodellare l'argomento in base al numero di elementi in i


Questo è carino. Aiuta se moltiplichi ⍳7 * 7 con la maschera di bit e prendi il punto fisso di modifica degli zeri nella sequenza?
mschauer,

2

C 157 155 byte

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

Sembra giusto, non mi sono preoccupato di controllare completamente. Va fino a 999999 che è apparentemente abbastanza grande.

Versione non golfata:

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

Versione parzialmente golfata:

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

Hai bisogno delle parentesi graffe dopo else?
Zacharý,

Non grazie. Inoltre non ho tecnicamente bisogno delle parentesi graffe per la (r=0)maggior parte del tempo. Ma alcuni compilatori sono schizzinosi. Sono troppo pigro per controllare le specifiche in questo momento.
LambdaBeta,

2

R, 86 byte

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}

Utilizza R Truthy integrato T(inizializzato su TRUE/ 1) per contare i numeri nella sequenza e il valore Falsy F(inizializzato su FALSE/ 0) per contare gli indicibili. Oltre a ciò, il programma controlla semplicemente se ogni numero è divisibile per sette o contiene il numero.


-4 byte in sostituzione 7%in%el(strsplit(c(T,""),""))di 55%in%utf8ToInt(paste(T))? (non testato)
JayCe,

2

C - 115 byte

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: Grazie a @mschauer che ha sottolineato che mi sono perso alcune cose.


Bel approccio. Due osservazioni r% 10-7 acquisisce solo sette finali e non corrompe il tuo heap: la profondità dello stack aumenta polinomialmente ... s [99] è sicuro.
mschauer,

2

Javascript, 80 byte

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

Poiché vi sono solo requisiti minimi ma non requisiti massimi, questa soluzione continua a produrre indefinitamente.

Per verificare che l'algoritmo sia corretto, è possibile eseguire lo stesso codice stampando solo gli ultimi 10 numeri e la somma:

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

SintassiError: mancante) tra parentesi
l4m2

1

Mathematica, 82 byte

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

1

JavaScript 81 byte

Originale (98 byte)

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

Benvenuti nel sito! Non so molto su JavaScript, ma potresti fare qualcosa del genere 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

Grazie @DrMcMoylex, che ha lasciato cadere qualche altro byte. Non dubito che ci sia ancora spazio per miglioramenti.
Richard Sime,

Sono contento di poterti aiutare! Un'altra cosa che ho appena realizzato, è che potresti fare 9e5invece Math.pow(7,7), dal momento che la sfida ha detto:Print/output AT LEAST the first 7^7
DJMcMayhem

Sì, bello scatto Doc! Ciò mi ha permesso di eliminare un uguale anche da un operatore di confronto.
Richard Sime,

Non sembra fare quello che ci si aspetta. Quando riempi gli spazi vuoti, apparentemente devi applicare di nuovo le regole piuttosto che resettare un contatore (vedi questa parte della sequenza:) 34 1 36 **8** 38. Ma per quello che vale, la versione attuale potrebbe essere giocato a golf un po 'di più: for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld,

1

Befunge, 100 o 156 byte

Questa prima versione è la più portatile delle due, limitandosi a celle di memoria a 7 bit, che è ciò che ottieni nell'interprete di riferimento.

"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 seconda versione funziona solo con interpreti che hanno celle di memoria a 32 bit, e quindi non è strettamente standard Befunge, ma che ci consente di memorizzare valori più grandi in memoria senza doverli dividere tra celle.

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

In entrambi i casi il programma funziona a tempo indeterminato, ma la prima versione traboccerà intorno ai 2 milioni, mentre la seconda versione dovrebbe arrivare al valore massimo int (circa 2 miliardi).

Puoi provarlo online , ma dovrai interrompere il processo per impedirne il funzionamento per sempre.


1

Clojure, 130 byte

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

Riduzione di base, tenendo traccia dei contenuti del vettore risultato e di quanti valori sono stati ignorati. L'ultimo 0prende il primo elemento del ridotto [r s], restelimina il primo elemento del risultato indicizzato 0.


1

Perl6, 41 byte

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

1

Tcl , 64 byte

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

Provalo online!


simpatico! molto più breve della mia ...
hdrz,

Questo scrive "... 33 34 7 36 8 38 ..." invece di "... 33 34 1 36 8 38 ..."
mschauer,

@mschauer: Ok, lo aggiusterò quando avrò tempo ...
sergiol

@hdrz Ho provato la tua soluzione e ha lo stesso problema di cui parlava mschauer!
sergiol,

1

JavaScript, 64 byte

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 per confrontare con le altre poche ( console.log) risposte JavaScript, sono 70 byte
l4m2

1

Japt , 25 byte

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

Prova la somma e gli ultimi 10 elementi.

Genera le prime 1.000.000 di voci della sequenza e le stampa. Un milione è il numero più corto 7**7 == 823543di Japt.

La nuova riga finale è significativa, in quanto attiva l'assegnazione implicita a U.

La generazione dell'elenco richiede solo un secondo, ma l'output dell'intero array probabilmente farà bloccare il browser.

Disimballato e come funziona

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

Utilizza la proprietà per cui la definizione ricorsiva può essere risolta osservando la sequenza già generata.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.