क्यूरेटर की दुविधा

Question

परिचय

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

कार्यक्रम की आवश्यकताएँ

आपके प्रोग्राम को पाँच पूर्णांक (एक फ़ंक्शन को पास करना चाहिए या स्टड के माध्यम से इनपुट करना चाहिए) (या किसी और के माध्यम से)। पहले चार चार कलाकारों में से प्रत्येक द्वारा आपूर्ति की गई चित्रों की संख्या है। अंतिम मान एक क्रमचय सूचकांक है i(1 से गिनती, 0 नहीं)। क्यूरेटर iचित्रों के लेक्सिकोग्राफिक क्रम द्वारा वें क्रमचय को देखना चाहता है ।

आपके प्रोग्राम को इस क्रमचय को किसी भी उचित प्रारूप में आउटपुट करना होगा: जैसे abbccdया [0 1 1 2 2 3]। दस चित्रों से कम कुल इनपुट के लिए रनटाइम एक घंटे से भी कम समय का होना चाहिए (यह उम्मीद है कि कोई समस्या नहीं होनी चाहिए)।

आपको किसी भी इन-बिल्ट फ़ंक्शंस का उपयोग करने की अनुमति नहीं है

उदाहरण

इनपुट: ० १ २ ० २

यह देखते हुए कि हमारे पास कलाकार बी द्वारा एक पेंटिंग और कलाकार सी द्वारा दो (और वे सभी एक जैसे दिखते हैं), लेक्सिकोग्राफ़िक क्रम में क्रमबद्धताएं हैं:

['bcc', ' cbc ', 'ccb']

हाइलाइट किया गया क्रमांकन सही आउटपुट होगा, क्योंकि यह लेक्सिकोग्राफ़िक क्रम में दूसरा है।

इनपुट: १ २ ० १ ५

['एबड', 'एब्ड', 'अडब', 'बबड', ' बडब ', 'बडबड', 'बब्दा', 'बडब', 'बडबा', 'डब्बा', 'डब्बा', 'डब्बा']

परिक्षण

यहां कुछ परीक्षण दिए गए हैं जो सही होने चाहिए।

1 2 4 1 5    - ABBDCCCC
2 2 3 1 86   - ABBCACDC
4 1 2 0 24   - AACACBA
1 4 3 2 65   - ABBCBBDCDC

Python3 में कोड का एक छोटा टुकड़ा जो यादृच्छिक रूप से इनपुट और आउटपुट उत्पन्न करना चाहिए वह यहां उपलब्ध है (प्रवेश के लिए मान्य नहीं है, यह क्रमपरिवर्तन के पायथन आयात का उपयोग करता है):

from itertools import permutations
from random import randint
a,b,c,d,n = randint(1,2),randint(1,2),randint(1,3),randint(1,3),randint(1,15)
print(str(a) + " " + str(b) + " " + str(c) + " " + str(d) + " " + str(n) + " - " + str(sorted(set([''.join(p) for p in permutations(a * "a" + b * "b" + c * "c" + d * "d")]))[n-1]))

स्कोरबोर्ड

Optimizer - CJam       - 39  - Confirmed - Bruteforce
EDC65     - JavaScript - 120 - Confirmed - Bruteforce
Jakube    - Python2    - 175 - Confirmed - Algorithmic

Comments

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

— डेविड जेएन

यह एक मान्य प्रविष्टि नहीं होगी, लेकिन मुझे लगता है कि यह अभी भी किसी के लिए उपयोगी हो सकता है: {:A.a.{~97+[:I.}:मान्य J और कार्य करता है, लेकिन A.अधिकांश कार्यों के लिए उपयोग करता है , इसलिए यह मान्य नहीं है। यदि आप ऐसा फ़ंक्शन लिख सकते हैं जो इस फ़ंक्शन को प्रतिस्थापित A.और सब्सक्राइब करता है, तो आपके पास एक मान्य उत्तर होगा।

— atı 17uʎs

@ toı useuʎs - आपको "एबीसीडी" का उपयोग करने की आवश्यकता नहीं है, आप किसी भी वर्ण / संख्यात्मक / प्रतीकात्मक प्रणाली का उपयोग कर सकते हैं। मुझे डर है कि मैं J को नहीं जानता, और इसलिए मैं सटीक समस्या नहीं बता सकता, लेकिन आशा है कि यह मदद करता है =)

— अलेक्जेंडर क्रैग्स

@PopeyGilbert खैर, एक ऐसा संस्करण जो सिर्फ संख्याओं को बाहर निकालता है {:A.[:I.}:... बात यह है कि, लेकिन मुझे नहीं लगता A.कि यह मान्य होगा: jsoftware.com/help/dfox/dacapdot.htm

— Janıʇǝɥʇilʎs

क्या होगा यदि आवश्यक क्रमचय मौजूद नहीं है? 1 0 0 0 100?

— edc65

Answer 1

पायथन 2: 175 163 चार

यह एक गंभीर गोल्फ जवाब नहीं है। एक अलग एल्गोरिथ्म के साथ मैं 138 बाइट तक पहुँचा। बस इसे यहां पोस्ट करना चाहते थे, क्योंकि यह जानवर बल का उपयोग नहीं करता है। जटिलता थीटा (# चित्र) है।

f=lambda x:0**x or x*f(x-1)
def g(Q,n):
 while sum(Q):
  for j in 0,1,2,3:
   p=f(sum(Q)-1)*Q[j]
   for k in Q:p/=f(k)
   if p<n:n-=p
   else:print j;Q[j]-=1;break

उपयोग:

g([1, 4, 3, 2], 65)

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

समान एल्गोरिथ्म, बस कुछ गोल्फ: गणना के क्रम में तथ्यात्मक विधि और थोड़ा बदलाव आयात नहीं करते हैं।

पायथ अनुवाद: 61 वर्ण

Lu*GhHUb1WsPQV4J*@QNytsPQFZPQ=J/JyZ)I<JeQ XQ4-eQJ)EN XQNt@QNB

यहां कुछ खास नहीं, मेरे अजगर कोड का सटीक अनुवाद। हालांकि बहुत लंबा रास्ता। मैंने भी कुछ बदसूरत (लंबी) चीजों का इस्तेमाल किया था। पहले 9 अक्षर अकेले ही फैक्टरियल की परिभाषा है।

Lu*GhHUb1    def y(b): G=1; for H in range(b): G*= H+1; return G

इसके अलावा सामान Q[j]-=1भी बहुत लंबा है: XQNt@QN(1 चरित्र अजगर से अधिक !!!)

उपयोग:

इसे यहाँ आज़माएँ: पायथ कंपाइलर / एक्ज़ीक्यूटर । डिबग मोड को अक्षम करें और [2, 2, 3, 1, 86]इनपुट के रूप में उपयोग करें ।

Comments

यह काम करता हैं! पहले पायथन समाधान के साथ आने के लिए बधाई! हालांकि, मैंने पाया कि मेरे वातावरण में मुझे from math import*फ़ंक्शन से बाहर जाना है। आपको लीडरबोर्ड में जोड़ना!

— अलेक्जेंडर क्रैग्स

वाह ... आपका समाधान अविश्वसनीय रूप से कुशल है - 32 चित्रों के लिए यह केवल 0.034 सेकंड o.0 लेता है।

— अलेक्जेंडर क्रैग

Answer 2

CJam, 50 43 39 बाइट्स

q~(])\{W):Wa*}%s:X{Xm*:s_&}X,(*{$X=},$=

यह बहुत गोल्फ हो सकता है।

निम्नलिखित प्रारूप में STDIN से इनपुट लेता है:

4 1 2 0 24

पेंटिंग को आउटपुट देता है। उपरोक्त इनपुट के लिए उदाहरण के लिए:

0020210

इसे यहाँ ऑनलाइन आज़माएँ

ध्यान दें कि ऑनलाइन कंपाइलर बड़े पेंटिंग आकारों के लिए देता है। आपको जावा संस्करण पर बड़े इनपुट की कोशिश करनी होगी

Comments

पहला सॉल्वर होने पर बधाई! 50 बाइट्स निश्चित रूप से हरा करने के लिए एक कठिन मूल्य है। मैं आपको लीडरबोर्ड के शीर्ष के रूप में जोड़ूंगा!

— अलेक्जेंडर क्रैग्स

@PopeyGilbert आपको उत्तर स्वीकार करने से पहले कम से कम 1 सप्ताह या तो इंतजार करना चाहिए

— ऑप्टिमाइज़र

आह, ठीक है, मुझे बहुत खेद है! अपनी पिछली चुनौती में मैंने स्वीकार किए गए उत्तर को बदल दिया जब किसी ने पीटा। मेरी गलती।

— अलेक्जेंडर क्रैग्स

@PopeyGilbert आप में से बहुत महान हैं (और काश सभी चुनौती देने वाले लेखक थे), और सिद्धांत रूप में अगर आप करते हैं, तो जल्दी स्वीकार करने में कुछ भी गलत नहीं है, लेकिन कुछ लोगों को बुरा लगता है अगर यहाँ एक चुनौती जल्दी जवाब स्वीकार कर लेती है (क्योंकि, मैं लगता है, किसी को भी उम्मीद नहीं है कि लेखक स्वीकार किए गए उत्तर को बदल देगा)।

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

मुझे व्यक्तिगत रूप से लगता है कि स्वीकार करने से पहले चुनने के लिए कम से कम 2 उत्तर होने चाहिए, भले ही यह जल्दी हो। बेशक अगर एक हफ्ते तक केवल 1 जवाब है, तो इसे स्वीकार करें।

— ऑप्टिमाइज़र

Answer 3

जावास्क्रिप्ट (ईएस 6) 120 138 147

आवश्यक पांच मापदंडों के साथ एक फ़ंक्शन के रूप में, कंसोल के माध्यम से आउटपुट।
प्रतीकों का उपयोग 0,1,2,3। मैं कुल प्रतीकों को शांत करता हूं, फिर प्रत्येक आधार 4 अंकों का निर्माण करता हूं और जांचता हूं कि अंकों की आवश्यक संख्या कितनी है। किसी भी अंक की गलत संख्या वाले नंबर को छोड़ दिया जाता है।
नोट: जावास्क्रिप्ट 32 बिट पूर्णांक के साथ यह 15 चित्रों तक काम करता है।

शार्ट को संपादित करें (.toString से बचें) और तेज़ तरीके से (संशोधित निकास स्थिति)। 1 सेकंड के नीचे प्रत्येक परीक्षा के लिए समय।

Edit2 कोई एल्गोरिथ्म परिवर्तन नहीं, अधिक गोल्फ (पठनीयता के लिए इंडेंटेशन जोड़ा गया)

F=(w,x,y,z,n)=>{
  for(a=0;n;n-=l=='0,0,0,0')
    for(l=[w,x,y,z],t=w+x+y+z,v='',b=a++;t--;b/=4)--l[d=b&3],v=d+v;
  console.log(v)
}

Ungolfed और कोई FireFox की आवश्यकता है

F=function(w,x,y,z,n) {
  for(a=0; n; a++) // exit when solution found (if wrong parameters, run forever)
  {
    l=[w,x,y,z]; // required number of each symbol
    t=w+x+y+z; // total of digits
    v=''; // init output string
    for(b=a;
      t--; // digit count down
      b >>= 2) // shift for next digit
    {
        d = b & 3; //get digit
        --l[d]; // decrement for the current digit
        v = d + v; // add to output string         
    }
    l[0]|l[1]|l[2]|l[3] // if digits ok
    ||--n // decrement counter
  }
  console.log(v) // when found, exit for and print the answer
}

FireBug / FireFox कंसोल में टेस्ट करें

F(1, 2, 4, 1, 5) 
F(2, 2, 3, 1, 86)
F(4, 1, 2, 0, 24)
F(1, 4, 3, 2, 65)

उत्पादन

01132222
01120232
0020210
0112113232

Comments

नमस्कार! इसे चलाने में थोड़ी परेशानी हो रही है। मैं फ़ायरफ़ॉक्स डाउनलोड कर रहा हूँ यह देखने के लिए कि क्या इससे मदद मिलेगी। मैं आपको लीडरबोर्ड में शामिल करूँगा!

— अलेक्जेंडर क्रैग्स

मुझे यहाँ एक अच्छी तालिका मिली - मुझे लगता है कि फ़ायरफ़ॉक्स आवश्यक है। परीक्षण किया और यह काम करता है! पुष्टि के लिए लीडरबोर्ड बदला गया।

— अलेक्जेंडर क्रैग्स

लीडरबोर्ड लेकिन कोई उत्थान नहीं है ... आप वास्तव में इसे पसंद नहीं करते हैं! :(

— edc65

आह! आई एम सो सॉरी = (अब इसे उतारा गया है =)

— अलेक्जेंडर क्रैग्स

मुझे आश्चर्य है कि यह एल्गोरिथ्म CJam में कब तक रहेगा। लेकिन अब तक, मुझे नहीं पता कि यह कैसे काम करता है: P

— ऑप्टिमाइज़र

Answer 4

अजगर , २०

@fqPQm/TdU4^U4sPQteQ

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

इनपुट पायथन लिस्ट फॉर्म में है, उदा [1, 2, 4, 1, 5]

आउटपुट भी पायथन लिस्ट फॉर्म में है, उदा [0, 1, 1, 3, 2, 2, 2, 2]उपरोक्त इनपुट के लिए ।

समाधान क्रूर बल है, और मेरी मशीन पर लगभग 10 सेकंड, सबसे खराब स्थिति है।

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

@fqPQm/TdU4^U4sPQteQ
           ^U4sPQ         All permutations of [0, 1, 2, 3] with length equal to the number
                          of paintings.
     m/TdU4               Find the count (/) of paintings by painter in the input list.
 fqPQ                     Filter the permutations on the counts being the desired counts
                          in the input.
                          This gives all possible orderings of the paintings.
@                teQ      Index into this list at the given location - 1. (0-indexing)