Escreva um programa que calcule se um valor monetário inserido, como um inteiro, pode ser representado por uma combinação única de moedas e / ou notas, o que significa que a mesma moeda / nota não pode ser usada mais de uma vez.

Seu programa deve ter um valor como entrada e pode obter uma lista de valores de moedas / notas via entrada ou pelo equivalente no idioma de uma matriz. A lista de moedas / notas deve poder ser alterada; portanto, verifique se é claro onde isso está definido se você estiver usando uma constante.

Seu programa deve gerar qualquer valor de verdade / falsidade, respectivamente.

Observe que não é necessário exibir a lista de moedas / notas que compõem o valor .

EXEMPLO

Usando a libra esterlina, (£ 1,00 = 100 e 420,69 = 42069)

coins = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000]

A seguinte saída será verdadeira:

6 (1, 5)
15 (10, 5)
88 (1, 2, 5, 10, 20, 50)
512 (500, 10, 2)
7003 (5000, 2000, 2, 1)

A seguir, o resultado será falso:

4
209
8889
4242424242
[ANYTHING ABOVE 8888]

DADOS ALTERNATIVOS DO ENSAIO (dólar americano)

coins = [1, 5, 10, 25, 50, 100, 200, 500, 1000, 2000, 5000, 10000]

Boa sorte!

Braquilog 2 (TIO Nexus), 2 bytes

⊇+

Experimente online!

Pega a lista de moedas via entrada padrão ou anexa-a ao início do programa como uma matriz literal (ou funcionará, então você decide como você se sente "mais legítimo"; a primeira é permitida por padrão Regras do PPCG, este último especificamente permitido pela questão); e pega o valor a ser produzido como argumento da linha de comando.

Explicação

Este programa utiliza detalhes de implementação do funcionamento do wrapper do TIO Nexus para Brachylog; especificamente, ele permite que você forneça um argumento de linha de comando para dar entrada via Saída. (Isso não estava previsto no design original do Brachylog; no entanto, as linguagens são definidas por sua implementação no PPCG e, se surgir uma implementação que faz o que eu preciso, posso tirar vantagem disso.) programa se parece com isso:

⊇+
⊇   Some subset of {standard input}
 +  sums to {the first command-line argument}

Como um programa completo, ele retorna um valor booleano; true.se todas as asserções do programa puderem ser satisfeitas simultaneamente ou false.se não puderem.

(Um lembrete ou para pessoas que ainda não sabem: o Brachylog 2 usa sua própria codificação de caracteres, com ⊇um único byte de comprimento.)

05AB1E , 4 bytes

æOså

Explicação:

æ      Calculate the powerset of the first input
 O     Sum each element
  s    Put the second input at the top of the stack
   å   Check whether the input is in the powerset sum.

Experimente online!

Mathematica, 25 bytes

!FreeQ[Tr/@Subsets@#,#2]&

Função pura pegando uma matriz de valores de moeda como o primeiro argumento e o número inteiro alvo como o segundo argumento e retornando Trueou False.

Gelatina, 6 bytes

ŒPS€e@

Experimente online!

-2 bytes graças a Leaky Nun
-13 bytes graças a Leaky Nun (longa história)

Retina , 52 31 bytes

\d+
$*
^((1+) |1+ )+(?<-2>\2)+$

Experimente online! Recebe a entrada como uma lista separada por espaços de moedas e notas, seguida pelo valor desejado. Edit: Salvo 18 bytes graças a @Kobi que depurou meu código. Explicação: As duas primeiras linhas simplesmente convertem de decimal para unário. A terceira linha captura a lista de moedas e notas. A alternância permite que o mecanismo volte atrás e opte por não capturar moedas / notas específicas. O grupo de balanceamento combina o valor com todos os sufixos da lista de captura (desnecessário, mas mais golfista).

Braquilog , 7 bytes

tT&h⊇+T

Experimente online!

Como funciona

tT&h⊇+T
tT      the second input is T
  &     and
   h    the first input
    ⊇   is a superset of a set
     +  that sums up to
      T T

Incluindo a combinação, 9 bytes

tT&h⊇.+T∧

Experimente online!

Java (OpenJDK 8) , 125 bytes

boolean f(int[]c,int n){int l=c.length;if(l<1)return n==0;int[]a=java.util.Arrays.copyOf(c,l-1);return f(a,n-c[l-1])|f(a,n);}

Experimente online!

Prolog (SWI) , 46 bytes

a([],0).
a([H|T],X):-Y is X-H,(a(T,Y);a(T,X)).

Experimente online!

Garfo da minha resposta Python .

JavaScript (ES6), 81 69 67 64 bytes

Leva a lista de moedas ce a quantidade alvo ana sintaxe de curry (c)(a). Retorna 0ou true.

c=>g=(a,m=1)=>c.map((c,i)=>x-=c*(m>>i&1),x=a)&&!x||x-a&&g(a,m+1)

Casos de teste

let f =

c=>g=(a,m=1)=>c.map((c,i)=>x-=c*(m>>i&1),x=a)&&!x||x-a&&g(a,m+1)

const pound = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000];

console.log(f(pound)(6))
console.log(f(pound)(15))
console.log(f(pound)(88))
console.log(f(pound)(512))
console.log(f(pound)(7003))

console.log(f(pound)(4))
console.log(f(pound)(209))
console.log(f(pound)(8889))
console.log(f(pound)(4242424242))

Haskell , 28 bytes

A função do operador (#)pega um número inteiro e uma lista de números inteiros (ou, geralmente, qualquer Traversablecontêiner de números) e retorna a Bool.

Use como 6#[1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000].

c#l=elem c$sum<$>mapM(:[0])l

Experimente online!

Como funciona

• cé o valor desejado e la lista de valores da moeda.
• mapM(:[0])lmapas (:[0])mais l, emparelhando cada valor com 0, e depois constrói o produto cartesiano, dando listas onde cada elemento é ou seu valor correspondente em l, ou 0.
• sum<$>soma cada combinação e elem c$verifica se cestá na lista resultante.

R, 88 bytes

-5 bytes graças a @Jarko Dubbeldam

retorna uma função anônima. Ele gera todas as combinações possíveis de moedas (usando expand.gridpares de T,F) e verifica se os valores estão presentes. ké moedas, já que cé uma palavra reservada em R. Pode verificar vários valores de uma só vez.

function(k,v)v%in%apply(expand.grid(Map(function(x)!0:1,k)),1,function(x)sum(k[x]))

Experimente online!

Japonês , 7 bytes

à mx èN

Experimente online! Saídas 0para falsy, um número inteiro positivo para a verdade.

Explicação

à mx èN
          // Implicit: U = input array, V = input integer, N = array of all inputs
à         // Take all combinations of U.
  mx      // Map each combination to its sum.
     è    // Count the number of items in the result which also exist in
      N   //   the array of inputs.
          // This returns 0 if no combination sums to V, a positive integer otherwise.
          // Implicit: output result of last expression

Python 3 , 52 bytes

5 bytes graças a ovs.

f=lambda c,n:c and f(c[1:],n-c[0])|f(c[1:],n)or n==0

Experimente online!

Ruby , 39 bytes

Retorna nilcomo o valor falso e o menor valor da moeda na lista que compõe o número como verdade (todos os números são verdadeiros em Ruby).

f=->c,n{n!=0?c.find{|i|f[c-[i],n-i]}:1}

Porém, lembre-se de que esse algoritmo é incrivelmente lento, com O(C!)complexidade de tempo, onde Cestá o tamanho da lista de moedas. Eventualmente, ele termina, mas a maioria dos casos de teste atinge o tempo limite na maioria dos intérpretes online f(UK_POUND, 5).

Aqui está uma versão de 41 bytes que termina muito mais rapidamente adicionando uma condição de finalização extra e é muito mais difícil realmente atingir o tempo limite

f=->c,n{n>0?c.find{|i|f[c-[i],n-i]}:n==0}

Experimente online!

Utilitários Bash + GNU, 56 39

printf %$2s|egrep "^ {${1//,/\}? {}}?$"

A lista de denominações de entrada (sem classificação) é fornecida como uma lista separada por vírgulas. A lista de entrada e o valor são fornecidos como parâmetros de linha de comando.

Saída fornecida na forma do código de retorno do shell. Inspecione echo $?depois de executar o script. 0significa verdade, 1significa falsidade.

Experimente online .

• printf %$2sgera uma sequência de valueespaços
• "^ {${1//,/\}? {}}?$"é uma expansão de shell que expande a lista de denominação para um regex como ^ {1}? {2}? {5}? {10}? ... $. Acontece que o egrepmecanismo regex é inteligente o suficiente para corresponder corretamente a isso, independentemente da ordem em que as denominações estão
• egrep verifica se a sequência de espaços corresponde à regex

C, 66 bytes

m;v;f(n){for(m=1e5;m/=10;)for(v=5;n-=n<v*m?0:v*m,v/=2;);return!n;}

Veja como funciona aqui .

C, 53 bytes

g(c,w,n)int*c;{for(;n-=n<c[--w]?0:c[w],w;);return!n;}

Essa variante pega a matriz de moedas, que anula o objetivo desse problema, porque se resume a uma simples subtração.

O primeiro argumento é a matriz de moedas, o segundo é a contagem de moedas e o terceiro é o valor.

C, 48 bytes

g(c,n)int*c;{for(;n-=n<*c?0:*c,*++c;);return!n;}

Uma alternativa para a variante anterior. Ele pressupõe que a matriz de moedas possa ser revertida e terminada em zero.

Pitão , 6 bytes

/sMtyE

Suíte de teste.

CJam , 18 17 bytes

q~_,2\m*\f.*::+#)

Experimente online!

Explicação

q~                  e# Read and eval input.
  _,                e# Duplicate the money list and take its length.
    2\m*            e# Take the (length)th Cartesian power of [0 1].
        \f.*        e# Element-wise multiplication of each set of 0's and 1's with the money
                    e#   list. This is essentially the powerset, but with 0s instead of 
                    e#   missing elements.
            ::+     e# Sum each set.
               #    e# Find the index of the desired amount in the list. (-1 if not found)
                )   e# Increment. -1 => 0 (falsy), anything else => nonzero (truthy)

C (gcc) , 91 bytes

i,j,c[]={1,2,5};f(n){for(i=1000;i;i/=10)for(j=2;j>=0;j--)n-=n<i*c[j]?0:i*c[j];return n==0;}

Experimente online!

PHP, 70 bytes

imprime 1 para verdadeiro e nada para falso

<?foreach($_GET[1]as$v)$i-=$v*$r[]=($i=&$_GET[0])/$v^0;echo max($r)<2;

Experimente online!

Oitava, 39 bytes

 @(L,n)any(cellfun(@sum,powerset(L))==n)

Uma função anônima que pega uma matriz de valores de moeda como o primeiro argumento e o número inteiro de destino como o segundo argumento e retorna verdadeiro ou falso.

Experimente online!

Mathematica, 42 bytes

ListQ@NumberDecompose[#,Sort[#2,Greater]]&

entrada

[15, 10,5}]