Jack gosta da linguagem de programação C, mas odeia escrever expressões como V=a*b*h; multiplicar os valores.

Em V=abh;vez disso, ele gostaria de escrever , por que o compilador deve gemer sobre o abhsímbolo ser indefinido, uma vez que int a, b, h;estão definidos, para que possamos deduzir a multiplicação?

Ajude-o a implementar um analisador que decifre um único termo de multiplicação, desde que o conjunto de variáveis ​​definidas no escopo atual seja conhecido.

Para simplificar, a multiplicação por número (como em 2*a*b) não é levada em consideração, apenas as variáveis ​​aparecem.

A entrada é um termo de multiplicação T , cumprindo regexp:

[a-zA-Z_][a-zA-Z_0-9]*

e um conjunto de variáveis Z .

Um P de análise do termo T sobre o conjunto de variáveis ​​Z é uma sequência que segue o seguinte:

1. depois de remover todas as ocorrências de *P, recebemos T,
2. ou é um nome de variável de Z ou consiste em nomes de variáveis ​​adequados de Z divididos por *caracteres únicos .

A solução deve imprimir todas as análises de um termo.

Amostra:

Vars           a, c, ab, bc
Term           abc
Solution       ab*c, a*bc

Vars           ab, bc
Term           abc
Solution       -

Vars           -
Term           xyz
Solution       -

Vars           xyz
Term           xyz
Solution       xyz

Vars           width, height
Term           widthheight
Solution       width*height

Vars           width, height
Term           widthheightdepth
Solution       -

Vars           aaa, a
Term           aaaa
Solution       aaa*a, a*aaa, a*a*a*a

A entrada (a lista de variáveis ​​e o termo) pode ser fornecida de qualquer maneira adequada ao idioma.

A saída pode estar em qualquer forma sensata (uma análise por linha ou uma lista separada por vírgula etc.) - mas deve ser inequívoca e possível de ser lida.

A saída vazia é aceitável se não houver uma possível análise de um termo (nos exemplos que usei '-' para maior clareza).

Este é um código de golfe, portanto o código mais curto vence.

Pyth, 18 caracteres

mj\*dfqzsTsm^Qkhlz

Esta solução é adaptada da minha solução de interpretação de peixes . Os problemas são realmente muito semelhantes.

Espera entrada como tal:

aaaa
"a", "aaa"

Dá saída assim:

['a*aaa', 'aaa*a', 'a*a*a*a']

Experimente aqui.

• sm^Qkhlz: Gera todas as seqüências de variáveis ​​que contêm até o comprimento do número de variáveis ​​da sequência de entrada.

• fqzsT: Filtra as sequências variáveis ​​que correspondem à sequência de entrada

• mj\*d: Insere o *símbolo e imprime.

Python 2-144 94 bytes

R=lambda S,V,F=[]:S and[R(S[len(v):],V,F+[v])for v in V if v==S[:len(v)]]or print("*".join(F))

Isso define uma função Ra ser usada como:

>>> R("abc", ["a", "bc", "ab", "c"])

Imprime a saída como:

a*bc
ab*c

JavaScript (ES6) 111

Adaptado da minha resposta "peixe" , a principal diferença é encontrar todas as soluções, não apenas a primeira.

F=(v,t)=>(k=(s,r)=>s?v.map(v=>s.slice(0,l=v.length)==v&&k(s.slice(l),[...r,v])):console.log(r.join('*')))(t,[])

A saída é impressa no console. O resultado da função não tem significado e deve ser descartado.

Teste no console Firefox / FireBug

F(['a','c','ab','bc'],'abc')  
a*bc  
ab*c

F(['ab','bc'],'abc')

F(['aaa','a'],'aaaa')
aaa*a
a*aaa
a*a*a*a

F(['xyz'],'xyz')
xyz