Les nombres innommables de Cantor


58

Un nombre indéfinissable est un nombre qui est divisible par sept ou dont sept est l'un des chiffres. Un jeu pour enfants doit compter en sautant des nombres indicibles

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

La version du jeu de Cantor est la séquence définie en remplissant de manière récursive la séquence "1 2 3 4 5 6 () 8 ..." dans les espaces () ci-dessus.

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

Imprimer / éditer au moins les 7 premiers ^ ^ 7 numéros du jeu de nombres indicibles de Cantor ...

Bien que la définition soit donnée de manière récursive, vous n'êtes pas obligé d'utiliser la récursion dans le code.

C'est du , alors le programme avec le plus petit nombre d'octets gagne!

Remarque: la somme des nombres de 1 à 7 ^ 7 correspond à 203511962727. Les 10 derniers chiffres de cette plage sont 823534 823535 221563 108068 823538 823539 823540 823541 823542 221565.

Dump Pastebin des 1000 premières itérées: http://pastebin.com/Ksiu9Svf


8
Veuillez fournir les 7 ^ 7 premiers chiffres de cette séquence afin que nous puissions vérifier nos solutions.
Nouvel An


2
Dans le cas où quelqu'un veut générer un peu plus de chiffres et de comparaison des résultats: La somme des 7 premiers ^ 77 chiffres dans la séquence est 3336402440238885119980169136020683586413168645292341926482898521634332654984279162327502549917668322950744929983987545341421076028
Niklas B.

Bien sûr, le nombre de 1 dans cette séquence est 22977, ce qui signifie que si vous choisissez un élément parmi les premiers 7 ^ 77 uniformément au hasard, vous avez 2 * 10 ^ -61 chances que ce soit un
Niklas B.

1
Si cela vous intéresse, voici un graphique montrant la croissance du nombre de répétitions: drive.google.com/file/d/0B71iQwGfNtw5NGladjdOZVhoNkk/…
Niklas B.

Réponses:


6

Pyth , 25 23 22 octets

Merci à @Maltysen pour -2 octets

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

Un programme qui imprime un flux infini.

Essayez-le en ligne! (Sortie rincée par intervalles et expire au bout d'une minute)

Comment ça fonctionne

.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 octets . Cela fonctionne parce que 7c'est primordial, donc la divisibilité est possible en vérifiant la factorisation en premier, ce qui cadre bien avec l'autre vérification
Maltysen

vous pouvez la poster, la partie principale de la vôtre
Maltysen

1
Félicitations pour avoir gagné ce concours. J'aime aussi le truc de @Maltysen!
mschauer

23

Python 2, 77 75 74 70 octets

Merci à @MartinEnder pour suggérer la limite 9e5qui Ende r d à travailler après un changement.
Merci à @mschauer pour avoir suggéré un flux infini, économisant 4 octets.

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

C'est un générateur qui produit un flot infini de nombres.


Ne pourriez-vous pas supprimer entièrement la limite supérieure?
mschauer

@mschauer Merci, je n'ai pas pensé à celui-là.
PurkkaKoodari

if n%7<1or'7'in`n`else npourrait être légèrement plus rapide (même nombre d'octets), car n%7<1est plus rapide que de vérifier la chaîne, et orcourt-circuiter. C'est dommage que ça yield[n,next(i)][n%7<1or'7'in`n`]ne marche pas.
mbomb007

@ mbomb007 Je ne pense pas que la vitesse soit un problème ici, mais merci. :)
PurkkaKoodari

10

Perl, 47 46 41 39 octets

5 octets sauvegardés grâce à @Dada

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

Essayez-le en ligne! TIO Nexus, maintenant avec le support Perl! Cela tronquera la sortie après un certain point, mais si vous avez installé Perl, vous pouvez l'exécuter localement pour produire la sortie complète.

Le code utilise quelques bizarreries étranges de la syntaxe de Perl, je vais donc expliquer comment cela fonctionne ci-dessous.

Répartition du code:

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]=$_=...gagner 2 octets si je ne me trompe pas.
Dada

@ Dada, en fait, puisque cela me évite d'avoir à assigner à $_, cela me fait gagner 5 octets. Merci!
Gabriel Benamy

1
Oh, en effet, je viens juste de jeter un coup d'œil rapide et je n'ai pas remarqué cette affectation au milieu .. bon travail :)
Dada

C'est à ce moment (et à ce moment seulement!) Que j'ai compris l'affirmation "Perl peut être tout à fait le langage en écriture seule".
haneefmubarak

@ Grimy s'il vous plaît ne modifiez pas le code des autres. Si vous souhaitez améliorer une réponse, ajoutez un commentaire incluant l'amélioration ou postez votre propre réponse. Comme vous ne pourrez probablement pas atteindre le PO par un commentaire, envoyez simplement votre propre réponse.
ovs

5

PHP, 80 (Wahooka) 57 54 octets

Bien que l'idée vienne de Wahooka. Je pense que ma version est suffisamment différente pour en faire une réponse personnelle:

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

5

Haskell, 67 à 66 octets

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 est une liste infinie des nombres.

Essayez-le en ligne!

fcommence une nouvelle itération avec 1un index dont le nombre à choisir est 0. Chaque fois qu'il y a un espace, nous prenons une nouvelle itération, sélectionnons son ithélément et continuons l'itération en cours avec i+1. S'il n'y a pas d'écart, on prend le nombre actuel xet on continue sans augmenter i.

Edit: -1 octet grâce à @BMO.


4

MATL , 26 à 25 octets

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

Essayez-le en ligne! with 9e5replace by 9e4, de sorte que le temps d'exécution maximal et la taille de sortie du compilateur en ligne ne soient pas dépassés.

Comment ça fonctionne

Cela utilise l'itération au lieu de la récursivité. (En fait, MATL n'a pas de récursivité).

Un tableau de nombres de 1à 9e5est d'abord généré (c'est suffisant, car 9e5dépasse 7^7). Ensuite, les chiffres qui sont des multiples de 7ou ont 7comme chiffres sont identifiés, et remplacé par 1, 2... Le processus est répété jusqu'à ce qu'il n'y a pas de chiffres qui ont besoin d'être remplacés.

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 octets

La solution triviale utilisant la boucle infinie, rien de fantaisie ..

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

Vous pouvez utiliser incr. Et si tcl version> = 8.6, incrla première itération suppose l’incrémentation d’une nouvelle variable de 0à 1si cette variable n’a pas été définie auparavant; afin que vous puissiez vous débarrasser des deux premières setinstructions.
sergiol

joué au golf par moi -même, j’ai aussi enlevé quelques espaces blancs inutiles.
sergiol

Le site où j'ai posté mes suggestions de golf pour vous les a perdues, alors j'ai fait ma nouvelle réponse
sergiol

3

PHP, 106 80 octets

Merci Ismael Miguel pour l’aide fournie avec la solution ternaire et le code de boucle plus court utilisé pour pendant au lieu de.

Impossible de vérifier les dernières parties de la séquence complète en raison de la durée d'exécution maximale de 30 secondes de PhpFiddle. Semble fonctionner au moins 1K en fonction de la sortie d’échantillon fournie par l’OP.

Le golf:

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

Version golfée 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)." ";Je ne connais pas le nombre d'octets, mais je suis sûr qu'il est bien inférieur à 106 octets. Essayez-le et voyez si cela fonctionne.
Ismael Miguel

Très bien, merci pour l'aide. La seule modification à votre code a été de mettre les 7 premiers entre guillemets, ce qui a ajouté deux octets à votre version à 78 octets.
Wahooka

Vous pouvez économiser 3 octets ou plus en faisant for($n=1;;$n++)echo$a[]=strpos($n,"7")>-1||$n%7==0?array_shift($a)." ":"$n ";. Je ne sais pas si vous pouvez remplacer $n%7==0par !$n%7mais cela vaut la peine d'essayer.
Ismael Miguel

1
Continuez comme ça -6: $ n = 0 est inutile, "7" peut être 7.
Crypto

1
pourquoi changer? for(;;)echo$a[]=strpos(++$n,55)<-1&&$n%7?"$n ":$a[++$b-1];(58 octets). ++$b-1parce que$a[null] === null
Christoph

3

Julia, 62 octets

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

Rien d'extraordinaire. Utilise que la séquence dans les espaces vides est la séquence elle-même. Effectue des copies de matrice excessives pour sauvegarder certains octets.


3

Perl 6 ,  74 57 54  53 octets

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

L'essayer

Étendu:

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

Tester:

$ 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

On dirait que vous pourriez économiser un octet en disant ~7au lieu de '7'.
Sean

2

Ceylan, 202 octets

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

Ce n'est pas une fonction, mais une déclaration d'objet implémentant une séquence infinie (Iterable). L'objet peut être imprimé directement, print(u)génère ceci:

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

Pour imprimer plus, utilisez printAll(u). Le code suivant utilise des nouvelles lignes et imprime également la somme (et les 30 premiers éléments illustrés ci-dessus):

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

Voici la version non-golfée et commentée:

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

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}

Première soumission, je suis sûr que cela peut être amélioré :)


1
Bienvenue chez PPCG! Cela va-t-il au moins à 7 ^ 7 (c'est-à-dire 823543) et compte-t-il les nombres qui contiennent le chiffre 7, c'est-à-dire 17?
ETHproductions

Ce n'est pas sûr. Correction maintenant. Je pensais que ce problème était un peu trop facile :)
Christopher Lates Le

Bien, mais je ne suis pas sûr que cela soit qualifié. Le nombre après 34(ce qui est 8actuellement) devrait être 7, mais comme il 7s'agit d'un nombre indiciable, le programme doit commencer une troisième itération et imprimer à la place 1.
ETHproductions

2

Dyalog APL , 39 octets

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

⍳7*7est 1 2 3 ... 7 7

{ }⍣≡est l' opérateur du point fixe - applique une fonction plusieurs fois jusqu'à ce que le résultat se stabilise

A@I⊢B modifier l' opérateur - remplacer les éléments à des indices Idans BdesA

0=7|⍵ masque de bits pour où l'argument est divisible par 7

'7'∊¨⍕¨⍵ masque binaire pour lequel la mise en forme décimale de l'argument contient un 7

ou

à quels indices l'un ou l'autre des masques ci-dessus est-il vrai?

i← affecter à i

⍵⍴⍨⍴i remodeler l'argument pour le nombre d'éléments dans i


C'est sympa. Cela aide-t-il si vous multipliez 77 * 7 par le masque de bits et prenez le point de repère de modification des zéros dans la séquence?
mschauer

2

C 157 155 octets

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

Cela semble correct, je n'ai pas pris la peine de vérifier complètement. Va jusqu'à 999999, ce qui est apparemment assez grand.

Version non-golfée:

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

Version partiellement golfée:

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

Avez-vous besoin des accolades après else?
Zacharý

Je pas, merci. De plus, techniquement, je n’ai pas besoin d’attelles la (r=0)plupart du temps. Mais certains compilateurs sont difficiles. Je suis trop paresseux pour vérifier les spécifications en ce moment.
LambdaBeta

2

R, 86 octets

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}

Utilise la vérité de R intégrée T(initialisée à TRUE/ 1) pour compter les nombres de la séquence et la valeur Falsy F(initialisée à FALSE/ 0) pour compter les indéfinissables. En dehors de cela, le programme vérifie simplement si chaque nombre est divisible par sept ou s'il contient le nombre.


-4 octets remplaçant 7%in%el(strsplit(c(T,""),""))par 55%in%utf8ToInt(paste(T))? (non testé)
JayCe

2

C - 115 octets

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: Merci à @mschauer qui a fait remarquer que j'avais raté certaines choses.


Belle approche. Deux remarques. r% 10-7 ne capture que les sept derniers et ne corrompt pas votre segment de mémoire: la profondeur de pile augmente de façon polynomiale ... s [99] est sans danger.
mschauer

2

Javascript, 80 octets

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

Puisqu'il existe seulement des exigences minimales mais pas des exigences maximales, cette solution continue à produire indéfiniment.

Pour vérifier que l'algorithme est correct, vous pouvez exécuter le même code en n'imprimant que les 10 derniers chiffres et la somme:

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

SyntaxError: manquant) entre parenthèses
l4m2

1

Mathematica, 82 octets

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

1

JavaScript 81 octets

Original (98 octets)

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

Golfé

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

Bienvenue sur le site! Je ne connais pas beaucoup le javascript, mais pourriez-vous faire quelque chose du genre 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

Merci @DrMcMoylex, qui a perdu quelques octets de plus. Je ne doute pas qu'il y ait encore place à amélioration.
Richard Sime

Heureux d'avoir pu aider! Une autre chose que je viens de réaliser, c’est que vous pourriez faire 9e5au lieu de Math.pow(7,7), puisque le défi disait:Print/output AT LEAST the first 7^7
DJMcMayhem

Oui, belle photo Doc! Cela m'a également permis de supprimer un égal d'un opérateur de comparaison.
Richard Sime

Il ne semble pas faire ce qui est attendu. Lorsque vous comblez les lacunes, vous devez apparemment appliquer les règles à nouveau plutôt que de simplement réinitialiser un compteur (voir cette partie de la séquence:) 34 1 36 **8** 38. Mais pour ce que ça vaut la peine, la version actuelle pourrait être un peu plus golfed: for(c=i=0;++i<9e5;)console.log(!/7/.test(i)&&i%7?i:c++%6+1).
Arnauld

1

Befunge, 100 ou 156 octets

Cette première version est la plus portable des deux, se limitant aux cellules de mémoire 7 bits, ce que vous obtenez dans l'interpréteur de référence.

"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 deuxième version ne fonctionne qu'avec les interpréteurs dotés de cellules de mémoire 32 bits et n'est donc pas strictement Befunge standard, mais cela nous permet de stocker des valeurs plus importantes en mémoire sans avoir à les diviser en plusieurs cellules.

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

Dans les deux cas, le programme fonctionne indéfiniment, mais la première version dépassera la barre des 2 millions, tandis que la seconde version devrait atteindre la valeur maximale en int (environ 2 milliards).

Vous pouvez essayer en ligne , mais vous devrez arrêter le processus pour l'empêcher d'essayer de s'exécuter pour toujours.


1

Clojure, 130 octets

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

Réduire de base, en gardant une trace du contenu du vecteur de résultat et du nombre de valeurs ignorées. Le dernier 0prend le premier élément du réduit [r s], restsupprime le premier élément du résultat indexé par 0.


1

Perl6, 41 octets

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

1

Tcl , 64 octets

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

Essayez-le en ligne!


agréable! beaucoup plus court que le mien…
hdrz

Ceci écrit "... 33 34 7 36 8 38 ..." au lieu de "... 33 34 1 36 8 38 ..."
mschauer

@mschauer: Ok, je vais arranger ça quand j'ai le temps ...
sergiol

@hdrz j'ai essayé votre solution et elle a le même problème que mschauer a raconté!
sergiol

1

JavaScript, 64 octets

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 à comparer avec les autres ( console.log) réponses JavaScript, il s’agit de 70 octets
l4m2

1

Japt , 25 octets

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

Testez la somme et les 10 derniers éléments.

Génère les premiers 1 000 000 entrées de la séquence et les imprime. Un million est le nombre le plus court sur 7**7 == 823543Japt.

Le retour à la ligne final est significatif car il active l’affectation implicite à U.

La génération de la liste ne prend qu’en une seconde environ, mais la sortie de l’ensemble du tableau risque de bloquer votre navigateur.

Déballé et comment ça marche

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

Utilise la propriété selon laquelle la définition récursive peut être résolue en examinant la séquence déjà générée.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.