क्रमपरिवर्तन के साथ मज़ा


17

कौन पूरी तरह से क्रमपरिवर्तन से प्यार नहीं करता है, है ना? मुझे पता है, वे अद्भुत हैं-इतना मज़ा!

ठीक है, क्यों नहीं इस मज़ा लेते हैं और इसे बनाने के funner ?

यहाँ चुनौती है:

सटीक रूप में एक इनपुट को देखते हुए: nPr, जहां nपूल से लिया और है rकि पूल से चयन की संख्या है (और nऔर rपूर्णांक हैं), उत्पादन / क्रमपरिवर्तन की सही संख्या लौटने। उन लोगों के लिए जो शब्दावली के साथ थोड़ा कठोर हैं : क्रमपरिवर्तन, डीईएफ। २ अ

हालाँकि, यह वह जगह है जहाँ चुनौती खेल में आती है (यह बहुत आसान नहीं है):

आप अपने क्रमपरिवर्तन समारोह के लिए किसी भी पुस्तकालय, ढांचे, या विधि में निर्मित का उपयोग नहीं कर सकते हैं। आप एक भाज्य विधि, क्रमपरिवर्तन विधि, या किसी भी प्रकार का उपयोग नहीं कर सकते हैं; आपको खुद सब कुछ लिखना होगा।

यदि आगे स्पष्टीकरण की आवश्यकता है, तो कृपया मुझे टिप्पणियों में बताने में संकोच न करें और मैं तुरंत उसके अनुसार कार्य करूंगा।


यहाँ एक I / O उदाहरण दिया गया है:

नमूना समारोह है permute(String) -> int

इनपुट:

permute("3P2")

आउटपुट:

6

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है!


2
ओह। मैंने सोचा था कि यह चुनौती क्रमोन्नति समूहों पर होगी । सुन्दर सामान। यह शांत भी है, और क्रमपरिवर्तन समूहों से निकटता से संबंधित है। चुनौती से प्यार है।
जस्टिन

जब आप कहते हैं कि कोई बिल्ट-इन या लाइब्रेरी मेथड नहीं है, तो क्या आप परमीशन के लिए या किसी चीज के लिए हैं? क्या मैं अंतर्निहित splitइनपुट को इनपुट विभाजित करने के लिए उपयोग कर सकता हूं P? एक फ़ंक्शन के बारे में क्या है जो एक स्ट्रिंग को एक संख्या में परिवर्तित करता है?
xnor

3
जवाब है कि मान सकते हैं 0 <= r <= n?
पीटर टेलर

1
@ डोप्प्प क्या आपका मतलब है कि आर नहीं है n से बड़ा ?
डेनिस

1
@RetoKoradi - मुझे लगता है कि अधिकांश पोस्टरों को उनके उत्तरों को फिर से करने के लिए मजबूर नहीं करने के प्रयास में, आपको बस किसी भी तथ्यात्मक या क्रमचय विधियों / कार्यों का उपयोग करने की अनुमति नहीं है।
डैनियल

जवाबों:


4

CJam, 15 14 बाइट्स

r~\;~\),>UXt:*

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

r              e# Read a token ("nPr") from STDIN.
 ~             e# Evaluate. This pushes the numbers n, Pi and r on the stack.
  \;           e# Discard Pi.
    ~          e# Take the bitwise NOT of r. Pushes -(r+1).
     \)        e# Increment n.    
       ,       e# Turn n+1 into [0 ... n].
        >      e# Keep only the last r+1 elements.
         UXt   e# Replace the first element with 1.
               e# This avoid dealing with the egde case nP0 separately.
            :* e# Compute their product.

4

पर्ल, 27 बाइट्स

#!perl -pl61
$\*=$`-$%++for/P/..$'}{

शेबंग को 4 के रूप में गिना जाता है, स्टड से इनपुट लिया जाता है।


नमूना उपयोग

$ echo 3P2 | perl npr.pl
6

$ echo 7P4 | perl npr.pl
840

किस प्रकार का विकल्प है l61?
feersum

@ फ़ेर्सम इसे (चार 49, अष्टक 61) सेट करता $\है 1
प्रिमो

3

हास्केल, 71 66 बाइट्स

p s|(u,_:x)<-span(/='P')s,(n,k)<-(read u,read x)=product[n-k+1..n]

बहुत सीधा सामान: 'P' पर विभाजित करें और फिर उत्पाद को (n-k + 1) और n के बीच में ले जाएं।

एक whereखंड के बजाय पैटर्न गार्ड का उपयोग करने के लिए उनके विचार के लिए निम्मी के लिए धन्यवाद , यह 5 बाइट्स से मुंडा।


2

मिंकोलंग 0.11 , 13 25 19 बाइट्स

यह सुझाव देने के लिए Sp3000 का धन्यवाद !

1nnd3&1N.[d1-]x$*N.

इसे यहाँ आज़माएँ।

व्याख्या

1        Push 1
n        Take integer from input (say, n)
n        Take integer from input (say, k); ignores non-numeric characters in the way
d3&1N.   Output 1 if k is 0
[   ]    Loop k times
 d1-     Duplicate top of stack and subtract 1
x        Dump top of stack
$*       Multiply all of it together
N.       Output as integer

यह एलेक्स के: n P k= के समान एल्गोरिथ्म का उपयोग करता है n(n-1)(n-2)...(n-k+1)


2

जूलिया, ६३ ५ 58 48 बाइट्स

s->((n,r)=map(parse,split(s,"P"));prod(n-r+1:n))

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसेf=s->...

Ungolfed:

function f(s::AbstractString)
    # Get the pool and number of selections as integers
    n, r = map(parse, split(s, "P"))

    # Return the product of each number between n-r+1 and n
    return prod(n-r+1:n)
end

यह इस तथ्य का उपयोग करता है कि क्रमपरिवर्तन की संख्या n ( n -1) ( n -2) है ... ( n -) k +1) है।

ग्लेन हे के लिए 10 बाइट्स धन्यवाद!


कोई जरूरत नहीं है Int, तो आप बस का उपयोग कर सकते हैं map(parse,...)
ग्लेन ओ

@ गलो मेरा मन उड़ गया है। मुझे एहसास नहीं Intथा कि उस स्थिति में आवश्यक था। बहुत बहुत धन्यवाद!
एलेक्स ए।

2

बाश + लिनक्स बर्तन, 33

jot -s\* ${1#*P} $[${1/P/-}+1]|bc

jotrपर शुरू होने वाले पूर्णांक के अनुक्रम का उत्पादन करता है n-r+1, और उन्हें अलग करता है *। यह अभिव्यक्ति bcअंकगणितीय मूल्यांकन के लिए पाइप की गई है ।


1

MATLAB, 54 बाइट्स

[n,r]=strread(input(''),'%dP%d');disp(prod((n-r+1):n))

इसे और छोटा बनाने की कोशिश की गई, लेकिन MATLAB में से एक चीज बहुत खराब है। इनपुट स्ट्रिंग से केवल दो नंबर प्राप्त करने में 32 अक्षर लगते हैं!

काफी स्व व्याख्यात्मक कोड। उस फॉर्म में इनपुट प्राप्त करें %dP%dजहां% d पूर्णांक है। में विभाजित करें nऔर r। तब रेंज में हर पूर्णांक के उत्पाद प्रदर्शित n-r+1करने के लिए n। दिलचस्प बात xP0यह है कि यह सही उत्तर देने के लिए भी काम करता है। इसका कारण यह है कि MATLAB में prod()फ़ंक्शन 1 रिटर्न करता है यदि आप कोशिश करते हैं और खाली सरणी का उत्पाद करते हैं। जब भी rशून्य होगा, रेंज एक खाली सरणी होगी, इसलिए बिंगो हमें 1 मिलता है।


यह ऑक्टेव के साथ भी पूरी तरह से काम करता है । आप इसे यहाँ ऑनलाइन आज़मा सकते हैं


1

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

s=>(f=(n,k)=>k?(n- --k)*f(n,k):1,f.apply(f,s.split('P')))

1

जावा (594 - बाइट्स)

import java.util.*;import java.lang.*;public class Perm {private String a;private static int[] nr=new int[2];private static int sum=1;Scanner in=new Scanner(System.in);public String input(){a=in.nextLine();return a;}public void converter(String a){this.a=a;String b=a.substring(0,1);String c=a.substring(2);nr[0]=Integer.parseInt(b);nr[1]=Integer.parseInt(c);}public int param(){for(int counter=0; counter < nr[1]; counter++){sum=sum*nr[0]--;}return sum;}public static void main(String args[]){Perm a;a=new Perm();String k=a.input();a.converter(k);int ans=a.param();System.out.println(ans);}}

1

जे, 23 बाइट्स

^!._1/@(".;._1)@('P'&,)

एक अनाम फ़ंक्शन। उदाहरण:

   f =. ^!._1/@(".;._1)@('P'&,)
   f '10P4'
5040

स्पष्टीकरण:

       (  ;._1)@('P'&,)   Split over 'P', and on each slice,
        ".                read a number.
      @                   Then,
^!._1/                    fold (/) with the built-in "stope function" (^!.k) for k=1.

जिस स्टॉप फ़ंक्शन का मैंने उपयोग किया, वह एक अंतर्निहित के रूप में गिनती पर सीमा का उपयोग कर सकता है ... यह गुणन ऑपरेटर की सामान्यता और तथ्यात्मक ऑपरेटर की विशिष्टता के बीच कहीं रहता है।


1

एपीएल, २३

{{×/⍵↑⍳-⍺}/-⍎¨⍵⊂⍨⍵≠'P'}

स्ट्रिंग को तर्क के रूप में लेता है। स्पष्टीकरण:

              ⍵⊂⍨⍵≠'P'  ⍝ Split by 'P'.
           -⍎¨          ⍝ Convert to numbers and negate making a vector (−n −r)
 {       }/             ⍝ Reduce it by a defined function, which
      ⍳-⍺               ⍝ makes a vector of numbers from 1 to n (⍺)
    ⍵↑                  ⍝ takes r last elements (⍵←−r)
  ×/                    ⍝ and multiplies them together.

यह कौन सा एपीएल है? मुझे Dyalog की अपनी प्रति के साथ एक त्रुटि मिलती है।
lirtosiast

1
@ थोमसकवा द्यलोग में उपयोग ⎕ML←3
user46915

1

अजगर 2, 66

def f(s):a,b=map(int,s.split('P'));P=1;exec"P*=a;a-=1;"*b;print P

बहुत सीधा। के रूप में संख्या इनपुट संसाधित करता है a,b। एक चालू उत्पाद रखता है P, जो पहले की bशर्तों से गुणा किया जाता है a, a-1, a-2, ...


2
मैं नहीं देखता कि input()एक त्रुटि कैसे हो सकती है।
फेर्सम

@ Faersum मैंने इसे आज़माया और यह वास्तव में एक सिंटैक्स त्रुटि फेंकता है।
एलेक्स ए।

मैं जैसे उद्धरण के साथ इनपुट ले रहा था "3P2", जो मुझे लगता है कि आमतौर पर अनुमति दी जाती है, लेकिन यहां चुनौती "सटीक रूप में एक इनपुट" कहती है, इसलिए मैं इसे एक फ़ंक्शन में बदल देता हूं जो एक स्ट्रिंग लेता है।
xnor

1

टीआई-बेसिक, 52 बाइट्स

Ans→Str1
expr(sub(Ans,1,⁻1+inString(Ans,"P→P        ;n
1
If expr(Str1                               ;If n^2*r ≠ 0
prod(randIntNoRep(P,P+1-expr(Str1)/P²
Ans

TI-BASIC में "एक सूची का उत्पाद" फ़ंक्शन है, इसलिए बिल्डिंस पर प्रतिबंध के आसपास प्राप्त करना बहुत कठिन नहीं है। हालाँकि, TI-BASIC खाली सूचियों का समर्थन नहीं करता है - इसलिए हमें इसकी आवश्यकता है

दो नंबर निकालने के लिए, मैं एक विकल्प के रूप में पहला नंबर निकालता हूं। ये है महंगा है ; यह पूरी दूसरी पंक्ति लेता है। दूसरे नंबर के लिए फिर से ऐसा करने की आवश्यकता से बचने के लिए, मैंने चर पी को उस नंबर पर सेट किया, और पूरे स्ट्रिंग का उपयोग करके मूल्यांकन कियाexpr( , फिर P² द्वारा विभाजित किया।

अंत में, मैं दो नंबरों के बीच सूची का एक यादृच्छिक क्रमपरिवर्तन ले रहा हूं (एक संख्या में दूसरे को जोड़ने के लिए ध्यान रखना) और उत्पाद लेना।


1

ऑरोबोरोस , 47 45 बाइट्स

इस में से कुछ बहुत बदसूरत है - मुझे लगता है कि यह आगे गोल्फ हो सकता है।

Sr.r-1(
)s.!+S1+.@@.@\<!@@*Ys.!+*S.!!4*.(sn1(

ओरूरबोरोस में कोड की प्रत्येक पंक्ति अपनी पूंछ खाने वाले सांप का प्रतिनिधित्व करती है।

साँप १

Sसाझा स्टैक पर स्विच करता है। r.rएक नंबर पढ़ता है, इसे डुप्लिकेट करता है, और दूसरा पढ़ता है। (गैर-वर्णिक वर्ण जैसे Pछोड़े गए हैं।) -दोनों को घटाते हैं। यदि इनपुट था 7P2, अब हम है 7, 5साझा ढेर पर। अंत में, 1(सांप के अंतिम चरित्र को खाता है। चूंकि यह चरित्र है कि निर्देश सूचक चालू है, सांप मर जाता है।

साँप २

)sपहली बार के माध्यम से कुछ भी नहीं करता है। .!+साँप 2 के ढेर के ऊपर की नकल करता है, जाँच करता है कि क्या यह शून्य है, और यदि ऐसा है तो 1 जोड़ता है। पहली पुनरावृत्ति पर, स्टैक खाली है और माना जाता है जैसे कि इसमें अनंत शून्य समाहित है, इसलिए यह धक्का देता है1 ; बाद के पुनरावृत्तियों पर, स्टैक में एक गैर-अक्षीय मान होता है और इसका कोई प्रभाव नहीं होता है।

अगला, Sसाझा स्टैक पर स्विच करता है, जहां हमारे पास nउत्पाद की गणना के लिए संख्या और एक काउंटर होता है। 1+काउंटर बढ़ाता है। .@@.@\<!दोनों संख्याओं को डुप्लिकेट करता है और 1 धक्का देता है यदि nवह काउंटर से अधिक या बराबर है, तो 0। @@*Yफिर इस मात्रा से काउंटर को गुणा करता है और स्नेक 2 के स्टैक पर प्रतिलिपि बनाता है।

s.!+स्नेक 2 के स्टैक पर वापस जाता है और पहले नंबर को शीर्ष नंबर 1 में बदलने के लिए उसी कोड का उपयोग करता है यदि यह 0 था और इसे उसी तरह रखें। फिर *इस स्टैक पर बैठे आंशिक उत्पाद द्वारा परिणाम को गुणा करता है।

अब हम साझा किए गए स्टैक ( S) पर वापस जाते हैं , काउंटर-या-शून्य ( .) की नक़ल करते हैं , और इसे दो बार नकारते हैं ( !!) एक नॉनज़रो काउंटर को 1 में बदल देते हैं। 4*.(इसे 4 से गुणा करते हैं, डुप्लिकेट करते हैं, और कई पात्रों को खाते हैं। साँप का अंत।

  • यदि हम रुकने की स्थिति में नहीं पहुंचे हैं, तो हमें स्टैक पर एक 4 मिला है। (खाए जाने के बाद के चार अक्षर , और कोड की शुरुआत के चारों ओर छोरों को नियंत्रित करते हैं। यहां )चार वर्णों का पुनर्मिलन होता है, sवापस सांप के 2 के ढेर में बदल जाता है, और निष्पादन जारी रहता है।
  • यदि काउंटर पास हो गया है n, तो हमें स्टैक पर 0 मिला है, और कुछ भी नहीं खाया गया है। snस्नेक 2 के स्टैक पर स्विच करता है और एक नंबर के रूप में शीर्ष मूल्य को आउटपुट करता है; तब 1(आखिरी पात्र खाता है और मर जाता है।

नतीजा यह है कि उत्पाद (r+1)*(r+2)*...*nकी गणना और आउटपुट है।

कोशिश करके देखो

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.