Bạn đã được tặng một túi Skittles. Mọi người đều biết rằng để đánh giá cao các hương vị khác nhau nhất, bạn cần phải xoay vòng giữa các hương vị.

Khái niệm cơ bản:

1. Bạn chỉ có thể ăn 1 miếng nhỏ mỗi lần
2. Thứ tự mà bạn ăn skittles của bạn phải được định kỳ.
3. Mỗi thời kỳ không thể chứa một hương vị đặc biệt hơn một lần.
4. Túi của bạn chỉ có rất nhiều skittles. Bạn không thể ăn nhiều hương vị đặc biệt của skittle hơn xuất hiện trong túi của bạn.
5. Bạn muốn ăn càng nhiều skittles càng tốt (có thể không phải lúc nào cũng có thể)

Ví dụ:

Hãy nói rằng bạn bắt đầu với 3 skittles Red, 2 Blue và 3 Green:

R B G R B G R G       Invalid:  The last R must be followed by a B, not a G
R B G R B G R         Valid, but sub-optimal
R R R                 Valid, but sub-optimal
R G B R G B R G       Valid and optimal
G R B G R B G R       Also valid and optimal (there are multiple good solutions)

Đầu ra đầu vào

• Bạn được thông qua một danh sách các số nguyên dương không trống cho số màu. (Ví dụ trên sẽ là [3,2,3]).
• Bạn cần trả về một danh sách chứa thứ tự hợp lệ và tối ưu.
• Thay vì sử dụng màu sắc, bạn sẽ sử dụng các chỉ số từ danh sách đầu vào. (Đầu ra ví dụ cuối cùng ở trên sẽ là [2,0,1,2,0,1,2,0]).
• Đầu ra của bạn có thể là 0 chỉ mục hoặc 1 chỉ mục. Ví dụ của tôi sẽ được lập chỉ mục 0

Các trường hợp thử nghiệm

1                          0
4                          0 0 0 0
4 1                        0 0 0 0
3 1                        0 1 0                   or  0 0 0
5 2 2                      0 1 2 0 1 2 0
2 3 5                      2 1 0 2 1 0 2 1         or  1 2 0 1 2 0 1 2
2 4 5                      2 1 2 1 2 1 2 1 2
3 4 5                      2 1 0 2 1 0 2 1 0 2 1   or  1 2 0 1 2 0 1 2 0 1 2
1 1 1 1 1 6                5 0 1 2 3 4 5           (lots of other solutions)
1 1 1 1 1 8                5 5 5 5 5 5 5 5
2 4 6 8                    3 2 1 3 2 1 3 2 1 3 2 1 3 2

Đây là một môn đánh gôn , vì vậy hãy làm cho các giải pháp của bạn càng ngắn càng tốt bằng ngôn ngữ yêu thích của bạn!

JavaScript (ES6), 177 175 byte

a=>a.map((n,i)=>[n,l=i]).sort((a,b)=>a[0]-b[0]).reduce((P,x,i,a)=>(v=a.reduce((p,c,j)=>j<i?p:p+Math.min(c[0],x[0]+1),0))>m?[...Array(m=v)].map((_,k)=>a[l-k%(l+1-i)][1]):P,m=0)

Định dạng và nhận xét

a => a                              // given an array a:
.map((n, i) => [n, l = i])          // map it to [value, index] arrays / set l = length - 1
.sort((a, b) => a[0] - b[0])        // sort it by values in ascending order
.reduce((P, x, i, a) =>             // for each reference entry x at position i:
  (v = a.reduce((p, c, j) =>        //   for each entry c at position j:
    j < i ?                         //     if c is before x:
      p                             //       keep the previous sum (which is 0)
    :                               //     else:
      p + Math.min(c[0], x[0] + 1), //       add minimum(value[j], value[i] + 1)
    0                               //   initialize the sum at 0
  )) > m ?                          //   if the new sum v is better than our current best m:
    [...Array(m = v)].map((_, k) => //     update m to v and update the result to an array
      a[l - k % (l + 1 - i)][1]     //     of length m filled with indices picked repeatedly
    )                               //     between i and l
  :                                 //   else:
    P,                              //     keep the previous result
  m = 0                             // start with best score m = 0
)                                   // the final result is returned by the outer reduce()

Sử dụng công thức

Dưới đây là bảng cho thấy công thức hoạt F(i, j) = minimum(value[j], value[i] + 1)động như thế nào , ở đây với i = 0và đầu vào [ 5, 2, 2 ].

Công thức này có thể được hiểu như sau: đối với mỗi loại Skittle, chúng ta có thể chọn không quá số lượng loại có sẵn ít nhất cộng với một loại.

 j | Sorted    | value[j] | F(0, j) | Selected        | Output
   | input     |          |         | Skittles        | (starting from bottom left)
---+-----------+----------+---------+-----------------+-----------------------------
 0 | 2 2       |     2    |    2    | [2] [2]         | \
 1 | 1 1       |     2    |    2    | [1] [1]         |  > 0 1 2 0 1 2 0
 2 | 0 0 0 0 0 |     5    |    3    | [0] [0] [0] 0 0 | /

Các trường hợp thử nghiệm

let f =

a=>a.map((n,i)=>[n,l=i]).sort((a,b)=>a[0]-b[0]).reduce((P,x,i,a)=>(v=a.reduce((p,c,j)=>j<i?p:p+Math.min(c[0],x[0]+1),0))>m?[...Array(m=v)].map((_,k)=>a[l-k%(l+1-i)][1]):P,m=0)

console.log(JSON.stringify(f([ 1                ]))); // 0
console.log(JSON.stringify(f([ 4                ]))); // 0 0 0 0
console.log(JSON.stringify(f([ 4, 1             ]))); // 0 0 0 0
console.log(JSON.stringify(f([ 3, 1             ]))); // 0 1 0
console.log(JSON.stringify(f([ 5, 2, 2          ]))); // 0 2 1 0 2 1 0
console.log(JSON.stringify(f([ 2, 3, 5          ]))); // 2 1 0 2 1 0 2 1
console.log(JSON.stringify(f([ 2, 4, 5          ]))); // 2 1 2 1 2 1 2 1 2
console.log(JSON.stringify(f([ 3, 4, 5          ]))); // 2 1 0 2 1 0 2 1 0 2 1
console.log(JSON.stringify(f([ 1, 1, 1, 1, 1, 6 ]))); // 5 4 3 2 1 0 5
console.log(JSON.stringify(f([ 1, 1, 1, 1, 1, 8 ]))); // 5 5 5 5 5 5 5 5
console.log(JSON.stringify(f([ 2, 4, 6, 8       ]))); // 3 2 1 3 2 1 3 2 1 3 2 1 3 2

Thạch , 22 byte

ċЀṢN
ỤṚ;\Ṛẋ"‘Ṣ$ḣ"ÇLÞṪ

Lập chỉ mục 1 dựa trên.

Hãy thử trực tuyến!

Làm sao?

Lặp lại từng tiền tố của các chỉ mục được sắp xếp theo giá trị giảm dần một lần so với mức có thể đạt được với túi skittles đã cho, sau đó loại bỏ skittle hoặc skittles cuối cùng từ mỗi trong số này khi cần thiết để có thể đạt được và trả về một cái có nhiều skittles nhất .

Số cần được xóa khỏi một lần lặp lại định kỳ bổ sung chỉ là số có số đếm tối thiểu trên tiền tố đó.

ỤṚ;\Ṛẋ"‘Ṣ$ḣ"ÇLÞṪ - Main link                   e.g. [6,4,2,8]
Ụ                - grade up: sort indices by value  [3,2,1,4]
 Ṛ               - reverse                          [4,1,2,3]
   \             - cumulative reduce with
  ;              -     concatenation (get prefixes) [[4],[4,1],[4,1,2],[4,1,2,3]]
    Ṛ            - reverse                          [[4,1,2,3],[4,1,2],[4,1],[4]]
         $       - last two links as a monad
       ‘         -     increment                    [7,5,3,9]
        Ṣ        -     sort                         [3,5,7,9]
      "          - zip with
     ẋ           -     list repetition              [[4,1,2,3,4,1,2,3,4,1,2,3],[4,1,2,4,1,2,4,1,2,4,1,2,4,1,2],[4,1,4,1,4,1,4,1,4,1,4,1,4,1],[4,4,4,4,4,4,4,4,4]]
            Ç    - call last link (1) as a monad    [-1,-1,-1,-1]
          "      - zip with
           ḣ     - head list to (remove excess)     [[4,1,2,3,4,1,2,3,4,1,2],[4,1,2,4,1,2,4,1,2,4,1,2,4,1],[4,1,4,1,4,1,4,1,4,1,4,1,4],[4,4,4,4,4,4,4,4]]
              Þ  - sort by
             L   -     length                       [[4,4,4,4,4,4,4,4],[4,1,2,3,4,1,2,3,4,1,2],[4,1,4,1,4,1,4,1,4,1,4,1,4],[4,1,2,4,1,2,4,1,2,4,1,2,4,1]]
               Ṫ - tail                             [4,1,2,4,1,2,4,1,2,4,1,2,4,1]

ċЀṢN - Link 1: head amounts (negative of skittle excess of each N+1 repeated period)
   Ṣ  - sort                                        [2,4,6,8]
 Ѐ   - for each mapped over right argument
ċ     - count                                       [1,1,1,1]
    N - negate                                      [-1,-1,-1,-1]

Python3, 174 172 167 byte

Ý tưởng

Ví dụ: 3 Red, 2 Blue và 3 Green skittles người ta có thể sắp xếp chúng thành một lưới, được sắp xếp theo màu sắc và số lượng:

r g
r g b
r g b

Nếu một người cố gắng ăn chính xác i skittles, thì ít nhất người ta có thể ăn i * c skittles, trong đó c là số lượng skittles trong cột r-th, ví dụ: i = 2 người ít nhất có thể ăn 6 skittles.

r g
# # #
# # #

Điều duy nhất còn lại phải làm là đếm xem có bao nhiêu skittles có thể được ăn trong một khoảng thời gian không đầy đủ.

Chơi gôn

def f(a):
 r=range;f=m=0;s=r(len(a));b=sorted(zip(a,s))[::-1]
 for i in s:
  c=b[i][0];n=-~i*c+sum(c<e[0]for e in b)
  if n>m:f,m=i+1,n
 return[b[j%f][1]for j in r(m)]

Đã bình luận

def f(a):
    r = range;
    f = m = 0;                          - Some variables we need later on
    s = r(len(a));                      - Integers from 0 to (num_skittles - 1)
    b = sorted(zip(a,s))[::-1]          - Zip with s to remember initial order,
                                          then sort and reverse
    for i in s:
        c = b[i][0]
        n = (i+1)*c                     - If we attempt to eat i different skittles,
                                          we can surely eat (i+1)*c skittles.
          + sum(1 for e in b if e[0]>c) - The additional sum corresponds to an incomplete period.
        if n>m:                         - If a better way of eating skittles is found:
            f,m = i+1,n                 - update variables
    return [b[j%f][1] for j in r(m)]

Hãy thử trực tuyến!

Chỉnh sửa: Thay thế (i+1)bằng -~iđể lưu 2 byte.

Chỉnh sửa: -5 byte nhờ Dead Possum