En arithmétique, un nombre n-lisse , où n est un nombre premier donné, est défini mathématiquement comme un entier positif qui n'a pas de facteurs premiers supérieurs à n. Par exemple, 42 est 7-lisse parce que tous ses facteurs premiers sont inférieurs ou égaux à 7, mais 44 n'est pas 7-lisse car il a également 11 comme facteur premier.

Définissez un nombre assez lisse comme un nombre sans facteur premier supérieur à sa propre racine carrée. Ainsi, la liste des nombres assez lisses peut être formulée comme suit:

• (MODIFIÉ!) 1 est un nombre assez lisse, en raison de son absence totale de facteurs premiers. (Notez que dans la version originale de cette question, 1 a été exclu par erreur de la liste, donc si vous l'excluez de vos sorties, vous ne serez pas marqué comme mauvais.)
• Entre 4 (= 2 ² ) et 8, les nombres assez lisses sont à 2 lisses, ce qui signifie qu'ils ont 2 comme seul facteur premier.
• Entre 9 (= 3 ² ) et 24, les nombres assez lisses sont 3-lisses, et peuvent avoir 2 et 3 dans leurs factorisations principales.
• Entre 25 (= 5 ² ) et 48, les nombres assez lisses sont 5-lisses et peuvent avoir 2s, 3s et 5s dans leurs factorisations principales.
• Et ainsi de suite, en améliorant les critères à chaque fois que le carré du prochain nombre premier est atteint.

La liste des nombres assez lisses est fixe et commence comme suit: 1, 4, 8, 9, 12, 16, 18, 24, 25, ...

Votre défi est d'écrire du code qui produira tous les nombres assez fluides jusqu'à 10 000 inclus (= 100 ² ). Il doit y avoir au moins un séparateur (peu importe le type - espace, virgule, nouvelle ligne, quoi que ce soit) entre chaque numéro de la liste et le suivant, mais le caractère utilisé n'a aucune importance.

Comme d'habitude, le nombre d'octets le plus bas l'emporte - évidemment, la simple sortie de la liste ne vous sera pas trop bénéfique ici. Bonne chance!

En fait, 11 octets

4╤R`;yM²≤`░

Essayez-le en ligne!

Ne comprend pas 1.

Explication:

4╤R`;yM²≤`░
4╤R          range(10**4)
   `;yM²≤`░  filter: take values where
    ;yM²       the square of the largest prime factor
        ≤      is less than or equal to the value

Gelée , 12 octets

Æf>½S
³²ḊÇÐḟ

Essayez-le en ligne!

Comment ça fonctionne

³²ḊÇÐḟ  Main link. No arguments.

³       Yield 100.
 ²      Square it to yield 10,000.
  Ḋ     Dequeue; yield [2, ..., 10,000].
   ÇÐḟ  Filter-false; keep elements for which the helper link returns 0.

Æf>½S   Helper link. Argument: n

Æf      Compute the prime factorization of n.
  >½    Compare the prime factors with the square root of n.
    S   Sum; add the resulting Booleans.

Brachylog , 21 19 octets

1 octet grâce à Fatalize, pour l'inspiration d'un autre 1 octet.

100^:4reP$ph^<=P@w\

Essayez-le en ligne!

Prend environ 6 secondes ici.

100^:4reP$ph^<=P@w\
100                      100
   ^                     squared
    :4                   [10000,4]
      r                  [4,10000]
       eP                P is an integer in that interval (choice point),
        P$ph^<=P         P, prime factorized (from biggest to smallest),
                         take the first element, squared, is less than
                         or equal to P
               P@w       Write P with a newline,
                  \      Backtrack to the last choice point and make
                         a different choice until there is no more
                         choice and the program halts.

Solution précédente de 21 octets

100^:4reP'($pe^>P)@w\

Essayez-le en ligne!

Prend environ 6 secondes ici.

100^:4reP'($pe^>P)@w\
100                      100
   ^                     squared
    :4                   [10000,4]
      r                  [4,10000]
       eP                P is an integer in that interval (choice point),
        P'(      )       The following about P cannot be proved:
           $pe               one of its prime factor
              ^              squared
               >P            is greater than P
                  @w     Write P with a newline,
                    \    Backtrack to the last choice point and make
                         a different choice until there is no more
                         choice and the program halts.

Haskell, 53 octets

r=[1..10^4]
[n|n<-r,product[x|x<-r,x*x<=n]^n`mod`n<1]

Je n'ai pas le temps de jouer au golf maintenant, mais je veux illustrer une méthode pour tester si nest assez lisse: multiplier les nombres de 1à sqrt(n)(c.- à -d. Calculer une factorielle), augmenter le produit à une puissance élevée et vérifier si le résultat est un multiple de n.

Remplacez par r=[2..10^4]si 1ne doit pas être sorti.

Pyth , 16 15 octets

1 octet grâce à Jakube.

tf!f>*YYTPTS^T4

Essayez-le en ligne!

tf!f>*YYTPTS^T4
             T   10
            ^T4  10000
           S^T4  [1,2,3,...,10000]
 f               filter for elements as T for
                 which the following is truthy: 
         PT          prime factorization of T
   f                 filter for factor as Y:
     *YY                 Y*Y
    >   T                greater than T ?
  !                  logical negation
t                remove the first one (1)

05AB1E, 16 14 13 octets

4°L¦vyf¤yt›_—

Explication

4°L¦v             # for each y in range 2..10000
      yf¤         # largest prime factor of y
         yt       # square root of y
           ›_     # less than or equal
             —    # if true then print y with newline

Essayez-le en ligne

Matlab, 58 57 56 52 48 octets

for k=1:1e4
if factor(k).^2<=k
disp‌​(k)
end
end

Pour chaque nombre, il vérifie si tous les facteurs au carré ne sont pas supérieurs au nombre lui-même. Si oui, affiche ce numéro.

Merci à @Luis Mendo d' avoir joué à cette approche

Une autre approche (50 octets):

n=1:10^4;for k=n
z(k)=max(factor(k))^2>k;end
n(~z)

Pour chaque nombre, calcule si son facteur premier maximal au carré est inférieur au nombre lui-même. L'utilise ensuite pour l'indexation.

SQF , 252 227 220

Format de script standard:

#define Q(A,B) for #A from 2 to B do{
Q(i,10000)if([i]call{params["j"];u=sqrt j;a=true;Q(k,u)a=a and((j%k!=0)or(j/k<u)or!([j/k]call{params["x"];q=true;Q(z,sqrt x)q=q and(x%z!=0)};q}))};a})then{systemChat format["%1",i]}}

Incluez le pré-processeur dans la chaîne de compilation lors de l'appel, par exemple:

• execVM "FILENAME.sqf"
• call compile preprocessFile "FILENAME.sqf"

Cela écrit dans le journal System Chat, qui est la chose la plus proche que SQF doit stdout

C, 113 octets

#include<stdio.h>
main(a){for(;++a<10001;){int n=2,c=a;for(;n*n<=a;n++)while(c%n<1)c/=n;if(c<2)printf("%d ",a);}}

Ideone it!

Pyke, 13 12 11 octets

T4^S#DP#X<!

Essayez-le ici!

(Le lien ne monte que jusqu'à 10 ^ 3 car 10 ^ 4 fois)

T4^S        -  one_range(10^4)
    #DP#X<! - filter_true(V, ^): (as i)
      P     -   factors(i)
       #X<! -  filter_true(V, ^):
        X   -   ^ ** 2
         <! -    not (i < ^)

J, 20 octets

(#~{:@q:<:%:)2+i.1e4

Résultat:

   (#~{:@q:<:%:)2+i.1e4
4 8 9 12 16 18 24 25 27 30 32 36 40 45 48 49 50 54 56 60 63 64 70 72 75 80...

Essayez-le en ligne ici.

Python 2, 90 octets

for i in range(4,10001):
 n=2;j=i
 while n*n<=j:
  while i%n<1:i/=n
  n+=1
 if i<2:print j

Ideone it!

R, 97 octets

b=F;for(j in 1:1e4){for(i in which(!j%%1:j)[-1])if(which(!i%%1:i)[2]==i)b=i<=j^0.5;if(b)print(j)}

non golfé

b <- F                               #Initializes
for (j in 1:1e4){                    #Loop across integers 1..10^4
    a <- which(!j%%1:j)[-1]          #Finds all factors
    for (i in a)                     #Loop across factors
         b <- which(!i%%1:i)[2]==i   #Tests primeness
         if(b) c <- i<=j^0.5         #If prime, tests smoothness
    if(c) print(j)                   #If biggest prime factor gives smooth
}                                    #result, Prints the number.

Pyth, 12 octets

g#^ePT2tS^T4

Ne comprend pas 1.