[Br] eaking Code Golf [Ba] d


20

Considera la seguente stringa:

Tin Snips

Questa stringa contiene diversi simboli atomici nella tavola periodica . Potremmo riscrivere questa stringa per identificarne diverse:

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

Certo, potremmo anche scrivere in questo modo:

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

Le regole per riscrivere l'input sono le seguenti:

  1. Il caso dell'input non ha importanza in termini di corrispondenza dei simboli atomici.
  2. Se un elemento viene utilizzato in un simbolo atomico, il suo caso deve cambiare in modo che il simbolo sia corretto. Es: hsarebbe diventato [H].
  3. Tutti i simboli degli elementi sono racchiusi tra parentesi quadre ASCII [e ].
  4. Lo spazio bianco è preservato: Big egonon è possibile combinare "g" ed "e" in [Ge].
  5. Non tutti i caratteri di input devono essere combinati in un simbolo atomico: se un carattere di input non viene inserito in un simbolo, viene passato così com'è (il caso non ha importanza).
  6. Se è possibile creare un simbolo, è necessario crearlo. In altre parole, non è consentito l'output Tinnell'esempio sopra perché è possibile creare almeno un simbolo in quella parola. L'unica volta in cui un personaggio può passare inutilizzato è quando non può essere usato per costruire un simbolo atomico.
  7. Ai fini di questa sfida, tutti gli elementi da Idrogeno (1) a Oganesson (118) sono validi. Nessun elemento superiore è valido.
  8. Alcuni degli elementi superiori hanno nomi e simboli ambigui: ai fini di questa sfida, deve essere utilizzata la versione di Wikipedia . Per comodità, i simboli atomici consentiti sono qui: 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.

Scrivi un programma o una funzione che genera tutte le possibili uscite da un singolo input fornito. Sia l'input che l'output possono essere in qualsiasi forma di tua scelta. Potrebbe trattarsi di una stringa, una matrice di caratteri o qualche altra struttura di dati: qualunque cosa sia conveniente e rappresenti chiaramente l'input e l'output. Sia l'input che l'output possono essere passati in / out dal tuo codice, comunque tu scelga: in / out standard, argomento / ritorno della funzione o qualcos'altro.

  • L'input deve essere una stringa (vedi paragrafo precedente) di lunghezza positiva contenente solo caratteri ASCII di caso arbitrario e il carattere spazio ( 0x20).
  • Il codice deve generare tutte le stringhe di output che possono essere create utilizzando le regole di input sopra.
  • L'ordine dell'output è definito dall'implementazione. L'unico requisito è che siano presenti tutte le stringhe di output.
  • Se presentato con una stringa di input valida che non contiene alcun simbolo atomico, emettere semplicemente la stringa di input.
  • Se presentato con una stringa di input non valida secondo le regole sopra (null, zero caratteri, contiene caratteri illegali, ecc.) Il tuo programma potrebbe fare qualsiasi cosa (crash, output vuoto, ecc.)
  • L'output non fa distinzione tra maiuscole e minuscole oltre ai simboli atomici che devono corrispondere alla tabella periodica.
  • Scappatoie standard non consentite.

Casi 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]

Questo è il codice golf, quindi fammi vedere il tuo codice più corto!


1
Per @Rassars commento Tin sarebbe T[I][N]non [T][I][N]perché T non è un elemento. La mia domanda (e forse quella di Rassar) è: dobbiamo solo dare 1. Solo output in cui viene effettuato il numero massimo di sottosezioni di elementi? 2. Solo la quantità minima di spreco? (Il HeHe con idrogeni indica che la risposta a questa è no) 3. Tutte le uscite in cui le partite sono completamente esaurite? (in questo caso T[I][N], così come T[In]sarebbe valida.) Penso che l'interpretazione corretta è 3.
livello del fiume St


1
Quindi ci sono 2 possibilità per Quack: Q[U][Ac][K]e Q[U]a[C][K]. Giusto?
Root Due

1
Tutti i casi sono stati verificati.
Calcolatrice

1
@ Challenger5 "Il tuo codice deve generare tutte le stringhe di output che possono essere create utilizzando le regole di input sopra"
Jonathan Allan

Risposte:


5

Python 3, 289 263 byte

Ho trovato una libreria più completa su 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]

Vecchia risposta:

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]

Utilizza una libreria elements.pyda http://www.lfd.uci.edu/~gohlke/code/elements.py.html . Mancano gli elementi da 110 a 118, ma era la libreria più aggiornata che potessi trovare. Costo 40 byte per aggiungere gli elementi mancanti.

La parte più difficile è stata la logica per cui un personaggio può essere attraversato senza far parte di un simbolo di elemento.


1
Aspetta, non era mendeleevun utente, non una biblioteca?
Matthew Roh,

3

Gelatina ,  192  191 byte

-1 mediante l'uso di Ɗ(una rapida sviluppata da allora)

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

Provalo online! - Troppo inefficiente per il completamento del test case "Stack Exchange" entro il limite degli anni '60 (eseguendolo offline fornisce il risultato corretto entro 2 minuti).

Come?

La prima riga di codice è un collegamento niladico per creare un elenco contenente tutti i 118 simboli degli elementi. Per fare ciò concatena due liste, la prima contenente tutte le lunghezze 2 liste di caratteri (es. Stringhe) la seconda una lista di caratteri e titoli caso l'elenco risultante. Le due liste stesse vengono create principalmente cercando le parole nel dizionario di Jelly per creare stringhe singole.

La prima di queste compressioni è:

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

quale cede

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

Dove tutti tranne la voce finale (divisa per spazi) sono voci nel dizionario di Jelly. Gli spazi vengono filtrati con ḟ⁶, quindi il risultato viene diviso in due:

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

Il secondo,

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

è formato dalla concatenazione delle parole "fringuello", "pub", "cielo" e "voto" (senza spazi), e come tale è un elenco di caratteri:

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

Le due liste sono concatenate ;e ogni voce è racchiusa in un titolo usando Œt, producendo:

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

Un elenco contenente tutti i 118 simboli degli elementi richiesti (ci sono duplicati, ma va bene).

La seconda riga di codice è un collegamento monadico (una funzione di supporto progettata per accettare un input) che restituisce un 1 se l'input, con il titolo inserito esiste nell'elenco creato sopra e uno 0 altrimenti.

La terza riga di codice è il collegamento principale, una funzione monadica che accetta una stringa e restituisce un elenco di elenchi di caratteri (ovvero stringhe) come richiesto:

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

1

C ++ 11, 944 928 byte

Ecco un pezzo di codice davvero terribile, ma dovrebbe funzionare. Potrebbe essere ancora molto più breve probabilmente.

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

Chiama con:

int main()
{
    F("Tin Snips");cout << "\n";
    F("Quack");cout << "\n";
    F("hehe");cout << "\n";
    F("Stack Exchange");
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.