Podczas podnoszenia ciężarów chcę uzyskać określony ciężar, mocując kilka płyt do pręta.

Mam następujące tablice:

• 6 płytek po 1 kg każda
• 6 płytek po 2,5 kg każda
• 6 płytek po 5 kg każda
• 6 płytek po 10 kg każda

Sam pręt waży 10 kg.

Dozwolone jest jedynie mocowanie płyt parami - są one przymocowane na każdym końcu pręta, a układ na dwóch końcach musi być całkowicie symetryczny (np. Przymocowanie dwóch 5-kilogramowych płyt na jednym końcu i jednej 10-kilogramowej płyty na drugi koniec jest zabroniony ze względów bezpieczeństwa).

Stwórz program lub funkcję, która mówi mi, ile płyt każdego rodzaju muszę użyć, aby uzyskać daną całkowitą wagę. Dane wejściowe to liczba całkowita większa niż 11; wynikiem jest lista / tablica / ciąg 4 liczb. Jeśli nie jest możliwe połączenie istniejących płyt w celu uzyskania docelowej masy, wypisz zerową / pustą tablicę, niepoprawny ciąg, wyrzuć wyjątek lub coś takiego.

Jeśli istnieje kilka rozwiązań, kod musi wypisać tylko jedno (nie zmuszaj użytkownika do wyboru - jest zbyt zajęty innymi rzeczami).

Przypadki testowe:

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

Jeśli Twój kod wyświetla liczby w odwrotnej kolejności (od grubej płyty do lekkiej), podaj ją wyraźnie, aby uniknąć pomyłek.

Galaretka , 22 bajty

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

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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 bajtów

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

W przypadku danych wejściowych, które nie mają rozwiązania, tworzy to puste dane wyjściowe (bez błędów).

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Funkcja anonimowa. Pobiera na wejściu liczbę i albo wyświetla listę, albo błędy i zwraca, {}[[1]]jeśli nie ma rozwiązania.

Galaretka, 25 bajtów

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

Wypróbuj tutaj.

Python 3, 112 bajtów

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]

Anonimowa funkcja, która pobiera za pomocą argumentu masę docelową i zwraca liczbę każdej płytki jako listę. Jeśli nie ma rozwiązania, generowany jest błąd. To czysta brutalna siła.

Jak to działa

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

Wypróbuj na Ideone

Brachylog , 50 bajtów

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

Zwraca, falsegdy nie jest to możliwe.

Pyth, 34 31 25 bajtów

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 [25; y;) ^ U4 4

Zestaw testowy.

Błędy w niemożliwości.

Jest to w zasadzie brutalna siła.

Jest to dość szybkie, ponieważ istnieje tylko 256 możliwych ustawień.

Scala, 202 bajty

Zdecydowano, że Scala nie ma tu dużo miłości, dlatego przedstawiam (prawdopodobnie nie optymalne) rozwiązanie w Scali.

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 generuje w odwrotnej kolejności i z dodatkowymi śmieciami w porównaniu do rozwiązań na poczcie. Gdy nie znaleziono rozwiązania, drukuje 0.

Uwaga: Mogłem nie usunąć dowolny z nowej linii lub spacjami bo Scala jest głupi, więc myślę, że w celu zmniejszenia rozmiaru, metoda musi być przerobione chyba brakowało mi coś oczywistego.

APL, 40 bajtów

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

W ⎕IO ← 0. Po angielsku:

1. 10+2×,∘.+⌿1 2.5 5 10∘.×⍳4: zbuduj tablicę wszystkich możliwych wag, obliczając zewnętrzną sumę wag 4D według rodzaju wagi;
2. ⍵⍳⍨: przeszukaj indeks podanego. Jeśli nie zostanie znaleziony, indeks wynosi 1 + suma tablicy w kroku 1;
3. (4⍴4)⊤: reprezentują indeks w podstawie 4, to znaczy obliczają współrzędne danego ciężaru w przestrzeni 4D;
4. 2×: przenieś wynik do przestrzeni problemowej, gdzie współrzędne powinny być interpretowane jako połowa liczby płyt.

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

Bonus : ponieważ APL jest językiem tablicowym, można przetestować kilka wag jednocześnie. W takim przypadku wynik jest transponowany:

      {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 bajtów

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

Zwraca 00-2w przypadku błędu. Alternatywne rozwiązanie, które zwraca undefinedbłąd, również 109 bajtów:

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)