ตัวเลขsubfactorialหรือrencontres ( A000166 ) เป็นลำดับของตัวเลขที่คล้ายกับตัวเลข factorial ซึ่งแสดงใน combinatorics ของพีชคณิต โดยเฉพาะอย่างยิ่งที่subfactorial ลำดับที่n ! nให้จำนวนderangementsของชุดองค์ประกอบn Derangement เป็นการเปลี่ยนแปลงที่ไม่มีองค์ประกอบใดอยู่ในตำแหน่งเดียวกัน สามารถกำหนด subfactorial ผ่านความสัมพันธ์การเกิดซ้ำดังต่อไปนี้:

!n = (n-1) (!(n-1) + !(n-2))

ในความเป็นจริงความสัมพันธ์ที่เกิดซ้ำกันนั้นมีไว้สำหรับปัจจัย แต่สำหรับ subfactorial เราเริ่มต้นจาก:

!0 = 1
!1 = 0

^{(สำหรับแฟคทอเรียลที่เรามีแน่นอน1! = 1 )}

งานของคุณคือการคำนวณ! nให้n

กฎระเบียบ

เช่นเดียวกับแฟคทอเรียล subfactorial นั้นเติบโตอย่างรวดเร็ว มันเป็นเรื่องปกติถ้าโปรแกรมของคุณสามารถจัดการปัจจัยการผลิตnเช่นนั้น! nสามารถแสดงโดยแบ่งตามชนิดจำนวนพื้นเมืองภาษาของคุณ อย่างไรก็ตามอัลกอริทึมของคุณจะต้องทำงานในทฤษฎีสำหรับnเอง นั่นหมายความว่าคุณอาจสันนิษฐานได้ว่าผลลัพธ์ที่สมบูรณ์และค่ากลางสามารถแสดงด้วยภาษาของคุณได้อย่างแม่นยำ โปรดทราบว่าสิ่งนี้จะไม่รวมค่าคงที่eหากเก็บหรือคำนวณด้วยความแม่นยำแน่นอน

ผลลัพธ์ต้องเป็นจำนวนเต็มที่แน่นอน (โดยเฉพาะคุณไม่สามารถประมาณผลลัพธ์ด้วยสัญกรณ์ทางวิทยาศาสตร์)

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานใด ๆ ในการรับอินพุตและจัดเตรียมเอาต์พุต

คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

กรณีทดสอบ

n     !n
0     1
1     0
2     1
3     2
4     9
5     44
6     265
10    1334961
12    176214841
13    2290792932
14    32071101049
20    895014631192902121
21    18795307255050944540
100   34332795984163804765195977526776142032365783805375784983543400282685180793327632432791396429850988990237345920155783984828001486412574060553756854137069878601

Funciton , 336 ไบต์

จำนวนไบต์สันนิษฐานว่าเข้ารหัส UTF-16 ด้วย BOM

┌─╖┌─╖  ┌─╖ 
│f╟┤♭╟┐┌┤♭╟┐
╘╤╝╘═╝├┘╘═╝├────┐
 │┌─╖ │ ┌┐┌┘╔═╗╓┴╖
 ││f╟─┴┐└┴┼─╢0║║f║
 │╘╤╝  │  │ ╚═╝╙─╜
 │┌┴╖ ┌┴╖┌┴╖ ╔═╗
 ││+╟┐│×╟┤?╟┐║1║
 │╘╤╝│╘╤╝╘╤╝┘╚╤╝
 └─┘ └─┘  └───┘

ฟังก์ชันนี้กำหนดฟังก์ชั่นfซึ่งใช้จำนวนเต็มหนึ่งตัวและส่งออกจำนวนเต็มอีกตัวที่ 90 องศาหันไปทางซ้าย มันทำงานได้กับอินพุตขนาดใหญ่โดยพลการ

ลองออนไลน์!

เมื่อพิจารณาว่านี่เป็น Funciton มันก็เร็วพอสมควร (n = 20 ใช้เวลาประมาณ 14 วินาทีใน TIO) การชะลอตัวหลักมาจากการเรียกซ้ำสองครั้งเนื่องจากฉันไม่คิดว่า Funciton interpreter จะบันทึกฟังก์ชั่นโดยอัตโนมัติ

แต่น่าเสียดายที่แบบอักษรที่♭มีช่องว่างบางรูปแบบไม่ถูกต้อง monospace และ / หรือแทรกช่องว่างเล็ก ๆ ระหว่างบรรทัด นี่เป็นสกรีนช็อตของรหัสจาก TIO ในทุกด้าน:

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

คำอธิบาย

นี้โดยทั่วไปจะดำเนินการเรียกซ้ำที่กำหนดในความท้าทายที่แม้ว่ามันจะใช้กรณีฐาน(- 1) = 0 = 1! คำนวณn-1และn-2ด้วยฟังก์ชั่นรุ่นก่อน♭และผลลัพธ์ระดับกลางn-1ถูกนำมาใช้ซ้ำในสามแห่ง ไม่มีอะไรมากไปกว่านั้นดังนั้นฉันจะผ่านการควบคุมอย่างรวดเร็ว:

               ─┐
               ╓┴╖
               ║f║
               ╙─╜

นี่คือส่วนหัวของฟังก์ชั่นซึ่งส่งเสียงฟังก์ชั่นของการป้อนข้อมูลnเส้นยาวที่แนบมา นี่จะมาถึงทางแยก T ทันทีซึ่งจะเป็นการซ้ำค่า

        ┌┐┌┘╔═╗
        └┴┼─╢0║
          │ ╚═╝

0กล่องเป็นเพียงตัวอักษรตัวเลข ทางแยก 4 ทางคำนวณสองฟังก์ชั่น: เส้นทางที่นำไปสู่ด้านล่างคำนวณ0 <nซึ่งเราจะใช้เพื่อกำหนดกรณีฐาน เส้นทางที่จะไปแยกซ้ายคำนวณ0 << n (ซ้ายกะ) แต่เราทิ้งค่านี้กับสร้าง Starkov

         ┌┴╖ ╔═╗
         ┤?╟┐║1║
         ╘╤╝┘╚╤╝
          └───┘

?เรานำไปนี้ลงในเงื่อนไขสามทาง 1หากมีค่าเป็นเท็จเรากลับผลอย่างต่อเนื่อง ปลายด้านขวาที่หลวมของ?คือฟังก์ชั่นเอาท์ ฉันบิดมันประมาณ 180 องศาตรงนี้เพื่อให้การวางแนวสัมพัทธ์ของอินพุตและเอาต์พุตของfสะดวกขึ้นในส่วนที่เหลือของโปรแกรม

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

        ┌─╖ 
      ┐┌┤♭╟┐
      ├┘╘═╝
      │
     ─┴┐

ในสาขาอื่น ๆ ที่เราคำนวณแรกn-1แล้วแยกเส้นทางสองครั้งเพื่อให้เราได้รับสามสำเนาของค่า (หนึ่งสำหรับค่าสัมประสิทธิ์ของการเกิดขึ้นอีกหนึ่งสำหรับ subfactorial แรกสุดท้ายสำหรับn-2 )

┌─╖┌─╖
│f╟┤♭╟
╘╤╝╘═╝
 │┌─╖
 ││f╟
 │╘╤╝
 │┌┴╖
 ││+╟
 │╘╤╝
 └─┘ 

เหมือนที่ผมกล่าวว่าเราพร่องหนึ่งคัดลอกอีกครั้งกับอีก♭แล้วเราเลี้ยงทั้งn-1และn-2ซ้ำไปและในที่สุดก็เพิ่มทั้งสองมีผลร่วมกันในf+

       ┐
       │
      ┌┴╖
     ┐│×╟
     │╘╤╝
     └─┘

สิ่งที่เหลือคือการคูณn-1โดย! (n-1) + (n-2)

โอเอซิส 5 ไบต์

ใช้สูตรที่กำหนดโดย Martin รหัส:

+n<*X

รุ่นที่ผ่า:

+n<*

ด้วยและa(0) = 1a(1) = 0

คำอธิบายa(n) =:

+       # Add the previous two terms, a(n - 1) + a(n - 2).
 n<     # Compute n - 1.
   *    # Multiply the top two elements.

ลองออนไลน์!

Haskell , 25 ไบต์

f 0=1
f n=n*f(n-1)+(-1)^n

ลองออนไลน์! ใช้การเกิดซ้ำอื่น ๆ จากหน้าOEIS

เยลลี่ขนาด 7 ไบต์

R=Œ!Ḅċ0

วิธีการนี้สร้างความแตกต่างดังนั้นมันค่อนข้างช้า

ลองออนไลน์!

มันทำงานอย่างไร

R=Œ!Ḅċ0  Main link. Argument: n

R        Range; yield [1, ..., n].
  Œ!     Yield all permutations of [1, ..., n].
 =       Perform elementwise comparison of [1, ..., n] and each permutation.
    Ḅ    Unbinary; convert each result from base 2 to integer. This yields 0 for
         derangements, a positive value otherwise.
     ċ0  Count the number of zeroes.

Brachylog (2), 11 ไบต์

⟦₁{p:?\≠ᵐ}ᶜ

ลองออนไลน์!

คำอธิบาย

นี่เป็นเพียงการแปลสเป็คโดยตรงจากภาษาอังกฤษเป็น Brachylog (และมีข้อได้เปรียบที่สามารถแก้ไขได้อย่างง่ายดายเพื่อจัดการการเปลี่ยนแปลงเล็กน้อยในสเปคเช่นการค้นหาจำนวน derangements ของรายการที่เฉพาะเจาะจง)

⟦₁{p:?\≠ᵐ}ᶜ
⟦₁           Start with a list of {the input} distinct elements
  {      }ᶜ  Then count the number of ways to
   p         permute that list
      \      such that taking corresponding elements
    :?       in {the permutation} and the list of distinct elements
       ≠     gives different elements
        ᵐ    at every position

ภาษาที่มีโซลูชั่นในตัว

การปฏิบัติตามคำแนะนำของ xnorนี่คือคำตอบ CW ซึ่งเป็นคำตอบเล็ก ๆ น้อย ๆ ที่อิงอยู่ในตัวเดียวเพื่อคำนวณ subfactorial หรือสร้าง derangements ทั้งหมดควรได้รับการแก้ไข

Mathematica ขนาด 12 ไบต์

Subfactorial

Python 3 , 35 32 ไบต์

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

ใช้ความสัมพันธ์นี้เกิดขึ้นอีก! n = n (n-1) + (-1) ⁿจาก@ Laikoni คำตอบของ Haskellกับกรณีฐาน0 = 1

ลองออนไลน์!

M , 9 ไบต์

o2!÷Øe+.Ḟ

ที่คุณสามารถดูโดยการลบḞ, Mใช้คณิตศาสตร์สัญลักษณ์ดังนั้นจะไม่มีปัญหาความแม่นยำ

ลองออนไลน์! ไม่ใช่ทางออกที่สั้นที่สุดที่ได้รับการโพสต์ แต่อย่างรวดเร็ว

มันทำงานอย่างไร

o2!÷Øe+.Ḟ  Main link. Argument: n

o2         Replace input 0 with 2, as the following formula fails for 0.
  !        Compute the factorial of n or 2.
   ֯e     Divide the result by e, Euler's natural number.
      +.   Add 1/2 to the result.
        Ḟ  Floor; round down to the nearest integer.

MATL , 9 8 ไบต์

:tY@-!As

เช่นเดียวกับคำตอบของ @Dennis 'Jellyสิ่งนี้จะสร้างการเรียงสับเปลี่ยนและนับว่ามีจำนวนเท่าใด ดังนั้นจึงช้า

ลองออนไลน์!

:     % Input n implicitly: Push [1 2 ... n]
t     % Duplicate 
Y@    % Matrix of all permutations, each on a row
-     % Element-wise subtract. A zero in a row means that row is not a derangement
!     % Transpose
A     % True for columns that don't contain zeros
s     % Sum. Implicitly display

คณิตศาสตร์ 21 ไบต์

Round@If[#>0,#!/E,1]&

ฉันมากใหม่นี้และมีความคิดสิ่งที่ฉันทำไม่ ...

ลองออนไลน์!

Ruby, 27 ไบต์

f=->n{n<1?1:n*f[n-1]+~0**n}

~0**nสั้นกว่า(-1)**n!

CJam (10 ไบต์)

1qi{~*)}/z

สาธิตออนไลน์

สิ่งนี้ใช้การเกิดซ้ำ!n = n !(n-1) + (-1)^nซึ่งฉันได้รับจากการn! / eค้นพบแล้วมีอยู่ใน OEIS แล้ว

การผ่า

ลูปจะคำนวณ(-1)^n !nดังนั้นเราต้องใช้ค่าสัมบูรณ์ที่ท้าย:

1     e# Push !0 to the stack
qi{   e# Read an integer n and loop from 0 to n-1
  ~   e#   Bitwise not takes i to -(i+1), so we can effectively loop from 1 to n
  *   e#   Multiply
  )   e#   Increment
}/
z     e# Take the absolute value

05AB1E , 8 ไบต์

΃N*®Nm+

ลองออนไลน์!

คำอธิบาย

Î         # initialize stack with 0 and input
 ƒ        # for N in range [0 ... input]:
  N*      # multiply top of stack with N
    ®Nm   # push (-1)^N
       +  # add

MATLAB, 33 ไบต์

@(n)(-1)^n*hypergeom([1 -n],[],1)

ฟังก์ชัน Anonympus ที่ใช้สูตรในส่วนที่ 3 ของDerangements และแอปพลิเคชันโดย Mehdi Hassani

ตัวอย่างการใช้:

>> @(n)(-1)^n*hypergeom([1 -n],[],1)
ans = 
    @(n)(-1)^n*hypergeom([1,-n],[],1)
>> ans(6)
ans =
   265

JavaScript (ES6), 26 ไบต์

f=n=>!n||n*f(n-1)-(~n%2|1)

ใช้ความสัมพันธ์ที่เกิดซ้ำจากคำตอบของ @ Laikoni ใน ES7 คุณสามารถบันทึกไบต์โดยใช้แทน+(-1)**n-(~n%2|1)

PostScript, 81 76 69 ไบต์

นี่คือการใช้งานของสูตรทั้งสอง

n * f (n-1) + (- 1) ^ n

/ f {dup 0 eq {pop 1} {dup dup 1 sub f mul exchange 2 mod 2 mul 1 sub sub} ifelse} def

/f{dup 0 eq{pop 1}{dup dup 1 sub f mul -1 3 2 roll exp add}ifelse}def

เวอร์ชันนั้นให้ผลลัพธ์แบบลอย หากจำเป็นต้องส่งออกจำนวนเต็ม:

/f{dup 0 eq{pop 1}{dup dup 1 sub f mul -1 3 2 roll exp cvi add}ifelse}def

ซึ่งมีน้ำหนัก 73 ไบต์

สูตรอื่นยาวกว่าเล็กน้อย: 81 ไบต์

(n-1) * (f (n-1) + f (n-2))

/f{dup 1 le{1 exch sub}{1 sub dup f exch dup 1 sub f 3 -1 roll add mul}ifelse}def

ฟังก์ชั่นเหล่านี้ได้รับการโต้แย้งจากสแต็กและปล่อยให้ผลลัพธ์ในสแต็ก

คุณสามารถทดสอบฟังก์ชั่นทั้งในไฟล์หรือที่พร้อมท์ PostScript แบบโต้ตอบ (เช่น GhostScript) ด้วย

0 1 12{/i exch def [i i f] ==}for

เอาท์พุต

[0 1]
[1 0.0]
[2 1.0]
[3 2.0]
[4 9.0]
[5 44.0]
[6 265.0]
[7 1854.0]
[8 14833.0]
[9 133496.0]
[10 1334961.0]
[11 14684570.0]
[12 176214848.0]

ต่อไปนี้เป็นไฟล์ PostScript ที่สมบูรณ์ซึ่งแสดงผลไปยังหน้าจอหรือหน้าเครื่องพิมพ์ (ความคิดเห็นใน PostScript เริ่มต้นด้วย%)

%!PS-Adobe-3.0

% (n-1)*(f(n-1)+f(n-2))
% /f{dup 1 le{1 exch sub}{1 sub dup f exch dup 1 sub f 3 -1 roll add mul}ifelse}def

% n*f(n-1)+(-1)^n
/f{dup 0 eq{pop 1}{dup dup 1 sub f mul -1 3 2 roll exp add}ifelse}def

% 0 1 12{/i exch def [i i f] ==}for

/FS 16 def              %font size
/LM 5 def               %left margin
/numst 12 string def    %numeric string buffer

/Newline{currentpoint exch pop FS sub LM exch moveto}def
/Courier findfont FS scalefont setfont
LM 700 moveto

(Subfactorials) Newline
0 1 12{
    dup numst cvs show (: ) show f numst cvs show Newline
}for
showpage
quit

PHP, 69 ไบต์

function f($i){return$i>1?$i*f($i-1)+(-1)**$i:1-$i;}echo f($argv[1]);

ใช้วิธีนี้ a(n) = n*a(n-1) + (-1)^n

PHP, 50 44

for(;$i++<$argn;)$n=++$n*$i-$i%2*2;echo$n+1;

ทำงานด้วย echo <n> | php -nR '<code>

ความงามของa(n) = n*a(n-1) + (-1)^nมันคือมันขึ้นอยู่กับค่าก่อนหน้าเท่านั้น สิ่งนี้อนุญาตให้นำไปปฏิบัติซ้ำ ๆ ซ้ำ ๆ ได้ นี้ช่วยประหยัดเวลานานฟังก์ชั่น declarition

-6 ไบต์โดย @Titus ขอบคุณมาก!

Mathematica ขนาด 40 ไบต์

±0=1;±1=0;±n_:=(n-1)(±(n-1)+±(n-2))

ซึ่งมีขนาด 31 ไบต์ภายใต้การเข้ารหัส ISO 8859-1 ที่เป็นค่าเริ่มต้น

C, 34 ไบต์

a(n){return n?n*a(n-1)-n%2*2+1:1;}

คำอธิบาย:

a(n){                            } define a function called a of n
     return                     ;  make the function evaluate to...
            n?                :1   set the base case of 1 when n is 0
              n*a(n-1)             first half of the formula on the page
                      -n%2*2+1     (-1)**n

R, 47 ไบต์

n=scan();`if`(!n,1,floor(gamma(n+1)/exp(1)+.5))

ใช้สูตรเดียวกับคำตอบของชำเลือง

วิธีอื่น 52 ไบต์โดยใช้PerMallowsห้องสมุด

n=scan();`if`(!n,1,PerMallows::count.perms(n,n,'h'))

จริงแล้ว 18 ไบต์

;!@ur⌠;!@0Dⁿ/⌡MΣ*≈

ลองออนไลน์!

คำอธิบาย:

;!@ur⌠;!@0Dⁿ/⌡MΣ*≈
;                   duplicate input
 !                  n!
  @ur               range(0, n+1) (yields [0, n])
     ⌠;!@0Dⁿ/⌡M     for each i in range:
      ;               duplicate i
       !              i!
        @0Dⁿ          (-1)**i
            /         (-1)**i/i!
               Σ    sum
                *   multiply sum by n!
                 ≈  floor into int

รุ่น 12 ไบต์ที่สามารถใช้งานได้หากจริงมีความแม่นยำมากขึ้น:

;!╠@/1½+L@Y+

ลองออนไลน์!

แตกต่างจากคำตอบอื่น ๆ ทั้งหมด (ขณะที่โพสต์) วิธีนี้ไม่ใช้สูตรแบบเรียกซ้ำหรือสูตรการรวม แต่จะใช้สูตรต่อไปนี้แทน:

สูตรนี้ใช้งานง่ายในจริง:

!╠@/1½+L
!         n!
 ╠        e
  @/      divide n! by e
    1½+   add 0.5
       L  floor

ตอนนี้ปัญหาเดียวคือว่าสูตรถือเป็นบวกnเท่านั้น ถ้าคุณพยายามที่จะใช้สูตรอัตราผลตอบแทนที่ไม่ถูกต้องn = 0 0นี้ได้รับการแก้ไขได้อย่างง่ายดาย แต่: nโดยการใช้การปฏิเสธแบบบูลเพื่อป้อนข้อมูลและเพิ่มว่าการส่งออกของสูตรที่เอาท์พุทที่ถูกต้องจะได้รับทั้งหมดไม่ใช่เชิงลบ ดังนั้นโปรแกรมที่มีการแก้ไขนั้นคือ:

;!╠@/1½+L@Y+
;             duplicate input
 !            n!
  ╠           e
   @/         divide n! by e
     1½+      add 0.5
        L     floor
         @Y   boolean negate the other copy of the input (1 if n == 0 else 0)
           +  add

ซ้อนกัน 30 ไบต์

[:[#-::#-f\f+*]$not,\2<# !]@:f

ลองออนไลน์!

ฟังก์ชั่นวนซ้ำง่าย ๆ ใช้ความจริงที่ว่าสำหรับ!n = not n n < 2โทรn fมา

อลิซ , 20 18 ไบต์

1/o
k\i@/&wq*eqE+]

ลองออนไลน์!

คำอธิบาย

การใช้งานนี้เรียกซ้ำจากLaikoni ของคำตอบ , n! = n (n-1) + (-1) n คล้ายกับคำตอบที่ Funciton ผมใช้กรณีฐาน(- 1) = 1 เราใส่ที่11.ในกองด้วย ถ้าอย่างนั้น ...

.../o
...\i@/...

... เป็นเพียงแค่กรอบ I / O ทศนิยมปกติ รหัสหลักเป็นจริง

&wq*eqE+]k

พังทลายลง:

&w    Push the current IP address N times to the return address stack, which
      effectively begins a loop which will be executed N+1 times.
  q     Push the position of the tape head, which we're abusing as the
        iterator variable n.
  *     Multiply !(n-1) by n.
  e     Push -1.
  q     Retrieve n again.
  E     Raise -1 to the nth power.
  +     Add it to n*!(n-1).
  ]     Move the tape head to the right.
k     Jump back to the w, as long as there is still a copy of the return
      address on the return address stack. Otherwise, do nothing and exit
      the loop.