In aritmetica, un numero n-liscio , dove n è un dato numero primo, è matematicamente definito come un numero intero positivo che non ha fattori primi maggiori di n. Ad esempio, 42 è 7-smooth perché tutti i suoi fattori primi sono inferiori o uguali a 7, ma 44 non è 7-smooth perché ha anche 11 come fattore primo.

Definisci un numero abbastanza regolare come numero senza fattori primi maggiori della sua radice quadrata. Pertanto, l'elenco di numeri abbastanza fluidi può essere formulato come segue:

• (EDITED!) 1 è un numero abbastanza regolare, a causa della sua completa mancanza di fattori primi. (Si noti che nella versione originale di questa domanda, 1 è stato erroneamente escluso dall'elenco, quindi se lo si esclude dalle uscite non si verrà contrassegnati come errati.)
• Tra 4 (= 2 ² ) e 8, i numeri abbastanza uniformi sono 2-smooth, il che significa che hanno 2 come unico fattore primo.
• Tra 9 (= 3 ² ) e 24, i numeri abbastanza uniformi sono 3-smooth e possono avere 2s e 3s nelle loro prime fattorizzazioni.
• Tra 25 (= 5 ² ) e 48, i numeri abbastanza uniformi sono 5-smooth e possono avere 2s, 3s e 5s nelle loro prime fattorizzazioni.
• E così via, aggiornando i criteri ogni volta che viene raggiunto il quadrato del numero primo successivo.

L'elenco dei numeri abbastanza fluidi è fisso e inizia come segue: 1, 4, 8, 9, 12, 16, 18, 24, 25, ...

La tua sfida è quella di scrivere codice che produrrà tutti i numeri abbastanza fluidi fino a 10.000 inclusi (= 100 ² ). Ci deve essere almeno un separatore (non importa di che tipo - spazio, virgola, newline, qualsiasi cosa) tra ciascun numero nell'elenco e quello successivo, ma è del tutto irrilevante quale carattere viene utilizzato.

Come al solito, vince il conteggio di byte più basso - ovviamente, semplicemente generare l'elenco non sarà troppo utile per te qui. In bocca al lupo!

In realtà, 11 byte

4╤R`;yM²≤`░

Provalo online!

Non include 1.

Spiegazione:

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

Gelatina , 12 byte

Æf>½S
³²ḊÇÐḟ

Provalo online!

Come funziona

³²ḊÇÐḟ  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 byte

1 byte grazie a Fatalize, per l'ispirazione di un altro 1 byte.

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

Provalo online!

Ci vogliono circa 6 secondi qui.

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.

Precedente soluzione a 21 byte

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

Provalo online!

Ci vogliono circa 6 secondi qui.

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 byte

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

Non ho tempo per giocare a golf ora, ma voglio illustrare un metodo per testare se nè abbastanza fluido: moltiplica i numeri da 1a sqrt(n)(cioè calcola un fattoriale), aumenta il prodotto ad alta potenza e controlla se il risultato è un multiplo di n.

Passare a r=[2..10^4]if 1non dovrebbe essere emesso.

Pyth , 16 15 byte

1 byte grazie a Jakube.

tf!f>*YYTPTS^T4

Provalo online!

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 byte

4°L¦vyf¤yt›_—

Spiegazione

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

Provalo online

Matlab, 58 57 56 52 48 byte

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

Per ogni numero controlla se tutti i fattori al quadrato non sono maggiori del numero stesso. Se sì, visualizza quel numero.

Grazie a @Luis Mendo per il golf questo approccio

Un altro approccio (50 byte):

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

Per ogni numero viene calcolato se il suo fattore primo massimo quadrato è inferiore al numero stesso. Quindi lo utilizza per l'indicizzazione.

SQF , 252 227 220

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

Includere il pre-processore nella catena di compilazione quando si chiama, ad esempio:

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

Questo scrive nel registro della chat di sistema, che è la cosa più vicina a cui SQF ha bisogno

C, 113 byte

#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 esso!

Pyke, 13 12 11 byte

T4^S#DP#X<!

Provalo qui!

(Il collegamento arriva fino a 10 ^ 3 perché 10 ^ 4 volte fuori)

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 byte

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

Risultato:

   (#~{:@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...

Provalo online qui.

Python 2, 90 byte

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 esso!

R, 97 byte

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

ungolfed

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 byte

g#^ePT2tS^T4

Non include 1.