Ao fazer levantamento de peso, quero fazer um peso específico, anexando várias placas a uma barra.

Eu tenho as seguintes placas:

• 6 placas de 1 kg cada
• 6 placas de 2,5 kg cada
• 6 placas de 5 kg cada
• 6 placas de 10 kg cada

A barra em si pesa 10 kg.

Só é permitido fixar as placas em pares - elas são fixadas em cada extremidade da barra e o arranjo nas duas extremidades deve ser completamente simétrico (por exemplo, fixando duas placas de 5 kg em uma extremidade e uma placa de 10 kg em a outra extremidade é proibida por razões de segurança).

Faça um programa ou uma função que me diga quantas placas de cada tipo eu tenho que usar para obter um determinado peso total. A entrada é um número inteiro maior que 11; a saída é uma lista / matriz / sequência de 4 números. Se for impossível combinar placas existentes para obter o peso desejado, produza uma matriz zero / vazia, uma sequência inválida, lance uma exceção ou algo parecido.

Se houver várias soluções, o código deverá gerar apenas uma (não faça o usuário escolher - ele está ocupado demais com outras coisas).

Casos de teste:

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 o seu código exibir os números na ordem oposta (da placa pesada para a leve), especifique isso explicitamente para evitar confusão.

Gelatina , 22 bytes

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

Experimente online! ou verifique todos os casos de teste .

Como funciona

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 bytes

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

Para entradas que não têm solução, isso produz uma saída vazia (sem erro).

Experimente online!

Explicação

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 bytes

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

Função anônima. Pega um número como entrada e gera uma lista ou erros e retorna {}[[1]]se não houver solução.

Gelatina, 25 bytes

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

Experimente aqui.

Python 3, 112 bytes

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]

Uma função anônima que recebe entrada, via argumento, da massa alvo e retorna o número de cada placa como uma lista. Se não houver solução, será gerado um erro. Isso é pura força bruta.

Como funciona

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

Experimente no Ideone

Braquilog , 50 bytes

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

Retorna falsequando não é possível.

Pitão, 34 31 25 bytes

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

Suíte de teste.

Erros na impossibilidade.

Isso é essencialmente uma força bruta.

Isso é bastante rápido, uma vez que existem apenas 256 arranjos possíveis.

Scala, 202 bytes

Decidiu que Scala não recebe muito amor aqui, por isso apresento uma solução (provavelmente não ótima) em 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);}

O programa é gerado na ordem inversa e com lixo extra comparado às soluções postadas. Quando uma solução não é encontrada, imprime 0.

Nota: eu poderia não remover qualquer uma das novas linhas ou espaços porque Scala é mudo, então eu acho que para reduzir o tamanho, o método deve ser refeito a menos que eu perdi alguma coisa óbvia.

APL, 40 bytes

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

Em ⎕IO ← 0. Em inglês:

1. 10+2×,∘.+⌿1 2.5 5 10∘.×⍳4: crie a matriz de todos os pesos possíveis, calculando a soma externa 4D dos pesos por tipo de peso;
2. ⍵⍳⍨: pesquisa o índice do dado. Se não encontrado, o índice é 1 + a contagem da matriz na etapa 1;
3. (4⍴4)⊤: representa o índice na base 4, ou seja, calcula a coordenada da massa especificada no espaço 4D;
4. 2×: leve o resultado ao espaço do problema, onde as coordenadas devem ser interpretadas como metade do número de placas.

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

Bônus : como o APL é uma linguagem de matriz, vários pesos podem ser testados ao mesmo tempo. Nesse caso, o resultado é transposto:

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

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

Retorna 00-2por erro. Solução alternativa que retorna undefinedcom erro, também 109 bytes:

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)