Mensagem Secreta Parte 1, Elementos


8

Você e seu amigo querem enviar mensagens secretas um ao outro. No entanto, porque vocês são teóricos da conspiração e pensam que o governo possui um computador quântico que pode quebrar qualquer criptografia padrão. Portanto, você está inventando um dos seus. A primeira etapa é a seguinte: usando uma sequência de entrada, você verifica se todas as letras podem ser representadas pelos símbolos dos elementos da tabela periódica (sem distinção entre maiúsculas e minúsculas). Se possível, substitua cada seção pelo nome do elemento que o símbolo representa. Se todas as letras não puderem ser substituídas dessa maneira, basta usar a sequência original.

Sua tarefa:

Você deve escrever um programa ou função que codifique uma mensagem, conforme descrito anteriormente. Lembre-se de que se o seu programa buscar dados de uma fonte externa, o tamanho da fonte externa deverá ser adicionado à contagem de bytes ( essa brecha ). Os elementos e símbolos usados ​​estão aqui:

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:

Uma sequência a ser codificada. Você pode usar isso em maiúsculas ou minúsculas, se desejar, desde que você especifique esse requisito em sua resposta.

Resultado:

A sequência, codificada conforme descrito anteriormente, se possível.

Exemplos:

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

Pontuação:

Este é o , o código mais curto em bytes vence!


Comentários não são para discussão prolongada; esta conversa foi movida para o bate-papo .
Dennis

Todos podem considerar os elementos e símbolos como um dicionário como entrada, porque, a partir de agora, esse desafio é basicamente sobre comprimir isso?
Daniel

@Dopapp, não, pois isso tornaria as respostas que já foram enviadas e as pessoas trabalharam muito, completamente não competitivas. Comprimir os elementos sempre seria o maior desafio de qualquer maneira.
Gryphon

Respostas:


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 o banco de dados interno do Mathematica para buscar nomes de elementos e suas abreviações. A entrada pode ser misturada em maiúsculas e minúsculas e é armazenada na variávelS . A saída é o resultado da expressão, não é impressa explicitamente.

No momento, o código totalmente funcional ocupa 404 bytes, pois o banco de dados químico interno do Mathematica está um pouco atrasado. ElementData[118, "Name"]retorna em ununoctiumvez de oganesson(os elementos super pesados ​​onde apenas recentemente nomeados corretamente, ununoctium era um nome de espaço reservado para o elemento 118).
Para atualizá-lo ElementData, desprotego-o e fixo os valores dos elementos Nihonium (113), Moscovium (115), Tennessine (118) e Oganesson (118).

Se o banco de dados do Mathematica estivesse atualizado, eu exigiria apenas 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]

6

JavaScript (ES6), 881 871 bytes

Leva a string de entrada em maiú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 teste estendidos

Como esse desafio também é uma variante do problema exato do conjunto de capas, adicionamos os seguintes casos de teste:

  • "NA" → "Sódio"
  • "NAG" → "N" + "AG" → "NitrogenSilver"
  • "NAP" → "NA" + "P" → "fósforo de sódio"

Quão?

Otimização preliminar

Ignoramos completamente os 26 elementos a seguir, porque eles podem ser substituídos com segurança por dois símbolos de um caractere 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

Codificando e decodificando os elementos

Usamos uma lista entrelaçada de símbolos de elementos em maiúsculas e nomes de elementos em minúsculas. Os símbolos são sempre armazenados como estão, enquanto os nomes são reduzidos de acordo com as seguintes regras:

  1. Se a primeira letra do nome corresponder à primeira letra do símbolo, o omitimos.
  2. Se o elemento passar na regra 1 e seu nome terminar em "ium", omitimos esse sufixo.

Exemplos:

  • AG / Prata: "AGsilver"
  • K / Potássio: "Kpotássio"
  • Zn / Zinco: "ZNinc"
  • He / Hélio: "Calcanhar"

Os 58 elementos que acionam as duas regras são armazenados no início da lista, seguidos pelos 27 elementos que acionam apenas a regra nº 1, seguidos pelos 7 elementos que não acionam nenhuma regra.

Decodificamos esta lista para preencher a tabela de pesquisa o , onde as chaves são os símbolos e os valores são os nomes dos 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()

Cobrindo a sequência de entrada

Tentamos substituir todas as letras maiúsculas na string de entrada por símbolos de elementos, usando a função recursiva g () que eventualmente retorna uma string de substituição ou indefinida se nenhuma capa exata for encontrada:

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'

2

Javascript, 1487 1351 1246 1170 1243 1245 bytes

economizou 234 bytes graças a @ musicman523

salvou 174 bytes graças a @ovs

economizou 7 bytes graças a @Shaggy

adicionado 75 bytes para fazê-lo funcionar com 2 elementos de letra

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

(Um pouco mais) versão legível:

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

"versão legível", sim, totalmente legível. Bom trabalho embora. Esse será um desafio com muitos bytes para qualquer idioma que não tenha elementos internos (qualquer coisa que não seja o Mathematica).
Gryphon

1
Você pode fatorar "ium" para salvar bytes?
precisa

Essa é uma boa ideia, @ musicman523
Gryphon

@ Gregry Você também pode tentar fatorar on. Além disso, se você quiser torná-lo mais legível por humanos, use delineadores mais legíveis que 0e 1. Por exemplo, qualquer um ,;.!/-_:~ *|=+'".
DanTheMan

1
Isso falha ao identificar elementos de 2 caracteres na sequência de entrada.
Arnauld
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.