मिया सेट्स का क्रम

Question

पासा खेल मिया आकार दो के सेट का एक बहुत ही गैर-तुच्छ क्रम प्रस्तुत करता है:

{3,1} < {3,2} < {4,1} < {4,2} < {4,3} < {5,1} < {5,4} < {6,1} < {6,5} < {1,1} < {2,2} < {6,6} < {1,2}

सामान्य तौर पर, एक ट्यूल के भीतर का क्रम मायने नहीं रखता है {x,y}={y,x}, {1,2}किसी भी चीज से अधिक है, जोड़े गैर-जोड़े से अधिक हैं और एक टाई के मामले में संख्यात्मक मूल्य तय करता है।

अब मान लीजिए कि आप nपासा का उपयोग करना चाहते हैं । इसके अलावा, dices के mचेहरे हैं।

उदाहरण:

• {1,5,3,4} < {1,2,6,3} 5431 <6321 के बाद से
• {1,2,3,5} < {1,1,5,6} < {1,1,5,5}, {1,1,6,6} < {1,1,1,3} < {2,2,2,3} < {1,1,1,1} < {1,2,3,4}
• {2,2,5} < {1,1,6} चूंकि दोनों सेटों में प्रत्येक एक जोड़ा और 611> 522 है

संक्षेप में, {1, ..., n}किसी भी चीज़ से अधिक है। आज्ञा देना p > q, तो p-of-a-kind, q-of-a-तरह से अधिक है। एक टाई के मामले में, दूसरा (, तीसरा, ...) - सबसे लंबे समय तक एक तरह की जीत। अंत में, यदि कोई निर्णय अभी तक नहीं किया जा सका, तो सबसे बड़ी संख्यात्मक मूल्य जीत होगी। एक सेट का संख्यात्मक मान सबसे बड़ा पूर्णांक है जिसे आप सेट में उपलब्ध संख्याओं से बना सकते हैं, समवर्ती का उपयोग करते हुए। उदाहरण:

• {2,5,4,3} 5432 बन जाता है
• {4,11,3,4} B443 बन जाता है (> 6-सामना वाले पासा की अनुमति है, B = 11)

आपका काम अपनी पसंद की भाषा में सबसे छोटा संभव कार्यक्रम (यानी फ़ंक्शन) लिखना है, जो कि दो कंटेनरों (सूची, सरणी, सेट, ...) को दिया जाता है, चाहे वह पहला या दूसरा जीता हो।

नोट: आप मान सकते हैं कि दो कंटेनरों की लंबाई समान है और इसमें केवल सकारात्मक पूर्णांक हैं, लेकिन कुछ और नहीं। विशेष रूप से वे हल नहीं हो सकते हैं। वापसी मूल्य कुछ भी हो सकता है, उदाहरण के लिए {-1, 0, 1} {पहली जीत, टाई, दूसरा जीत}।

Comments

जिनमें से एक जीत {1,1,6}, {2,2,5}? क्या आप सबसे बड़े p-of-a-kind या किसी पासा के संख्यात्मक मूल्य की तुलना करते हैं?

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

मुझे यह जाँचने दें कि क्या आदेश देने की मेरी समझ सही है: पहले, {1, ..., n} उच्चतम है। प्रत्येक सूची के लिए, सबसे सामान्य मूल्य लेते हैं, और समान रूप से सामान्य मूल्यों में सबसे बड़ा लेते हैं। यदि एक सूची में से अधिक है, यह जीतता है। यदि समान रूप से सामान्य है, जो भी अधिक से अधिक जीत है। यदि समानता और मूल्य दोनों में समान हैं, तो उन सभी को प्रत्येक सूची से हटा दें और फिर से तुलना करें।

— xnor

@ मर्टिन: बहुत बढ़िया सवाल। मुझे लगता है कि उस पर कोई "विहित" निर्णय नहीं है, और जब से मेरे जूलिया कार्यक्रम का कहना है कि {1,1,6} {2,2,5} से अधिक जीतता है, तो यह सिर्फ इतना ही है।

— पैसिबी

@ एक्सनॉर: हां, हालांकि मार्टिन की टिप्पणी और मेरे जवाब पर विचार करें।

— पसिबी

@oVooVo ओह, हाँ, यह वास्तव में आपके उदाहरण पर विचार करता है जहां आप अंकों को सबसे बड़े से सबसे छोटे से छाँटने के बाद उन्हें संख्यात्मक मान से क्रमबद्ध करते हैं।

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

Answer 1

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

ṢŒrUṢṚZ
Ṣ⁼J;ǵÐṀ

उन सूचियों की एक सूची लेता है जिनमें से प्रत्येक एक रोल का प्रतिनिधित्व करता है (इसलिए यदि वांछित हो तो दो से अधिक हो सकता है) और विजेता की सूची लौटाता है।

इसे ऑनलाइन आज़माएं! ... वैकल्पिक रूप से यहां एक संस्करण है जो सबसे कमजोर से मजबूत के बजाय रोल को सॉर्ट करता है।

कैसे?

Ṣ⁼J;ǵÐṀ - Main link: list of list of dice rolls, L
     µÐṀ - filter keep maximal (i.e. sort L by the previous link as a key and keep maximums)
         -                                            e.g. [5,3,1,3]
Ṣ        -     sort roll                                   [1,3,3,5]
  J      -     range(length(roll))                         [1,2,3,4]
 ⁼       -     equal? [1,2,3,...n] beats everything        0
    Ç    -     call last link as a monad with input roll   [[2,1,1],[3,5,1]]
   ;     -     concatenate                                 [0,[2,1,1],[3,5,1]]

ṢŒrUṢṚZ - Link 1, rest of sort key: dice rolls        e.g. [5,3,1,3]
Ṣ       - sort the roll                                    [1,3,3,5]
 Œr     - run length encode                                [[1,1],[3,2],[5,1]]
   U    - upend (reverse each)                             [[1,1],[2,3],[1,5]]
    Ṣ   - sort                                             [[1,1],[1,5],[2,3]]
     Ṛ  - reverse                                          [[2,3],[1,5],[1,1]]
      Z - transpose                                        [[2,1,1],[3,5,1]]
        -     ...this is a list of: 1) the group sizes descending; and
                 2) the face values of each group, descending across equal group sizes

Comments

@oVooVo गोल्फ का प्रयास करते समय यह अधिक मुझे लगता है कि देखा 1,1,2और 1,2,2बराबर माना जाता है, लेकिन कल्पना वर्तमान में उन्हें या तो भेद नहीं करता।

— जोनाथन एलन

आगे के निरीक्षण पर @oVooVo ने {1,1,5,6} < {1,1,5,5}जहां उदाहरण दिया है 6 > 5। क्या आप स्पष्ट कर सकते हैं?

— जोनाथन एलन

@oVooVo शायद यह इस तरह से होना चाहिए - मैंने "अधिकतम चयन" को प्रतिस्थापित कर दिया है ÐṀ, एक प्रकार के साथ Þ, परीक्षण प्रयोजनों के लिए - उदाहरण से आइटम का उपयोग करके उन्हें उसी क्रम में क्रमबद्ध करें। उपयोग किया गया ऑर्डरिंग है: पहले यदि यह "टॉप-डॉग" है, तो नीचे उतरने वाले समान चेहरों की गिनती और अंत में अनूठे चेहरों द्वारा।

— जोनाथन एलन

{1,1,5,5} में दो "2-ऑफ-ए-तरह" हैं: (1,1) और (5,5)। {1,1,5,6} के पास केवल एक "2-ऑफ-ए-तरह" है। * ~ 1,1,5,5} जीतता है। यहां मूल्य मायने नहीं रखता। इसी तरह, {1,1,2,2}> {4,5,6,6}।

— पसबी

{1,2,2}> {1,1,2}। क्योंकि दोनों में एक 2-तरह का, संख्यात्मक टाई-ब्रेकिंग लागू होता है। {1,2,2} => 221 और {1,1,2} => 211। स्पष्ट रूप से 221 211 से अधिक है। मैं इसे ऐनक में स्पष्ट करूँगा।

— पसबी

Answer 2

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

(a,b,g=a=>a.map(n=>e[n]=e[n]+1||1,e=[1])&&[[...e].every(n=>n==1),...e.filter(i=x=>x).sort(h=(a,b)=>b-a),...a.sort(h)],c=g(a),d=g(b))=>d.map((n,i)=>n-c[i]).find(i)

स्पष्टीकरण: दो सरणियों को पैरामीटर के रूप में लेता है। gप्रत्येक एरे को काउंट की सूची में परिवर्तित करता है। फिर यह देखने के लिए सूची की जाँच की जाती है कि यह एक सेट से मेल खाती है या नहीं 1..n। काउंट्स को सॉर्ट किया जाता है और सॉर्ट किए गए मानों को मिलाया जाता है। फिर दो परिणामों की तुलना की जाती है। यदि दूसरा सरणी जीतता है और नकारात्मक सरणी पूर्णांक जीतता है तो रिटर्न वैल्यू एक पूर्णांक है, यदि पहला सरणी जीतता है, अन्यथा नकली जावास्क्रिप्ट मान undefinedवापस आ जाता है।

Comments

आपका कार्यक्रम {1,1,6} <{2,2,5} कहता है, जो गलत है।

— पसिबी

@oVooVo क्षमा करें, मुझे नियमों को गलत समझना चाहिए था (मुझे लगा कि आपने सबसे लंबे समय तक चलने वाले सांख्यिक मूल्य के आधार पर संबंधों को तोड़ दिया है)।

— नील

Answer 3

PHP 333 बाइट्स

मुझे लगता है कि वहाँ कम dices तो 1 के साथ सड़क शुरुआत के रूप में उच्चतम मूल्य के लिए चेहरे हैं

मैं थोड़ा और बनाता हूं। इनपुट एक सरणी है जिसमें दो से अधिक मान हैं। आउटपुट क्रमबद्ध सरणी है।

<? $m=$_GET[m];foreach($m as$k=>$v){rsort($v);$m[$k]=$v;}function t($a,$b){if($a==$r=range($x=count($a),1))return 1;elseif($b==$r)return-1;$c=array_pad(array_values(array_count_values($a)),$x,0);$d=array_pad(array_values(array_count_values($b)),$x,0);rsort($c);rsort($d);if($e=$c<=>$d)return$e;return$a<=>$b;}usort($m,t);print_r($m);

टूट - फूट

$m=$_GET["m"]; # Array as Input
foreach($m as$k=>$v){
    rsort($v); # reverse sort of an item
    $m[$k]=$v; # replace the sort item
}
function t($a,$b){ #sorting algorithm
    if($a==$r=range($x=count($a),1))return 1; # $a is highest value
    elseif($b==$r)return-1; # $b is highest value
    $c=array_pad(array_values(array_count_values($a)),$x,0); 
# prepare check multiple values for fist value
    $d=array_pad(array_values(array_count_values($b)),$x,0); 
# prepare check multiple values for second value
    rsort($c);
    rsort($d);
    if($e=$c<=>$d)return$e; # compare first and second multiples
    return$a<=>$b; # compare dices
}
usort($m,"t"); # start sort
print_r($m); #print sorted array from low to high

Answer 4

जूलिया (489 बाइट्स)

function a(x,y)l=length;g=collect;s=sort;m=maximum;r=repmat;function b(z)w=sum(r(z,1,m(z)).==r(g(1:m(z))',l(z),1),1);u=zeros(m(w));map(i->if i>0 u[i]+=1;end,w);return u end;function c(x,y)if l(x)>l(y)return-1 elseif l(x)<l(y)return 1 else for i=l(x):-1:1 if x[i]>y[i] return-1 elseif x[i]<y[i] return 1 end end;return 0;end end;x=s(x);y=s(y);if x==y return 0;elseif x==g(1:l(x));return-1 elseif y==g(1:l(y))return 1 else d=c(b(x),b(y));if d==0 return c(x,y);else return d;end end end

पठनीय:

  1 function a(ds1, ds2)
  2     function countNOfAKind(ds)
  3         # return array. n-th value is number of occurences of n-of-a-kind.
  4         # e.g. findNOfAKind([1, 1, 1, 2, 2, 3, 3]) == [0, 2, 1]
  5         ps = sum(repmat(ds, 1, maximum(ds)) .== repmat(collect(1:maximum(ds))', length(ds), 1), 1);
  6         ls = zeros(maximum(ps));
  7         map(i -> if i>0 ls[i] += 1 end, ps);
  8         return ls
  9     end
 10 
 11     function cmpLex(ds1, ds2)
 12         # compare ds1, ds2 reverse-lexicographically, i.e. compare last distinct value.
 13         if length(ds1) > length(ds2)
 14             return -1
 15         elseif length(ds1) < length(ds2)
 16             return 1
 17         else
 18             for i = length(ds1):-1:1
 19                 if ds1[i] > ds2[i]
 20                     return -1
 21                 elseif ds1[i] < ds2[i]
 22                     return 1
 23                 end
 24             end
 25             return 0;
 26         end
 27     end
 28     
 29     ds1=sort(ds1);
 30     ds2=sort(ds2);
 31     if ds1 == ds2
 32         return 0;
 33     elseif ds1 == collect(1:length(ds1))
 34         return -1
 35     elseif ds2 == collect(1:length(ds2))
 36         return 1
 37     else
 38         d = cmpLex(countNOfAKind(ds1), countNOfAKind(ds2))
 39         if d == 0
 40             return cmpLex(ds1, ds2);
 41         else
 42             return d;
 43         end
 44     end
 45 end

Comments

आप लंबाई की तुलना क्यों कर रहे हैं? निर्देश कहते हैं "दो कंटेनरों की लंबाई समान है"। क्या मैं कुछ भूल रहा हूँ?

— डेविड मार्क

मैंने लाइन 31 में लंबाई की तुलना को हटा दिया। यह आवश्यक नहीं था, लेकिन चोट भी नहीं लगी। लाइन 15 में तुलना आवश्यक है, क्योंकि कच्चे इनपुट की तुलना करने के लिए cmpLex का उपयोग न केवल 40 की लाइन में किया जाता है, बल्कि countNOfAKind के परिणाम की तुलना करने के लिए लाइन 38 में भी किया जाता है। हालांकि यह फ़ंक्शन समान आकार के इनपुट के लिए अलग-अलग आकार के आउटपुट का उत्पादन कर सकता है: countNOfAKind ([3,2]) = [2] (क्योंकि दो एकाकी संख्या (3 और 2) हैं), countNOfAKind ([2,2] =) [०, १] (क्योंकि कोई अकेला नंबर और एक जोड़ा नहीं है।

— पसिबी