Wiederholt! Factorials!


34

Nicht zu verwechseln mit Find the factorial!

Einführung

Die Fakultät einer ganzen Zahl nkann berechnet werden durch

n!=n×(n-1)×(n-2)×(...)×2×1

Das ist relativ einfach und nichts Neues. Fakultäten können jedoch auf doppelte Fakultäten erweitert werden , so dass für gerade Zahlen und für ungerade Zahlen. Wir sind aber nicht auf doppelte Fakultäten beschränkt. Zum Beispiel oder oder abhängig von Startwert.

n!!=n×(n-2)×(n-4)×(...)×4×2
n!!=n×(n-2)×(n-4)×(...)×3×1
n!!!=n×(n-3)×(n-6)×(...)×6×3
n!!!=n×(n-3)×(n-6)×(...)×5×2
n!!!=n×(n-3)×(n-6)×(...)×4×1

Zusammenfassend: wobei Oder im Klartext: Subtrahieren Sie die Fakultätszählung wiederholt von der Basiszahl und multiplizieren Sie alle resultierenden positiven ganzen Zahlen.

n!(k)={1if n=0nif 0<nkn((nk)!(k))if n>k
n!(k)=n!!k

Die Herausforderung

Schreiben Sie eine Funktion, die jede Art von wiederholten Fakultäten für jede nicht negative ganze Zahl berechnet.

Eingang

Entweder

  • Eine Zeichenfolge mit einer nicht negativen Ganzzahl zur Basis zehn, gefolgt von mindestens einem Ausrufezeichen. ZB "6!"oder "9!!"oder "40!!!!!!!!!!!!!!!!!!!!".

oder

  • Dieselben Werte werden durch zwei Ganzzahlen dargestellt: ein nicht negativer Basiswert und ein positiver Wert, der die Fakultätszählung darstellt. Dies kann gemäß einem beliebigen Format aus den Standard-E / A-Regeln erfolgen.

Ausgabe

Das Ergebnis dieser Berechnung.

Challenge-Bemerkungen

  • 0!entspricht 1per definitionem. Ihr Code muss dies berücksichtigen.
  • Die Fakultätszählung wird durch den außerhalb dieses Bereichs begrenzt. Sie können alles ausgeben. Abgesehen davon , das ist die einzige Ausnahme von dieser Regel.
    0<factorial countbase value
    0!

Beispiele

Input                              Output

3!!!                               3
0!                                 1
6!                                 720
9!!                                945
10!!!!!!!!                         20
40!!!!!!!!!!!!!!!!!!!!             800
420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  41697106428257280000000000000000

Probieren Sie es mit einer ungolfed Python-Implementierung aus: Probieren Sie es online aus!

Allgemeine Bemerkungen


6
In den Beispielen, 0!jedoch in den Hinweisen zur Herausforderung, wird angegeben, dass die Fakultätsanzahl kleiner oder gleich dem Basiswert ist.
Jonathan Allan

1
Würde nicht 3 !!! Null sein? n * (n-3) = 3 * (3-3) = 0.
ouflak

2
@ouflak Wenn es funktioniert wie 1 !, nicht wirklich. Es ist mehr wie 1! = 1. 2 !! = 2. 3 !!! = 3. Es gibt keine Berechnung, weil Sie am Ende der Rekursivität sind. Keine 0 in Produkten oder jede einzelne Fakultät würde am Ende auf 0 fallen.
V. Courtois

4
3!!!!!!!sollte nicht undefiniert sein - es sollte nur die Antwort geben 3. Es ist dasselbe wie 1!!=1(nicht undefiniert). Außerdem besagt Ihre Eingabespezifikation, dass es immer mindestens eine geben wird !, sodass das erste Beispiel 3nicht der Spezifikation entspricht.
Greg Martin

3
@ FabianRöling: Aber das ist nicht was das ist. Es geht nicht darum, Begriffe aus einer Fakultät (3!)!zu entfernen . Es ist ein irreführender Name. Ich ging davon aus, dass die Factorial-Funktion wiederholt in einer Kette angewendet werden würde, und musste sorgfältig lesen, um zu sehen, was es tatsächlich war. Zum Glück erklärt die Frage es klar. Ein besserer Name könnte schrittweise oder schrittweise oder so sein.
Peter Cordes

Antworten:



13

ArnoldC , 702 698 634 Bytes

LISTEN TO ME VERY CAREFULLY f
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE p
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE r
YOU SET US UP 1
HEY CHRISTMAS TREE c
YOU SET US UP 0
STICK AROUND n
GET TO THE CHOPPER r
HERE IS MY INVITATION r
YOU'RE FIRED n
ENOUGH TALK
GET TO THE CHOPPER n
HERE IS MY INVITATION n
GET DOWN p
ENOUGH TALK
GET TO THE CHOPPER c
HERE IS MY INVITATION 0
LET OFF SOME STEAM BENNET n
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE c
GET TO THE CHOPPER n
HERE IS MY INVITATION 0
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
CHILL
I'LL BE BACK r
HASTA LA VISTA, BABY

Probieren Sie es online!

Übersetzt in Pseudocode:

f(n,p) {
  r=1;
  c=0;
  while (n) {
    r=r*n;
    n=n-p;
    c=n<0;
    if (c) n=0;
  }
  return r;
}

Hinweis: ArnoldC hat nur einen Datentyp: 16-Bit-Integer mit Vorzeichen. Daher kann ich den 420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!Fall nicht testen .


Nur neugierig auf deinen Pseudocode. Wofür ist die Variable 'c'?
6.

@ouflak Ich habe meine Antwort ein paar Mal bearbeitet und vergessen. Die cVariable speichert tatsächlich den Wert des Vergleichs zwischen nund 0.
Charlie

+1 und ich habe es für meine LUA-Antwort ausgeliehen (abzüglich des 'c').
6.

12

Gelee , 4 Bytes

RṚmP

Probieren Sie es online!

Wie? Wenn n und k , erzeugt es zuerst den Bereich n,,1 (mit RṚ) und mbehält dann jedes kth Element dieses Bereichs bei (also n,nk,n2k,,nn/kk ) und multipliziert sie schließlich mit P.


Funktioniert gut und am Ende so einfach. Ich kenne Jelly überhaupt nicht, aber zumindest sieht es gut aus :)
V. Courtois

1
@ V.Courtois Wenn und k gegeben sind , erzeugt es zuerst den Bereich n , , 1 (mit ) und behält dann jedes k- te Element dieses Bereichs bei (also n , n - k , n - 2 k , , n - n / k k ) und multipliziert sie schließlich mit . Nur der einfache Ansatz. Bearbeiten: Ich habe diese Erklärung in die Antwort eingefügt. nkn,,1RṚmkthn,n-k,n-2k,,n-n/kkP
Mr. Xcoder

Hah, vielen Dank. Eines Tages möchte ich vielleicht in dieser Sprache Golf spielen, also muss ich diese Monaden, Dyaden usw. lernen
V. Courtois

Alternative , das aussieht wie CJam: r1mP.
Erik der Outgolfer

1
@KyeWShi Jelly hat eine eigene Codepage , sodass jedes der 256 enthaltenen Zeichen als 1 Byte codiert wird.
Mr. Xcoder

8

APL (Dyalog Extended) , 7 Byte SBCS

Anonyme implizite Präfixfunktion. Nimmt [n,b]als Argument.

×/-\…1¨

Probieren Sie es online!

 eine für jedes Element des Arguments; [1,1]

-\ kumulative Differenz; [n,n-b]

 Bereich unter Verwendung des zweiten Elements des linken Arguments als Indikator für den Schritt, z. B. geht [9,7]weiter mit5

×/ Produkt


7

Haskell , 21 Bytes

n%a=product[n,n-a..1]

Probieren Sie es online!

Das Kombinieren der eingebauten Produktfunktion mit einer schrittweisen Bereichsaufzählung übertrifft das, was ich rekursiv codieren könnte (selbst wenn flawr ein Byte speichert).

22 Bytes

n%a|n<1=1|m<-n-a=n*m%a

Probieren Sie es online!

Hier ist eine Lösung, die Eingaben im String-Format wie 9!!folgt vornimmt , was meiner Meinung nach interessanter ist.

42 Bytes

(\[(n,a)]->product[n,n-length a..1]).reads

Probieren Sie es online!


2
Ich denke, Sie könnten die rekursive Lösung aufn%a|n<1=1|m<-n-a=n*m%a
flawr


5

JavaScript (ES6), 21 Byte

Übernimmt die Eingabe als (k)(n).

k=>g=n=>n<1||n*g(n-k)

Probieren Sie es online!

Oder 24 Bytes zur Unterstützung von BigInts.


JavaScript (ES6), 55 Byte

Übernimmt die Eingabe als Zeichenfolge in dem in der Challenge beschriebenen Format.

s=>(a=s.split`!`,k=a.length-1,g=n=>n<1||n*g(n-k))(a[0])

Probieren Sie es online!


5

Leerzeichen , 91 Bytes

[S S S T    N
Push_1][S N
S _Duplicate_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer_(base)][T    T   T   _Retrieve_base][S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer_(factorial)][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_base][S S S T  N
_Push_1][T  S S T   _Subtract][N
T   T   S N
_If_negative_jump_to_Label_PRINT_RESULT][S N
S _Duplicate_base][S T  S S T   S N
_Copy_0-based_2nd_(result)][T   S S N
_Multiply][S N
T   _Swap_top_two][S S S N
_Push_0][T  T   T   _Retrieve_factorial][T  S S T   _Subtract][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT_RESULT][S N
N
_Discard_top][T N
S T _Print_result_as_integer]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Erklärung im Pseudocode:

Integer result = 1
Integer base = STDIN as integer
Integer factorial = STDIN as integer
Start LOOP:
  If(base <= 0):
    Call function PRINT_RESULT
  result = result * base
  base = base - factorial
  Go to next iteration of LOOP

function PRINT_RESULT:
  Print result as integer to STDOUT


4

Perl 6 , 22 Bytes

{[*] $^a,*-$^b...^1>*}

Probieren Sie es online!

Anonymer Codeblock, der das Produkt des Bereichs beginnend mit der ersten Eingabe zurückgibt, absteigend um die Sekunde, bis es unter 1der letzten Zahl liegt. Dies funktioniert für 0, da der Basisfall für das Reduzieren nach Produkt 1 ist, die Ausgabe also 1 ist.


4

05AB1E , 10 8 7 Bytes

ݦRIιнP

Eingabe als zwei getrennte Eingänge: erster Eingang ist base; zweiter Eingang ist factorial.

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

-2 Bytes dank @ Mr.Xcoder .
-1 Byte danke an @JonathanAllan .

Erläuterung:

Ý        # Create a list in the range [0, (implicit) base-input]
 ¦       # And remove the first item to make it the range [1, base]
         # (NOTE: this is for the edge case 0. For the other test cases simply `L` instead
         #  of `ݦ` is enough.)
  R      # Reverse this list so the range is [base, 1]
   Iι    # Uninterleave with the second input as step-size
         #  i.e. base=3, factorial=7: [[3],[2],[1],[],[],[],[]]
         #  i.e. base=10, factorial=8: [[10,2],[9,1],[8],[7],[6],[5],[4],[3]]
         #  i.e. base=420, factorial=30: [[420,390,360,...,90,60,30],[419,389,359,...],...]
     н   # Only leave the first inner list
      P  # And take the product of its values
         # (which is output implicitly as result)

Ursprüngliche 10- Byte- Antwort:

L0KD¤-IÖÏP

Eingabe als zwei getrennte Eingänge: erster Eingang ist base; zweiter Eingang ist factorial.

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

Erläuterung:

L           # Create a list in the range [1, (implicit) base-input]
 0K         # Remove all 0s (edge case for input 0, which will become the list [1,0])
   D        # Duplicate this list
    ¤       # Get the last value (without popping)
            # (could also be `Z` or `¹` for max_without_popping / first input respectively)
     -      # Subtract it from each item in the list
      IÖ    # Check for each if they're divisible by the second factorial-input
        Ï   # In the list we copied, only leave the values at the truthy indices
         P  # And take the product of those
            # (which is output implicitly as result)

1
Dieser 6-Byte-Test LR²ιнP( online testen ! ) Funktioniert für jeden Testfall, mit Ausnahme von 0.
Mr. Xcoder

Aber ich denke, dass 0 Fall in höchstens 2 Bytes behoben werden kann. Wenn Sie einen Weg finden, ihn zu beheben, können Sie ihn nehmen :) EDIT: Vielleicht LR²ιн0KPfür 8 Bytes?
Mr. Xcoder

@ Mr.Xcoder Schöne Antwort! Noch nie mit einem bestimmten Schritt unverschachtelt verwendet. :)
Kevin Cruijssen

0KSollte unnötig sein, da 0!es sich um eine ungültige Eingabe in der Spezifikation handelt (obwohl sie in den Beispielen enthalten ist). Ich habe dies kommentiert .
Jonathan Allan

1
... und wenn 0! in der Eingabedomäne ist, ݦRXιнPspart ein Byte.
Jonathan Allan

4

x86-64-Maschinencode, 12 Byte

Der gleiche Maschinencode führt im 32-Bit-Modus das Gleiche aus, und für 16-Bit-Ganzzahlen im 16-Bit-Modus.

Dies ist eine Funktion, die mit args n=RCX, aufrufbar ist k=ESI. 32-Bit-Rückgabewert in EAX.

Aufrufbar von C mit der x86-64-System-V-Aufrufkonvention mit Dummy-Args, um die reellen Args in die richtigen Register zu bringen. uint32_t factk(int, uint32_t k, int, uint64_t n); Ich konnte nicht einfach Windows x64 verwenden, weil ein Operand mulRDX blockiert und wir nicht möchten, dass REX-Präfixe auf R8 / R9 zugreifen. ndarf keinen Müll in den hohen 32-Bit haben, damit JRCXZ funktioniert, aber ansonsten ist alles 32-Bit.

NASM-Auflistung (relative Adresse, Maschinencode, Quelle)

 1                         factk:
 2 00000000 6A01             push 1
 3 00000002 58               pop rax             ; retval = 1
 4 00000003 E306             jrcxz  .n_zero      ; if (n==0) return
 5                         .loop:                ; do {
 6 00000005 F7E1              mul   ecx            ; retval *= n  (clobbering RDX)
 7 00000007 29F1              sub   ecx, esi       ; n -= k
 8 00000009 77FA              ja   .loop         ; }while(sub didn't wrap or give zero)
 9                         .n_zero:
10 0000000B C3               ret

0xc = 12 Bytes


Oder 10 Bytes, wenn wir den n=0Sonderfall nicht behandeln mussten , ohne das jrcxz.

Für standard Fakultät würden Sie loopanstelle von sub / ja 2 Bytes speichern, aber ansonsten genau den gleichen Code.


Testanrufer, der argcals k, mit nfest codiertem bestanden wird.

align 16
global _start
_start:
  mov  esi, [rsp]
;main:
  mov  ecx, 9
  call factk

  mov  esi, eax
  mov  edx, eax
  lea  rdi, [rel print_format]
  xor  eax, eax
extern printf
  call printf
extern exit
  call exit

section .rodata
print_format: db `%#x\t%u\n`

```

3

APL (Dyalog Unicode) , 11 Byte SBCS

Anonyme stillschweigende Infix-Funktion. Nimmt nals rechtes Argument und bals linkes Argument.

×/1⌈⊢,⊢-×∘⍳

Probieren Sie es online!

×∘⍳ mehrfach bdurch den ɩ ntegers 1 durchn

⊢- subtrahiere das von n

⊢, voranstellen n

1⌈ max von einem und jedem von denen

×/ Produkt



3

Wolfram Language (Mathematica) , 22 21 Bytes

1##&@@Range[#,1,-#2]&

Probieren Sie es online!

-1 danke an attinat: Times --> 1##&

Erläuterung: Verwenden Sie diese Option Range, um eine Liste der Werte zu {n, n-k, n-2k, n-3k, ...}erstellen. Halten Sie an, bevor Sie unter 1 fallen (dh halten Sie genau richtig an). Dann multiplizieren Sie alle Zahlen in dieser Liste mit Times(oder 1##&).


-1 Byte mit 1##&stattTimes
attinat

3

Java 10, 44 Bytes

f->b->{int r=1;for(;b>0;b-=f)r*=b;return r;}

Nimmt die Fakultät als erste Eingabe, die Basis als zweite.

Probieren Sie es online aus.

Dies funktioniert im größten Testfall aufgrund des begrenzten Integer-Bereichs (32 Bit) nicht. Um dies zu beheben können wir verwenden BigIntegers, die zufällig ist genau doppelt so groß - 88 79 Bytes :

f->b->{var r=f.ONE;for(;b.signum()>0;b=b.subtract(f))r=r.multiply(b);return r;}

-9 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

f->b->{       // Method with two integer parameters and integer return-type
  int r=1;    //  Result-integer, starting at 1
  for(;b>0;   //  Loop as long as the base is still larger than 0
      b-=f)   //    After every iteration: decrease the base by the factorial
    r*=b;     //   Multiply the result by the base
  return r;}  //  Return the result


@ OlivierGrégoire Np, und danke! :)
Kevin Cruijssen



2

MathGolf , 7 6 Bytes

╙╒x%ε*

Probieren Sie es online!

Fand eine clevere Möglichkeit, mit 0 umzugehen! ohne die anderen Testfälle zu ändern. Übernimmt die Eingabe als k n(umgekehrte Reihenfolge), was beim impliziten Aufsplittern hilft.

Erläuterung

╙        maximum of two elements (pops largest of k and n,
         which is n for every valid case except 0!, where 1 is pushed)
 ╒       range(1,n+1)
  x      reverse int/array/string
   %     slice every k:th element
    ε*   reduce list with multiplication

2

Attache , 21 bis 19 Bytes

${x<y∨x*$[x-y,y]}

Probieren Sie es online! Ziemlich direkte rekursive Implementierung. (Hinweis: Dies ist im trueWesentlichen so 1, wie es in arithmetischen Operationen verwendet werden kann 1.) Dies ist eines der wenigen Programme, die ich für diese Site geschrieben habe, in denen durch die Verwendung eines Unicode-Operators Bytes gespart werden (1, um genau zu sein).

Alternativen

20 Bytes: ${x<y or x*$[x-y,y]}

21 Bytes: Prod@${{_%y=x%y}\1:x}

27 Bytes: ${x*[`1,$][x>y][x-y,y]∨1}

27 Bytes: ${If[x>y,x*$[x-y,y],_or 1]}

27 Bytes: ${x*[`1,$][x>y][x-y,y]or 1}

29 Bytes: ${If[x>y,x*$[x-y,y],_+not _]}


2

Rust , 92 73 61 Bytes

fn f(n:i128,k:i128)->i128{if n<=0{return 1}return n*f(n-k,k)}

Ich fange gerade an, Rost zu lernen, also bin ich sicher, dass dies kürzer sein kann. Wird aktualisiert, sobald ich es erfahre. Der Rückgabewert sollte sein i128, um den letzten Test zu berechnen.

Bearbeiten: Rekursion ist kürzer.

Probieren Sie es online!

Sie können Ihren eigenen Test hinzufügen oder einen der bereits vorhandenen bearbeiten.


2

q , 59 57 55 53 Bytes

{prd 2+(&)1_i=last i:("J"$x(&)not[n])#(!)sum n:"!"=x}

Erläuterung:

q)x:"12!!" / let our input be 12!!, assign to x
q)sum n:"!"=x / count "!"s
2i
q)(!)sum n:"!"=x / (!)m -> [0,m)
0 1
q)("J"$x(&)not[n]) / isolate the number in input
12
q)("J"$x(&)not[n])#(!)sum n:"!"=x / x#y means take x items from list y, if x>y, circle around
0 1 0 1 0 1 0 1 0 1 0 1
q)i:("J"$x(&)not[n])#(!)sum n:"!"=x / assign to i
q)i
0 1 0 1 0 1 0 1 0 1 0 1
q)(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / take last elem of i and see which are equal in i
010101010101b
q)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / drop first elem
10101010101b
q)(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / indices of 1b (boolean TRUE)
0 2 4 6 8 10
q)2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / add 2 across array
2 4 6 8 10 12
q)prd 2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / product across array
46080

Hier ist auch eine Version in k (gleiche Logik), 42 41 Bytes

{*/2+&1_i=last i:("J"$x@&~:n)#!+/n:"!"=x}

Willkommen auf der Seite! Ich habe Ihrem Beitrag eine Code-Formatierung hinzugefügt, die mit vier Leerzeichen vor der Zeile oder durch das Einschließen von dreifachen Backticks erfolgen kann.
Weizen-Zauberer

@ SriotchilismO'Zaic Dank :-)
kritzeln

1
Ich empfehle, eine Erklärung und möglicherweise einen Link zu einem Online-Dolmetscher wie TIO hinzuzufügen . Nur-Code-Antworten werden normalerweise automatisch als minderwertig gekennzeichnet.
mbomb007

@ mbomb007 interessant. Gibt es einen Bot, der Antworten meldet? Was passiert mit minderwertigen Einsendungen? Ich werde bald aktualisieren!
kritzeln

Ja, da ist ein Bot. StackExchange verwendet Bots, um nach potenziellem Spam und Antworten von geringer Qualität zu suchen. Personen mit ausreichender Reputation können die Überprüfungswarteschlange anzeigen. meta.stackexchange.com/a/161391/285610
mbomb007


1

Netzhaut , 66 Bytes

^0
1
\d+
*!,
+`(!+)(!+),\1$
$1$2,$2,$1
!+$
1
+`(!+),(\d+)
$.($2*$1

Probieren Sie es online! Link enthält schnellere Testfälle. Mauls-Nummern ohne Ausrufezeichen. Erläuterung:

^0
1

Repariere es 0!.

\d+
*!,

In Unary konvertieren nund ein Trennzeichen hinzufügen.

+`(!+)(!+),\1$
$1$2,$2,$1

Subtrahiere wiederholt kvon nwhile n>kund sammle die Ergebnisse.

!+$
1

Ersetzen Sie kdurch 1(in Dezimal).

+`(!+),(\d+)
$.($2*$1

Nacheinander mit jedem Zwischenwert multiplizieren und in Dezimalzahl umrechnen.




1

Viertens (viertens) , 50 Bytes

: f 1 1 2over / 1+ 0 do 2over i * - 1 max * loop ;

Probieren Sie es online!

Code Erklärung

: f                \ start a new word definition
  1 1              \ add placeholder and accumulator to stack
  2over / 1+       \ get the number of times to run the loop (num/factorial + 1)
  0 do             \ start loop from 0 to num/factorial
    2over          \ copy num and factorial to the top of the stack
    i * -          \ get the current number to multiply by (num - factorial * i)
    1 max          \ make sure it can't be 0 or negative [set to 1 if it is]
    *              \ multiply accumulator by result
  loop             \ end loop
;                  \ end the word definition           



1

Gaia , 6 Bytes

…)¦v%Π

Probieren Sie es online!

Nimmt die Eingabe als n, k, so Eingang 3 4wäre 3!!!!.

…	 push [0...n-1], or [] if n == 0
 )¦	 increment each value (does nothing if [])
   v	 reverse list
    %	 take every k'th element
     Π	 product; product([]) = 1.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.