เพื่อไม่ให้สับสนกับค้นหาปัจจัย!

บทนำ

แฟคทอเรียลของจำนวนเต็มnสามารถคำนวณได้โดย

มันค่อนข้างง่ายและไม่มีอะไรใหม่ อย่างไรก็ตามแฟกทอเรียลสามารถขยายเป็นแฟคทอเรียลสองเท่าเช่น สำหรับเลขคู่และ สำหรับเลขคี่ แต่เราไม่ จำกัด เพียงแฟคทอเรียลสองเท่า ตัวอย่างเช่น หรือ หรือ ขึ้นอยู่กับ ค่าเริ่มต้น

โดยสรุป: โดยที่ หรือในภาษาอังกฤษธรรมดา: ลบจำนวนแฟกทอเรียลออกจากจำนวนฐานซ้ำ ๆ กันและคูณจำนวนเต็มบวกทั้งหมดที่เกิดขึ้น

ความท้าทาย

เขียนฟังก์ชั่นที่จะคำนวณแฟคทอเรียลแบบซ้ำสำหรับจำนวนเต็มใด ๆ ที่ไม่เป็นลบ

อินพุต

ทั้ง

• สตริงที่มีจำนวนเต็มฐานสิบที่ไม่เป็นลบตามด้วยเครื่องหมายอัศเจรีย์ 1 ตัวหรือมากกว่า เช่น"6!"หรือหรือ"9!!""40!!!!!!!!!!!!!!!!!!!!"

หรือ

• ค่าเดียวกันที่แสดงโดยจำนวนเต็มสองตัวคือค่าฐานที่ไม่เป็นลบหนึ่งค่าและค่าบวกหนึ่งค่าที่แทนการนับแบบแฟคทอเรียล ซึ่งสามารถทำได้ตามรูปแบบใด ๆ จากกฎ I / O เริ่มต้น

เอาท์พุต

ผลการคำนวณดังกล่าว

คำพูดที่ท้าทาย

• 0!เท่ากับ1โดยนิยาม รหัสของคุณจะต้องบัญชีสำหรับสิ่งนี้
• การนับแฟคทอเรียลนั้นถูก จำกัด ด้วยนอกช่วงนี้คุณมีอิสระที่จะเอาท์พุทอะไรก็ได้ นอกเหนือจากซึ่งเป็นข้อยกเว้นเฉพาะกฎนี้ $$0 < factorial~count \leq base~value$$ 0!

ตัวอย่าง

Input                              Output

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

ลองใช้ด้วยการใช้งาน Python ที่ไม่ได้รับโชค: ลองออนไลน์!

ข้อสังเกตทั่วไป

• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่ใช้จำนวนไบต์น้อยที่สุดในแต่ละภาษาจะเป็นผู้ชนะ
• กฎระเบียบมาตรฐาน , I / O กฎระเบียบและกฎหนีใช้
• โปรดรวมลิงก์ลองใช้ออนไลน์เพื่อแสดงรหัสของคุณทำงาน
• โปรดกระตุ้นคำตอบด้วยคำอธิบายรหัสของคุณ

R , 33 ไบต์

function(n,k)prod(seq(n+!n,1,-k))

ลองออนไลน์!

จับโดยการเพิ่มการปฏิเสธตรรกะของn$n=0$$n$

ArnoldC , 702 698 634 ไบต์

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

ลองออนไลน์!

แปลเป็น 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;
}

หมายเหตุ: ArnoldC มีข้อมูลประเภทเดียวเท่านั้น: จำนวนเต็มที่มีเครื่องหมาย 16 บิต ดังนั้นฉันไม่สามารถทดสอบ420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!เคสได้

เยลลี่ 4 ไบต์

RṚmP

ลองออนไลน์!

อย่างไร? รับและเป็นครั้งแรกที่สร้างช่วง (กับ) จากนั้นมันจะเก็บทุกองค์ประกอบของช่วงนี้ (ดังนั้น ) และในที่สุดพวกเขาโดยใช้คูณ$n$$k$$n,\cdots, 1$k th n , n - k , n - 2 k , ⋯ , n - ⌊ n / k ⌋ kRṚm$k^{\text{th}}$$n, n-k, n-2k,\cdots,n-\lfloor n/k\rfloor k$P

APL (Dyalog Extended) , 7 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ ใช้[n,b]เป็นอาร์กิวเมนต์

×/-\…1¨

ลองออนไลน์!

1¨ หนึ่งสำหรับแต่ละองค์ประกอบของการโต้แย้ง [1,1]

-\ ผลต่างสะสม [n,n-b]

… ช่วงโดยใช้องค์ประกอบที่สองของอาร์กิวเมนต์ซ้ายเป็นตัวบ่งชี้ของขั้นตอนเช่น[9,7]ดำเนินการต่อด้วย5

×/ สินค้า

Haskell , 21 ไบต์

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

ลองออนไลน์!

การรวมฟังก์ชั่นผลิตภัณฑ์ในตัวกับการระบุช่วงการก้าวจะเป็นสิ่งที่ฉันสามารถเขียนโค้ดซ้ำได้

22 ไบต์

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

ลองออนไลน์!

นี่เป็นวิธีแก้ปัญหาการป้อนข้อมูลในรูปแบบสตริง9!!ซึ่งฉันคิดว่าน่าสนใจกว่า

42 ไบต์

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

ลองออนไลน์!

Pyth , 6 ไบต์

นี่คือ 6-byters เทียบเท่าทั้งหมด:

*F:Q1E
*F:E1Q
*F%E_S

ลองออนไลน์! ( *F:Q1E)

หรือ11 ไบต์โดยรับอินพุตเป็นสตริง:

*F:.vQ1/Q\!

ชุดทดสอบ

JavaScript (ES6), 21 ไบต์

(k)(n)จะเข้าเป็น

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

ลองออนไลน์!

หรือ24 ไบต์เพื่อรองรับ BigInts

JavaScript (ES6), 55 ไบต์

รับอินพุตเป็นสตริงโดยใช้รูปแบบที่อธิบายไว้ในการท้าทาย

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

ลองออนไลน์!

ช่องว่าง , 91 ไบต์

[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]

เพิ่มตัวอักษรS(ช่องว่าง), T(แท็บ) และN(บรรทัดใหม่) เป็นการเน้นเท่านั้น
[..._some_action]เพิ่มเป็นคำอธิบายเท่านั้น

ลองใช้ออนไลน์ (ด้วยพื้นที่ว่างเปล่าแท็บและบรรทัดใหม่เท่านั้น)

คำอธิบายในรหัสเทียม:

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

Python 2 , 29 ไบต์

f=lambda n,b:n<1or n*f(n-b,b)

ลองออนไลน์!

Perl 6 , 22 ไบต์

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

ลองออนไลน์!

codeblock ที่ไม่ระบุชื่อที่ส่งคืนผลิตภัณฑ์ของช่วงเริ่มต้นจากอินพุตแรกลดลงเป็นวินาทีจนกว่าจะอยู่ด้านล่าง1ยกเว้นหมายเลขสุดท้าย สิ่งนี้ใช้ได้ผล0เนื่องจากกรณีพื้นฐานของการลดโดยผลิตภัณฑ์คือ 1 ดังนั้นผลลัพธ์คือ 1

05AB1E , 10 8 7 ไบต์

ݦRIιнP

อินพุตเป็นสองอินพุตแยกกัน: อินพุตแรกเป็นbase; factorialเป็นอินพุทที่สอง

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

-2 ไบต์ขอบคุณที่@ Mr.Xcoder
-1 ขอบคุณไบต์@JonathanAllan

คำอธิบาย:

Ý        # 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)

คำตอบเดิม 10 ไบต์ :

L0KD¤-IÖÏP

อินพุตเป็นสองอินพุตแยกกัน: อินพุตแรกเป็นbase; factorialเป็นอินพุทที่สอง

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

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)

รหัสเครื่อง x86-64 ขนาด 12 ไบต์

รหัสเครื่องเดียวกันทำสิ่งเดียวกันในโหมด 32 บิตและสำหรับจำนวนเต็ม 16 บิตในโหมด 16 บิต

นี้เป็นฟังก์ชั่น callable กับ args ,n=RCX k=ESI32 EAXบิตในค่าตอบแทน

เรียกได้จาก C พร้อมกับ x86-64 System V การเรียกการประชุมด้วย dummy args เพื่อรับ args จริงในการลงทะเบียนที่ถูกต้อง uint32_t factk(int, uint32_t k, int, uint64_t n); ฉันไม่สามารถใช้ Windows x64 เพียงเพราะmulclobbers RDX 1 ตัวถูกดำเนินการและเราไม่ต้องการให้ REX นำหน้า R8 / R9 nต้องไม่มีขยะใด ๆ ในระดับสูง 32 บิตดังนั้น JRCXZ จึงทำงานได้ แต่นอกเหนือไปจากนั้นคือทั้งหมด 32 บิต

รายการ NASM (ที่อยู่ญาติ, รหัสเครื่อง, แหล่งที่มา)

 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 ไบต์

หรือ 10 ไบต์ถ้าเราไม่ได้ต้องการที่จะจัดการกับกรณีพิเศษทิ้งออกn=0jrcxz

สำหรับแฟคทอเรียลมาตรฐานคุณจะใช้loopแทน sub / ja เพื่อบันทึก 2 ไบต์ แต่ไม่เช่นนั้นจะเป็นรหัสเดียวกัน

ทดสอบโทรที่ผ่านargcเป็นkที่มีnการกำหนดค่าตายตัว

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`

```

APL (Dyalog Unicode) , 11 ไบต์^SBCS

ฟังก์ชั่นเงียบสงบไม่ระบุชื่อ รับnอาร์กิวเมนต์ที่ถูกต้องและbอาร์กิวเมนต์ซ้าย

×/1⌈⊢,⊢-×∘⍳

ลองออนไลน์!

×∘⍳ คูณbโดยɩ ntegers 1 ผ่านn

⊢- ลบออกจาก n

⊢, ย่อหน้า n

1⌈ สูงสุดของหนึ่งและแต่ละเหล่านั้น

×/ สินค้า

ทับทิมขนาด 25 ไบต์

f=->s,r{s<1?1:s*f[s-r,r]}

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 22 21 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณ attinat: Times --> 1##&

คำอธิบาย: ใช้Rangeเพื่อสร้างรายการค่า{n, n-k, n-2k, n-3k, ...}หยุดก่อนที่จะไปต่ำกว่า 1 (เช่นหยุดเพียงขวา) จากนั้นคูณตัวเลขทั้งหมดในรายการนี้ด้วยTimes(หรือ1##&)

Java 10, 44 ไบต์

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

รับแฟกทอเรียลเป็นอินพุตแรกฐานเป็นวินาที

ลองออนไลน์

สิ่งนี้ไม่ได้ผลสำหรับกรณีทดสอบที่ใหญ่ที่สุดเนื่องจากช่วงจำนวนเต็ม จำกัด (32- บิต) ในการแก้ไขปัญหานี้เราสามารถใช้ได้โดยบังเอิญBigIntegersซึ่งมีขนาดใหญ่เป็นสองเท่า - 88 79 ไบต์ :

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

-9 ไบต์ขอบคุณที่@ OlivierGrégoire

ลองออนไลน์

คำอธิบาย:

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

Japtet , 8 ไบต์

TõUV f ×

ลองมัน

-1 ต้องขอบคุณ EoI ที่ชี้ให้เห็นว่าปุยที่ไม่มีคาเฟอีนเป็นใบ้ได้อย่างไร!

C (gcc) , 41 ไบต์

r;f(n,k){for(r=1;n>0;n-=k)r*=n;return r;}

ลองออนไลน์!

MathGolf , 7 6 ไบต์

╙╒x%ε*

ลองออนไลน์!

พบวิธีที่ฉลาดในการจัดการ 0! โดยไม่มีการเปลี่ยนแปลงกรณีทดสอบอื่น ๆ รับอินพุตเป็นk n(เรียงลำดับกลับกัน) ซึ่งช่วยในการ popping โดยนัย

คำอธิบาย

╙        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

ทูต , 21 19 ไบต์

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

ลองออนไลน์! การใช้งานแบบเรียกซ้ำโดยตรง (หมายเหตุ: trueมีความสำคัญ1เนื่องจากสามารถใช้ในการดำเนินการทางคณิตศาสตร์เป็น1.) นี่เป็นหนึ่งในไม่กี่โปรแกรมที่ฉันเขียนสำหรับไซต์นี้ซึ่งการใช้ตัวดำเนินการ unicode ช่วยประหยัดไบต์ (1 เพื่อความแม่นยำ)

ทางเลือก

20 ไบต์: ${x<y or x*$[x-y,y]}

21 ไบต์: Prod@${{_%y=x%y}\1:x}

27 ไบต์: ${x*[`1,$][x>y][x-y,y]∨1}

27 ไบต์: ${If[x>y,x*$[x-y,y],_or 1]}

27 ไบต์: ${x*[`1,$][x>y][x-y,y]or 1}

29 ไบต์: ${If[x>y,x*$[x-y,y],_+not _]}

สนิม , 92 73 61 ไบต์

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

ฉันเพิ่งเริ่มเรียนรู้การเกิดสนิมดังนั้นฉันมั่นใจว่ามันจะสั้นกว่านี้ จะอัปเดตตามที่ฉันเรียนรู้ ค่าส่งคืนควรจะi128คำนวณการทดสอบครั้งสุดท้าย

แก้ไข: การเรียกซ้ำสั้นกว่า

ลองออนไลน์!

คุณสามารถเพิ่มการทดสอบของคุณเองหรือแก้ไขหนึ่งในการทดสอบที่มีอยู่แล้ว

q , 59 57 55 53 ไบต์

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

คำอธิบาย:

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

นี่คือรุ่นใน k (ตรรกะเดียวกัน), 42 41 ไบต์

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

Physica , 22 ไบต์

f=>n;k:n<1||n*f[n-k;k]

ลองออนไลน์!

26 ไบต์

เรียนรู้วิธีใช้ "ภาษา" ของฉันเองอีกครั้ง \ หากฉันรู้วิธีเขียนโปรแกรมแยกวิเคราะห์เมื่อ 2 ปีที่แล้วนี่จะเป็น 20 ไบต์ :(

->n;k:GenMul##[n…1]{%%k}

หรือ

->n;k:GenMul##Range[n;1;k]

ลองออนไลน์!

เรติน่า 66 ไบต์

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

ลองออนไลน์! ลิงค์นั้นรวมถึงกรณีทดสอบที่เร็วกว่า ขยำหมายเลขโดยไม่มีเครื่องหมายอัศเจรีย์ คำอธิบาย:

^0
1

0!แก้ไขปัญหาขึ้น

\d+
*!,

แปลงnเป็น unary และเพิ่มตัวคั่น

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

ซ้ำแล้วซ้ำอีกลบkจากnในขณะที่n>kและเก็บผล

!+$
1

แทนที่kด้วย1(เป็นทศนิยม)

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

ทวีคูณโดยแต่ละค่ากลางเปลี่ยนเป็นทศนิยม

Japtet , 8 ไบต์

1õUV f ×

ลองมัน

JavaScript (Node.js) , 35 ไบต์

(n,i,f=i)=>i-n<1?f:r(n,i-n,f*(i-n))

ลองออนไลน์!

Forth (gforth) , 50 ไบต์

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

ลองออนไลน์!

รหัสคำอธิบาย

: 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           

Perl 5 -Mbigint -p , 45 ไบต์

$b=s/!//g;$\=1*$_||1;$\*=$_ while($_-=$b)>0}{

ลองออนไลน์!

Stax , 6 ไบต์

å▐█ΩV∟

เรียกใช้และแก้ไขข้อบกพร่อง

{count} {base}มันต้องใช้เวลาการป้อนข้อมูลในรูปแบบ

Gaiaขนาด 6 ไบต์

…)¦v%Π

ลองออนไลน์!

จะเข้าเป็นn, kเพื่อป้อนข้อมูลของจะ3 43!!!!

…	 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.