In questa sfida, il tuo compito è quello di prendere un anione e un catione e produrre la formula chimica del composto. L'input segue queste regole:

• Prendere in 2 stringhe (in qualsiasi ordine) che rappresentano l'anione e cationi, per esempio F, NH_4o Al.
• Per assumere la carica di ogni ione, puoi averlo come parte della stringa separata da un punto di inserimento (ad es. F^-1) O prendere ulteriori argomenti numerici.
  • Nota: finché il tipo di input numerico è firmato, la carica dell'anione verrà trasmessa come numero negativo.
• I simboli saranno sempre reali e le cariche accurate.

L'output dovrebbe seguire queste regole:

• Utilizzare _per i pedici: Fe ₂ O ₃ sarebbe Fe_2O_3.
• Prima il catione: NaCl, non ClNa.
• Molecola neutra: Li ₂ O, non LiO o LiO ^- .
• Coefficienti più bassi possibili: Fe ₂ O ₃ , non Fe ₄ O ₆ .
• Nessun pedice: NaCl, non Na ₁ Cl ₁ .
• Nessun spostamento: NH ₄ OH, non NH ₅ O.
• Parentesi condizionali:
  • Non usare le parentesi su uno ione a singolo atomo: MgCl ₂ , non Mg (Cl) ₂ .
  • Non usare le parentesi se esiste solo uno degli ioni per molecola: KClO ₃ , non K (ClO ₃ ).
  • Usa le parentesi se ci sono due o più di uno ione poliatomico: Be ₃ (PO ₄ ) ₂ , non Be ₃ PO _{4 2} o Be ₃ P ₂ O ₈ .

Ecco alcuni input e output di esempio aggiuntivi:

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

Dato che si tratta di code-golf , vince la risposta più breve in byte.

APL (Dyalog) , 60 59 61 byte

+2 poiché gli addebiti devono essere dati firmati.

Funzione infix anonima. Prende un elenco di ioni (anione, catione) come argomento di sinistra e un elenco di cariche corrispondenti come argomento di destra.

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

Provalo online!

{... }∘| funzione dove ⍺è l'argomento sinistro ed ⍵è la grandezza dell'argomento giusto:

 ∧/⍵ LCM delle accuse

 ⍵÷⍨ dividere le accuse per quello

 s← negozio a s(per i ubscripts)

 '_',∘⍕¨ formattare (stringere) e anteporre la barra di scorrimento a ciascuno

 (... )/ replica ogni lettera di ciascuna con il valore corrispondente da:

  s≠1 È sdiverso da 1? (dà 1 o 0)

  m← conservare in m(per m ultiple)

 (... ),¨ anteponi rispettivamente quanto segue a quelli:

  ⍺{... }¨m per ciascuno, chiama questa funzione con ioni e mcome argomenti:

   ⎕D,⎕A D igits seguita da un alfabeto maiuscolo

   ⍺∩ intersezione di ioni e quello

   ≢ calcola il numero di personaggi in quello

   1< Uno in meno? (cioè abbiamo uno ione multi-elemento?)

   ⍵∧ e abbiamo bisogno del multiplo di quello ione?

   : in tal caso, quindi:

    ')(',⍺ anteporre la stringa allo ione

    1⌽ ruota ciclicamente di un passo verso sinistra (mette )a destra)

   ⋄ altro

    ⍺ restituisce lo ione non modificato

 ∊ ϵ nlist (appiattisci)

C, 208 205 175 169 byte

argv[1]: cation
argv[2]: anion Le
cariche di ioni sono prese su 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 byte

Grazie a Neil per aver salvato 6 byte.

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

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

Provalo online!

L'input è separato da avanzamento riga (la suite di test utilizza la separazione virgola per comodità).

Spiegazione

^
(

Iniziamo anteponendo (a ciascuna molecola. Gli ^abbinamenti on line iniziano perché m)verso la fine del programma imposta la modalità multilinea per tutte le fasi precedenti.

\^.+
)_$&$*

Sostituiamo la ^[-+]nparte con )_, seguita da ncopie di 1(cioè convertiamo le accuse in unario, facendo cadere i segni).

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

Questa fase fa tre cose: divide entrambe le cariche dal loro GCD, le converte in decimali e le scambia. Il GCD può essere trovato abbastanza facilmente in regex, abbinando il più lungo 1+che ci consente di abbinare entrambe le cariche usando solo il backreference \1. Per dividere per questo, utilizziamo la funzione "numero di acquisizione" di Retina, che ci dice quanto spesso un gruppo è stato usato. Così $#2è la prima carica divisa per il GCD ed $#3è la seconda carica divisa per il GCD (entrambi in decimale).

_1$

Rimuoviamo le _1s dalle estremità di entrambe le parti.

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

E lasciamo cadere le parentesi dalle linee che finiscono in un )(cioè quelle che avevano un _1lì), così come le linee che contengono solo un singolo atomo.

¶

Infine, concateniamo le due molecole facendo cadere l'alimentazione di linea.

Haskell , 101 97 byte

(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

Provalo online! Esempio di utilizzo: Fe^+3, O^-2è considerato come ("Fe"#"O")3 2.

Python 3 , 131 byte

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]

Provalo online!

Python 2 , 196 174 170 155 149 140 136 byte

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]

Provalo online!

Python 3 , 129 byte

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*

Provalo online!

Se dobbiamo gestire cariche negative degli anioni, quindi 153 byte:

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*

Provalo online!

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

Sì, presentazione ridicolmente grande, non sono sicuro di quanto competitivo sarà ...

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 routine impacchettate ordinatamente in una directory. Mè il principale. Si aspetta 2 stringhe nello stack formattate come ioni e inserisce una stringa di molecole nello stack.

Sdivide lo ione in carica come numero e la formula dell'elemento come stringa. Ad esempio, "PO_4^-3"verrebbe preso dallo stack -3e "PO_4"inserito nello stack.

Junisce il numero di ioni con la formula e decide se racchiudere la formula tra parentesi. Il bit precedente ELSEriguarda 1 ione, lasciando la stringa così com'è. Ad esempio, se 1e "PO_4"sono in pila, vengono sostituiti da "PO_4". 1e "H"dà "H".

Il resto riguarda più ioni; se è un singolo atomo non è tra parentesi, altrimenti lo è. Per decidere se lo è, controllo la lunghezza della stringa e controllo se l'ultimo carattere è >"Z". Le espressioni booleane restituiscono 1 per true e 0 per false. Sottraendo il risultato di questo confronto dalla lunghezza della stringa, ottengo 1 o meno quando è un singolo atomo, altrimenti più: la lunghezza 1 è un singolo atomo; la lunghezza 2 avrà una lettera come ultimo carattere; per un singolo atomo è minuscolo, quindi >"Z", ottenendo il risultato 1, altrimenti 2; lunghezza 3 o più significa più di 1 atomo e con 0 o 1 sottratto dalla lunghezza il risultato sarà almeno 2. Ad esempio, 3e "PO_4"dà "(PO_4)_3". 3e "Al"dà "Al_3".

Mprima divide ogni ione usando S. Dopo la prima riga, il livello 5 della pila (quindi l'oggetto sepolto più profondo) contiene la carica del secondo ione, la formula del secondo ione di livello 4, la formula del primo ione di livello 3, il valore assoluto del livello 2 della carica del primo ione e il valore assoluto del livello 1 della carica del secondo ione. Ad esempio, se trovati ioni sulla pila sono "Al^+3", "SO_4^-2"otteniamo -2, "SO_4", "Al", 3, 2.

La seconda riga calcola gcd delle 2 cariche (lasciando intatte le cariche).

La terza riga divide ciascuna carica per gcd (per calcolare i multipli) e la unisce con la formula dello ione usando J. Quindi abbiamo due stringhe ciascuna con un dato ione con carica rimossa (o un multiplo di essa) e una carica della seconda sepolta dietro di loro. Ad esempio, -2, "Al_2", "(SO_4)_3"(-2 è la carica di SO_4).

La quarta riga toglie la carica e se è positiva scambia le due stringhe (in modo che il catione venga prima) prima di unirle. Così, nell'esempio di cui sopra, perché è negativo, si sono uniti in ordine in cui sono: "Al_2(SO_4)_3".

JavaScript, 145 byte

(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,"")

Prende argomenti cè catione, aè anione, pè carica positiva, nè carica negativa.