Size bir çanta Skittles verildi. Herkes farklı lezzetleri en çok takdir etmek için lezzetler arasında dönmeniz gerektiğini bilir.

Temelleri:

1. Bir seferde sadece 1 skittle yiyebilirsiniz
2. Skittle'larınızı yeme sırası periyodik olmalıdır .
3. Her dönem belirli bir lezzeti bir kereden fazla içeremez.
4. Çantanızda sadece çok fazla kızak var. Belirli bir skittle lezzetini çantanızda göründüğünden daha fazla yiyemezsiniz.
5. Mümkün olduğu kadar çok yavru kedi yemek istersiniz (her zaman mümkün olmayabilir)

Örnekler:

3 Kırmızı, 2 Mavi ve 3 Yeşil skittle başladığınızı varsayalım:

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)

Giriş çıkış

• Renk sayıları için boş olmayan bir pozitif tamsayılar listesi geçirilirsiniz. (Yukarıdaki örnek [3,2,3]).
• Geçerli ve optimum sipariş içeren bir liste döndürmeniz gerekir.
• Renkleri kullanmak yerine, giriş listesindeki indeksleri kullanacaksınız. (Yukarıdaki son örnek çıktı olacaktır [2,0,1,2,0,1,2,0]).
• Çıktınız 0 dizinli veya 1 dizinli olabilir. Örneklerim 0 dizinli olacak

Test Durumları

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

Bu bir kod golfü , bu yüzden çözümlerinizi en sevdiğiniz dilde mümkün olduğunca kısa yapın!

JavaScript (ES6), 177 175 bayt

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)

Biçimlendirilmiş ve yorumlanmış

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()

Kullanılan formül

Aşağıda formülün F(i, j) = minimum(value[j], value[i] + 1), burada i = 0ve girdinin nasıl çalıştığını gösteren bir tablo bulunmaktadır [ 5, 2, 2 ].

Bu formül aşağıdaki gibi yorumlanabilir: her bir Skittle tipi için, mevcut en az tip artı birinden fazla seçemeyiz.

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

Test senaryoları

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

Jöle , 22 bayt

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

1 tabanlı indeksleme.

Çevrimiçi deneyin!

Nasıl?

Verilen skittles torbasıyla elde edilebilecek değere göre bir kez daha azalan değere göre sıralanmış dizinlerin her önekini tekrarlar, daha sonra ulaşılabilir hale getirmek için gerektiğinde her birinden son skittle veya skitt'leri kaldırır ve en fazla skittle olanı döndürür .

Ek bir periyodik tekrardan kaldırılması gereken sayı, yalnızca bu önek boyunca minimum sayıya sahip sayıdır.

ỤṚ;\Ṛẋ"‘Ṣ$ḣ"Ç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 Bayt

Fikir

Örneğin, 3 Kırmızı, 2 Mavi ve 3 Yeşil skittle, bunları renk ve miktara göre sıralanmış bir ızgarada düzenleyebilir:

r g
r g b
r g b

Eğer biri tam olarak i skittles yemeye çalışırsa, toplamda en az i * c skittles yiyebilir, burada c r-sütundaki skittle sayısıdır, örneğin i = 2 için en az 6 skittle yiyebilir.

r g
# # #
# # #

Yapılması gereken tek şey, eksik bir periyotta kaç ek skittle yenilebileceğidir.

golfed

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

Yorumlananlar

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

Çevrimiçi deneyin!

Düzenle: 2 bayt kaydetmek için (i+1)ile değiştirildi -~i.

Düzenleme: Dead Possum sayesinde -5 bayt