Es gibt eine ziemlich merkwürdige Zahl, die manchmal in mathematischen Problemen oder Rätseln auftaucht. Das Pseudofaktorielle (N) ist das kleinste (dh niedrigste) gemeinsame Vielfache der Zahlen 1 bis N; Mit anderen Worten, es ist die niedrigste Zahl, die alle Zahlen von 1 bis N als Faktoren hat.

Zum Beispiel pseudofaktoriell (7) = 3 * 4 * 5 * 7, das ist das Gleiche wie 7! mit der Ausnahme, dass 2 und 6 entfernt wurden, weil sie in anderen Begriffen enthalten sind.

Schreiben Sie ein Programm zur Berechnung von Pseudofaktoren (N), und wie immer gewinnt der kürzeste Code.

Hier ist eine kurze Liste für Ihre Verwendung. Weitere Testfälle finden Sie im OEIS unter A003418 .

Fakultät:

1. 1
2. 2
3. 6
4. 24
5. 120
6. 720
7. 5040

Pseudofaktoriell:

1. 1
2. 2
3. 6
4. 12
5. 60
6. 60
7. 420

Dyalog APL , 3 Bytes

∧/⍳

APL schlägt Jelly ‽

⍳ 1 obwohl Argument

∧/ LCM über

Gelee , 4 Bytes

Ræl/

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

Ræl/  Main link. Input: n

R     Range; yield [1, ..., n].
   /  Reduce the range...
 æl     by LCM.

C (mit x86), 52 Bytes

d(n,k,b,t){for(b=k=1;b;++k)for(t=n,b=0;t;b+=k%t--);}

Prüft Zahlen von 1 aufwärts. Dividiert es für jede Zahl durch alle Zahlen von n bis 1 und summiert die verbleibenden Zahlen. Stoppt, wenn die Summe 0 ist.

Verwendungszweck:

main()
{
    printf("%d\n", d(7)); // outputs 420
}

Es ist nicht offensichtlich, wie ein Wert zurückgegeben wird (es gibt keine returnAnweisung).

Die Aufrufkonvention für x86 besagt, dass die Funktion ihren Wert im eaxRegister zurückgeben muss. Praktischerweise idiverwartet der Divisionsbefehl seine Eingabe in eaxund gibt das Ergebnis in eax(Quotient) und edx(Rest) aus. Die letzte Iteration dividieren kdurch 1, so eaxenthält den richtigen Wert , wenn die Funktion beendet.

Dies funktioniert nur, wenn Optimierungen aktiviert sind (im Debug-Modus werden diese ausgegeben 421).

Haskell, 20 Bytes

f x=foldr1 lcm[1..x]

Anwendungsbeispiel: map f [1..7]-> [1,2,6,12,60,60,420].

Der lcmTrick in Haskell.

Python + SymPy, 45 Byte

import sympy
lambda n:sympy.lcm(range(1,n+1))

Ziemlich selbsterklärend.

Python 2, 57 54 Bytes

i=r=input();exec't=r\nwhile r%i:r+=t\ni-=1;'*r;print r

Teste es auf Ideone .

Wie es funktioniert

Die Eingabe wird in den Variablen i und r gespeichert .

execFührt den folgenden Code r- mal aus.

t=r
while r%i:r+=t
i-=1

Während i von r bis 1 variiert , addieren wir den Anfangswert von r (in t gespeichert ) so oft wie nötig, um selbst ein Vielfaches von i zu erzeugen . Das Ergebnis ist offensichtlich ein Vielfaches von t .

Der Endwert von r ist also ein Vielfaches aller ganzen Zahlen im Bereich [1, ..., n] , wobei n die Eingabe ist.

Python, 46 Bytes

g=lambda n,c=0:n<1or(c%n<1)*c or g(n,c+g(n-1))

Auf der Suche nach dem Vielfachen cvon g(n-1)direkt. Ich hatte zwar vorher, dass diese Methode fälschlicherweise 0 als ein Vielfaches von irgendetwas finden würde, aber das orKurzschließen oder (c%n<1)*cwird auch überspringen, c==0weil 0 falsch ist.

50 Bytes:

g=lambda n,i=1:n<1or(i*n%g(n-1)<1)*i*n or g(n,i+1)

Wie Dennis 'Lösung , aber als rekursive Funktion. Nach der Berechnung g(n-1)wird nach dem kleinsten Vielfachen i*ngesucht n, das auch ein Vielfaches von ist g(n-1). Wirklich langsam.

Dank Dennis 4 Bytes um ein Vielfaches von der Suche nstatt g(n-1).

J 9 Bytes

[:*./1+i.

Unkomplizierter Ansatz. Erstellt den Zahlenbereich [0, ..., n-1], fügt dann jeweils einen hinzu und reduziert ihn mithilfe des LCM.

Verwendungszweck

   f =: [:*./1+i.
   f 7
420

MATL , 4 Bytes

:&Zm

Probieren Sie es online!

Erläuterung

:      % Take input N implicitly. Generate range [1 2 ... N]
&Zm    % LCM of the numbers in that array. Display implicitly

Mathematica, 13 Bytes

LCM@@Range@#&

Julia, 11 Bytes

!n=lcm(1:n)

Probieren Sie es online!

Pyth - 8 Bytes

Überprüft alle Zahlen, bis eine teilbare gefunden wird [1..N].

f!s%LTSQ

Test Suite .

Oktave, 27 Bytes

@(x)lcm(1,num2cell(1:x){:})

Erstellt eine anonyme Funktion, die als aufgerufen werden kann ans(N).

Online Demo

Erläuterung

Diese Lösung erstellt eine Liste aller Zahlen zwischen 1und x( 1:x), konvertiert sie in ein Zellenfeld mit num2cell. Die {:}Indizierung erstellt dann eine durch Kommas getrennte Liste, die lcmals mehrere Eingabeargumente übergeben wird, um das am wenigsten verbreitete Vielfache zu berechnen. Eine 1 wird immer als erstes Argument an übergeben, lcmda lcmimmer mindestens zwei Eingabeargumente benötigt werden.

MATLAB, 49 Bytes

@(x)find(~any(bsxfun(@rem,1:prod(1:x),(1:x)')),1)

Perl 6 , 13 Bytes

{[lcm] 1..$_}

Anonymer Codeblock, der einen Bereich von 1 bis zur Eingabe (einschließlich) erstellt und diesen dann mit reduziert &infix:<lcm>.

Beispiel:

#! /usr/bin/env perl6
use v6.c;

my &postfix:<p!> = {[lcm] 1..$_}

say 1p!; # 1
say 2p!; # 2
say 3p!; # 6
say 4p!; # 12
say 5p!; # 60
say 6p!; # 60
say 7p!; # 420

say 10000p!; # 5793339670287642968692270879...
# the result from this is 4349 digits long

JavaScript (ES6), 92 88 80 74 69 Byte:

Danke @ConorOBrien und @Neil

y=>(g=(a,b)=>b?g(b,a%b):a,[...Array(y)].map((_,i)=>y=y*++i/g(y,i)),y)

05AB1E, 20 Bytes

Lpvyi¹LÒN>¢àN>*ˆ}}¯P

Erläuterung

Lpv                    # for each item in isprime(range(1,N)): N=7 -> [0,1,1,0,1,0,1]
   yi                  # if prime
     ¹LÒN>¢            # count occurrences of the prime 
                         in the prime-factorization of range(1,N):
                         p=2 -> [0,1,0,2,0,1,0]
           àN>*ˆ       # add max occurrence of that prime multiplied by the prime 
                         to global array: N=7 -> [4,3,5,7]
                }}     # end if/loop
                  ¯P   # get product of global array

Probieren Sie es online aus

Minkolang 0,15 , 12 Bytes

Ich habe zwei 12-Byte-Lösungen und habe sie beide enthalten.

1n[i1+4$M]N.

Probieren Sie es hier aus!

Erläuterung

1               Push 1
 n              Take number from input
  [             For loop that repeats n times
   i1+          Push loop counter + 1
      4$M       Pop b, a and push lcm(a,b)
         ]      Close for loop
          N.    Output as number and stop.

Ungefähr so ​​einfach wie es nur geht.

11nLd[4$M]N.

Probieren Sie es hier aus!

Erläuterung

11              Push two 1s
  n             Take number from input
   L            Pop b, a and push range from a to b, inclusive
    d           Duplicate top of stack (n)
     [4$M]      Pop b, a and push lcm(a,b), n times
          N.    Output as number and stop.

Daraus lässt sich eine dritte Lösung ableiten: a entfernen 1und a dnach dem Strom hinzufügen d. In beiden Fällen wird die zusätzliche Nummer benötigt, da die for-Schleife ein Mal zu oft ausgeführt wird und das einmalige Ausführen zwei Bytes ( 1-kurz vor der [) dauert .

Ruby, 25 Bytes

g=->n{(1..n).reduce :lcm}

Ruby, 25 Bytes

g=->n{n<1?1:a[n-1].lcm n}

GameMaker-Sprache, 60 Byte

for(b=k=1;b;++k){b=0for(t=argument0;t;b+=k mod t--)}return k

Basierend auf der Logik von Anatolygs Antwort.

PHP, 61 52 48 Bytes

sparte 9 Bytes dank @ user59178, 4 Bytes durch Zusammenführen der Schleifen.

Rekursion in PHP ist aufgrund des functionSchlüsselworts umfangreich; Also benutze ich Iteration.
Und mit ein paar "kleinen" Tricks habe ich jetzt sogar Arnauld´s JS geschlagen .

while(++$k%++$i?$i>$argv[1]?0:$i=1:$k--);echo$k;

Nimmt Eingaben vom Kommandozeilenargument entgegen. Laufen Sie mit -r.

Nervenzusammenbruch

while(++$k%++$i?    # loop $i up; if it does not divide $k
    $i>$argv[1]?0       # break if $i (smallest non-divisor of $k) is larger than input
    :$i=1               # while not, reset $i and continue loop with incremented $k
    :$k--);         # undo increment while $i divides $k
echo$k;         # print $k

ungolfed

Das sind eigentlich zwei Loops in einem:

while($i<=$argv[1]) # loop while $i (smallest non-divisor of $k) is not larger than input
    for($k++,       # loop $k up from 1
        $i=0;$k%++$i<1;);   # loop $i up from 1 while it divides $k
echo$k;             # print $k

Hinweis: Von meiner Antwort auf das Duplikat kopiert

AWK, 42 Bytes

{for(x=n=1;n<=$1;)if(x%n++){x++;n=1}$0=x}1

Befehlszeilenverwendung:

awk '{for(x=n=2;n<=$1;)if(x%n++){x++;n=2}$0=x}1' <<< NUM

Ich habe AWKgestern keine Lösung und kein Duplikat der Frage gesehen, also dachte ich, ich würde das zusammenwerfen. Es ist ziemlich langsam für 19meine Box oder größer zu lösen , aber es funktioniert.

Japt, 10 Bytes

Kein LCM eingebaut.

@õ e!vX}a1

Versuch es

Pyke, 3 Bytes, nicht konkurrierend

S.L

Probieren Sie es hier aus!

S   - range(1, input+1)
 .L - lowest_common_multiple(^)

Hoon , 67 Bytes

|*
*
(roll (gulf 1 +<) |=({a/@ b/_1} (div (mul a b) d:(egcd a b))))

Erstellen Sie die Liste [1..n], falten Sie die Liste mit lcm. Leider gibt es in der Hoon-Stdlib keine vorgefertigte, die ich verwenden kann: /

𝔼𝕊𝕄𝕚𝕟, 7 Zeichen / 9 Bytes

Мū…⩤⁽1ï

Try it here (ES6 only).

Nur ein LCM von inclusive reicht von 1 bis input.

QBIC , 35 32 Bytes

Das hat mich hierher gebracht.

:{p=0[a|~q%b|p=1]]~p=0|_Xq\q=q+1

Erläuterung:

:        Get cmd line param as number 'a'
{        Start an infinite DO loop
p=0      Sets a flag that shows if divisions failed
[a|      FOR (b=1; b<=a; b++)
~q%b     IF 'q' (which starts at 1 in QBIC) is not cleanly divisible by 'b'
|p=1     THEN Set the flag
]]   Close the FOR loop and the IF, leave the DO open
~p=0     IF 'q' didn't get flagged
|_Xq     THEN quit, printing 'q'
\q=q+1   ELSE raise 'q', redo
         [DO Loop implicitly closed by QBIC]

Hier ist eine Version, die den Test beendet, qwenn bsie nicht sauber aufgeteilt wird. Auch die Reihenfolge der Prüfung bist gegen qin der Annahme , umgekehrt , dass höhere b's zu teilen sein wird härter durch (nehmen 2, 3, 4zum Beispiel: wenn %2=0, %4könnte sein !0. Umgekehrt nicht so sehr ...).

:{p=0[a,2,-1|~q%b|p=1┘b=2]]~p=0|_Xq\q=q+1

Axiom, 35 Bytes

f(x)==reduce(lcm,[i for i in 1..x])

Testcode und Ergebnisse

(25) -> [[i,f(i)] for i in [1,6,19,22,30]]
   (25)  [[1,1],[6,60],[19,232792560],[22,232792560],[30,2329089562800]]
                                                  Type: List List Integer

Ich mache einfach die Lösung von Finden Sie die kleinste positive ganze Zahl, die alle ganzen Zahlen von 1 bis n als Faktoren hat, weil Sie sagen, es ist doppelt, ich poste es hier

Pari / GP , 14 Bytes

n->lcm([1..n])

Probieren Sie es online!

8. 23 Bytes

Code

1 ' lcm rot 2 swap loop

Dieser Code belässt das resultierende Pseudofaktorielle im TOS

Verwendung und Beispiel

ok> 7 1 ' lcm rot 2 swap loop .
420

Oder klarer

ok> : pseudofact 1 ' n:lcm rot 2 swap loop ;

ok> 7 pseudofact .
420