Mensaje secreto Parte 1, Elementos

8

Tú y tu amigo quieren enviarse mensajes secretos. Sin embargo, porque son teóricos de la conspiración y piensan que el gobierno tiene una computadora cuántica que puede descifrar cualquier cifrado estándar. Por lo tanto, estás inventando uno propio. El primer paso de esto es el siguiente: tomando una cadena de entrada, verifica si todas las letras pueden ser representadas por los símbolos de los elementos de la tabla periódica (sin distinción entre mayúsculas y minúsculas). Si pueden serlo, reemplaza cada sección con el nombre del elemento que representa el símbolo. Si no se pueden reemplazar todas las letras de esta manera, simplemente use la cadena original.

Tu tarea:

Debe escribir un programa o función que codifique un mensaje, como se describió anteriormente. Recuerde que si su programa obtiene datos de una fuente externa, el tamaño de la fuente externa debe agregarse al recuento de bytes ( este vacío ). Los elementos y símbolos utilizados están aquí:

H   Hydrogen
He  Helium
Li  Lithium
Be  Beryllium
B   Boron
C   Carbon
N   Nitrogen
O   Oxygen
F   Fluorine
Ne  Neon
Na  Sodium
Mg  Magnesium
Al  Aluminum
Si  Silicon
P   Phosphorus
S   Sulfur
Cl  Chlorine
Ar  Argon
K   Potassium
Ca  Calcium
Sc  Scandium
Ti  Titanium
V   Vanadium
Cr  Chromium
Mn  Manganese
Fe  Iron
Co  Cobalt
Ni  Nickel
Cu  Copper
Zn  Zinc
Ga  Gallium
Ge  Germanium
As  Arsenic
Se  Selenium
Br  Bromine
Kr  Krypton
Rb  Rubidium
Sr  Strontium
Y   Yttrium
Zr  Zirconium
Nb  Niobium
Mo  Molybdenum
Tc  Technetium
Ru  Ruthenium
Rh  Rhodium
Pd  Palladium
Ag  Silver
Cd  Cadmium
In  Indium
Sn  Tin
Sb  Antimony
Te  Tellurium
I   Iodine
Xe  Xenon
Cs  Cesium
Ba  Barium
La  Lanthanum
Ce  Cerium
Pr  Praseodymium
Nd  Neodymium
Pm  Promethium
Sm  Samarium
Eu  Europium
Gd  Gadolinium
Tb  Terbium
Dy  Dysprosium
Ho  Holmium
Er  Erbium
Tm  Thulium
Yb  Ytterbium
Lu  Lutetium
Hf  Hafnium
Ta  Tantalum
W   Tungsten
Re  Rhenium
Os  Osmium
Ir  Iridium
Pt  Platinum
Au  Gold
Hg  Mercury
Tl  Thallium
Pb  Lead
Bi  Bismuth
Po  Polonium
At  Astatine
Rn  Radon
Fr  Francium
Ra  Radium
Ac  Actinium
Th  Thorium
Pa  Protactinium
U   Uranium
Np  Neptunium
Pu  Plutonium
Am  Americium
Cm  Curium
Bk  Berkelium
Cf  Californium
Es  Einsteinium
Fm  Fermium
Md  Mendelevium
No  Nobelium
Lr  Lawrencium
Rf  Rutherfordium
Db  Dubnium
Sg  Seaborgium
Bh  Bohrium
Hs  Hassium
Mt  Meitnerium
Ds  Darmstadtium
Rg  Roentgenium
Cn  Copernicium
Nh  Nihonium
Fl  Flerovium
Mc  Moscovium
Lv  Livermorium
Ts  Tennessine
Og  Oganesson

Entrada:

Una cadena a codificar. Puede tomar esto en mayúsculas o minúsculas si lo desea, siempre que especifique ese requisito en su respuesta.

Salida:

La cadena, codificada como se describe anteriormente, si es posible.

Ejemplos:

Hi!                --> HydrogenIodine!
This is an example --> This is an example
Neon               --> NeonOxygenNitrogen
Snip               --> SulfurNitrogenIodinePhosphorus OR TinIodinePhosphorus
Nag                --> NitrogenSilver

Puntuación:

Este es el , ¡el código más corto en bytes gana!

Grifo
fuente
Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
Dennis
¿Pueden todos tomar los elementos y símbolos como un diccionario como entrada porque a partir de ahora, este desafío se trata básicamente de comprimir eso?
Daniel
@Dopapp, no, ya que eso haría que las respuestas que ya se hayan enviado y que la gente haya trabajado muy duro no sean competitivas. Comprimir los elementos siempre sería la mayor parte del desafío de todos modos.
Gryphon

Respuestas:

2

Mathematica, 404 (239) bytes

S="";l=ToLowerCase;e=ElementData;Unprotect[e];a="Abbreviation";n="Name";e[113,a]="Nh";e["Nh",n]="Nihonium";e[115,a]="Mc";e["Mc",n]="Moscovium";e[117,a]="Ts";e["Ts",n]="Tennessine";e[118,a]="Og";e["Og",n]="Oganesson";r=StringReplace;A=Reverse@SortBy[Table[e[j,a],{j,118}],StringLength];If[StringFreeQ[r[l@S,Table[l@A[[j]]->"",{j,118}]],Alphabet[]],r[l@S,Table[l@A[[j]]->Capitalize@e[A[[j]],n],{j,118}]],S]

Usando la base de datos incorporada de Mathematica para buscar nombres de elementos y sus abreviaturas. La entrada se puede mezclar en mayúsculas y minúsculas y se almacena en la variableS . El resultado es el resultado de la expresión, no se imprime explícitamente.

En este momento, el código totalmente operativo ocupa 404 bytes, ya que la base de datos química incorporada de Mathematica está un poco atrás. ElementData[118, "Name"]devuelve en ununoctiumlugar de oganesson(los elementos súper pesados ​​donde recientemente se nombraron correctamente, ununoctium era un nombre de marcador de posición para el elemento 118).
Para actualizar ElementData, lo desprotejo y fijo los valores para los elementos Nihonium (113), Moscovium (115), Tennessine (118) y Oganesson (118).

Si la base de datos de Mathematica estuviera actualizada, solo requeriría 239 bytes.

S="";l=ToLowerCase;e=ElementData;r=StringReplace;A=Reverse@SortBy[Table[e[j,"Abbreviation"],{j,118}],StringLength];If[StringFreeQ[r[l@S,Table[l@A[[j]]->"",{j,118}]],Alphabet[]],r[l@S,Table[l@A[[j]]->Capitalize@e[A[[j]],"Name"],{j,118}]],S]
Jonathan Frech
fuente
6

JavaScript (ES6), 881871 bytes

Toma la cadena de entrada en mayúsculas.

s=>(o={},'HEelLIithBEeryllMGagnesCAalcTIitanVanadCRhromGAallGEermanSEelenRBubidSRtrontYttrZRirconTCechnetRUuthenRHhodPDalladCDadmTEellurBAarCEerPRraseodymNDeodymPMromethSMamarEUuropGDadolinTBerbDYysprosERrbTMhulLUutetREhenIRridTLhallFRrancRAadACctinTHhorPArotactinUranAMmericCMurESinsteinFMermMDendelevLRawrencRFutherfordDBubnSGeaborgMTeitnerDSarmstadtRGoentgenFLlerovMCoscovLVivermorHydrogenBoronCarbonNitrogenOxygenFluorineNEeonALluminumPhosphorusSulfurCLhlorineARrgonMNanganeseZNincASrsenicBRromineKRryptonMOolybdenumIodineXEenonLAanthanumTAantalumPTlatinumATstatineRNadonTSennessineOGganessonNAsodiumKpotassiumFEironAGsilverWtungstenAUgoldHGmercury'.split(/([A-Z]+|[a-z]+)/).map((r,i,a)=>i%4-3?0:o[e=a[i-2]]=i>339?r[0].toUpperCase()+r.slice(1):e[0]+r+(i<235?'ium':'')),g=([c,...s],r)=>c?c<'A'|c>'Z'?g(s,r+c):o[c]&&g(s,r+o[c])||o[c+=s.shift()]&&g(s,r+o[c]):r)(s,'')||s

Casos de prueba extendidos

Debido a que este desafío también es una variante del problema exacto del conjunto de portadas, he agregado los siguientes casos de prueba:

  • "NA" → "Sodio"
  • "NAG" → "N" + "AG" → "NitrogenSilver"
  • "NAP" → "NA" + "P" → "Fósforo de sodio"

¿Cómo?

Optimización preliminar

Ignoramos por completo los siguientes 26 elementos, porque se pueden reemplazar de forma segura con dos símbolos de un carácter entre BCFHIKNOPSUVWY:

Bh, Bi, Bk, Cf, Cn, Co, Cs, Cu, Hf, Ho, Hs, In, Nb,
Nh, Ni, No, Np, Os, Pb, Po, Pu, Sb, Sc, Si, Sn, Yb

Codificación y decodificación de los elementos.

Utilizamos una lista entrelazada de símbolos de elementos en mayúsculas y nombres de elementos en minúsculas. Los símbolos siempre se almacenan tal cual, mientras que los nombres se acortan de acuerdo con las siguientes reglas:

  1. Si la primera letra del nombre coincide con la primera letra del símbolo, la omitimos.
  2. Si el elemento pasa la regla # 1 y su nombre termina en "ium", omitimos este sufijo.

Ejemplos:

  • Ag / Plata: "AGsilver"
  • K / Potasio: "Kpotassium"
  • Zn / Zinc: "ZNinc"
  • Él / Helio: "HEEL"

Los 58 elementos que activan ambas reglas se almacenan al principio de la lista, seguidos de los 27 elementos que activan solo la regla # 1, seguidos de los 7 elementos que no activan ninguna regla.

Decodificamos esta lista para llenar la tabla de búsqueda o , donde las claves son los símbolos y los valores son los nombres de los elementos decodificados:

"HEelLIith[...]HGmercury"       // encoded list
.split(/([A-Z]+|[a-z]+)/)       // split it by character case, which gives:
                                // [ '', 'HE', '', 'el', '', 'LI', '', 'ith', etc. ]
.map((r, i, a) =>               // for each item 'r' at position 'i' in this array 'a':
  i % 4 - 3 ?                   //   if we're not currently pointing to an element name:
    0                           //     do nothing
  :                             //   else:
    o[e = a[i - 2]] =           //     save o[e], where e = element symbol
      i > 339 ?                 //     if symbol/name first letters do not match:
        r[0].toUpperCase() +    //       we need to capitalize the first letter of the name
        r.slice(1)              //       and keep the rest unchanged
      :                         //     else:
        e[0] +                  //       we use the first letter of the symbol,
        r +                     //       followed by the name,
        (i < 235 ? 'ium' : '')  //       followed by the 'ium' suffix when appropriate
)                               // end of map()

Cubriendo la cadena de entrada

Intentamos reemplazar todas las letras mayúsculas en la cadena de entrada con símbolos de elementos, utilizando la función recursiva g () que eventualmente devuelve una cadena de reemplazo o indefinida si no se encuentra una cubierta exacta:

g = ([c,                                  // c = next character
         ...s],                           // s = array of remaining characters
                r) =>                     // r = replacement string
  c ?                                     // if there's still at least one character:
    c < 'A' | c > 'Z' ?                   //   if it's not an upper-case letter:
      g(s, r + c)                         //     just append it to 'r'
    :                                     //   else:
      o[c] && g(s, r + o[c]) ||           //     try to find a symbol matching 'c'
      o[c += s.shift()] && g(s, r + o[c]) //     or a symbol matching 'c' + the next char.
  :                                       // else:
    r                                     //   success: return 'r'
Arnauld
fuente
2

Javascript, 1487 1351 1246 1170 1243 1245 bytes

ahorró 234 bytes gracias a @ musicman523

ahorró 174 bytes gracias a @ovs

ahorró 7 bytes gracias a @Shaggy

se agregaron 75 bytes para que funcione para elementos de 2 letras

b=>~((o=0,d=Array.from([...b].map((u,i,a)=>(h=e=>("he0Hel2h0Hydrogen1li0Lith2be0Beryll2b0Boron1c0Carbon1n0Nitrogen1o0Oxygen1f0Fluorine1ne0Neon1na0Sod2mg0Magnes2al0Aluminum1p0Phosphorus1s0Sulfur1cl0Chlorine1ar0Argon1k0Potass2ca0Calc2ti0Titan2v0Vanad2cr0Chrom2mn0Manganese1fe0Iron1ni0Nickel1cu0Copper1zn0Zinc1ga0Gall2ge0German2as0Arsenic1se0Selen2br0Bromine1kr0Krypton1rb0Rubid2sr0Stront2y0Yttr2zr0Zircon2nb0Niob2mo0Molybdenum1tc0Technet2ru0Ruthen2rh0Rhod2pd0Pallad2ag0Silver1cd0Cadm2in0Ind2te0Tellur2i0Iodine1xe0Xenon1cs0Ces2ba0Bar2la0Lanthanum1ce0Cer2pr0Praseodym2nd0Neodym2pm0Prometh2sm0Samar2eu0Europ2gd0Gadolin2tb0Terb2dy0Dyspros2ho0Holm2er0Erb2tm0Thul2lu0Lutet2hf0Hafn2ta0Tantalum1w0Tungsten1re0Rhen2ir0Irid2pt0Platinum1au0Gold1hg0Mercury1tl0Thall2at0Astatine1rn0Radon1fr0Franc2ra0Rad2ac0Actin2th0Thor2pa0Protactin2u0Uran2np0Neptun2pu0Pluton2am0Americ2cm0Cur2bk0Berkel2cf0Californ2es0Einstein2fm0Ferm2md0Mendelev2no0Nobel2lr0Lawrenc2rf0Rutherford2db0Dubn2sg0Seaborg2bh0Bohr2hs0Hass2mt0Meitner2ds0Darmstadt2rg0Roentgen2nh0Nihon2fl0Flerov2mc0Moscov2lv0Livermor2ts0Tennessine1og0Oganesson".replace(/2/g,'ium1').split(1).map(a=>a.split(0)).find(a=>a[0]==e)||[,0])[1],o?(o=0,''):((p=a[i+1])&&(o=1,h(u+p))||(o=0,h(u)))))).join``).search(0))?b:d

(Un poco más) versión legible:

b=>~((o=0,d=Array.from([...b].map((u,i,a)=>(h=e=>(
"he0Hel2h0Hydrogen1li0Lith2be0Beryll2b0Boron1c0Carbon1n0Nitrogen1o0Oxygen1f0Flu            
orine1ne0Neon1na0Sod2mg0Magnes2al0Aluminum1p0Phosphorus1s0Sulfur1cl0Chlorine1ar0
Argon1k0Potass2ca0Calc2ti0Titan2v0Vanad2cr0Chrom2mn0Manganese1fe0Iron1ni0Nickel1
cu0Copper1zn0Zinc1ga0Gall2ge0German2as0Arsenic1se0Selen2br0Bromine1kr0Krypton1rb
0Rubid2sr0Stront2y0Yttr2zr0Zircon2nb0Niob2mo0Molybdenum1tc0Technet2ru0Ruthen2rh0
Rhod2pd0Pallad2ag0Silver1cd0Cadm2in0Ind2te0Tellur2i0Iodine1xe0Xenon1cs0Ces2ba0Ba
r2la0Lanthanum1ce0Cer2pr0Praseodym2nd0Neodym2pm0Prometh2sm0Samar2eu0Europ2gd0Gad
olin2tb0Terb2dy0Dyspros2ho0Holm2er0Erb2tm0Thul2lu0Lutet2hf0Hafn2ta0Tantalum1w0Tu
ngsten1re0Rhen2ir0Irid2pt0Platinum1au0Gold1hg0Mercury1tl0Thall2at0Astatine1rn0Ra
don1fr0Franc2ra0Rad2ac0Actin2th0Thor2pa0Protactin2u0Uran2np0Neptun2pu0Pluton2am0
Americ2cm0Cur2bk0Berkel2cf0Californ2es0Einstein2fm0Ferm2md0Mendelev2no0Nobel2lr0
Lawrenc2rf0Rutherford2db0Dubn2sg0Seaborg2bh0Bohr2hs0Hass2mt0Meitner2ds0Darmstadt
2rg0Roentgen2nh0Nihon2fl0Flerov2mc0Moscov2lv0Livermor2ts0Tennessine1og0Oganesson
".replace(/2/g,'ium1').split(1).map(a=>a.split(0)).find(a=>a[0]==e)||[,0])[1],o?
(o=0,''):((p=a[i+1])&&(o=1,h(u+p))||(o=0,h(u)))))).join``).search(0))?b:d
SuperStormer
fuente
"versión legible", sí, totalmente legible. Buen trabajo sin embargo. Este será un desafío intensivo en bytes para cualquier idioma que no tenga elementos incorporados (cualquier cosa que no sea Mathematica).
Gryphon
1
¿Se puede factorizar "ium" para guardar bytes?
musicman523
Esa es una buena idea, @ musicman523
Gryphon
@Gryphon También podrías intentar factorizar on . Además, si desea que sea más legible para los humanos, use más delineadores legibles que 0y 1. Por ejemplo, cualquiera de ,;.!/-_:~ *|=+'".
DanTheMan
1
Esto no puede identificar elementos de 2 caracteres en la cadena de entrada.
Arnauld