Considere a seguinte string:

Tin Snips

Essa sequência contém vários símbolos atômicos na tabela periódica . Poderíamos reescrever essa sequência para identificar várias delas:

[Ti][N] [Sn][I][P][S]

Claro, também poderíamos escrever desta maneira:

T[In] [S][Ni][P][S]

As regras para reescrever a entrada são as seguintes:

1. O caso da entrada não importa em termos de símbolos atômicos correspondentes.
2. Se um elemento é usado em um símbolo atômico, sua caixa deve mudar para que o símbolo esteja correto. Ex: hse tornaria [H].
3. Todos os símbolos dos elementos estão entre colchetes ASCII [e ].
4. O espaço em branco é preservado: Big egonão é possível combinar o "g" e o "e" em [Ge].
5. Nem todos os caracteres de entrada precisam ser combinados em um símbolo atômico: se um caractere de entrada não for colocado em um símbolo, ele será passado como está (o caso não importa).
6. Se um símbolo pode ser criado, ele deve ser criado. Em outras palavras, não é permitido produzir Tinno exemplo acima, porque é possível criar pelo menos um símbolo nessa palavra. A única vez que um caractere pode ser passado sem uso é quando ele não pode ser usado para construir um símbolo atômico.
7. Para os propósitos deste desafio, todos os elementos de Hydrogen (1) a Oganesson (118) são válidos. Nenhum elemento superior é válido.
8. Alguns dos elementos superiores têm nomes e símbolos ambíguos: para os fins deste desafio, a versão na Wikipedia deve ser usada. Por conveniência, os símbolos atômicos permitidos estão aqui: H, He, Li, Be, B, C, N, O, F, Ne, Na, Mg, Al, Si, P, S, Cl, Ar, K, Ca, Sc, Ti, V, Cr, Mn, Fe, Co, Ni, Cu, Zn, Ga, Ge, As, Se, Br, Kr, Rb, Sr, Y, Zr, Nb, Mo, Tc, Ru, Rh, Pd, Ag, Cd, Em, Sn, Sb, Te, Eu, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, UE, Gd, Tb, Dy, Ho, Er, Tm, Yb, Lu, Hf, Ta, W, Re, OS, Ir, Pt, Au, Hg, Tl, Pb, Bi, Po, At, Rn, Fr, Ra, Ac, Th, Pa, U, Np, Pu, Am, Cm, Bk, Cf, Es, Fm, Md, Não, Lr, Rf, Db, Sg, Bh, Hs, Mt, Ds, Rg, Cn, Nh, Fl, Mc, Lv, Ts, Og.

Escreva um programa ou função que gere todas as saídas possíveis a partir de uma única entrada fornecida. Tanto a entrada como a saída podem estar em qualquer forma que você escolher. Pode ser uma cadeia de caracteres, uma matriz de caracteres ou alguma outra estrutura de dados: o que for conveniente e represente claramente a entrada e a saída. Tanto a entrada quanto a saída podem ser passadas para dentro / fora do seu código, mas você escolhe: entrada / saída padrão, argumento / retorno da função ou outra coisa.

• A entrada deve ser uma sequência (ver parágrafo anterior) de comprimento positivo contendo apenas caracteres ASCII de maiúsculas e minúsculas e o 0x20caractere espaço ( ).
• Seu código deve gerar todas as seqüências de saída que podem ser criadas usando as regras de entrada acima.
• A ordem da saída é definida pela implementação. O único requisito é que todas as seqüências de saída estejam presentes.
• Se apresentado com uma sequência de entrada válida que não contém símbolos atômicos, basta gerar a sequência de entrada.
• Se for apresentada uma sequência de entrada que não é válida de acordo com as regras acima (nulo, zero caracteres, contém caracteres ilegais, etc.), seu programa pode fazer qualquer coisa (falha, saída em branco etc.)
• A saída diferencia maiúsculas de minúsculas, exceto símbolos atômicos, que precisam corresponder à tabela periódica.
• Não são permitidas brechas padrão.

Casos de teste:

Tin Snips
[Ti][N] [Sn][I][P][S]
[Ti][N] [S][Ni][P][S]
[Ti][N] [S][N][I][P][S]
T[In] [Sn][I][P][S]
T[In] [S][Ni][P][S]
T[In] [S][N][I][P][S]
T[I][N] ...

Quack
Q[U][Ac][K]
Q[U]a[C][K]

hehe
[H]e[H]e
[H]e[He]
[He][H]e
[He][He]

Stack Exchange
[S][Ta][C][K] Ex[C][H]a[N][Ge]
[S]t[Ac][K] Ex[C][H]a[N][Ge]

Isso é código de golfe, então deixe-me ver seu código mais curto!

Python 3, 289 263 bytes

Encontrou uma biblioteca mais completa no Pypi: mendeleev

from mendeleev import*
Z={element(i).symbol for i in range(1,119)}
L,R='[]'
def f(h,r=''):t=h.title();return((Z&{t[0]}and f(h[1:],r+L+t[0]+R)or[])+(Z>{(t+L)[:2]}and f(h[2:],r+L+t[:2]+R)or[])+(not{(r[-1:]+t[0]).title(),t[0]}&Z and f(h[1:],r+h[0])or[]))if h else[r]

Resposta antiga:

from elements import*
Z={e.symbol for e in ELEMENTS}|{*'Cn Ds Fl Lv Mc Nh Og Rg Ts'.split()}
L,R='[]'
def f(h,r=''):t=h.title();return((Z&{t[0]}and f(h[1:],r+L+t[0]+R)or[])+(Z>{(t+L)[:2]}and f(h[2:],r+L+t[:2]+R)or[])+(not{(r[-1:]+t[0]).title(),t[0]}&Z and f(h[1:],r+h[0])or[]))if h else[r]

Usa uma biblioteca elements.py de http://www.lfd.uci.edu/~gohlke/code/elements.py.html . Faltam elementos 110 a 118, mas foi a biblioteca mais atualizada que pude encontrar. Custo de 40 bytes para adicionar os elementos ausentes.

A parte mais complicada era a lógica de quando um personagem pode ser passado sem fazer parte de um símbolo de elemento.

Jelly ,  192  191 bytes

-1 usando Ɗ(uma rápida desenvolvida desde então)

“¦UV2ḤF2ı½ṅḶḊ⁼5JI5MẇvẋẊẊ¬Ḥḳ'ƈ<ḷėƤ7*⁾ṾxMæS⁺`?^Ƭb¦ɗDß⁼pþɲOṃ⁽2Ė>,Ḣ(ḞŒƊOGƤ×⁺ṇṂ®ȤT0y°^Ẇ⁺:Þ]ṢṬ¶ịṪḂƇ ñAƬCṫ$wÆĿĖỴỴƇẓƊqḌ@;ẏ`ṃFƥḣ⁽²»ḟ⁶s2;“¤²R.ȯ7ŒL£ɦ»Œt
Œte¢
ŒṖµL€=1oÇ€ṂµÐfµṡ2;€ÇÐfÇ€€S€¬SµÐḟ⁾[]jŒtƊ¹Ç?€€

Experimente online! - Ineficiente demais para a conclusão do caso de teste "Stack Exchange" dentro do limite dos anos 60 (executá-lo offline fornece o resultado correto em 2 minutos).

Quão?

A primeira linha de código é um link niládico para criar uma lista contendo todos os 118 símbolos de elementos. Para isso, concatena duas listas, a primeira contendo todas as 2 listas de caracteres (ou seja, cadeias) e a segunda uma lista de caracteres e o título da lista resultante. As duas listas são criadas principalmente procurando palavras no dicionário de Jelly para criar seqüências únicas.

A primeira dessas compressões é:

“¦UV2ḤF2ı½ṅḶḊ⁼5JI5MẇvẋẊẊ¬Ḥḳ'ƈ<ḷėƤ7*⁾ṾxMæS⁺`?^Ƭb¦ɗDß⁼pþɲOṃ⁽2Ė>,Ḣ(ḞŒƊOGƤ×⁺ṇṂ®ȤT0y°^Ẇ⁺:Þ]ṢṬ¶ịṪḂƇ ñAƬCṫ$wÆĿĖỴỴƇẓƊqḌ@;ẏ`ṃFƥḣ⁽²»

que produz

" biznagas sepmag ratbag catchflies paracmes mdse bharal ramcat monopteros irrepressibilities lunarnauts geniculate hopbinds rutabaga potlache broghs bergamas crossbirth purblind xebecs nonhardy classism fleurets moneybag scarce corf Mg Sr Zr CD HG CF FM Lr SG TM Gd Bk Fr Rh Fe Sn lv cndbmnnbkrmtpdnp"

Onde todos, exceto a entrada final (dividida por espaços), são entradas no dicionário de Jelly. Os espaços são filtrados ḟ⁶e, em seguida, o resultado é dividido em dois:

["bi","zn","ag","as","se","pm","ag","ra","tb","ag","ca","tc","hf","li","es","pa","ra","cm","es","md","se","bh","ar","al","ra","mc","at","mo","no","pt","er","os","ir","re","pr","es","si","bi","li","ti","es","lu","na","rn","au","ts","ge","ni","cu","la","te","ho","pb","in","ds","ru","ta","ba","ga","po","tl","ac","he","br","og","hs","be","rg","am","as","cr","os","sb","ir","th","pu","rb","li","nd","xe","be","cs","no","nh","ar","dy","cl","as","si","sm","fl","eu","re","ts","mo","ne","yb","ag","sc","ar","ce","co","rf","Mg","Sr","Zr","CD","HG","CF","FM","Lr","SG","TM","Gd","Bk","Fr","Rh","Fe","Sn","lv","cn","db","mn","nb","kr","mt","pd","np"]

O segundo,

“¤²R.ȯ7ŒL£ɦ»

é formado a partir da concatenação das palavras "tentilhão", "pub", "céu" e "voto" (sem espaços) e, como tal, é uma lista de caracteres:

['f','i','n','c','h','p','u','b','s','k','y','v','o','w']

As duas listas são concatenadas ;e todas as entradas são maiúsculas de minúsculas usando Œt, resultando em:

["Bi","Zn","Ag","As","Se","Pm","Ag","Ra","Tb","Ag","Ca","Tc","Hf","Li","Es","Pa","Ra","Cm","Es","Md","Se","Bh","Ar","Al","Ra","Mc","At","Mo","No","Pt","Er","Os","Ir","Re","Pr","Es","Si","Bi","Li","Ti","Es","Lu","Na","Rn","Au","Ts","Ge","Ni","Cu","La","Te","Ho","Pb","In","Ds","Ru","Ta","Ba","Ga","Po","Tl","Ac","He","Br","Og","Hs","Be","Rg","Am","As","Cr","Os","Sb","Ir","Th","Pu","Rb","Li","Nd","Xe","Be","Cs","No","Nh","Ar","Dy","Cl","As","Si","Sm","Fl","Eu","Re","Ts","Mo","Ne","Yb","Ag","Sc","Ar","Ce","Co","Rf","Mg","Sr","Zr","Cd","Hg","Cf","Fm","Lr","Sg","Tm","Gd","Bk","Fr","Rh","Fe","Sn","Lv","Cn","Db","Mn","Nb","Kr","Mt","Pd","Np","F","I","N","C","H","P","U","B","S","K","Y","V","O","W"]

Uma lista contendo todos os 118 símbolos de elementos, conforme necessário (há duplicatas, mas tudo bem).

A segunda linha de código é um link monádico (uma função auxiliar projetada para receber uma entrada) que retorna 1 se a entrada com maiúsculas de minúsculas existir na lista criada acima e 0 caso contrário.

A terceira linha de código é o link principal, uma função monádica que pega uma string e retorna uma lista de listas de caracteres (ou seja, strings) conforme necessário:

ŒṖµL€=1oÇ€ṂµÐfµṡ2;€ÇÐfÇ€€S€¬SµÐḟ⁾[]jŒtƊ¹Ç?€€ - Main link: s
ŒṖ                                           - all partitions of s
  µ        µÐf                               - filter keep:
   L€=1                                      -     length €ach equals (vectorises) 1
       o                                     -     or
        ǀ                                   -     last link as a monad (is an element when title-cased)
          Ṃ                                  -     minimum 
                                             - (i.e. all partitions that are all single characters OR are strings that when title-cased are elements)
              µ              µÐḟ             - filter discard:
               ṡ2                            -     slices of length 2
                 ;€                          -     concatenate €ach
                    Ðf                       -     filter keep:
                   Ç                         -         last link as a monad (is an element when title-cased)
                      Ç€€                    -     last link as a monad for €ach for €ach
                         S€                  -     sum €ach
                           ¬                 -     logical not
                            S                -     sum
                                             - (i.e. discard any partitions that contain a run of two that joined together and title-cased ARE an element but separately NEITHER are)
                                         ?€€ - if then else for €ach (partition) for €ach (part):
                                        Ç    -     IF: last link as a monad (is an element when title-cased)
                                             -   THEN:
                                      Ɗ      -         last three links as a monad:
                                ⁾[]                      "[]"
                                   j         -           joined by:
                                    Œt       -           title case the part
                                             -   ELSE:
                                       ¹     -         the part itsef (¹ is the identity atom)

C ++ 11, 944 928 bytes

Aqui está um código realmente terrível, mas deve funcionar. Provavelmente ainda poderia ser muito mais curto.

#import<iostream>
#import<set>
using namespace std;int r,i;set<string>O;S(string&s){s[0]-=s[0]>90?32:0;if(s[1])s[1]+=s[1]<91?32:0;char*l="HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnNhFlMcLvTsOg";for(r=0;*l++;)if(*l>90){if(*(l++-1)==s[0]&&*(l-1)==s[1])r=1;}else if(*(l-1)==s[0]&&!s[1])r=1;}P(set<string>*V,string s,string o,int b,int l=0,int m=0){if(!s[b])O.insert(o);else if(l)P(V,s,o,b+1);else if(V[b].size()==0)P(V,s,o+s[b],b+1);else for(auto t:V[b]){P(V,s,o+"["+t+"]",b+1,t.length()-1);if(t.length()>1&&V[b].size()==1&&V[b+1].size()>0&&!m)P(V,s,o+s[b],b+1,0,1);}}F(string s){set<string>V[s.length()];for(i=0;s[i++];){string t="";t+=s[i-1];S(t);if(r)V[i-1].insert(t);t+=s[i];S(t);if(r&&s[i])V[i-1].insert(t);}P(V,s,"",0);for(auto o:O)cout<<o<<"\n";O.clear();}

Ligue para:

int main()
{
    F("Tin Snips");cout << "\n";
    F("Quack");cout << "\n";
    F("hehe");cout << "\n";
    F("Stack Exchange");
}