मुझे एक पोल रंग दो

22

कहते हैं कि आपका काम पोल पेंट करना है, और एक ग्राहक आपको 4 लाल वर्गों और 3 पीले वर्गों के साथ एक पोल पेंट करने के लिए कहता है। आप इस प्रकार से बहुत आसानी से कर सकते हैं:

r y r y r y r

सिर्फ पीली और लाल धारियों के साथ। अब कहते हैं कि आपका ग्राहक आपको 2 लाल खंडों, 2 पीले खंडों और 1 हरे खंड के साथ एक पोल पेंट करने के लिए कहता है । ऐसे कुछ तरीके हैं जिनसे आप अपना पोल पेंट कर सकते हैं

g y r y r
y g r y r
y r g y r
y r y g r
y r y r g
g r y r y
r g y r y
r y g r y
r y r g y
r y r y g
y r g r y
r y g y r

अधिक सटीक रूप से पोल पेंट करने के 12 तरीके हैं। यह अधिक रंगों और वर्गों को शामिल करता है जो इसमें शामिल हैं

अब यदि आपका ग्राहक कहता है कि वे 3 लाल खंड और 1 पीला खंड चाहते हैं, तो इस तरह से एक पोल पेंट करने का कोई तरीका नहीं है। कोई फर्क नहीं पड़ता कि आप वर्गों को व्यवस्थित करने का प्रयास कैसे करते हैं दो लाल खंड स्पर्श करेंगे, और जब दो लाल खंड स्पर्श करते हैं तो वे एक ही लाल खंड बन जाते हैं।

और यह पोल डंडों के लिए हमारे एक नियम से बहुत अधिक है

आसन्न खंड समान रंग के नहीं हो सकते हैं

कार्य

आवश्यक रंग और वर्गों की एक सूची को देखते हुए, अनुरोध के अनुसार एक पोल पेंट करने के लिए संभावित तरीकों की संख्या को आउटपुट करें। आप किसी भी उचित तरीके से रंगों का प्रतिनिधित्व कर सकते हैं (पूर्णांक, वर्ण, स्ट्रिंग्स), लेकिन आपको एक बार में 255 से अधिक अलग-अलग रंग नहीं दिए जाएंगे। यदि आप चाहें तो रंगों को निर्दिष्ट नाम नहीं भी चुन सकते हैं और यदि आसान है तो बस अनुभाग की सूची लें।

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

ये हाथ से गणना करने के लिए कठिन हैं, खासकर जब वे बड़े हो जाते हैं। अगर किसी के पास सुझाव दिया गया मामला है तो मैं उसे जोड़ दूंगा।

[4,3]    -> 1
[2,2,1]  -> 12
[3,1]    -> 0
[8,3,2]  -> 0
[2,2,1,1]-> 84
code-golf  permutations 
— गेहूं का जादूगर
स्रोत
क्या हम इनपुट के रूप में लेते हैं, उदाहरण के लिए, [4,3] के लिए "rrrryyy"?
— सिंह
@ लियो यकीन है कि पूरी तरह से उचित है।
— गेहूं जादूगर
क्या मुझे इनपुट मिल सकता है [1, 1, 1, 1, 2, 2, 2]? मुझे ऐसा लगता है।
— आउटगॉल्फ जूल
1
— अक्षत महाजन
4
सुपर महत्वपूर्ण नहीं है, लेकिन पोल शब्द को कैपिटल करना ऐसा लगता है जैसे आप पोलैंड के एक व्यक्ति के बारे में बात कर रहे हैं।
— एनएच।

जवाबों:

9

गणितज्ञ, ३ 37 44 48 60 62 बाइट्स

पूर्णांक की सूची के रूप में इनपुट लें {1, 1, 1, 2, 2}। इसे वुल्फराम सैंडबॉक्स पर आज़माएं ।

पैटर्न-मिलान विधि, धन्यवाद @ एक पेड़!

Count[Split/@Permutations@#,{{_}..}]&

Splitलगातार तत्वों, जैसे की उप-सूचियों में एक ही सूची विभाजन {1, 1, 2, 3, 4, 4}में{{1, 1}, {2}, {3}, {4, 4}}

{{_}..}अर्थात् है {{_}, {_}, {_}, ...}। पैटर्न अनार्य उपविदों की सूची से मेल खाता है।

Differences विधि, 48 बाइट्स:

Tr@Abs@Clip[1##&@@@Differences/@Permutations@#]&

कोड Differencesयह निर्धारित करने के लिए उपयोग करता है कि आसन्न तत्व समान हैं या नहीं।

क्रमशः:

  1. Permutations@# एक एन! * एन सूची के लिए इनपुट सूची के सभी क्रमपरिवर्तन उत्पन्न करता है।
  2. Differences/@ एन तत्वों के बीच अंतर की गणना करता है, और एक एन उपज देता है! * (एन -1) सूची।
  3. 1##&@@@सभी सूचियों के गुणन की गणना करता है। यदि एक सूची में 0(दो आसन्न तत्व समान हैं), तो परिणाम होगा 0, अन्यथा गैर-शून्य, एक एन तक! सूची।
  4. Clip[]जैसा कार्य करता है Sign[], सूची को (-inf, inf) से [-1, 1] में रूपांतरित करें
  5. Tr@Absसभी -1में बदल जाता है 1और अब N! -length सूची में केवल 0(अमान्य) और 1(मान्य) शामिल हैं। तो हम सिर्फ सूची का योग करते हैं।
— कीउ गण
स्रोत
4
आप कुछ पैटर्न मिलान के साथ 4 बाइट्स बचा सकते हैं Permutations@#~Count~Except@{___,x_,x_,___}&:।
— एक पेड़ नहीं
2
मेरे पास एक और है: Count[Split/@Permutations@#,{{_}..}]&37 बाइट्स!
— पेड़ नहीं
7

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

Œ!QIẠ€S

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

उदाहरण के [1,1,1,1,2,2,2]लिए इनपुट लेता है [4,3]। [8,3,2]Testcase TIO पर चलने के लिए बहुत समय लगता है।

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

Œ!QIẠ€S - main link, input as a list
Œ!      - all permutations
  Q     - remove duplicates
   I    - take increments (returns a 0 for two adjacent identical numbers)
    Ạ€  - apply “all” atom to each: 0 for containing 0 and 1 otherwise
      S - sum
— fireflame241
स्रोत
आप दुर्व्यवहार रियायती अवधि ...;)
— एरिक Outgolfer
Œ!QIẠ€Sकाम करता है ? इसे ऑनलाइन आज़माएं!
— nmjcman101
@ nmjcman101 जो काम करता दिखाई देता है। अच्छा लगा! मैं Pअपनी सादगी के लिए किसी भी और सभी परमाणु से अधिक पसंद करता हूं ।
— फायरफ्लेम 241
@ fireflame241 तकनीकी रूप से यह कोई भी और सभी परमाणु नहीं है, यह सभी परमाणु है।
— निकोलस
P€इसके बजाय BTW Ạ€अभी भी काम करेगा।
— निकोलग्राफ जूल
5

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

Expand[1##&@@(LaguerreL[#,-1,x](-1)^#)]/._^i_:>i!&

इसे मैथिक्स में , या वोल्फ्राम सैंडबॉक्स में आज़माएं !

परीक्षण मामलों में इनपुट की तरह लेता है - उदाहरण के लिए {4,3}"4 लाल धारियां, 3 पीली धारियां"।

यह एक सूत्र है जो मुझे यहां मिला है । "नाओवे" का अर्थ है "मुझे नहीं पता कि गणित कैसे काम करता है इसलिए कृपया मुझसे स्पष्टीकरण न पूछें ..."

— पेड़ नहीं
स्रोत
1
क्या हमारे पास इस उत्तर में दिए गए गणित की व्याख्या हो सकती है?
— TheLethalCoder
@ TheLethalCoder सेकंड, क्या कोई मुझे मैथ्स समझा सकता है?
— एक पेड़ नहीं
3

रूबी 2.4, 47 बाइट्स

इनपुट पात्रों में से एक सूची है: परीक्षण मामले के लिए [4,3], इनपुट हो सकता है %w[a a a a b b b], "1111222".charsया कुछ अन्य सरणी स्वरूपण विधि है कि रूबी में मान्य है।

->x{x.permutation.uniq.count{|a|a*''!~/(.)\1/}}

2.4 के लिए आवश्यक है Enumerator#uniq(पहले के संस्करणों में केवल यह Arrayवर्ग पर उपलब्ध था )। जैसे, TIO लिंक पहले क्रम के माध्यम से क्रमिक एन्यूमरेटर को सरणी में बदलने के लिए 5 बाइट्स जोड़ता है to_a, क्योंकि इसमें उपरोक्त फ़ंक्शन नहीं है।

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

— मूल्य स्याही
स्रोत
3

आर, 72 बाइट्स

pryr::f(sum(sapply(unique(combinat::permn(x)),pryr::f(!sum(!diff(x))))))

फ़ंक्शन बनाता है 

function (x) 
{
    sum(sapply(unique(combinat::permn(x)), pryr::f(!sum(!diff(x)))))
}

[1,1,1,1,2,2,2]आउटगीर की टिप्पणी के अनुसार एरिक के रूप में इनपुट लेता है । उपयोग combinatके permnसमारोह सभी क्रमपरिवर्तन की एक सूची बना, और फिर uniqueसब अलग प्रविष्टियों मिलता है। sapplyफिर सभी प्रविष्टियों पर निम्नलिखित फ़ंक्शन लागू करता है:

pryr::f(!sum(!diff(x)))

जिसका मूल्यांकन करता है

function (x) 
!sum(!diff(x))

ध्यान दें कि यह बड़े फ़ंक्शन के इनपुट xके समान नहीं है x। इस फ़ंक्शन में किसी अन्य वर्ण का उपयोग करने से यह pryr::fमाना जाएगा कि बड़े फ़ंक्शन को किसी अन्य तर्क की आवश्यकता है।

वैसे भी, जब एक क्रमचय दिया जाता है, तो यह फ़ंक्शन वेक्टर के बीच का अंतर लेता है 2 1 3 4 2 1 -> -1 2 1 -2 -1:। !नॉनजेरो के FALSEऔर ज़ीरोस को परिवर्तित करता है TRUE, जिससे वेक्टर बन जाता है FALSE FALSE FALSE FALSE FALSE। यह जांचना कि किसी भी प्रकार की जाँच करने के लिए है TRUE( TRUEमतलब होगा diff=0-> दो समान संख्याएँ)। हम फिर से इस में उलट सकते हैं !कि क्या क्रमपरिवर्तन में लगातार मान हैं या नहीं।

इन बूलियन्स पर सुमिंग करने से हमें कुल संख्या में क्रमपरिवर्तन मिलते हैं जहां ऐसा नहीं है।

[8,3,2]टेस्टकेस के लिए काम नहीं करता है क्योंकि उन क्रमचयों को संग्रहीत करने के लिए 46GB के वेक्टर की आवश्यकता होती है।

— JAD
स्रोत
2

भूसी , 8 बाइट्स

#ȯ¬ṁtguP

इसे ऑनलाइन आज़माएं! प्रारूप में इनपुट लेता है "aaabb"के लिए [3,2]। सबसे लंबे समय तक परीक्षण के मामले में बाहर टाइम्स।

व्याख्या

यहाँ कुछ भी नहीं फैंसी, बस अद्वितीय क्रमांकन की गिनती कर रहे हैं जहां आसन्न तत्वों के सभी समूहों की लंबाई 1 है।

#ȯ¬ṁtguP
       P  Permutations.
      u   Remove duplicates.
#ȯ        Count how many satisfy the following condition:
     g    group adjacent elements,
   ṁt     concatenate tails of groups
  ¬       and negate.
— Zgarb
स्रोत
2

रूबी, 84 76 बाइट्स

f=->a,x=p{i=s=0;a.map{a[i-=1]-=1;a[i]<0||i!=x&&s+=f[a,i];a[i]+=1}.max>0?s:1}

एक पुनरावर्ती लंबोदा समारोह। प्रत्येक संभावित रंग को देखता है और एक पुनरावर्ती पेड़ की खोज को खुराक देता है, जितनी बार यह सभी पट्टियों का उपयोग करता है।

स्पष्टीकरण (पुराने संस्करण के लिए):

f=->
  a, # a is the input array in [3,3,4] form
  x = -1 # x is the last color placed (-1 when run normaly, used in recursive calls)
{
  j = i = s = 0;
  # i is the index
  # s is the sum of valid final patterns (the answer)
  # j is used to count the total stripes

  a.map{|e| # Iterate over array of colors

    a[i] -= 1; # remove a stripe of current color (the array will be used in recursive call)

    s += f[a,i] if i!=x && e>0;
      # add to sum recursively if:
        # we are not using the same color as the last color AND
        # we have stripes of the current color left to paint

    a[i] += 1; # replace the stripe we removed above 

    j += a[i]; # add stripes to j

    i+=1 # increment the index

  }; # End loop

  j == 0 ? 1 : s
  # if we had stripes, give the recursive sum, otherwise return 1 
}
— MegaTom
स्रोत
x=pप्रारंभिक स्थिति के रूप में? इस मामले में pएक उपनाम के रूप में कार्य करता है nilऔर इसके लिए उपयोग किए जा रहे चेक को संतुष्ट करना चाहिए।
— मूल्य इंक
1

MATL , 11 8 बाइट्स

Y@Xu!dAs

इनपुट प्रारूप के [1 1 1 1 2 2 2]लिए है[4 3] आदि के ।

अंतिम परीक्षण मामले के लिए स्मृति से बाहर चलाता है।

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

व्याख्या

Y@    % Implicit input. Matrix of all permutations. Each row is a permutation
Xu    % Unique rows
!     % Transpose
d     % Consecutive differences along each column
A     % All: true for columns such that all its entries are nonzero
s     % Sum. Implicitly display
— लुइस मेंडो
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.