Nesse desafio, sua tarefa é pegar um ânion e um cátion e produzir a fórmula química do composto. A entrada segue estas regras:

• Tome em 2 cadeias (em qualquer ordem) que representam o ani e cati, por exemplo F, NH_4, ou Al.
• Para assumir a carga de cada íon, você pode tê-lo como parte da cadeia de caracteres separada por um sinal de intercalação (por exemplo F^-1) ou receber argumentos numéricos adicionais.
  • Nota: Enquanto seu tipo de entrada numérica for assinado, a carga do ânion será repassada como um número negativo.
• Os símbolos sempre serão reais e cobram com precisão.

A saída deve seguir estas regras:

• Use _para subscritos: Fe ₂ O ₃ seria Fe_2O_3.
• Catião primeiro: NaCl, não ClNa.
• Molécula neutra: Li ₂ O, não LiO ou LiO ^- .
• Coeficientes mais baixos possíveis: Fe ₂ O ₃ , não Fe ₄ O ₆ .
• Nenhum subscrito: NaCl, não Na ₁ Cl ₁ .
• Sem mudança: NH ₄ OH, não NH ₅ O.
• Parênteses condicionais:
  • Não use parênteses em um íon de átomo único: MgCl ₂ , não Mg (Cl) ₂ .
  • Não use parênteses se houver apenas um íon por molécula: KClO ₃ , não K (ClO ₃ ).
  • NÃO use parênteses se houver dois ou mais íons poliatômicos: Seja ₃ (PO ₄ ) ₂ , não seja ₃ PO _{4 2} ou Seja ₃ P ₂ O ₈ .

Aqui estão algumas entradas e saídas de amostra adicionais:

Input               Output
Fe^+3, O^-2         Fe_2O_3
Fe^+2, O^-2         FeO
H^+1, SO_4^-2       H_2SO_4
Al^+3, SO_4^-2      Al_2(SO_4)_3
NH_4^+1, SO_4^-2    (NH_4)_2SO_4
Hg_2^+2, PO_4^-3    (Hg_2)_3(PO_4)_2
NH_4^+1, OH^-1      NH_4OH
Hg_2^+2, O_2^-2     Hg_2O_2

Como esse é o código-golfe , a resposta mais curta em bytes vence.

APL (Dyalog) , 60 59 61 bytes

+2, pois as cobranças devem ser assinadas.

Função de infixo anônimo. Toma a lista de íons (ânion, cátion) como argumento à esquerda e lista de cargas correspondentes como argumento à direita.

{∊(⍺{⍵∧1<≢⍺∩⎕D,⎕A:1⌽')(',⍺⋄⍺}¨m),¨(m←s≠1)/¨'_',∘⍕¨s←⍵÷⍨∧/⍵}∘|

Experimente online!

{… }∘| Funciona onde ⍺fica o argumento esquerdo e ⍵a magnitude do argumento direito:

 ∧/⍵ LCM das cobranças

 ⍵÷⍨ dividir as acusações por que

 s← armazenar em s(para s ubscripts)

 '_',∘⍕¨ formato (stringify) e acrescente a barra inferior a cada

 (… )/ Replique cada letra de cada uma com o valor correspondente de:

  s≠1 É sdiferente de 1? (dá 1 ou 0)

  m← armazenar em m(para m últiplo)

 (… ),¨ Acrescente o seguinte, respectivamente, aos seguintes:

  ⍺{… }¨m Para cada um, chame essa função com íons e mcomo argumentos:

   ⎕D,⎕A D igits seguido por letras maiúsculas A lphabet

   ⍺∩ interseção de íons e que

   ≢ contabilizar o número de caracteres nesse

   1< Um a menos que isso? (ou seja, temos um íon de vários elementos?)

   ⍵∧ e precisamos de múltiplos desse íon?

   : Se sim, então:

    ')(',⍺ coloque a corda no íon

    1⌽ gire ciclicamente um passo para a esquerda (coloca )à direita)

   ⋄ outro

    ⍺ devolver o íon não modificado

 ∊ ε nlist (achatar)

C, 208 205 175 169 bytes

argv[1]: cation
argv[2]: anion As
cargas de íons são cobradas em stdin.

#define z(b)for(i=*++v;*++i>95;);printf(b>1?*i?"(%s)_%d":"%s_%d":"%s",*v,b);
main(c,v,d,e,g,h,i)char**v,*i;{scanf("%d%d",&c,&d);for(e=c,h=-d;g=h;e=g)h=e%g;z(-d/e)z(c/e)}

Retina , 86 80 bytes

Agradecimentos a Neil por salvar 6 bytes.

^
(
\^.+
)_$&$*
(1+)(\1|¶.+)+_(\1)+$
$#3$2_$#2
_1$

m)T`()``.+\)$|\(.[a-z]?\)
¶

Experimente online!

A entrada é separada por alimentação de linha (a suíte de testes usa separação por vírgula por conveniência).

Explicação

^
(

Começamos anexando a (a cada molécula. As ^correspondências no início da linha porque, no m)final do programa, define o modo de múltiplas linhas para todas as etapas anteriores.

\^.+
)_$&$*

Substituímos a ^[-+]npeça por )_, seguida de ncópias de 1(ou seja, convertemos as cobranças em unárias, eliminando os sinais).

(1+)(\1|¶.+)+_(\1)+$
$#3$2_$#2

Essa etapa faz três coisas: divide as duas cargas pelo seu CDG, converte-as novamente em decimal e as troca. O GCD pode ser encontrado facilmente no regex, correspondendo ao mais longo 1+que permite combinar as duas cobranças usando apenas a referência anterior \1. Para dividir por isso, usamos o recurso "contagem de capturas" de Retina, que nos diz com que frequência um grupo foi usado. Assim $#2é a primeira carga dividida pelo GCD e $#3a segunda carga dividida pelo GCD (ambos em decimal).

_1$

Removemos _1s das extremidades de ambas as partes.

m)T`()``.+\)$|\(.[a-z]?\)

E eliminamos os parênteses das linhas que terminam em a )(ou seja, aquelas que tinham um _1lá), bem como as linhas que contêm apenas um único átomo.

¶

Por fim, concatenamos as duas moléculas soltando o avanço de linha.

Haskell , 101 97 bytes

(s#t)n m|let x#i|j<-div(lcm n m)i=l$x:[l(x:['(':x++")"|l x<':'])++'_':show j|j>1]=s#n++t#m
l=last

Experimente online! Exemplo de uso: Fe^+3, O^-2é tomado como ("Fe"#"O")3 2.

Python 3 , 131 bytes

lambda c,a,C,A:g(c,A/gcd(C,A))+g(a,C/gcd(C,A))
from math import*
g=lambda s,n:[s,[s,'(%s)'%s][sum(c<'`'for c in s)>1]+'_%d'%n][n>1]

Experimente online!

Python 2 , 196 174 170 155 149 140 136 bytes

lambda c,a,C,A:g(c,A/gcd(C,A))+g(a,C/gcd(C,A))
from fractions import*
g=lambda s,n:[s,[s,'(%s)'%s][sum(c<'`'for c in s)>1]+'_'+`n`][n>1]

Experimente online!

Python 3 , 129 bytes

lambda E,e,I,i,m=lambda e,i:(len(e)>2<=i)*"("+e+(len(e)>2<=i)*")"+"_%d"%i*(i>1):m(E,i/gcd(i,I))+m(e,I/gcd(i,I))
from math import*

Experimente online!

Se precisarmos lidar com cargas negativas dos ânions, então 153 bytes:

lambda E,e,I,i,a=abs,m=lambda e,i:(len(e)>2<=i)*"("+e+(len(e)>2<=i)*")"+"_%d"%i*(i>1):m(E,a(i)/gcd(a(i),a(I)))+m(e,a(I)/gcd(a(i),a(I)))
from math import*

Experimente online!

RPL (HP48 S / SX), 294,5 bytes

Sim, envio ridiculamente grande, não tenho certeza de quão competitivo será ...

DIR
  M
    « S ROT S SWAP ABS 4 PICK ABS
      DUP2 WHILE DUP2 REPEAT MOD SWAP END DROP2
      SWAP OVER / 4 ROLL J 3 ROLLD / ROT J
      ROT 0 > IF THEN SWAP END + »
  S
    « DUP "^" POS DUP2 1 + OVER SIZE SUB OBJ🡢
      3 ROLLD 1 - 1 SWAP SUB »
  J
    IF OVER 1 ==
    THEN SWAP DROP
    ELSE DUP SIZE DUP2 DUP SUB "Z" > - 1 >
      IF
      THEN "(" SWAP + ")" +
      END
      "_" + SWAP +
    END
END

3 rotinas empacotadas ordenadamente em um diretório. Mé o principal. Ele espera duas strings na pilha formatadas como íons e empurra uma string de molécula para a pilha.

Sdivide o íon em carga como um número e a fórmula do elemento como uma string. Por exemplo, "PO_4^-3"seria retirado da pilha -3e "PO_4"empurrado para a pilha.

June o número de íons à fórmula e decide se a fórmula deve ser colocada entre colchetes. O bit anterior ELSEtrata de 1 íon, deixando a corda como está. Por exemplo, se 1e "PO_4"estiverem na pilha, eles serão substituídos por "PO_4". 1e "H"dá"H" .

O resto lida com vários íons; se é um átomo único, não está entre parênteses, caso contrário, é. Para decidir se é, verifico o comprimento da sequência e verifico se o último caractere é >"Z". Expressões booleanas retornam 1 para verdadeiro e 0 para falso. Subtraindo o resultado dessa comparação do comprimento da string, obtenho 1 ou menos quando é único átomo, caso contrário, mais: length 1 é um único átomo; o comprimento 2 terá uma letra como último caractere; para um único átomo, está em minúsculas, >"Z"resultando em 1, caso contrário 2; comprimento 3 ou mais significa mais de 1 átomo e com 0 ou 1 subtraído do comprimento, o resultado será pelo menos 2. Por exemplo, 3e "PO_4"dá "(PO_4)_3". 3e "Al"dá "Al_3".

Mprimeiro divide cada íon usando S. Após a primeira linha, o nível 5 da pilha (portanto, o objeto mais profundo do corpo) contém carga do segundo íon, fórmula do segundo íon nível 4, fórmula do primeiro íon nível 3, valor absoluto do nível 2 da carga do primeiro íon e valor absoluto do nível 1 da carga do segundo íon novamente. Por exemplo, se dadas íons na pilha são "Al^+3", "SO_4^-2", obtemos -2, "SO_4", "Al", 3, 2.

A segunda linha calcula o MDC das 2 cobranças (deixando as cobranças intactas).

A terceira linha divide cada carga pelo MDC (para calcular os múltiplos) e a une à fórmula do íon usando J. Portanto, temos duas cordas, cada uma com um dado íon com carga removida (ou um múltiplo) e uma carga da segunda enterrada atrás deles. Por exemplo, -2, "Al_2", "(SO_4)_3"(-2 é a carga de SO_4).

A quarta linha libera a carga e, se for positiva, troca as duas cordas (para que o cátion seja o primeiro) antes de se juntar a elas. Assim, no exemplo acima, porque é negativo, eles são unidos na ordem em que são: "Al_2(SO_4)_3".

JavaScript, 145 bytes

(c,a,p,n,g=(a,b)=>b?g(b,a%b):a)=>`(${c})_${n/-g(p,-n)}(${a})_${p/g(p,-n)}`.replace(/\(((\w+)\)(?=_1)|([A-Z][a-z]*)\))/g,"$2$3").replace(/_1/g,"")

Toma argumentos cé cátion, aé ânion, pé carga positiva, né carga negativa.