Betrachten Sie die folgende Zeichenfolge:

Tin Snips

Diese Zeichenfolge enthält mehrere Atomsymbole im Periodensystem . Wir könnten diesen String umschreiben, um mehrere von ihnen zu identifizieren:

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

Natürlich könnten wir es auch so schreiben:

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

Die Regeln zum Umschreiben der Eingabe lauten wie folgt:

1. Der Fall der Eingabe spielt im Hinblick auf übereinstimmende Atomsymbole keine Rolle.
2. Wenn ein Element in einem atomaren Symbol verwendet wird, muss sich die Groß- und Kleinschreibung ändern, damit das Symbol korrekt ist. Bsp .: hwürde werden [H].
3. Alle Elementsymbole sind in eckigen ASCII-Klammern [und eingeschlossen ].
4. Leerzeichen bleiben erhalten: Big ego"g" und "e" können nicht kombiniert werden [Ge].
5. Nicht alle eingegebenen Zeichen müssen zu einem atomaren Symbol kombiniert werden: Wenn ein eingegebenes Zeichen nicht in ein Symbol eingefügt wird, wird es unverändert weitergegeben (Groß- / Kleinschreibung spielt keine Rolle).
6. Wenn ein Symbol erstellt werden kann, muss es erstellt werden. Mit anderen Worten, die Ausgabe Tinim obigen Beispiel ist nicht zulässig, da in diesem Wort mindestens ein Symbol erstellt werden kann. Ein Zeichen kann nur dann unbenutzt durchlaufen werden, wenn es nicht zum Aufbau eines Atomsymbols verwendet werden kann.
7. Für diese Herausforderung gelten alle Elemente von Wasserstoff (1) bis Oganesson (118). Es sind keine höheren Elemente gültig.
8. Einige der höheren Elemente haben mehrdeutige Namen und Symbole: Für diese Herausforderung wird die Version bei Wikipedia verwendet. Der Einfachheit halber sind die zulässigen Atomsymbole hier: 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, Ich, 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, Nein, Lr, Rf, Db, Sg, Bh, HS, Mt, DS, Rg, Cn, NH, FL, Mc, Lv, Ts, Og.

Schreiben Sie ein Programm oder eine Funktion, die alle möglichen Ausgaben aus einer einzigen bereitgestellten Eingabe generiert. Sowohl die Eingabe als auch die Ausgabe kann in einer beliebigen Form erfolgen. Dies kann eine Zeichenfolge, ein Array von Zeichen oder eine andere Datenstruktur sein: Was auch immer bequem ist und die Eingabe und Ausgabe klar darstellt. Sowohl die Eingabe als auch die Ausgabe können in Ihren Code eingegeben / ausgegeben werden, ganz gleich, wie Sie sich entscheiden: Standardeingabe / -ausgabe, Funktionsargument / -rückgabe oder etwas anderes.

• Die Eingabe muss eine Zeichenfolge (siehe vorheriger Absatz) mit positiver Länge sein, die nur ASCII-Zeichen in willkürlicher Schreibweise und das Leerzeichen ( 0x20) enthält.
• Ihr Code muss alle Ausgabezeichenfolgen generieren, die mithilfe der obigen Eingaberegeln erstellt werden können.
• Die Reihenfolge der Ausgabe ist implementierungsdefiniert. Die einzige Voraussetzung ist, dass alle Ausgabe-Strings vorhanden sind.
• Wenn eine gültige Eingabezeichenfolge angezeigt wird, die keine atomaren Symbole enthält, geben Sie einfach die Eingabezeichenfolge aus.
• Wenn eine Eingabezeichenfolge angezeigt wird, die gemäß den obigen Regeln nicht gültig ist (null, null Zeichen, enthält unzulässige Zeichen usw.), kann Ihr Programm alles tun (Absturz, leere Ausgabe usw.).
• Bei der Ausgabe wird die Groß- / Kleinschreibung nicht berücksichtigt, außer bei atomaren Symbolen, die mit dem Periodensystem übereinstimmen müssen.
• Standardlücken sind nicht erlaubt.

Testfälle:

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]

Das ist Codegolf, also lass mich deinen kürzesten Code sehen!

Python 3, 289 263 Bytes

Eine umfassendere Bibliothek zu Pypi gefunden: 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]

Alte Antwort:

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]

Verwendet eine Bibliothek elements.pyvon http://www.lfd.uci.edu/~gohlke/code/elements.py.html . Es fehlen die Elemente 110 bis 118, aber es war die aktuellste Bibliothek, die ich finden konnte. Das Hinzufügen der fehlenden Elemente kostet 40 Byte.

Der schwierigste Teil war die Logik dafür, wann ein Zeichen durchlaufen werden kann, ohne Teil eines Elementsymbols zu sein.

Jelly ,  192  191 Bytes

-1 durch Verwendung von Ɗ(ein seit der Entwicklung schnell)

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

Probieren Sie es online! - Der Testfall "Stack Exchange" ist zu ineffizient, um innerhalb der 60er-Grenze abgeschlossen zu werden (wenn er offline ausgeführt wird, wird innerhalb von 2 Minuten das richtige Ergebnis erzielt).

Wie?

Die erste Codezeile ist ein niladischer Link zum Erstellen einer Liste mit allen 118 Elementsymbolen. Zu diesem Zweck werden zwei Listen verkettet, wobei die erste alle Listen mit Zeichen der Länge 2 (dh Zeichenfolgen) enthält und die zweite Liste mit Zeichen und Titeln die resultierende Liste enthält. Die beiden Listen selbst werden hauptsächlich durch Nachschlagen von Wörtern in Jellys Wörterbuch erstellt, um einzelne Zeichenfolgen zu erstellen.

Die erste dieser Komprimierungen ist:

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

was ergibt

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

Wo alle bis auf den letzten Eintrag (durch Leerzeichen getrennt) Einträge in Jellys Wörterbuch sind. Die Leerzeichen werden mit herausgefiltert ḟ⁶und das Ergebnis in zwei Teile aufgeteilt:

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

Der Zweite,

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

wird aus der Verkettung der Wörter "finch", "pub", "sky" und "vow" (ohne Leerzeichen) gebildet und ist als solche eine Liste von Zeichen:

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

Die beiden Listen sind mit verkettet ;und jeder Eintrag wird mit Titel in Großbuchstaben versehenŒt , was ergibt:

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

Eine Liste mit allen 118 Elementsymbolen nach Bedarf (es gibt Duplikate, aber das ist in Ordnung).

Die zweite Codezeile ist eine monadische Verknüpfung (eine Hilfsfunktion, die eine Eingabe akzeptiert), die eine 1 zurückgibt, wenn die Eingabe mit dem Titel "cased" in der oben erstellten Liste vorhanden ist, und ansonsten eine 0.

Die dritte Codezeile ist der Hauptlink, eine monadische Funktion, die eine Zeichenfolge verwendet und bei Bedarf eine Liste mit Listen von Zeichen (dh Zeichenfolgen) zurückgibt:

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

Hier ist ein wirklich schrecklicher Code, der aber funktionieren sollte. Könnte wohl noch viel kürzer gemacht werden.

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

Rufen Sie an mit:

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