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 code-golf , 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

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

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.

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

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

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.

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

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

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

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.

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

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

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

Dyalog APL , 39 octets

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

⍳7*7est 1 2 3 ... 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 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;
        }
    }
}

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.

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.

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

Mathematica, 82 octets

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

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

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.

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.

Perl6, 41 octets

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

Tcl , 64 octets

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

Essayez-le en ligne!

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

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.