Considere la siguiente cadena:

Tin Snips

Esta cadena contiene varios símbolos atómicos en la tabla periódica . Podríamos reescribir esta cadena para identificar varios de ellos:

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

Por supuesto, también podríamos escribirlo de esta manera:

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

Las reglas para reescribir la entrada son las siguientes:

1. El caso de la entrada no importa en términos de símbolos atómicos coincidentes.
2. Si se utiliza un elemento en un símbolo atómico, su caso debe cambiar para que el símbolo sea correcto. Ej: hse convertiría [H].
3. Todos los símbolos de elementos están encerrados entre corchetes ASCII, [y ].
4. Se conserva el espacio en blanco: Big egono se puede combinar la "g" y la "e" en [Ge].
5. No todos los caracteres de entrada deben combinarse en un símbolo atómico: si un carácter de entrada no se coloca en un símbolo, se pasa como está (el caso no importa).
6. Si se puede hacer un símbolo, se debe hacer. En otras palabras, no se permite la salida Tinen el ejemplo anterior porque es posible crear al menos un símbolo en esa palabra. La única vez que un personaje puede pasar sin usar es cuando no se puede usar para construir un símbolo atómico.
7. Para los propósitos de este desafío, todos los elementos desde Hidrógeno (1) hasta Oganesson (118) son válidos. No hay elementos superiores válidos.
8. Algunos de los elementos superiores tienen nombres y símbolos ambiguos: a los fines de este desafío, se utilizará la versión de Wikipedia . Por conveniencia, los símbolos atómicos permitidos están aquí: 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, In, Sn, Sb, Te, I, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, Eu, 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, No, Lr, Rf, Db, Sg, Bh, Hs, Mt, Ds, Rg, Cn, Nh, Fl, Mc, Lv, Ts, Og.

Escriba un programa o función que genere todas las salidas posibles a partir de una sola entrada proporcionada. Tanto la entrada como la salida pueden estar en cualquier forma que elija. Esto podría ser una cadena, una matriz de caracteres o alguna otra estructura de datos: lo que sea conveniente y represente claramente la entrada y la salida. Tanto la entrada como la salida se pueden pasar dentro / fuera de su código como usted elija: entrada / salida estándar, argumento / retorno de función, o algo más.

• La entrada debe ser una cadena (ver párrafo anterior) de longitud positiva que contenga solo caracteres ASCII de mayúsculas y minúsculas y el espacio ( 0x20).
• Su código debe generar todas las cadenas de salida que se pueden crear utilizando las reglas de entrada anteriores.
• El orden de la salida está definido por la implementación. El único requisito es que todas las cadenas de salida estén presentes.
• Si se le presenta una cadena de entrada válida que no contiene ningún símbolo atómico, simplemente envíe la cadena de entrada.
• Si se le presenta una cadena de entrada que no es válida según las reglas anteriores (nulo, cero caracteres, contiene caracteres ilegales, etc.), su programa puede hacer cualquier cosa (bloqueo, salida en blanco, etc.)
• La salida no distingue entre mayúsculas y minúsculas, excepto los símbolos atómicos que necesitan coincidir con la tabla periódica.
• Lagunas estándar no permitidas.

Casos de prueba:

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]

Este es el código de golf, ¡así que déjame ver tu código más corto!

Python 3, 289 263 bytes

Encontré una biblioteca más completa en 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]

Vieja respuesta:

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]

Utiliza una biblioteca elements.pyde http://www.lfd.uci.edu/~gohlke/code/elements.py.html . Faltan elementos del 110 al 118, pero fue la biblioteca más actualizada que pude encontrar. Cuesta 40 bytes para agregar los elementos que faltan.

La parte más complicada fue la lógica de cuándo se puede pasar un personaje sin ser parte de un símbolo de elemento.

Jalea ,  192  191 bytes

-1 mediante el uso de Ɗ(un rápido desarrollado desde entonces)

“¦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Ɗ¹Ç?€€

Pruébalo en línea! - Demasiado ineficiente para que el caso de prueba "Stack Exchange" se complete dentro del límite de los 60 (ejecutarlo sin conexión da el resultado correcto en 2 minutos).

¿Cómo?

La primera línea de código es un enlace niládico para crear una lista que contiene los 118 símbolos de elementos. Para hacerlo, concatena dos listas, la primera contiene todas las listas de caracteres de longitud 2 (es decir, cadenas) y la segunda una lista de caracteres y títulos de casos la lista resultante. Las dos listas en sí se crean principalmente buscando palabras en el diccionario de Jelly para crear cadenas individuales.

La primera de estas compresiones es:

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

cuyos rendimientos

" 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"

Donde todos menos la entrada final (dividida por espacios) son entradas en el diccionario de Jelly. Los espacios se filtran con ḟ⁶, y luego el resultado se divide en dos:

["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"]

El segundo,

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

se forma a partir de la concatenación de las palabras "pinzón", "pub", "cielo" y "voto" (sin espacios), y como tal es una lista de caracteres:

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

Las dos listas se concatenan con ;y cada entrada está encerrada en un título usando Œt, produciendo:

["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"]

Una lista que contiene todos los símbolos de 118 elementos según sea necesario (hay duplicados, pero está bien).

La segunda línea de código es un enlace monádico (una función auxiliar diseñada para tomar una entrada) que devuelve un 1 si la entrada, con título en mayúscula, existe en la lista creada anteriormente y un 0 en caso contrario.

La tercera línea de código es el enlace principal, una función monádica que toma una cadena y devuelve una lista de listas de caracteres (es decir, cadenas) según sea necesario:

ŒṖµ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, 944928 bytes

Aquí hay una pieza de código realmente terrible, pero debería funcionar. Todavía podría hacerse mucho más corto probablemente.

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

Llamar con:

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