In der Arithmetik wird eine n-glatte Zahl , bei der n eine gegebene Primzahl ist, mathematisch als positive ganze Zahl definiert, die keine Primfaktoren größer als n hat. Zum Beispiel ist 42 7-glatt, weil alle Primfaktoren kleiner oder gleich 7 sind, aber 44 ist nicht 7-glatt, weil es auch 11 als Primfaktor hat.

Definieren Sie eine ziemlich glatte Zahl als eine Zahl ohne Primfaktoren, die größer sind als die eigene Quadratwurzel. Somit kann die Liste der ziemlich glatten Zahlen wie folgt formuliert werden:

• (EDITED!) 1 ist eine ziemlich glatte Zahl, da es keine Primfaktoren gibt. (Beachten Sie, dass in der Originalversion dieser Frage 1 fälschlicherweise aus der Liste ausgeschlossen wurde. Wenn Sie diese also von Ihren Ausgaben ausschließen, werden Sie nicht als falsch markiert.)
• Zwischen 4 (= 2 ² ) und 8 sind die hübschen glatten Zahlen 2-glatt, was bedeutet, dass sie 2 als einzigen Primfaktor haben.
• Zwischen 9 (= 3 ² ) und 24 sind die hübschen glatten Zahlen 3-glatt und können 2s und 3s in ihren primären Faktorisierungen haben.
• Zwischen 25 (= 5 ² ) und 48 sind die hübschen glatten Zahlen 5-glatt und können 2s, 3s und 5s in ihren Hauptfaktorisierungen haben.
• Und so weiter, indem Sie die Kriterien jedes Mal aktualisieren, wenn das Quadrat der nächsten Primzahl erreicht wird.

Die Liste der ziemlich glatten Zahlen ist fest und beginnt wie folgt: 1, 4, 8, 9, 12, 16, 18, 24, 25, ...

Ihre Herausforderung besteht darin, Code zu schreiben, der alle ziemlich glatten Zahlen bis einschließlich 10.000 (= 100 ²⁾ ausgibt ) . Zwischen jeder Zahl in der Liste und der nächsten muss mindestens ein Trennzeichen (es spielt keine Rolle, um welche Art es sich handelt - Leerzeichen, Komma, Zeilenvorschub usw.) stehen, es ist jedoch völlig unerheblich, welches Zeichen verwendet wird.

Wie üblich gewinnt die niedrigste Byteanzahl - offensichtlich ist es für Sie hier nicht von Vorteil, die Liste einfach auszugeben. Viel Glück!

Eigentlich 11 Bytes

4╤R`;yM²≤`░

Probieren Sie es online!

Enthält nicht 1.

Erläuterung:

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

Gelee , 12 Bytes

Æf>½S
³²ḊÇÐḟ

Probieren Sie es online!

Wie es funktioniert

³²ḊÇÐḟ  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 bis 19 Bytes

1 Byte danke an Fatalize, für die Inspiration eines weiteren 1 Byte.

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

Probieren Sie es online!

Dauert hier ungefähr 6 Sekunden.

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.

Vorherige 21-Byte-Lösung

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

Probieren Sie es online!

Dauert hier ungefähr 6 Sekunden.

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 Bytes

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

Ich habe jetzt keine Zeit zum Golfen, aber ich möchte eine Methode zum Testen veranschaulichen, ob nes ziemlich flüssig ist: Multiplizieren Sie die Zahlen von 1bissqrt(n) (dh Rechen einer Fakultät), das Produkt auf eine hohe Leistung zu erhöhen, und prüfen , ob das Ergebnis ist ein Vielfaches von n.

Wechseln Sie zu, r=[2..10^4]wenn 1nicht ausgegeben werden soll.

Pyth , 16 15 Bytes

1 Byte danke an Jakube.

tf!f>*YYTPTS^T4

Probieren Sie es 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 Bytes

4°L¦vyf¤yt›_—

Erläuterung

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

Probieren Sie es online aus

Matlab, 58 57 56 52 48 Bytes

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

Für jede Zahl wird geprüft, ob alle quadrierten Faktoren nicht größer als die Zahl selbst sind. Wenn ja, wird diese Nummer angezeigt.

Vielen Dank an @Luis Mendo für diesen Ansatz

Ein anderer Ansatz (50 Bytes):

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

Berechnet für jede Zahl, ob ihr maximaler quadratischer Primfaktor kleiner ist als die Zahl selbst. Verwendet es dann zur Indizierung.

SQF , 252 227 220

Standard-Skriptformat:

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

Beziehen Sie den Pre-Prozessor in die Kompilierungskette ein, wenn Sie z. B .:

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

Dies schreibt in das System-Chat-Protokoll, das der Standardeinstellung von SQF am nächsten kommt

C 113 Bytes

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

Pyke, 13 12 11 Bytes

T4^S#DP#X<!

Probieren Sie es hier aus!

(Link geht nur bis zu 10 ^ 3, da 10 ^ 4 mal aus)

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 Bytes

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

Ergebnis:

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

Probieren Sie es hier online aus.

Python 2, 90 Bytes

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

R 97 Bytes

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 Bytes

g#^ePT2tS^T4

Enthält nicht 1.