Pickomino 게임 에는 테이블 중앙에 여러 개의 타일이 있으며 각 타일에는 양의 정수가 다릅니다. 매 턴마다 플레이어는 특정 방식으로 주사위를 굴려서 음수가 아닌 정수인 점수를 얻습니다.

이제 플레이어는 여전히 점수보다 낮거나 같은 가장 높은 숫자의 타일을 가져 와서 타일을 중간에서 제거하고 스택에 추가합니다. 중간에있는 모든 숫자가 플레이어의 점수보다 높기 때문에 이것이 불가능한 경우 플레이어는 스택에서 최상위 타일을 잃습니다 (최근에 추가됨). 플레이어에 남은 타일이 없으면 아무 일도 일어나지 않습니다.

도전

자신을 상대로 게임을하는 플레이어를 시뮬레이션합니다. 중간에 타일 목록과 플레이어가 얻은 점수 목록을 얻습니다. 모든 턴이 평가 된 후 플레이어의 타일 목록을 반환합니다.

도전 규칙

• 타일이있는 목록이 정렬되어 있고 정수가 두 번 포함되어 있지 않다고 가정 할 수 있습니다.
• 원하는 순서대로 입력 목록을 모두 가져올 수 있습니다
• 출력은 스택에서 타일 순서를 유지해야하지만 목록이 위에서 아래로 정렬되는지 아래에서 위로 정렬되는지를 결정할 수 있습니다.

일반 규칙

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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]

플레이어는 파열하여 0 점을 얻습니다. 따라서 숫자 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: []

모래 상자

하스켈 , 119 111 104 103 바이트

Ørjan Johansen 덕분에 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
([]%)

온라인으로 사용해보십시오!

타일이 내림차순으로 정렬되어 있다고 가정합니다.

별로 멋진 일이 아닙니다. 첫 번째 논점은 플레이어 말뚝이고, 두 번째 논점은 중간 점입니다.

apt, 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

펄 6 , 89 바이트

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

온라인으로 사용해보십시오!

나는 이것으로부터 골프를 치기 위해 더 많은 바이트가 있다고 생각합니다 ...

C 번호 (카메라 C 번호 인터랙티브 컴파일러) , 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); 2 바이트를 절약 .

온라인으로 사용해보십시오!

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

루비 , 77 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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

온라인으로 사용해보십시오!

자바 스크립트 (ES6),  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[]

숯 , 35 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆη«

점수를 반복합니다.

≔⌈Φ講κιι

사용 가능한 가장 높은 타일을 찾으십시오.

¿ι«

존재한다면 ...

≔Φθ⁻κιθ

... 중간에서 타일을 제거하십시오 ...

⊞υι

... 그리고 그것을 스택에 추가하십시오.

»¿υ

그렇지 않으면 스택이 비어 있지 않으면 ...

⊞θ⊟υ

스택에서 최신 타일을 제거하고 중간으로 되돌립니다.

»Ｉυ

결과물을 가장 오래된 것부터 가장 오래된 것으로 인쇄하십시오.

파이썬 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

온라인으로 사용해보십시오!

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)

Pyth, 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

펄 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입력에서 으르렁 거리고 줄 바꿈 문자를 출력에 추가
• $_=$".<> : 다음 줄 (타일)을 읽고 공백을 기본 변수 앞에 추가합니다. $_
• for$i(@F){... }루프 $i오버 @F현재 라인의 필드 (점수)
• (.. ?.. :.. ).=$&3 진 l- 값에 이전 일치 추가
• ($m=max grep$_<=$i,/\d+/g)&&s/ $m\b//?$s타일에서 최대 값을 찾아서 제거한 경우 ( $_) l- 값은 점수 ( $s)
• $s=~s/ \d+$//?$_ 그렇지 않으면 마지막 숫자를 점수에서 제거 할 수 있으면 타일입니다
• :$G 마지막으로 발생하지 않기 때문에 쓰레기입니다
• $_=$s;s/ // 점수를 기본 var로 설정하고 선행 공백을 제거하려면