Considérez la chaîne suivante:

Tin Snips

Cette chaîne contient plusieurs symboles atomiques sur le tableau périodique . Nous pourrions réécrire cette chaîne pour en identifier plusieurs:

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

Bien sûr, nous pourrions également l'écrire de cette façon:

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

Les règles de réécriture de l'entrée sont les suivantes:

1. Le cas de l'entrée n'a pas d'importance en termes de correspondance des symboles atomiques.
2. Si un élément est utilisé dans un symbole atomique, sa casse doit changer pour que le symbole soit correct. Ex: hdeviendrait [H].
3. Tous les symboles d'élément sont placés entre crochets ASCII [et ].
4. L'espace est préservé: Big egone peut pas combiner le "g" et le "e" dans [Ge].
5. Tous les caractères d'entrée ne doivent pas être combinés en un symbole atomique: si un caractère d'entrée n'est pas placé dans un symbole, il est transmis tel quel (la casse n'a pas d'importance).
6. Si un symbole peut être créé, il doit l' être. En d'autres termes, il n'est pas autorisé à sortir Tindans l'exemple ci-dessus car il est possible de créer au moins un symbole dans ce mot. Le seul moment où un personnage peut passer inutilisé est lorsqu'il ne peut pas être utilisé pour construire un symbole atomique.
7. Aux fins de ce défi, tous les éléments de l'hydrogène (1) à Oganesson (118) sont valides. Aucun élément supérieur n'est valide.
8. Certains des éléments supérieurs ont des noms et des symboles ambigus: aux fins de ce défi, la version sur Wikipedia doit être utilisée. Pour plus de commodité, les symboles atomiques autorisés sont ici: 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, Og.

Écrivez un programme ou une fonction qui génère toutes les sorties possibles à partir d'une seule entrée fournie. L'entrée et la sortie peuvent être dans n'importe quelle forme de votre choix. Cela peut être une chaîne, un tableau de caractères ou une autre structure de données: tout ce qui est à la fois pratique et représente clairement l'entrée et la sortie. L'entrée et la sortie peuvent être transmises dans / hors de votre code comme vous le souhaitez: entrée / sortie standard, argument de fonction / retour, ou autre chose.

• L'entrée doit être une chaîne (voir le paragraphe précédent) de longueur positive contenant uniquement des caractères ASCII de casse arbitraire et le caractère espace ( 0x20).
• Votre code doit générer toutes les chaînes de sortie qui peuvent être créées à l'aide des règles d'entrée ci-dessus.
• L'ordre de sortie est défini par l'implémentation. La seule exigence est que toutes les chaînes de sortie soient présentes.
• S'il est présenté avec une chaîne d'entrée valide qui ne contient aucun symbole atomique, il suffit de sortir la chaîne d'entrée.
• S'il est présenté avec une chaîne d'entrée qui n'est pas valide selon les règles ci-dessus (null, zéro caractère, contient des caractères illégaux, etc.) votre programme peut faire n'importe quoi (plantage, sortie vide, etc.)
• La sortie est insensible à la casse autre que les symboles atomiques qui doivent correspondre au tableau périodique.
• Les échappatoires standard ne sont pas autorisées.

Cas de test:

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]

C'est le code golf, alors laissez-moi voir votre code le plus court!

Python 3, 289 263 octets

Trouvé une bibliothèque plus complète sur 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]

Ancienne réponse:

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]

Utilise une bibliothèque elements.pyde http://www.lfd.uci.edu/~gohlke/code/elements.py.html . Il manque les éléments 110 à 118, mais c'était la bibliothèque la plus récente que j'ai pu trouver. Coût 40 octets pour ajouter les éléments manquants.

La partie la plus délicate était la logique pour quand un personnage peut être traversé sans faire partie d'un symbole d'élément.

Gelée ,  192  191 octets

-1 en utilisant Ɗ(un rapide développé depuis)

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

Essayez-le en ligne! - Trop inefficace pour que le scénario de test "Stack Exchange" se termine dans la limite des années 60 (son exécution hors ligne donne le résultat correct dans les 2 minutes).

Comment?

La première ligne de code est un lien niladique pour créer une liste contenant les 118 symboles d'élément. Pour ce faire, il concatène deux listes, la première contenant toutes les listes de caractères de longueur 2 (c'est-à-dire les chaînes), la seconde une liste de caractères et le titre casse la liste résultante. Les deux listes elles-mêmes sont créées principalement en recherchant des mots dans le dictionnaire de Jelly pour créer des chaînes simples.

La première de ces compressions est:

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

qui donne

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

Où tous sauf l'entrée finale (divisés par des espaces) sont des entrées dans le dictionnaire de Jelly. Les espaces sont filtrés avec ḟ⁶, puis le résultat est divisé en deux:

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

La deuxième,

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

est formé de la concaténation des mots "pinson", "pub", "ciel" et "vœu" (sans espaces), et en tant que tel est une liste de caractères:

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

Les deux listes sont concaténées avec ;et chaque entrée est titrée en utilisant Œt, ce qui donne:

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

Une liste contenant les 118 symboles d'élément selon les besoins (il y a des doublons, mais ça va).

La deuxième ligne de code est un lien monadique (une fonction d'assistance conçue pour prendre une entrée) qui renvoie un 1 si l'entrée, avec un titre, existe dans la liste créée ci-dessus et un 0 dans le cas contraire.

La troisième ligne de code est le lien principal, une fonction monadique qui prend une chaîne et renvoie une liste de listes de caractères (c'est-à-dire des chaînes) selon les besoins:

ŒṖµ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 octets

Voici un morceau de code vraiment terrible, mais cela devrait fonctionner. Pourrait encore être raccourci beaucoup plus probablement.

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

Appeler avec:

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