Halter yaparken, bir bara birkaç plaka takarak belirli bir ağırlık yapmak istiyorum.

Aşağıdaki plakalarım var:

• Her biri 1 kg olan 6 tabak
• Her biri 2,5 kg olan 6 tabak
• Her biri 5 kg'lık 6 tabak
• Her biri 10 kg'lık 6 tabak

Çubuğun kendisi 10 kg ağırlığındadır.

Plakaların sadece çiftler halinde takılmasına izin verilir - çubuğun her iki ucuna takılırlar ve iki uçtaki düzenleme tamamen simetrik olmalıdır (örn. Bir ucunda iki adet 5 kg'lık plaka ve bir adet 10 kg'lık plaka diğer ucu güvenlik nedeniyle yasaktır).

Belirli bir toplam ağırlığı elde etmek için her türden kaç tabak kullanmam gerektiğini söyleyen bir program veya işlev yapın. Giriş 11'den büyük bir tamsayıdır; çıktı 4 sayıdan oluşan bir liste / dizi / dizgidir. Hedef ağırlığı elde etmek için mevcut plakaları birleştirmek mümkün değilse, sıfır / boş bir dizi, geçersiz bir dize, bir istisna veya benzeri bir çıktı alın.

Birkaç çözüm varsa, kod yalnızca bir çıktı vermelidir (kullanıcıyı seçmeyin - başka şeylerle çok meşgul).

Test senaryoları:

12 -> [2 0 0 0] - 2 plates of 1 kg plus the bar of 10 kg
13 -> [0 0 0 0] - a special-case output that means "impossible"
20 -> [0 0 2 0] - 2 plates of 5 kg + bar
20 -> [0 4 0 0] - a different acceptable solution for the above
21 -> [6 2 0 0] - 6 plates of 1 kg + 2 plates of 2.5 kg + bar
28 -> [0 0 0 0] - impossible
45 -> [0 2 6 0] - a solution for a random number in range
112 -> [2 4 6 6] - a solution for a random number in range
121 -> [6 6 6 6] - maximal weight for which a solution is possible

Kodunuz sayıları ters sırada (ağır plakadan hafif olana) çıkarırsa, karışıklığı önlemek için lütfen bunu açıkça belirtin.

Jöle , 22 bayt

4ṗạµ×2,5,10,20S€+⁵iƓịḤ

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

4ṗạµ×2,5,10,20S€+⁵iƓịḤ  Main link. No arguments

4                       Set the left argument and initial return value to 4.
 ṗ                      Take the Cartesian power of [1, 2, 3, 4] and 4, i.e.,
                        generate all 4-tuples of integers between 1 and 4.
  ạ                     Take the absolute difference of all integers in the
                        4-tuples and the integer 4. This maps [1, 2, 3, 4] to
                        [3, 2, 1, 0] and places [0, 0, 0, 0] at index 0.
   µ                    Begin a new, monadic chain. Argument: A (list of 4-tuples)
     2,5,10,20          Yield [2, 5, 10, 20].
    ×                   Perform vectorized multiplication with each 4-tuple in A.
              S€        Sum each resulting 4-tuple.
                +⁵      Add 10 to each sum.
                   Ɠ    Read an integer from STDIN.
                  i     Find its first index in the array of sums (0 if not found).
                     Ḥ  Unhalve; yield the list A, with all integers doubled.
                    ị   Retrieve the 4-tuple at the proper index.

MATL , 29 28 bayt

4t:qEZ^!"[l2.5AX]@Y*10+G=?@.

Çözümü olmayan girişler için bu boş bir çıktı üretir (hatasız).

Çevrimiçi deneyin!

açıklama

4           % Push 4
t:q         % Duplicate 4 and transform into range [0 1 2 3]
E           % Multiply by 2: transform into [0 2 4 6]
Z^          % Cartesian power. Each row is a "combination" of the four numbers
!           % Transpose
"           % For each column
  [l2.5AX]  %   Push [1 2.5 5 10]
  @         %   Push current column
  Y*        %   Matrix multiply. Gives sum of products
  10+       %   Add 10
  G=        %   Compare with input: are they equal?
  ?         %   If so
    @       %     Push current column, to be displayed
    .       %     Break loop
            %   Implicit end
            % Implicit end
            % Implicit display

Mathematica, 70 bayt

Select[FrobeniusSolve[{2,5,10,20},2#-20],AllTrue[EvenQ@#&&#<7&]][[1]]&

Anonim işlev. Girdi olarak bir sayı alır ve bir liste veya hata çıktısı verir ve {}[[1]]çözüm yoksa döndürür .

Jöle, 25 bayt

×2,5,10,20S+⁵⁼³
4ṗ4’ÇÐfḢḤ

Burada deneyin.

Python 3, 112 bayt

lambda n:[i for i in[[i//4**j%4*2for j in range(4)]for i in range(256)]if i[0]+2.5*i[1]+5*i[2]+10*i[3]+10==n][0]

Hedef kitlenin argüman yoluyla girişini alan ve her plakanın sayısını liste olarak döndüren anonim bir işlev. Herhangi bir çözüm yoksa, bir hata atılır. Bu saf kaba kuvvettir.

Nasıl çalışır

lambda n                                   Anonymous function with input target mass n
...for i in range(256)                     Loop for all possible arrangement indices i
[i//4**j%4*2for j in range(4)]             Create a base-4 representation of the index i,
                                           and multiply each digit by 2 to map from
                                           (0,1,2,3) to (0,2,4,6)
[...]                                      Package all possible arrangements in a list
...for i in...                             Loop for all possible arrangements i
i...if i[0]+2.5*i[1]+5*i[2]+10*i[3]+10==n  Return i if it gives the target mass
[...]                                      Package all solutions in a list
:...[0]                                    Return the first list element. This removes any
                                           multiple solutions, and throws an error if there
                                           being no solutions results in an empty list

Ideone üzerinde deneyin

Brachylog , 50 bayt

,L##l4,L:{.~e[0:3]}a:[2:5:10:20]*+:10+?,L:{:2*.}a.

falseMümkün olmadığında geri döner.

Pyth, 34 31 25 bayt

h + fqQ +; s * VT [1 2,5 5;) yMM ^ U4 4] * 4] 0 
yMh + fqQ +; s * VT [2 5; y;) ^ U4 4] * 4] 0
yMhfqQ +; s * VT [2; 5; y;) ^ U4 4

Test odası.

İmkansızlıkta hatalar.

Bu aslında bir kaba kuvvettir.

Bu oldukça hızlıdır, çünkü sadece 256 olası düzenleme vardır.

Scala, 202 bayt

Scala'nın burada çok fazla sevmediğine karar verdim, bu yüzden Scala'da (muhtemelen optimal değil) bir çözüm sunuyorum.

def w(i:Int){var w=Map(20->0,10->0,5->0,2->0);var x=i-10;while(x>0){
var d=false;for(a<-w.keys)if(a<=x & w(a)<6 & !d){x=x-a;w=w.updated(a,w(a)+2);d=true;}
if(!d){println(0);return;}}
println(w.values);}

Program, sonrası çözümlere kıyasla ters sırada ve ekstra önemsiz çıktılar verir. Bir çözüm bulunamadığında 0 yazdırır.

Not: Ben olabilir değil Scala dilsiz çünkü boyutunu azaltmak için düşünmek bu yüzden belirgin bir şey cevapsız sürece, yöntem yeniden yapılması gerekir, satırlarla veya boşluk kaldırın.

APL, 40 bayt

{2×(4⍴4)⊤⍵⍳⍨10+2×,⊃∘.+/↓1 2.5 5 10∘.×⍳4}

←IO ← 0. İngilizcede:

1. 10+2×,∘.+⌿1 2.5 5 10∘.×⍳4: ağırlık tipi başına ağırlıkların 4D dış toplamını hesaplayarak tüm olası ağırlıkların dizisini oluşturun;
2. ⍵⍳⍨: verilen dizini arar. Bulunamazsa dizin 1 + olur ve adım 1'deki dizinin çetelesi;
3. (4⍴4)⊤: baz 4'teki indeksi temsil eder, yani 4D uzayda verilen ağırlığın koordinatını hesaplar;
4. 2×: sonucu, koordinatların plaka sayısının yarısı olarak yorumlanması gereken sorunlu alana getirin.

Örnek: {2 × (4⍴4) ⊤⍵⍳⍨10 + 2 ×, ⊃∘. + / ↓ 1 2.5 5 10∘. × ⍳4} 112 2 4 6 6

Bonus : APL bir dizi dili olduğundan, aynı anda birkaç ağırlık test edilebilir. Bu durumda sonuç aktarılır:

      {2×(4⍴4)⊤⍵⍳⍨10+2×,⊃∘.+/↓1 2.5 5 10∘.×⍳4}12 13 20 21 28 45 112 121
2 0 0 6 0 0 2 6
0 0 0 2 0 2 4 6
0 0 2 0 0 2 6 6
0 0 0 0 0 2 6 6

JavaScript (ES6), 109 bayt

n=>`000${[...Array(256)].findIndex((_,i)=>i+(i&48)*9+(i&12)*79+(i&3)*639+320==n*32).toString(4)*2}`.slice(-4)

İadeler 00-2 hata. undefinedHataya dönen alternatif çözüm , ayrıca 109 bayt:

n=>[...Array(256)].map((_,i)=>`000${i.toString(4)*2}`.slice(-4)).find(s=>+s[0]+s[1]*2.5+s[2]*5+s[3]*10+10==n)