पिकोमिनो खेल रहा है

Question

खेल पिकोमिनो में , टेबल के बीच में कई टाइलें पड़ी हैं, जिनमें से प्रत्येक पर एक अलग सकारात्मक पूर्णांक है। प्रत्येक मोड़ पर, खिलाड़ी एक निश्चित तरीके से डाइस रोल करते हैं और एक अंक प्राप्त करते हैं, जो कि एक नॉननेगेटिव पूर्णांक है।

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

चुनौती

खुद के खिलाफ खेल खेलने वाले खिलाड़ी का अनुकरण करें। आपको बीच में टाइल्स की एक सूची और खिलाड़ियों को मिलने वाले स्कोर की एक सूची मिलती है। सभी मुड़ने के बाद खिलाड़ी की टाइलों की सूची लौटाएं।

चुनौती के नियम

• आप यह मान सकते हैं कि टाइल्स के साथ सूची का आदेश दिया गया है और इसमें दो बार कोई पूर्णांक नहीं है।
• आप किसी भी क्रम में इनपुट की दोनों सूचियाँ ले सकते हैं
• आउटपुट को टाइल के क्रम को स्टैक पर रखना पड़ता है, लेकिन आप यह तय कर सकते हैं कि सूची को ऊपर से नीचे या नीचे से ऊपर तक क्रमबद्ध किया गया है या नहीं।

सामान्य नियम

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है।
• डिफ़ॉल्ट लूपोल्स वर्जित हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• आपके उत्तर के लिए स्पष्टीकरण जोड़ना अनुशंसित है।

उदाहरण

(6 वें टेस्टकेस से लिया गया)

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 22, 22, 23, 21, 24, 0, 22]

पहला स्कोर 22 है, इसलिए बीच में सबसे ऊंची टाइल <= 22 लें, जो स्वयं 22 है।

Middle: [21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22]
Remaining scores: [22, 22, 23, 21, 24, 0, 22] 

अगला स्कोर 22 है, इसलिए बीच में उच्चतम टाइल लें <= 22. क्योंकि 22 पहले से ही लिया गया है, खिलाड़ी को 21 लेना है।

Middle: [23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 21]
Remaining scores: [22, 23, 21, 24, 0, 22]

अगला स्कोर 22 है, लेकिन सभी नंबर <= 22 पहले ही ले लिए गए हैं। इसलिए, खिलाड़ी स्टैक (21) पर सबसे ऊपरी टाइल खो देता है, जिसे बीच में लौटा दिया जाता है।

Middle: [21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22]
Remaining scores: [23, 21, 24, 0, 22]

अगला स्कोर 23, 21 और 24 है, इसलिए खिलाड़ी इन टाइलों को बीच से लेता है।

Middle: [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 23, 21, 24]
Remaining scores: [0, 22]

खिलाड़ी बस्ट और स्कोर शून्य। इसलिए, संख्या 24 (ढेर पर सबसे ऊपर) के साथ टाइल को बीच में लौटा दिया जाता है।

Middle: [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Stack: [22, 23, 21]
Remaining scores: [22]

अंतिम स्कोर 22 है, लेकिन सभी टाइलें <= 22 पहले से ही ली गई हैं, इसलिए खिलाड़ी स्टैक पर सबसे ऊपरी टाइल खो देता है (21)।

Middle: [21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Final Stack and Output: [22, 23]

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

(आउटपुट सूची में सबसे अंतिम टाइल के साथ)

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [26, 30, 21]
Output: [26, 30, 21]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [35, 35, 36, 36]
Output: [35, 34, 36, 33]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 17, 23, 19, 23]
Output: [23]

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: []
Output: []

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 17, 23, 19, 23, 0]
Output: []

Tiles: [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36]
Scores: [22, 22, 22, 23, 21, 24, 0, 22]
Output: [22, 23]

Tiles: [1, 5, 9, 13, 17, 21, 26]
Scores: [6, 10, 23, 23, 23, 1, 0, 15]
Output: [5, 9, 21, 17, 13, 1]

Tiles: []
Scores: [4, 6, 1, 6]
Output: []

---

सैंडबॉक्स

Comments

क्या हम मान सकते हैं कि बीच में शून्य के मान के साथ कोई टाइल नहीं हैं?

— को इग्नोरेंस का अवतार

@EmbodimentofIgnorance यह "सकारात्मक पूर्णांक" कहता है, इसलिए हाँ।

— अर्जन जोहान्सन

चूंकि टाइलें अद्वितीय हैं, इसलिए उन्हें बिटकॉम्ब के रूप में लेना स्वीकार्य होगा?

— अरनुलद

@TRITICIMAGVS हां, यदि मध्य ढेर खाली है, तो खिलाड़ी बीच से एक टाइल नहीं ले सकता है, इसलिए वे एक टाइल खो देते हैं (यदि उनके पास एक है)

— काला उल्लू काई

@ अर्नुलद स्वीकार्य है

— ब्लैक आउल काई

Answer 1

हास्केल , 119 111 104 103 बाइट्स

1 बाइट ने अर्जन जोहान्सन को धन्यवाद दिया

(#)=span.(<)
(a%(b:c))d|(g,e:h)<-b#d=(e:a)%c$g++h|g:h<-a,(i,j)<-g#d=h%c$i++g:j|1>0=a%c$d
(a%b)c=a
([]%)

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

मान लेता है कि टाइलें अवरोही क्रम में क्रमबद्ध हैं।

यहां ज्यादा फैंस नहीं जा रहे हैं। पहला तर्क खिलाड़ियों का ढेर है, दूसरा उनका स्कोर और तीसरा बीच में ढेर है।

Comments

यह सही नहीं हो सकता क्योंकि sortआरोही है। TIO परीक्षण मामला उस शाखा से कभी नहीं टकराता है। मैं इस तरह से पुनरावृत्त होने पर हर बार सभी मामलों का परीक्षण करने की सलाह देता हूं।

— अर्जन जोहान्सन

@ ØrjanJohansen धन्यवाद! अब तय हो गया। कम से कम मुझे अब और आयात नहीं करना है!

— तदर्थ गार्फ हंटर

एक बाइट के साथ सहेजें (#)=span.(<)।

— अर्जन जोहान्सन

@ ØrrrJohansen बदलाव किया। मजेदार बात यह है कि मैंने कोशिश की है कि पहले और सोचा कि यह एक बाइट जोड़ा।

— तदर्थ गार्फ हंटर

Answer 2

जाप, 24 बाइट्स

ऊफ! यह काम नहीं किया और साथ ही मैंने सोचा था कि यह होगा!

रिवर्स ऑर्डर में इनपुट लेता है।

®=Va§Z)Ì?NpVjZ:VpNo)nÃN¤

इसे आज़माएं या TIO पर सभी परीक्षण मामलों को चलाएं

®=Va§Z)Ì?NpVjZ:VpNo)nÃN¤     :Implicit input of N=[U=scores, V=tiles]
®                            :Map each Z in U
 =                           :  Reassign to Z
  Va                         :    0-based index of last element in V (-1 if not found)
    §Z                       :      Less than or equal to Z
      )                      :  End reassignment
       Ì                     :  Sign of difference with -1 (1 if found, 0 if not)
        ?                    :  If truthy (not zero)
         Np                  :    Push to N
           VjZ               :      Remove and return the element at index Z in V
              :              :  Else
               Vp            :    Push to V
                 No          :      Pop the last element of N
                   )         :    End Push
                    n        :    Sort V
                     Ã       :End map
                      N¤     :Slice the first 2 elements (the original inputs) off N

Answer 3

पर्ल 6 , 89 बाइट्स

{my@x;@^a;@^b>>.&{@x=|@x,|(keys(@a∖@x).grep($_>=*).sort(-*)[0]//(try ~@x.pop&&()))};@x}

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

मुझे लगता है कि इस बंद करने के लिए कुछ और बाइट्स हैं ...

Answer 4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 159 158 154 बाइट्स

के रूप में पुकारा गया f(tiles)(scores)

n=>m=>{var s=new Stack<int>();m.Add(0);n.ForEach(k=>{var a=m.Except(s).Where(x=>x<=k).Max();if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);});return s;}

यदि केवल System.Voidवास्तव में एक वापसी प्रकार है और प्रतिबिंब के लिए केवल एक प्लेसहोल्डर नहीं है। मैं दो बाइट की बचत के if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);साथ बदल सकता हूं var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);।

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

//Function taking in a list and returning
//another function that takes in another list and returns a stack
n=>m=>{
//Initialize the stack
var s=new Stack<int>();
//Add a zero to the tiles, to ensure no exceptions appear due to accessing
//non-existent elements in an empty collection later
//when we try to filter it later and getting the biggest element
m.Add(0);
//Iterate through our scores
n.ForEach(k=>{
//Create a variable called a, which we will use later
var a=
//Get all the elements in the middle that haven't appeared in our stack
m.Except(s).
//And throw away all elements that are bigger than our current score
Where(x=>x<=k).
//And get the biggest element there, and that is now the value of a
//Without the m.Add(0), we would get an exception here
Max();
//Self-explanatory, if a is less than 1 aka if a equals 0
//Checks if all elements in the middle are bigger than our score 
//Except for our self added 0, of course
if(a<1)
//Add 0 to the middle if the stack is empty
//Remember, zeros don't affect the list
m.Add(s.Count<1?0:
//Else pop the stack and add that to the middle
s.Pop());
//If a isn't 0, add a to the stack
else s.Push(a);});
//Afterwards, return the stack
return s;}

Answer 5

रूबी , 77 बाइट्स

->t,s,r=[]{s.map{|i|(x=(t-[p]).reject{|j|j>i}.max)?(t-=[x];r<<x):t<<r.pop};r}

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

Answer 6

जावास्क्रिप्ट (Node.js) , 80 बाइट्स

ES6 संस्करण के रूप में एक ही तर्क, लेकिन एक BigInt बिटमास्क के रूप में टाइल लेता है और BigInts की एक सरणी के रूप में स्कोर करता है।

m=>s=>s.map(g=x=>!x||m>>x&1n?m^=1n<<(x?r.push(x)&&x:r.pop()||~x):g(--x),r=[])&&r

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

---

जावास्क्रिप्ट (ईएस 6),  100 98 94  87 बाइट्स

के रूप में इनपुट लेता है (tiles)(scores)। टाइल्स को किसी भी क्रम में पारित किया जा सकता है।

t=>s=>s.map(g=x=>m[x]?m[x?r.push(x)&&x:r.pop()]^=1:g(x-1),t.map(x=>m[x]=1,m=[r=[]]))&&r

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

टिप्पणी की गई

t => s =>                 // t[] = tiles; s[] = scores
  s.map(g = x =>          // for each score x in s[]:
    m[x] ?                //   if m[x] is set:
      m[                  //     update the 'middle':
        x ?               //       if x is not equal to 0:
          r.push(x) && x  //         push x in the stack r[] and yield x
        :                 //       else:
          r.pop()         //         pop the last value from the stack
                          //         (may be undefined if the stack is empty)
      ] ^= 1              //     toggle the corresponding flag in m[]
    :                     //   else:
      g(x - 1),           //     try again with x - 1
    t.map(x =>            //   initialization of the 'middle': for each value x in t[]:
      m[x] = 1,           //     set m[x]
      m = [r = []]        //     the stack r[] is stored as the first entry of m[],
                          //     which ensures that g will always stop when x = 0
    )                     //   end of initialization
  ) && r                  // end of main loop; return r[]

Answer 7

चारकोल , 35 बाइट्स

Ｆη«≔⌈Φ講κιι¿ι«≔Φθ⁻κιθ⊞υι»¿υ⊞θ⊟υ»Ｉυ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆη«

स्कोर पर लूप।

≔⌈Φ講κιι

उच्चतम उपलब्ध टाइल के लिए देखें।

¿ι«

यदि यह मौजूद है तो ...

≔Φθ⁻κιθ

... टाइल को बीच से हटा दें ...

⊞υι

... और इसे स्टैक में जोड़ें।

»¿υ

अन्यथा, यदि स्टैक खाली नहीं है ...

⊞θ⊟υ

स्टैक से नवीनतम टाइल निकालें और इसे बीच में लौटा दें।

»Ｉυ

परिणामी स्टैक को सबसे पुराने से नवीनतम तक प्रिंट करें।

Answer 8

पायथन 2 , 120 बाइट्स

m,s=input()
t=[]
for n in s:
 i=[v for v in m if v<=n]
 if i:v=max(i);t+=[v];m.remove(v)
 else:m+=t and[t.pop()]
print t

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

Answer 9

05AB1E , 27 22 बाइट्स

vÐy>‹ÏDgĀià©K®së\sª])¨

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

v            # Loop `y` over the (implicit) input-list of scores:
 Ð           #  Triplicate the tiles list (takes it as implicit input in the first iteration)
  y>‹        #  Check for each if `y` <= the value in the tiles list
     Ï       #  Only leave the values at the truthy indices
 D           #  Duplicate the remaining tiles
  ¯Êi        #  If this list is not empty:
     à       #   Pop the list, and push its maximum
      ©      #   Store it in the register, without popping
       K     #   Remove it from the tiles list
        ®    #   Push the maximum again
         s   #   Swap the maximum and tiles-list on the stack
    ë        #  Else:
     \       #   Remove the duplicated empty tiles-list from the stack
      sª     #   Add the last tile to the tiles-list
]            # Close the if-else and loop
 )           # Wrap everything on the stack into a list
  ¨          # Remove the last item (the tiles-list)
             # (and output the result implicitly)

Answer 10

पायथ, 32 बाइट्स

VE ?JeS+0f!>TNQ=-QeaYJaQ.)|Y]0;Y

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

यहां कहीं न कहीं सुधार की गुंजाइश होनी चाहिए - किसी भी सुझाव की बहुत सराहना की जाएगी!

VE ?JeS+0f!>TNQ=-QeaYJaQ.)|Y]0;Y   Implicit: Q=input 1 (middle), E=input 2 (scores), Y=[]
VE                            ;    For each score, as N, in the second input:
         f    Q                      Filter Q, keeping elements T where:
          !>TN                         T is not greater than N 
                                       (less than or equal is the only standard inequality without a token in Pyth, grrr)
       +0                            Prepend 0 to the filtered list
     eS                              Take the largest of the above (_e_nd of _S_orted list)
    J                                Store the above in J
   ?                                 If the above is truthy:
                   aYJ                 Append J to Y
                  e                    Take last element of Y (i.e. J)
               =-Q                     Remove that element from Q and assign the result back to Q
                                     Else:
                          |Y]0         Yield Y, or [0] if Y is empty
                        .)             Pop the last element from the above (mutates Y)
                      aQ               Append the popped value to Q
                               Y   Print Y

Answer 11

पर्ल 5 -apl -MList:Util=max, 97 बाइट्स

$_=$".<>;for$i(@F){(($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$s:$s=~s/ \d+$//?$_:$G).=$&}$_=$s;s/ //

TIO

अगली पंक्ति में स्कोर और टाइल पढ़ता है और आउटपुट प्रिंट करता है।

किस तरह

• -apl: -pलाइनों पर प्रिंट करने के लिए -a, -lऔर इनपुट से chomp करने के लिए ऑटोसप्लिट, आउटपुट में न्यूलाइन कैरेक्टर जोड़ें
• $_=$".<> : नेक्स्ट लाइन (टाइल्स) पढ़ने के लिए और डिफॉल्ट var में स्पेस प्रीपेन्ड करें $_
• for$i(@F){... वर्तमान लाइन के क्षेत्रों पर }लूप (स्कोर)$i@F
• (.. ?.. :.. ).=$&पिछले मैच को टर्नरी एल-वैल्यू में जोड़ें
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sयदि अधिकतम मूल्य पाया और टाइल्स से हटा दिया गया है ( $_) एल-मान स्कोर है ( $s)
• $s=~s/ \d+$//?$_ अन्यथा अगर अंतिम संख्या को अंकों से हटाया जा सकता है तो यह टाइल है
• :$G अंत में यह कचरा है क्योंकि हो ही नहीं सकता
• $_=$s;s/ // डिफ़ॉल्ट संस्करण में स्कोर सेट करने के लिए, और प्रमुख स्थान को हटा दें