Deranged! Combinatorics: सबफैक्टेरियल की गणना करें

Question

Subfactorial या Rencontres संख्या ( A000166 ) भाज्य संख्या जो क्रमपरिवर्तन की साहचर्य में दिखाने के लिए इसी तरह की संख्या का एक अनुक्रम है। विशेष रूप से n वें सबफ़ैक्टीरियल ! N , n तत्वों के एक सेट के व्युत्पन्न की संख्या देता है । एक व्युत्पत्ति एक क्रमपरिवर्तन है जिसमें कोई भी तत्व समान स्थिति में नहीं रहता है। उपपरिवर्तन को निम्न पुनरावृत्ति संबंध के माध्यम से परिभाषित किया जा सकता है:

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

वास्तव में, एक ही पुनरावृत्ति सम्बन्ध तथ्य के लिए होता है, लेकिन उपपरिवर्तन के लिए हम निम्न से शुरू करते हैं:

!0 = 1
!1 = 0

^{(वास्तव में हमारे पास, निश्चित रूप से, 1! = 1 ) होगा।}

आपका काम गणना करना है ! N , n दिया ।

नियम

तथ्य की तरह, सबफैक्टेरियल बहुत जल्दी बढ़ता है। यह ठीक है यदि आपका प्रोग्राम केवल इनपुट n को ऐसे संभाल सकता है ! N को आपकी भाषा के मूल संख्या प्रकार द्वारा दर्शाया जा सकता है। हालांकि, आपके एल्गोरिथ्म को मनमाने ढंग से n के लिए सिद्धांत रूप में काम करना होगा । इसका मतलब है, आप मान सकते हैं कि अभिन्न परिणाम और मध्यवर्ती मूल्य आपकी भाषा द्वारा बिल्कुल प्रतिनिधित्व किया जा सकता है। ध्यान दें कि यह स्थिर ई को बाहर निकालता है अगर यह परिमित परिशुद्धता के साथ संग्रहीत या गणना की जाती है।

परिणाम एक सटीक पूर्णांक होना चाहिए (विशेष रूप से, आप वैज्ञानिक संकेतन के साथ परिणाम का अनुमान नहीं लगा सकते हैं)।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

परीक्षण के मामलों

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

Comments

सम्बंधित।

— मार्टिन एंडर

Answer 1

फंकिटॉन , 336 बाइट्स

बाइट काउंट यूटीएफ -16 को बीओएम के साथ एन्कोडिंग मानता है।

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

यह एक फ़ंक्शन को परिभाषित करता है fजो एक पूर्णांक लेता है और एक पूर्णांक को 90 डिग्री पर बाईं ओर मोड़ता है। यह मनमाने ढंग से बड़े इनपुट के लिए काम करता है।

इसे ऑनलाइन आज़माएं!

इस पर विचार Funciton है यह काफी तेजी से (n = 20 TIO पर 14 सेकंड के बारे में लेता है)। मुख्य मंदी डबल-पुनरावृत्ति से आती है, क्योंकि मुझे नहीं लगता कि फंक्स्टन इंटरप्रेटर स्वचालित रूप से फ़ंक्शन को याद करता है।

दुर्भाग्य से, कुछ मोनोपॉज़ किए गए फ़ॉन्ट सही ढंग से मोनोस्पेस नहीं देते हैं ♭और / या लाइनों के बीच छोटे अंतराल डालते हैं। यहाँ TIO से कोड का एक स्क्रीनशॉट इसकी सभी सुंदरता में है:

मुझे लगता है कि इसे कुछ और गोल्फ करना संभव हो सकता है, उदाहरण के लिए, सशर्त की शाखाओं >0को बदलने <1और स्वैप करने के लिए, ताकि मैं नंबर शाब्दिक, या शायद पूरी तरह से अलग सूत्र का उपयोग करके पुन: उपयोग कर सकूं, लेकिन मैं काफी यह पहले से ही कैसे कॉम्पैक्ट के साथ खुश है।

व्याख्या

यह मूल रूप से चुनौती में दी गई पुनरावृत्ति को लागू करता है, हालांकि यह आधार मामले का उपयोग करता है ! (- 1) =! 0 = 1 । n-1 और n-2 की गणना पूर्ववर्ती फ़ंक्शन के साथ की जाती है ♭, और मध्यवर्ती परिणाम n-1 का तीन स्थानों पर पुन: उपयोग किया जाता है। इसके लिए बहुत कुछ नहीं है, इसलिए मैं बस जल्दी से नियंत्रण प्रवाह से गुजरूंगा:

               ─┐
               ╓┴╖
               ║f║
               ╙─╜

यह फ़ंक्शन हेडर है जो फ़ंक्शन के इनपुट n लंबी संलग्न लाइन को उत्सर्जित करता है । यह तुरंत टी-जंक्शन तक पहुंचता है, जो बस मूल्य को दोहराता है।

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

0बॉक्स सिर्फ एक अंकीय शाब्दिक है। एक 4-वे जंक्शन दो कार्यों की गणना करता है: नीचे की ओर जाने वाला पथ 0 <n है , जिसका उपयोग हम आधार मामले को निर्धारित करने के लिए करेंगे। जो रास्ता अलग से छोड़ा जाता है वह 0 << n (एक वाम-शिफ्ट) की गणना करता है , लेकिन हम स्टार्कोव के निर्माण के साथ इस मूल्य को छोड़ देते हैं ।

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

हम इसे तीन-तरफ़ा सशर्त में ले जाते हैं ?। यदि मान गलत है, तो हम निरंतर परिणाम लौटाते हैं 1। का सही अंत ?फ़ंक्शन आउटपुट है। मैं इसे यहां 180 डिग्री से घुमा रहा हूं, ताकि इनपुट और आउटपुट के सापेक्ष अभिविन्यास fकार्यक्रम के बाकी हिस्सों में अधिक सुविधाजनक हो।

यदि शर्त सही थी, तो दूसरे मूल्य का उपयोग किया जाएगा। आइए इस शाखा की ओर जाने वाले मार्ग को देखें। (ध्यान दें कि फ़ंसीटॉन का मूल्यांकन वास्तव में आलसी है, ताकि इस शाखा का मूल्यांकन कभी नहीं होगा यदि इसकी आवश्यकता नहीं है, जो पहले स्थान पर पुनरावृत्ति को संभव बनाता है।)

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

दूसरी शाखा में हम पहले n-1 की गणना करते हैं और फिर दो बार पथ को विभाजित करते हैं, इसलिए हमें मूल्य की तीन प्रतियां मिलती हैं (पुनरावृत्ति के गुणांक के लिए, पहली उपप्रकार के लिए, n-2 के लिए अंतिम )।

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

जैसा कि मैंने कहा, हम एक प्रति फिर से दूसरे के साथ घटाते हैं ♭, फिर हम n-1 और n-2 दोनों को पुनरावर्ती रूप से फ़ीड करते हैं fऔर अंत में दोनों परिणामों को एक साथ जोड़ते हैं +।

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

अब सिर्फ़ गुणा करने के लिए है n-1 द्वारा ! (N-1) +! (N-2) ।

Answer 2

ओएसिस , 5 बाइट्स

मार्टिन द्वारा दिए गए सूत्र का उपयोग करता है। कोड:

+n<*X

विच्छेदित संस्करण:

+n<*

के साथ a(0) = 1और a(1) = 0।

स्पष्टीकरण a(n) =:

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

इसे ऑनलाइन आज़माएं!

Comments

X:-) बीटीडब्ल्यू का उपयोग करके अच्छी चाल , क्या आपने अभी तक इसे लागू किया है? इन दिनों में से एक को हम शुरुआती मूल्यों को बदलने के साथ दूर नहीं कर पाएंगे

— लुइस मेंडो

@LuisMendo हाँ मैंने किया! यह एक कमांड फ्लैग के रूप में उपयोग किया जाता है ( यहां जानकारी पृष्ठ का लिंक है)। सुझाव के लिए धन्यवाद :)।

— अदनान

Answer 3

हास्केल , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं! OEIS पेज से अन्य पुनरावृत्ति का उपयोग करता है ।

Answer 4

जेली , 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.

Answer 5

ब्रेकीलॉग (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

Answer 6

अंतर्निहित समाधान वाली भाषाएं

Xnor के सुझाव के बाद यह एक CW उत्तर है जिसमें उप -निर्माण की गणना करने या सभी व्युत्पत्तियों को उत्पन्न करने के लिए एक ही बिल्ट-इन पर आधारित तुच्छ समाधान संपादित किए जाने चाहिए।

गणितज्ञ, 12 बाइट्स

Subfactorial

Comments

sigh Mathematica ...

— epicbob57

Answer 7

पायथन 3 , 35 32 बाइट्स

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

इस का उपयोग करता है आवर्तन संबंध ! N = n! (N-1) + (-1) ^एन से @ Laikoni के हास्केल जवाब , आधार मामले के साथ ! 0 = 1 ।

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आप यहां दिए गए अन्य समीकरण का भी उपयोग कर सकते हैं , जो दो बाइट्स को बचाएगा f=lambda n:n<1or n*f(n-1)+(-1)**n:।

— अदनान

थोडा रीक्रिएटिंग के साथ तीन बाइट्स। ;)

— डेनिस

इस पुनरावृत्ति का मजेदार हिस्सा यह है कि यदि आप बेस केस को वापस धकेल देते हैं n=-1, तो यह बिल्कुल भी मायने नहीं रखता कि आप किस मूल्य का उपयोग करते हैं। यह कुछ भाषाओं के लिए उपयोगी हो सकता है (जैसे कि गणितज्ञ आप वास्तव में इसे अपरिभाषित छोड़ सकते हैं यदि वह किसी भी बाइट को सहेजे)।

— मार्टिन एंडर

Answer 8

एम , 9 बाइट्स

o2!÷Øe+.Ḟ

जैसा कि आप हटाकर देख सकते हैं Ḟ, एम प्रतीकात्मक गणित का उपयोग करता है, इसलिए कोई सटीक मुद्दे नहीं होंगे।

इसे ऑनलाइन आज़माएं! सबसे छोटा समाधान जो पोस्ट नहीं किया गया है, लेकिन तेजी से ।

यह काम किस प्रकार करता है

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.

Answer 9

MATL , 9 8 बाइट्स

:tY@-!As

करने के लिए इसी तरह @Dennis 'जेली जवाब , यह वास्तव में क्रमपरिवर्तन और मायने रखता है उनमें से कितने अपविन्यास हैं बनाता है; इसलिए यह धीमा है।

इसे ऑनलाइन आज़माएं!

:     % 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

Answer 10

गणित , 21 बाइट्स

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

मैं इसके लिए बहुत नया हूं और मुझे पता नहीं है कि मैं क्या कर रहा हूं ...

इसे ऑनलाइन आज़माएं!

Comments

एक ही बाइट काउंट पर दो विकल्प: Round[(#/. 0->2)!/E]&और ±0=1;±n_:=Round[n!/E](हालांकि मुझे नहीं पता कि मैथेमेटिका जैसी स्रोत फ़ाइलों के लिए मैथिक्स सिंगल-बाइट एन्कोडिंग का समर्थन करता है)।

— मार्टिन एंडर

पहले वाला अच्छा काम करता है (मुझे लगता है कि मुझे पता है कि वह क्या करता है), लेकिन मैथिक्स ±दूसरे में समर्थन नहीं करता है । यह साथ काम करेगा f, लेकिन दो बाइट्स की कीमत पर।

— डेनिस

उसी बाइट की गिनती में एक और Round[#!/E]+1-Sign@#&:। प्रारंभिक मूल्यों की घोषणा ...!

— ग्रेग मार्टिन

Answer 11

रूबी, 27 बाइट्स

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

~0**nसे छोटा है (-1)**n!

Answer 12

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

Answer 13

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

Answer 14

MATLAB, 33 बाइट्स

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

बेनामीपस फ़ंक्शन जो कि Derangements और अनुप्रयोगों की धारा 3 में सूत्र का उपयोग करता है ।

उदाहरण का उपयोग करें:

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

Answer 15

जावास्क्रिप्ट (ईएस 6), 26 बाइट्स

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

@ लॉकोनी के उत्तर से पुनरावृत्ति संबंध का उपयोग करता है। ES7 में आप +(-1)**nइसके बजाय का उपयोग करके एक बाइट बचा सकते हैं -(~n%2|1)।

Answer 16

पोस्टस्क्रिप्ट, 81 76 69 बाइट्स

यहाँ दोनों सूत्र के कार्यान्वयन हैं।

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

/ एफ {डुप ० ईक {पॉप १} {डुप डुप १ सब एफ चुल 2 एक्स 2 मॉड 2 म्यू 1 सब उप} ifelse} डिफ

/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) * (च (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

ये फ़ंक्शन स्टैक से अपना तर्क प्राप्त करते हैं, और स्टैक पर परिणाम छोड़ते हैं।

आप फ़ंक्शंस का परीक्षण कर सकते हैं, या तो एक फ़ाइल में या साथ एक इंटरैक्टिव पोस्टस्क्रिप्ट प्रॉम्प्ट (जैसे घोस्टस्क्रिप्ट) पर

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]

यहां एक पूरी पोस्टस्क्रिप्ट फ़ाइल है जो आउटपुट को स्क्रीन या एक प्रिंटर पेज तक पहुंचाती है। (पोस्टस्क्रिप्ट में टिप्पणियाँ के साथ शुरू %)।

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

Comments

-1 3 2 roll expकी तुलना में काफी कम है exch 2 mod 2 mul 1 sub।

— पीटर टेलर

@PeterTaylor तो यह है! :) मैं इसके बारे में भूल गया exp: उफ़: हालांकि, यह एक फ्लोट देता है, और मुझे लगता है कि मुझे सवाल के अनुरूप एक पूर्णांक आउटपुट करने की आवश्यकता है।

— पीएम 2 रिंग

मुझे लगता है कि आप अभी भी चक में रह सकते हैं cviऔर बचत कर सकते हैं। (नोट: अप्रयुक्त, लेकिन डॉक्टर को पढ़ने से मुझे लगता है कि यह काम करना चाहिए)।

— पीटर टेलर

@PeterTaylor हां, cviकाम करता है, और यह अभी भी मेरे पिछले संस्करण से छोटा है।

— PM 2Ring

Answer 17

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

Comments

आपको केवल फ़ंक्शन देने की आवश्यकता है, न कि पूरा कार्यक्रम, इसलिए आप अंतिम 17 वर्णों को छोड़ सकते हैं। विशेष-आवरण इनपुट नहीं द्वारा आगे की बचत है। मुझे लगता है कि दो बचतें इसे 47 बाइट तक ले जाती हैं।

— पीटर टेलर

Answer 18

पीएचपी, ५० ४४

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 यह है कि यह केवल पिछले मूल्य पर निर्भर करता है। यह इसे पुनरावर्ती के बजाय पुन: लागू करने की अनुमति देता है। यह एक लंबी फ़ंक्शन घोषणा को बचाता है ।

-6 बाइट्स @ टिट्स द्वारा। धन्यवाद !

Comments

-1 बाइट $i++<$argv[1]:। -2 बाइट्स for(;$i++<$argv[1];)$n=++$n*$i-$i%2*2;echo$n+1;:। (-3 साथ बाइट्स -Rऔर $argn।)

— टाइटस

@ क्या कोई ऊब गया है? : डी तुम मेरे लिए एक उदाहरण दे रही मन होगा -Rऔर $argn?

— क्रिस्टोफ़

ऊब नहीं है, लेकिन गोल्फ के लिए उत्सुक है। देखें php.net/manual/de/features.commandline.options.php: इको <इनपुट> | php -nR '<code>'। उदाहरण: codegolf.stackexchange.com/a/113046

— टाइटस

@ क्या मुझे यह सही लगा? ;-)

— क्रिस्टोफ़

Answer 19

गणितज्ञ, 40 बाइट्स

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

जो डिफ़ॉल्ट आईएसओ 8859-1 एन्कोडिंग के तहत 31 बाइट्स में आता है।

Answer 20

सी, 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

Answer 21

आर, 47 बाइट्स

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

Mego के जवाब के रूप में एक ही सूत्र का उपयोग करता है ।

PerMallowsलाइब्रेरी का उपयोग करते हुए वैकल्पिक विधि, 52 बाइट्स

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

Answer 22

दरअसल , 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

Comments

मेरे लिए नकारात्मक जवाब देता रहता है ...

— लीक

@LeakyNun यह सटीक सीमाओं के कारण है। बड़े इनपुट (चारों ओर n = 100) के लिए, (-1)**n/n!डबल-सटीक IEEE 754 फ़्लोट्स के साथ प्रतिनिधित्व नहीं किया जा सकता है। यह चुनौती के अनुसार स्वीकार्य है।

— मेगो

यहां तक ​​कि n=4...

— लीक नून

@ लीकेनून ओह। मुझे नहीं पता कि मैं फ्लोर्ड डिवीजन का उपयोग क्यों कर रहा था। अब इसे ठीक कर रहे हैं।

— मेगो

16 बाइट्स

— लीकी नून

Answer 23

स्टैक्ड , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सरल पुनरावर्ती कार्य। इस तथ्य का उपयोग करता है कि के !n = not nलिए n < 2। के रूप में बुलाओ n f।

Answer 24

ऐलिस , 20 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

इस का उपयोग करता है से प्रत्यावर्तन Laikoni का जवाब , ! N = n! (N-1) + (-1) ⁿ । फ़नसीटन उत्तर के समान, मैं बेस केस का उपयोग कर रहा हूं ! - (- 1) = 1 । हमने उस 1 को स्टैक पर रखा 1.। फिर यह...

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