11

एक प्रोग्राम लिखें जो एक इनपुट लेता है जैसे:

n,k

जो तब गणना करता है:

N और k का संयोजन। (सी (एन, के))

और फिर परिणाम प्रिंट करता है।

एक संख्यात्मक उदाहरण:

इनपुट:

5,2

आंतरिक संगणना:

(5!) / (3! X2!)

मुद्रित आउटपुट:

मैं एक ऐसा उत्तर देखना चाहता हूं, जो मेरे ६५ अक्षरों के अजगर समाधान को धड़कता है, लेकिन सभी भाषाओं का स्पष्ट रूप से स्वागत है।

यहाँ मेरा समाधान है:

n,k=input();f=lambda x:+(x<2)or x*f(x-1);print f(n)/(f(k)*f(n-k))

संपादित करें:

मैं मानता हूं कि यह प्रश्न कोडगोल्फ वेबसाइट गणितीय संयोजन पहेली से है। मुझे पता है कि मेरा जवाब ऐसा लग सकता है कि इस पर बहुत प्रगति नहीं हो सकती है, लेकिन इस पहेली के नेताओं ने इसे लगभग आधे अक्षरों में हल किया है।

भाषा के हिसाब से वर्तमान सबसे कम वर्ण हैं:

पर्ल: 35

रूबी: 36

अजगर: 39

PHP: 62

code-golf combinatorics

— बैकस
स्रोत

समारोह या पूर्ण कार्यक्रम? आपका विवरण फ़ंक्शन को कहता है जो सही परिणाम देता है, लेकिन आपका उदाहरण एक पूर्ण प्रोग्राम है जो इसे प्रिंट करता है।

— वेंचरो

@ वेंटरो यू आर राइट आई मीन प्रोग्राम। उसके लिए माफ़ करना।

— बैक

3

आम तौर पर, बुनियादी गणित की अवधारणाएं महान गोल्फ प्रश्न नहीं हैं क्योंकि जे, एपीएल, मेपल, गणितज्ञ और कई अन्य लोगों ने उन्हें बनाया होगा। इसके अलावा, इनपुट और आउटपुट प्रारूप के बारे में थोड़ा और विशिष्ट हो सकता है, और उदाहरण परिणाम प्रदान कर सकते हैं - मैं नहीं कर सकता। यदि आप 5 का चयन करते हैं, तो 2 या 2 का चयन करें यहां बताएं।

— जेसी मिलिकन

@ जेसे मुझे एक अन्य वेबसाइट से यह चुनौती मिली जो केवल प्रमुख स्क्रिप्टिंग भाषाओं की अनुमति देती है, मैं भविष्य में इस दिशानिर्देश को याद रखूंगा। मैंने चुनौती की आवश्यकताओं को और अधिक स्पष्ट करने के लिए अपने प्रश्न को संपादित किया, मुझे बताएं कि क्या यह पर्याप्त रूप से स्पष्ट है या नहीं।

— बैकस

मैं नया हूँ, इसलिए हम एक ही नाव में हैं। हालाँकि, परिणामों को संक्षेप में प्रस्तुत नहीं करते हैं; वे बस पुराने हो जाएंगे। बस वोट और (यदि उपयुक्त हो) उत्तर स्वीकार करें। (इसके अलावा, यदि आप J और GolfScript के जवाबों को बिना वजह अनदेखा करते हैं, तो आप लोगों को नाखुश कर देंगे।)

— जेसी मिलिकन

11

एपीएल, 3 बाइट्स

⎕!⎕

या उन लोगों के लिए जिनके ब्राउज़र उपरोक्त प्रदान नहीं करते हैं, ASCII रेंडरिंग में:

{Quad}!{Quad}

— jpjacobs
स्रोत

3

पूरी तरह से n,kइनपुट के अनुरूप होने के लिए , आपको करना होगा !/⌽⎕।

— मारिनस

10

आर (11 चार्ट)

choose(n,r)

— skeevey
स्रोत

10

सी 96

I / O के साथ (जिसमें लगभग 34 वर्ण लगते हैं)। इसे पठनीय बनाने के लिए नए जोड़े जोड़े गए।

main(a,b,c,d){scanf("%d,%d",&a,&b);
d=a-b;for(c=1;a>b;){c*=a--;}for(;d;)
{c/=d--;}printf("%d",c);}

अब अगर आप मुझे माफ करेंगे, तो मेरे पास ASCII n n k रॉकेट को पकड़ने के लिए चुनना होगा।

    d;main(a
   ,         b
  ,           c
 )  int        a
 ;   {scanf    (
 (   "%d %d"   )
 ,   &a,  &b   )
 ;   d    =a   -
 b   +     b   -
 b   *     1   ;
 a             -
 a  ;for    (  c
 =  1;a>   b   ;
 )  {c=   c    *
 (  (a-- )     )
 ;  }for(      b
 =  b + 1      ;
 d  ;    )     {
 c  =     c    /
 (  d--    )   ;
  }           {
  }           {
   }         (
  printf("%d",c)
 )      ;       }
/*     *  *   * *\
 * * X   * 8 * * |
|     *      *    \
*/    //       *  */

— walpen
स्रोत

7

गोल्फस्क्रिप्ट, 17 वर्ण

यह समाधान k = 0 या k = 1 जैसे मामलों को सही ढंग से संभालता है।

~>.,,]{1\{)*}/}//

फैक्टरियल-जैसा भाग पिछले उत्तर पर आधारित है ।

— Nabb
स्रोत

6

गोल्फक्राफ्ट 21

~~)>.,,]{{)}%{*}*}%~/

विशेष रूप से कम नहीं, गोल्फस्क्रिप्ट में एक वास्तविक फैक्टरियल फ़ंक्शन का अभाव है, हालांकि यह सबसे दुष्ट डेटा हेरफेर है जो मैंने कभी किया है, यह स्टैक ट्रेस के लिए कॉल करता है:

इनपुट से स्टैक पर "5,2" डेटा।
~Eval कमांड, ध्यान दें कि, एक ऑपरेटर है जो एक संख्या को एक सरणी में बदलता है।
[० १ २ ३ ३ ४] २
~बाइनरी नहीं।
[० १ २ ३ ४] -३
)वृद्धि।
[० १ २ ३ ४] -2
>अंतिम २ तत्वों को प्राप्त करने के लिए पैरामीटर के रूप में सरणी, -२ का अंत लें।
[३ ४]
.डुप्लिकेट तत्व।
[३ ४] [३ ४]
,ऐरे की लंबाई।
[३ ४] २
,सरणी के लिए संख्या बदलें।
[३ ४] [० १]
]सरणी बनाएँ।
[[३ ४] [० १]]
{{)}%{*}*}कोड का खंड।
[[३ ४] [० १]] {{)}% {*} *}
%सरणी के प्रत्येक तत्व के लिए एक बार ब्लॉक निष्पादित करें। निम्नलिखित भाग केवल पहले लूप को प्रदर्शित करता है।
[३ ४]
{)}%प्रत्येक ऐरे तत्व को बढ़ाना।
[४ ५]
{*}एक बहु कमांड युक्त ब्लॉक।
[४ ५] {*}
*ब्लॉक कमांड का उपयोग करके ऐरे को "फोल्ड" करें, जो कि इस मामले में सभी तत्वों का उत्पाद बनाते हैं।
20
बड़े लूप के समाप्त होने के बाद यह परिणामों के साथ एक सरणी देता है।
[२० २]
~ऐरो को डिक्स्ट्रक्ट करें।
२० २
/मंडल।
10

— aaaaaaaaaaaa
स्रोत

6

रूबी 1.9, 52 ४६ (४२) वर्ण

eval"A,B="+gets;i=0;p eval"(A-B+i+=1)/i*"*B+?1

यदि stderr को नजरअंदाज किया जाता है:

eval"A,B=I="+gets;p eval"I/(A-I-=1)*"*B+?1

रूबी १. Rub, ४३ अक्षर, स्टैडर के लिए कोई अतिरिक्त आउटपुट नहीं:

eval"a,b=i="+gets;p eval"i/(a-i-=1)*"*b+"1"

संपादन:

(52 -> 48) इनपुट पार्स करने के लिए एक छोटा रास्ता मिला
(48 -> 46) कम लूपिंग, अधिक eval।

— Ventero
स्रोत

4

पायथन (56)

f=lambda n,k:k<1and 1or f(n-1,k-1)*n/k;print f(*input())

असंगठित कोड और द्विपद गुणांक की गणना के लिए एक शॉर्टकट की कुछ व्याख्या। (नोट: वहाँ कुछ अंतर्दृष्टि है कि मैं सिर्फ 39 चार संस्करण के लिए नीचे पाने के लिए समझ नहीं आया है; मुझे नहीं लगता कि यह दृष्टिकोण आपको वहाँ मिल जाएगा।)

# Since choose(n,k) =
#
#     n!/((n-k)!k!)
#
#          [n(n-1)...(n-k+1)][(n-k)...(1)]
#        = -------------------------------
#            [(n-k)...(1)][k(k-1)...(1)]
#
# We can cancel the terms:
#
#     [(n-k)...(1)]
#
# as they appear both on top and bottom, leaving:
#
#    n (n-1)     (n-k+1)
#    - ----- ... -------
#    k (k-1)       (1)
#
# which we might write as:
#
#      choose(n,k) = 1,                      if k = 0
#                  = (n/k)*choose(n-1, k-1), otherwise
#
def choose(n,k):
    if k < 1:
        return 1
    else:
        return choose(n-1, k-1) * n/k

# input() evaluates the string it reads from stdin, so "5,2" becomes
# (5,2) with no further action required on our part.
#
# In the golfed version, we make use of the `*` unpacking operator, 
# to unpack the tuple returned by input() directly into the arguments
# of f(), without the need for intermediate variables n, k at all.
#
n, k = input()

# This line is left as an exercise to the reader.
print choose(n, k)

क्या आप अपनी लिपि का एक अपुष्ट उदाहरण प्रदान कर सकते हैं?

— बैकस

क्या हम *फॉर्म का इनपुट पार्स करने के लिए उपयोग कर सकते हैं 4545 78?

— Quixotic

दुर्भाग्य से, नहीं, लेकिन यह *मुद्दा नहीं है। 4545 78एक मान्य पायथन अभिव्यक्ति नहीं है, इसलिए input()एक बढ़ाएगा SyntaxError। यह ट्रिक पूरी तरह से समस्या पर निर्भर करती है x,y। यदि आपके पास एक फ़ंक्शन है जो x yएक ट्यूपल को पढ़ता है और वापस करता है, तो आप *उस ठीक के साथ उपयोग कर सकते हैं।

4

आरपीएल (4)

(अंतर्निहित फ़ंक्शन का उपयोग करके)

COMB

— ओलिवर
स्रोत

3

विंडोज पॉवरशेल, ५ Power

$a,$b=iex $input
$p=1
for($a-=$b;$a-ge1){$p*=1+$b/$a--}$p

— एक छोटा सा सिक्का
स्रोत

3

जे, ३३ ३६

(":!~/".;._1}:toJ',',1!:1(3))1!:2(4)

35 वर्ण इनपुट, पार्सिंग और आउटपुट हैं। अन्य वर्ण, !n n k है।

मेरे पास इस समय परीक्षण के लिए विंडोज नहीं है, लेकिन मेरा मानना है कि इसे वहां काम करना चाहिए।

— जेसी मिलिकन
स्रोत

3

क्यू, 32 चार

{f:{1*/1.+(!)x};f[x]%f[y]*f x-y}

— tmartin
स्रोत

2

पर्ल 6 (55)

my ($a,$b)=lines;$_=1;for 1..$a-$b {$_+=$_*$b/$^a};.say

— मिंग-तांग
स्रोत

2

आरपीएल (22)

(अंतर्निहित COMB फ़ंक्शन का उपयोग नहीं कर रहा है)

→ n k 'n!/(k!*(n-k)!)'

— ओलिवर
स्रोत

2

क्यू ( 50 45)

 f:{(prd 1.+til x)%((prd 1.+til y)*prd 1.+til x-y)}

आप निरर्थक कोष्ठक हटाकर और prd के बजाय 1 * / का उपयोग करके ऊपर से कुछ वर्णों को शेव कर सकते हैं।

f:{(1*/1.+til x)%(1*/1.+til y)*1*/1.+til x-y}

— sinedcm
स्रोत

2

गणितज्ञ १२

सीधा, बिल्ट-इन फ़ंक्शन।

n~Binomial~k

— DavidC
स्रोत

2

पर्ल 6 , 25 16 बाइट्स

-9 बाइट्स nwellnhof के लिए धन्यवाद

+*o&combinations

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

बेनामी फ़ंक्शन जो दो नंबर लेता है और एक इंट रिटर्न देता है। यह बिल्ट-इन का उपयोग करता है combinationsऔर लौटी हुई सूची को इंट में परिवर्तित करता है।

— मजाक कर रहा है
स्रोत

16 बाइट्स

— nwellnhof

@nwellnhof आह, मुझे एहसास नहीं था कि combinationsएक सूची के बजाय एक नंबर ले सकते हैं

— जो किंग

1

PHP (71 79 )

<?$a=fgetcsv(STDIN);$x=1;while($a[1]-$i)$x=$x*($a[0]-++$i+1)/$i;echo$x;

~~<?php $a=fgetcsv(STDIN);$x=1;while(++$i<=$a[1])$x=$x*($a[0]-$i+1)/$i;echo $x?>~~

— mellamokb
स्रोत

1

पायथन (54)

f=lambda n,k:k<1or f(n-1,k-1)*n/k;print 1*f(*input())

अनिवार्य रूप से ऊपर पायथन के रूप में एक ही है, लेकिन मैं छोड़ने से चार बाइट्स दाढ़ी

and 1

फ़ंक्शन परिभाषा से। हालाँकि, फ़ंक्शन का यह परिणाम 1 के बजाय ट्रू लौटने पर यदि k = 0 है, लेकिन इसे 1 * ट्रू = 1 से प्रिंटिंग से पहले 1 से गुणा करके तय किया जा सकता है, इस प्रकार दो बाइट्स जोड़ सकते हैं।

— टो
स्रोत

1

जे, 11 अक्षर

!~/".1!:1[1

कीबोर्ड से इनपुट लेता है।

    !~/".1!:1[1
5,2
10

— गैरेथ
स्रोत

0

हास्केल (80)

f(_,0)=1
f(n,k)=n/k*f(n-1,k-1)
main=getLine>>=putStr.show.f.read.(++")").('(':)

लेकिन, यदि प्रारूप के x yबजाय प्रारूप में इनपुट की अनुमति है x,y, तो यह 74 वर्ण है:

f[_,0]=1
f[n,k]=n/k*f[n-1,k-1]
main=interact$show.f.map read.take 2.words

— मारीनस
स्रोत

0

स्कैला 54

val n,k=readInt
((k+1)to n product)/(1 to(n-k)product)

— अज्ञात उपयोगकर्ता
स्रोत

0

पायथन (52)

 f=lambda n,k:k<1or f(n-1,k-1)*n/k;print+f(*input())

का उपयोग करके अन्य दो से बेहतर print+का परिणाम कन्वर्ट करने के लिए fसे booleanकरने के लिएint मामले में k==0।

अभी भी पता नहीं है कि इसे 39 में कैसे सिकोड़ें, मुझे आश्चर्य है कि क्या वे लैम्ब्डा का उपयोग कर रहे हैं।

— एंड्रिया अंबु
स्रोत

0

(ओपी केवल इनपुट और आउटपुट विधि / प्रारूप को शिथिल रूप से निर्दिष्ट करता है, इसलिए निम्नलिखित स्वीकार्य लगता है।)

सेज नोटबुक ( 39 41 40)

वर्तमान सेल में,

f=lambda n,k:k<1or f(n-1,k-1)*n/k;+f(*_)

जहां फार्म में इनपुट n,k दर्ज किया गया है और पूर्ववर्ती सेल में मूल्यांकन किया गया है। यह "कमांड-लाइन इनपुट" को इसे _(कमांड-लाइन तर्कों के समान) असाइन करता है ।

सेज नोटबुक ( 42 44) 43)

वैकल्पिक रूप से, "इन-सोर्स इनपुट" (केवल x=और न्यूलाइन अक्षरों को स्कोर में जोड़ने के साथ) का उपयोग करके, उदाहरण के लिए,

x=5,2
f=lambda n,k:k<1or f(n-1,k-1)*n/k;+f(*x)

ये दोनों दृष्टिकोण स्पष्ट रूप से दूसरों के पहले के उत्तर से स्पिन-ऑफ हैं।

— रेस
स्रोत

0

Tcl , 80 बाइट्स

proc C n\ k {proc f n {expr $n?($n)*\[f $n-1]:1}
expr [f $n]/([f $k]*[f $n-$k])}

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

— sergiol
स्रोत

बहुत ही अस्वास्थ्यकर दृष्टिकोण, 165 बाइट्स: tio.run/…

— सर्जियोल

0

जावास्क्रिप्ट, 27 बाइट्स

पहले मेरे अपने 35 बाइट समाधान:

f=(n,k)=>n-k&&k?f(--n,k)+f(n,k-1):1

या, वैकल्पिक रूप से,

f=(n,k,i=k)=>i?f(n-1,k-1,i-1)*n/k:1

सरल (n,k) = (n-1,k) + (n-1,k-1)नियम के साथ, पहले काम करता है । दूसरा जो प्रयोग कर रहा है (n,k) = (n-1,k-1) * n/k।

संपादित करें

मैं सिर्फ इस के डुप्लिकेट में अर्नोल्ड द्वारा समाधान देखा:

f=(n,k)=>k?n*f(n-1,k-1)/k:1

जो 8 बाइट कम (27 बाइट्स) है

— vrugtehagel
स्रोत

0

TI-BASIC, 16 वर्ण (8 बाइट)

Ans(1) nCr Ans(2

इनपुट लंबाई 2 की एक सूची है Ans।
आउटपुट यहाँ परिभाषित सूत्र का परिणाम है ।

यदि उपरोक्त समाधान पर्याप्त नहीं है, तो निम्न 35 वर्ण (24 बाइट) समाधान भी काम करता है:

Ans(2)!⁻¹(Ans(1)-Ans(2))!⁻¹Ans(1)!

नोट: TI-BASIC एक टोकन भाषा है। कैरेक्टर काउंट बाइट काउंट नहीं के बराबर होता है ।

— ताउ
स्रोत