Im Spiel Pickomino liegen mehrere Kacheln in der Mitte des Tisches, auf denen sich jeweils eine andere positive Ganzzahl befindet. In jeder Runde würfeln die Spieler auf eine bestimmte Weise und erhalten eine Punktzahl, die eine nicht negative ganze Zahl ist.

Jetzt nimmt der Spieler das Plättchen mit der höchsten Zahl, die noch niedriger oder gleich seiner Punktzahl ist, entfernt das Plättchen aus der Mitte und fügt es seinem Stapel hinzu. Wenn dies nicht möglich ist, weil alle Zahlen in der Mitte höher sind als die Punktzahl des Spielers, verliert der Spieler das oberste Plättchen von seinem Stapel (das zuletzt hinzugefügt wurde), das in die Mitte zurückgelegt wird. Wenn der Spieler keine Steine ​​mehr hat, passiert nichts.

Die Herausforderung

Simulieren Sie einen Spieler, der das Spiel gegen sich selbst spielt. Sie erhalten eine Liste der Kacheln in der Mitte und eine Liste der Punkte, die der Spieler erhalten hat. Gibt eine Liste der Kacheln des Spielers zurück, nachdem alle Züge ausgewertet wurden.

Herausforderungsregeln

• Sie können davon ausgehen, dass die Liste mit den Kacheln geordnet ist und keine Ganzzahl zweimal enthält.
• Sie können beide Eingabelisten in beliebiger Reihenfolge eingeben
• Die Ausgabe muss die Reihenfolge der Kacheln auf dem Stapel beibehalten. Sie können jedoch entscheiden, ob die Liste von oben nach unten oder von unten nach oben sortiert wird.

Allgemeine Regeln

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln . Sie können also STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code (dh TIO ) hinzu.
• Es wird empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Beispiel

(aus dem 6. Testfall entnommen)

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]

Die erste Punktzahl ist 22, also nimm das höchste Plättchen in der Mitte <= 22, also 22 selbst.

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] 

Die nächste Punktzahl ist 22, also nimm das höchste Plättchen in der Mitte <= 22. Da 22 bereits vergeben ist, muss der Spieler 21 nehmen.

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]

Die nächste Punktzahl ist 22, aber alle Zahlen <= 22 sind bereits vergeben. Daher verliert der Spieler das oberste Plättchen auf dem Stapel (21), das in die Mitte zurückgelegt wird.

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]

Die nächsten Punkte sind 23, 21 und 24, also nimmt der Spieler diese Steine ​​aus der Mitte.

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

Der Spieler bricht ab und erzielt null Punkte. Daher wird die Kachel mit der Nummer 24 (oberste auf dem Stapel) in die Mitte zurückgebracht.

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

Die letzte Punktzahl ist 22, aber alle Plättchen <= 22 sind bereits vergeben, sodass der Spieler das oberste Plättchen auf dem Stapel verliert (21).

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

Testfälle

(mit der obersten Kachel zuletzt in der Ausgabeliste)

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: []

Sandkasten

Haskell , 119 111 104 103 Bytes

1 Byte dank Ørjan Johansen gespeichert

(#)=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
([]%)

Probieren Sie es online aus!

Angenommen, die Kacheln sind in absteigender Reihenfolge sortiert.

Hier ist nicht viel los. Das erste Argument ist der Stapel der Spieler, das zweite ihre Punkte und das dritte der Stapel in der Mitte.

Japt, 24 Bytes

Uff! Das hat nicht so gut geklappt, wie ich es mir vorgestellt hatte!

Nimmt die Eingabe in umgekehrter Reihenfolge vor.

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

Probieren Sie es aus oder führen Sie alle Testfälle auf TIO aus

®=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

Perl 6 , 89 Bytes

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

Probieren Sie es online aus!

Ich denke, es gibt noch ein paar Bytes, die man abspielen kann ...

C # (Visual C # Interactive Compiler) , 159 158 154 Byte

Genannt als 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;}

Wenn nur System.Voidtatsächlich ein Rückgabetyp und nicht nur ein Platzhalter für die Reflexion ist. Ich wäre in der Lage zu ersetzen , if(a<1)m.Add(s.Count<1?0:s.Pop());else s.Push(a);mit var t=a>1?m.Add(s.Count<1?0:s.Pop()):s.Push(a);, spart zwei Bytes.

Probieren Sie es online aus!

//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;}

Ruby , 77 Bytes

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

Probieren Sie es online aus!

JavaScript (Node.js) , 80 Byte

Dieselbe Logik wie in der ES6-Version, jedoch werden die Kacheln als BigInt-Bitmaske und die Ergebnisse als Array von BigInts verwendet.

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

Probieren Sie es online aus!

JavaScript (ES6),  100 98 94  87 Byte

Nimmt Eingabe als (tiles)(scores). Die Kacheln können in beliebiger Reihenfolge übergeben werden.

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

Probieren Sie es online aus!

Kommentiert

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[]

Holzkohle , 35 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｆη«

Schleife über die Partituren.

≔⌈Φ講κιι

Suchen Sie nach der höchsten verfügbaren Kachel.

¿ι«

Wenn es existiert, dann ...

≔Φθ⁻κιθ

... entferne die Fliese aus der Mitte ...

⊞υι

... und zum Stapel hinzufügen.

»¿υ

Andernfalls, wenn der Stapel nicht leer ist ...

⊞θ⊟υ

Entfernen Sie die neueste Kachel vom Stapel und legen Sie sie wieder in die Mitte.

»Ｉυ

Drucken Sie den resultierenden Stapel vom ältesten zum neuesten.

Python 2 , 120 Bytes

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

Probieren Sie es online aus!

05AB1E , 27 22 Bytes

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Pyth, 32 Bytes

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

Versuchen Sie es online hier oder überprüfen alle Testfälle auf einmal hier .

Hier muss es irgendwo Verbesserungspotenzial geben - Vorschläge sind sehr willkommen!

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

Perl 5 -apl -MList:Util=max, 97 Bytes

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

TIO

Liest Partituren und Kacheln in der nächsten Zeile und druckt die Ausgabe.

Wie

• -apl: -pum Zeilen zu durchlaufen und zu drucken, -aautomatisch -lzu teilen, von der Eingabe zu chompen und der Ausgabe ein Zeilenumbruchzeichen hinzuzufügen
• $_=$".<> : um die nächste Zeile (Kacheln) zu lesen und ein Leerzeichen in die Standardvariable einzufügen $_
• for$i(@F){... }Schleife $iüber @FFelder der aktuellen Zeile (Scores)
• (.. ?.. :.. ).=$&vorherige Übereinstimmung an ternären l-Wert anhängen
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$sfalls der maximale Wert gefunden und von den Kacheln entfernt wurde ( $_) l-Wert ist Punktzahl ( $s)
• $s=~s/ \d+$//?$_ Andernfalls, wenn die letzte Zahl aus den Punktzahlen entfernt werden könnte, sind es Kacheln
• :$G Endlich ist es Müll, weil er nicht auftreten kann
• $_=$s;s/ // um die Punktzahl auf die Standardvariable zu setzen und das führende Leerzeichen zu entfernen