दोहराया गया! Factorials!

Question

तथ्य को खोजने के लिए भ्रमित होने की नहीं !

परिचय

एक पूर्णांक के भाज्य की nगणना n द्वारा की जा सकती है ! = N × ( n - 1 ) × ( n - 2 ) × ( । । । ) × 2 × 1

$$n!=n\times(n-1)\times(n-2)\times(...)\times2\times1$$

यह अपेक्षाकृत आसान है और कुछ भी नया नहीं है। हालांकि, factorials को डबल factorials तक बढ़ाया जा सकता है , जैसे कि

$$n!!=n\times(n-2)\times(n-4)\times(...)\times4\times2$$ भी संख्या के लिए, और $$n!!=n\times(n-2)\times(n-4)\times(...)\times3\times1$$ विषम संख्या के लिए × 3 × 1 । लेकिन हम दोहरे तथ्य तक सीमित नहीं हैं। उदाहरण के लिए $$n!!!=n\times(n-3)\times(n-6)\times(...)\times6\times3$$ या $$n!!!=n\times(n-3)\times(n-6)\times(...)\times5\times2$$ या $$n!!!=n\times(n-3)\times(n-6)\times(...)\times4\times1$$ शुरू करने मूल्य के आधार पर।

संक्षेप में:

$${\displaystyle n!^{(k)}={\begin{cases}1&{\text{if }}n=0 \\n&{\text{if }}0<n\leq k\\n\cdot\left({(n-k)!}^{(k)}\right)&{\text{if }}n>k\end{cases}}}$$ जहां $${\displaystyle n!^{(k)}=n\underbrace{!\dots!}_{k}}$$ Or, सादे अंग्रेजी में: बार-बार आधार संख्या से भाज्य गणना घटाएँ और सभी परिणामी धनात्मक पूर्णांकों को गुणा करें।

चुनौती

एक फ़ंक्शन लिखें जो किसी भी गैर-नकारात्मक पूर्णांक के लिए किसी भी प्रकार के दोहराए गए तथ्य की गणना करेगा।

इनपुट

भी

• एक गैर-नकारात्मक आधार-दस पूर्णांक युक्त स्ट्रिंग, जिसके बाद 1 या अधिक विस्मयादिबोधक चिह्न होते हैं। उदाहरण के लिए "6!"या "9!!"या "40!!!!!!!!!!!!!!!!!!!!"।

या

• दो पूर्णांकों द्वारा दर्शाए गए समान मान: एक गैर-नकारात्मक आधार मान और एक सकारात्मक मान जो कि भाज्य गणना का प्रतिनिधित्व करता है। यह डिफ़ॉल्ट I / O नियमों के किसी भी प्रारूप के अनुसार किया जा सकता है।

उत्पादन

उक्त गणना का परिणाम।

चुनौती की टिप्पणी

• 0!1परिभाषा से बराबर है। इसके लिए आपका कोड होना चाहिए।
• फैक्टोरियल काउंट $$0 < factorial~count \leq base~value$$ से सीमित है < f a c t o r i i a l c o u n t a b a s e v a l u e इस सीमा के बाहर, आप जो भी आउटपुट के लिए स्वतंत्र हैं। इसके अलावा 0!, जो इस नियम का एकमात्र अपवाद है।

उदाहरण

Input                              Output

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

इसे एक अनगॉल्ड पायथन कार्यान्वयन के साथ आज़माएं : इसे ऑनलाइन आज़माएं!

सामान्य टिप्पणियाँ

• यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम बाइट्स का उपयोग करने वाला उत्तर जीत जाता है।
• मानक नियम , I / O नियम और खामी नियम लागू होते हैं।
• अपने कोड को प्रदर्शित करने के लिए कृपया इसे ऑनलाइन आजमाएं- कोड शामिल करें।
• कृपया अपने कोड की व्याख्या के साथ अपने उत्तर को प्रेरित करें।

Comments

उदाहरण सूची 0!लेकिन चुनौती की टिप्पणी कहती है कि फैक्टरियल काउंट आधार मूल्य से कम या बराबर होगा।

— जोनाथन एलन

नहीं होगा 3 !!! शून्य हो? n * (n-3) = 3 * (3-3) = 0.

— ouflak

@ouflak अगर यह 1 की तरह काम करता है! तो वास्तव में नहीं। यह 1 की तरह अधिक है! = 1. 2 !! = 2. 3 !!! = 3. कोई गणना नहीं है, क्योंकि आप पुनरावृत्ति के अंत में हैं। उत्पादों में कोई 0 नहीं वरना हर एक गुट अंत में 0 से नीचे गिर जाएगा।

— वी। कोर्टोइस

3!!!!!!!अपरिभाषित नहीं होना चाहिए - यह सिर्फ जवाब देना चाहिए 3। यह 1!!=1(अपरिभाषित नहीं) के समान है। इसके अलावा आपके इनपुट विनिर्देश का कहना है कि हमेशा कम से कम एक होगा !, इसलिए पहला उदाहरण 3विनिर्देश को फिट नहीं करता है।

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

@ FabianRöling: लेकिन ऐसा नहीं है। इसके (3!)!बजाय यह एक तथ्य से शर्तों को हटा रहा है । यह एक भ्रामक नाम है; मुझे लगता है कि यह एक श्रृंखला में बार-बार फैक्टरियल फ़ंक्शन को लागू करने जा रहा था और यह देखने के लिए ध्यान से पढ़ना था कि यह वास्तव में क्या था। सौभाग्य से प्रश्न स्पष्ट रूप से इसकी व्याख्या करता है। एक बेहतर नाम हो सकता है कि फैडरेट से अलग हो या स्टेप फैक्टोरियल या कुछ और है।

— पीटर कॉर्ड्स

Answer 1

आर , 33 बाइट्स

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

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

संभालती $n=0$ के तार्किक निषेध जोड़कर $n$ ।

Answer 2

अर्नोल्ड , 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

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

छद्मकोड में अनुवादित:

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

नोट: अर्नोल्ड में केवल एक प्रकार का डेटा है: 16-बिट हस्ताक्षरित पूर्णांक। इसलिए मैं 420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!मामले का परीक्षण नहीं कर सकता ।

Comments

बस अपने psuedocode के बारे में उत्सुक। चर 'c' किसके लिए है?

— ouflak

@ouflak मैंने एक-दो बार अपना उत्तर संपादित किया और इसे भूल गया। cचर वास्तव में के बीच तुलना के मूल्य संग्रहीत करता है nऔर 0।

— चार्ली

+1 और मैंने इसे अपने LUA उत्तर के लिए ('c' घटाया)।

— ouflak

Answer 3

जेली , 4 बाइट्स

RṚmP

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

$n$$k$$n,\cdots, 1$RṚm$k^{\text{th}}$$n, n-k, n-2k,\cdots,n-\lfloor n/k\rfloor k$P

Comments

अच्छी तरह से काम करता है, और अंत में इतना आसान है। मैं जेली बिल्कुल नहीं जानता, लेकिन कम से कम यह अच्छा लगता है :)

— वी। कोर्टोइस

$n$$k$$n,\cdots, 1$RṚm$k^{\text{th}}$$n, n-k, n-2k,\cdots,n-\lfloor n/k\rfloor k$P

हाह आपका बहुत बहुत धन्यवाद। एक दिन मैं इस भाषा में गोल्फ के लिए चाहते हो सकता है तो मैं उन monads जानने के लिए होगा, dyads आदि

— वी Courtois

वैकल्पिक कि CJam की तरह दिखता है: r1mP।

— आउटगॉल्फ

@KyeWShi जेली का अपना कोडपेज है , इसलिए इसमें शामिल प्रत्येक 256 अक्षरों में से प्रत्येक को 1 बाइट के रूप में एन्कोड किया गया है।

— श्री एक्सकोडर

Answer 4

एपीएल (Dyalog विस्तारित) , 7 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह। [n,b]तर्क के रूप में लेता है।

×/-\…1¨

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

1¨ तर्क के प्रत्येक तत्व के लिए एक; [1,1]

-\ संचयी अंतर; [n,n-b]

… चरण के संकेतक के रूप में बाएं तर्क के दूसरे तत्व का उपयोग करके सीमा, जैसे [9,7]जारी है5

×/ उत्पाद

Answer 5

हास्केल , 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

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

Comments

मुझे लगता है कि आप पुनरावर्ती समाधान को कम कर सकते हैंn%a|n<1=1|m<-n-a=n*m%a

— दोष

Answer 6

अजगर , 6 बाइट्स

ये सभी 6 बाइट्स के बराबर हैं:

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

इसे ऑनलाइन आज़माएं! ( *F:Q1E)

या, 11 बाइट्स , एक स्ट्रिंग के रूप में इनपुट लेते हुए:

*F:.vQ1/Q\!

परीक्षण सूट।

Answer 7

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

के रूप में इनपुट लेता है (k)(n)।

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

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

या BigInts का समर्थन करने के लिए 24 बाइट्स ।

---

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

चुनौती में वर्णित प्रारूप का उपयोग करके, एक स्ट्रिंग के रूप में इनपुट लेता है।

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

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

Answer 8

व्हॉट्सएप , 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

Answer 9

पायथन 2 , 29 बाइट्स

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

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

Answer 10

पर्ल 6 , 22 बाइट्स

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

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

बेनामी कोडब्लॉक जो पहली इनपुट से शुरू होने वाले रेंज के उत्पाद को लौटाता है 1, अंतिम संख्या को छोड़कर, नीचे से दूसरे तक घटता है । यह काम करता है 0, क्योंकि उत्पाद द्वारा घटने का आधार मामला 1 है, इसलिए आउटपुट 1 है।

Answer 11

05AB1E , 10 8 7 बाइट्स

ݦRIιнP

दो अलग-अलग इनपुट के रूप में इनपुट: पहला इनपुट base; दूसरा इनपुट है factorial।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

-2 बाइट्स @ Mr.Xcoder को धन्यवाद ।
-1 बाइट @ जनाथनअल्लन को धन्यवाद ।

स्पष्टीकरण:

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

Comments

यह 6-बटर: LR²ιнP( इसे ऑनलाइन आज़माएं! ) 0 को छोड़कर हर परीक्षण के मामले में काम करता है।

— श्री एक्सकोडर

लेकिन मुझे लगता है कि 0 मामला सबसे अधिक 2 बाइट्स में तय किया जा सकता है। यदि आप इसे ठीक करने का कोई तरीका निकालते हैं, तो आप इसे ले सकते हैं :) EDIT: शायद LR²ιн0KP8 बाइट्स के लिए?

— श्री एक्सकोडर

@ Mr.Xcoder अच्छा जवाब! दिए गए कदम के साथ कभी भी uninterleave का उपयोग नहीं किया। :)

— केविन क्रूज़सेन

0Kअनावश्यक होना चाहिए क्योंकि 0!विनिर्देश द्वारा एक अमान्य इनपुट है (भले ही इसे उदाहरणों में शामिल किया गया है) - मैंने इस बारे में टिप्पणी की है।

— जोनाथन एलन

... और यदि 0! इनपुट डोमेन ݦRXιнPमें बाइट बचती है।

— जोनाथन एलन

Answer 12

x86-64 मशीन कोड, 12 बाइट्स

समान मशीन कोड 32-बिट मोड में एक ही काम करता है, और 16-बिट मोड में 16-बिट पूर्णांक के लिए।

यह एक समारोह, आर्ग के साथ प्रतिदेय है n=RCX, k=ESI। 32-बिट रिटर्न वैल्यू इन EAX।

C से x86-64 सिस्टम V के साथ कॉल करने योग्य डमी आर्गन्स के साथ कन्वेंशन वास्तविक रजिस्टरों को सही रजिस्टरों में लाने के लिए। uint32_t factk(int, uint32_t k, int, uint64_t n); मैं सिर्फ Windows x64 का उपयोग नहीं कर सका क्योंकि 1-ऑपरेंड mulक्लोबर्स RDX, और हम R8 / R9 तक पहुँचने के लिए REX उपसर्ग नहीं चाहते हैं। 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

048 = 12 बाइट्स

---

या 10 बाइट्स यदि हमें n=0विशेष मामले को संभालने की आवश्यकता नहीं है , तो बाहर जानाjrcxz ।

मानक तथ्य के लिए आप loop2 बाइट को बचाने के लिए सब / जेए के बजाय उपयोग करेंगे , लेकिन अन्यथा ठीक उसी कोड को।

---

टेस्ट फोन करने वाले है कि गुजरता 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`

```

Answer 13

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

बेनामी tacit infix फ़ंक्शन। nसही तर्क के bरूप में और बाएं तर्क के रूप में लेता है।

×/1⌈⊢,⊢-×∘⍳

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

×∘⍳ गुणा bद्वारा ɩ ntegers 1 के माध्यम सेn

⊢- उससे घटाओ n

⊢, आगे जोड़ते n

1⌈ उनमें से एक और प्रत्येक की अधिकतम

×/ उत्पाद

Answer 14

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

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

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

Answer 15

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 22 21 बाइट्स

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

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

-1 अटेंडेंट के लिए धन्यवाद: Times --> 1##&

स्पष्टीकरण: Rangeमानों की एक सूची बनाने के लिए उपयोग करें {n, n-k, n-2k, n-3k, ...}, 1 से नीचे जाने से पहले रोकना (यानी, बस सही रोकना)। फिर Times(या 1##&) के साथ इस सूची में सभी संख्याओं को गुणा करें ।

Comments

के 1##&बजाय के साथ -1 बाइटTimes

— attinat

Answer 16

जावा 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 बाइट्स का धन्यवाद @ ओलिवियरग्रेगायर ।

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

स्पष्टीकरण:

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

Comments

मुझे खेद है कि मैंने आपके संयोग के सही आकार को दोगुना कर दिया ... :(

— ओलिवियर ग्रेजायर

@ OlivierGrégoire एनपी, और धन्यवाद! :)

— केविन क्रूज़सेन

Answer 17

जाप , 8 बाइट्स

TõUV f ×

कोशिश करो

-1 शुक्रिया EoI की ओर इशारा करते हुए कि कैसे गूंगा शैतानी हो सकता है!

Comments

kTf1 बाइट के साथ प्रतिस्थापित किया जा सकता है

— अज्ञान

@EmbodimentofIgnorance, बेशक यह कर सकते हैं! मुझे पता था कि यह गोल्फ के लिए बहुत जल्दी था! : \

— झबरा

Answer 18

सी (जीसीसी) , 41 बाइट्स

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

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

Comments

r;f(n,k){for(r=1;n>0;n-=k)r*=n;n=r;}C (gcc) के लिए 36 बाइट्स

— GPS

Answer 19

मठगोल्फ , 7 6 बाइट्स

╙╒x%ε*

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

0 को संभालने का एक चतुर तरीका मिला! अन्य परीक्षण मामलों को बदलने के बिना। इनपुट k n(रिवर्स ऑर्डर) के रूप में लेता है , जो अंतर्निहित पॉपिंग के साथ मदद करता है।

व्याख्या

╙        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

Answer 20

अटैच , 21 19 बाइट्स

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

इसे ऑनलाइन आज़माएं! सुंदर प्रत्यक्ष पुनरावर्ती कार्यान्वयन। (नोट: trueअनिवार्य 1रूप से, जैसा कि अंकगणित संचालन में इसका उपयोग किया जा सकता है 1।) यह उन कुछ कार्यक्रमों में से एक है जो मैंने इस साइट के लिए लिखा है जहां यूनिकोड ऑपरेटर का उपयोग बाइट्स बचाता है (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 _]}

Answer 21

जंग , 92 73 61 बाइट्स

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

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

संपादित करें: पुनरावर्तन छोटा है।

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

आप अपना स्वयं का परीक्षण जोड़ सकते हैं, या पहले से मौजूद किसी एक को संपादित कर सकते हैं।

Answer 22

क्यू , 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}

Comments

साइट पर आपका स्वागत है! मैंने आपके पोस्ट में कोड स्वरूपण जोड़ा है जो लाइन से पहले चार स्थानों के साथ या ट्रिपल बैकटिक्स के साथ संलग्न करके किया जा सकता है।

— गेहूं जादूगर

@ SriotchilismO'Zaic धन्यवाद :-)

— घसीट

मैं एक स्पष्टीकरण और शायद TIO जैसे ऑनलाइन दुभाषिया के लिए एक कड़ी जोड़ने की सलाह देता हूं । कोड-ओनली उत्तर आमतौर पर स्वचालित रूप से निम्न गुणवत्ता के रूप में चिह्नित किए जाते हैं।

— mbomb007

@ mbomb007 दिलचस्प है। क्या कोई बॉट फ़्लैगिंग उत्तर है? निम्न-गुणवत्ता वाले सबमिशन का क्या होता है? मैं जल्द ही अपडेट करूंगा!

— घसीट

हाँ, एक बॉट है। StackExchange संभावित स्पैम और कम गुणवत्ता वाले उत्तर देखने के लिए बॉट्स का उपयोग करता है। उच्च प्रतिष्ठा वाले लोग समीक्षा कतार देख सकते हैं।meta.stackexchange.com/a/161391/285610

— mbomb007

Answer 23

फिजिका , 22 बाइट्स

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

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

---

26 बाइट्स

अपनी खुद की "भाषा" \ o / ... का उपयोग कैसे करें, इसे फिर से सीखें। अगर मुझे पता है कि 2 साल पहले एक पार्सर कैसे लिखना है, तो यह 20 बाइट्स होगा :(

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

या

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

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

Answer 24

रेटिना , 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!लिंक में तेजी से परीक्षण के मामले शामिल हैं। विस्मयादिबोधक चिह्न के बिना मौल्स नंबर। स्पष्टीकरण:

^0
1

फ़ैसला करना 0! ।

\d+
*!,

धर्मांतरित nयूनियरी में करें और एक विभाजक जोड़ें।

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

बार बार घटाना kसेn , जबकि n>k, और परिणाम को इकट्ठा।

!+$
1

बदलें kके साथ1 (दशमलव में)।

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

बदले में प्रत्येक मध्यवर्ती मूल्य से गुणा करें, दशमलव में परिवर्तित करें।

Answer 25

जाप , 8 बाइट्स

1õUV f ×

कोशिश करो

Answer 26

जावास्क्रिप्ट (Node.js) , 35 बाइट्स

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

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

Answer 27

फोर्थ (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           

Answer 28

पर्ल 5 -Mbigint -p , 45 बाइट्स

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

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

Answer 29

स्टैक्स , 6 बाइट्स

å▐█ΩV∟

इसे चलाएं और डीबग करें

यह फॉर्म में इनपुट लेता है {count} {base}।

Answer 30

गैया , 6 बाइट्स

…)¦v%Π

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

इनपुट लेता है के रूप में n, kहै, तो के इनपुट 3 4होगा 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.