Quando faccio sollevamento pesi, voglio fare un peso specifico attaccando più piastre a una barra.

Ho i seguenti piatti:

• 6 piatti da 1 kg ciascuno
• 6 piatti da 2,5 kg ciascuno
• 6 piatti da 5 kg ciascuno
• 6 piatti da 10 kg ciascuno

La barra stessa pesa 10 kg.

È consentito solo fissare le piastre in coppia: sono fissate a ciascuna estremità della barra e la disposizione alle due estremità deve essere completamente simmetrica (ad esempio, attaccando due piastre da 5 kg a un'estremità e una piastra da 10 kg a l'altra estremità è vietata per motivi di sicurezza).

Crea un programma o una funzione che mi dice quante piastre di ogni tipo devo usare per ottenere un dato peso totale. L'input è un numero intero maggiore di 11; l'output è un elenco / array / stringa di 4 numeri. Se è impossibile combinare piastre esistenti per ottenere il peso target, produrre un array zero / vuoto, una stringa non valida, generare un'eccezione o qualcosa del genere.

Se ci sono diverse soluzioni, il codice deve produrre solo una (non far scegliere all'utente - è troppo impegnato con altre cose).

Casi test:

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

Se il codice emette i numeri nell'ordine opposto (dalla piastra pesante a quella leggera), specificarlo esplicitamente per evitare confusione.

Gelatina , 22 byte

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

Provalo online! o verifica tutti i casi di test .

Come funziona

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 byte

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

Per gli input che non hanno soluzione, questo produce un output vuoto (senza errori).

Provalo online!

Spiegazione

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 byte

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

Funzione anonima. Accetta un numero come input e restituisce un elenco o errori e restituisce {}[[1]]se non esiste una soluzione.

Gelatina, 25 byte

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

Provalo qui.

Python 3, 112 byte

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]

Una funzione anonima che accetta, tramite argomento, la massa target e restituisce il numero di ciascuna piastra come elenco. Se non esiste alcuna soluzione, viene generato un errore. Questa è pura forza bruta.

Come funziona

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

Provalo su Ideone

Brachylog , 50 byte

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

Restituisce falsequando non è possibile.

Pyth, 34 31 25 byte

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

Suite di test.

Errori nell'impossibilità.

Questa è essenzialmente una forza bruta.

Questo è abbastanza veloce, poiché ci sono solo 256 possibili arrangiamenti.

Scala, 202 byte

Deciso che Scala non ha molto amore qui, quindi presento una soluzione (probabilmente non ottimale) in Scala.

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

Il programma esce in ordine inverso e con junk extra rispetto alle soluzioni in post. Quando non viene trovata una soluzione, stampa 0.

Nota: Potrei non rimuovere i ritorni a capo o spazi perché Scala è muto, quindi penso che per ridurre le dimensioni, il metodo deve essere rifatto a meno che non mi sono perso qualcosa di ovvio.

APL, 40 byte

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

In ⎕IO ← 0. In inglese:

1. 10+2×,∘.+⌿1 2.5 5 10∘.×⍳4: costruisce la matrice di tutti i pesi possibili, calcolando la somma esterna 4D dei pesi per tipo di peso;
2. ⍵⍳⍨: cerca l'indice del dato. Se non trovato l'indice è 1 + il conteggio dell'array al passaggio 1;
3. (4⍴4)⊤: rappresenta l'indice in base 4, ovvero calcola la coordinata del peso dato nello spazio 4D;
4. 2×: porta il risultato nello spazio problematico, dove le coordinate dovrebbero essere interpretate come metà del numero delle piastre.

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

Bonus : poiché APL è un linguaggio array, è possibile testare più pesi contemporaneamente. In questo caso il risultato viene trasposto:

      {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 byte

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

Restituisce 00-2in caso di errore. Soluzione alternativa che restituisce undefinederrori, anche 109 byte:

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)