W tym wyzwaniu Twoim zadaniem jest zabranie anionu i kationu i dostarczenie wzoru chemicznego związku. Dane wejściowe są zgodne z następującymi zasadami:

• Objąć 2 łańcuchów (w dowolnej kolejności) reprezentujących anionu i kationu, na przykład F, NH_4, lub Al.
• Aby przejąć kontrolę nad każdym jonem, możesz albo umieścić go jako część łańcucha oddzielonego znakiem karetki (np. F^-1), Albo wziąć dodatkowe argumenty liczbowe.
  • Uwaga: tak długo, jak długo wprowadzany jest typ numeryczny, ładunek anionu będzie przekazywany jako liczba ujemna.
• Symbole zawsze będą prawdziwe, a opłaty dokładne.

Dane wyjściowe powinny być zgodne z następującymi regułami:

• Użyj _dla indeksów dolnych: byłoby Fe ₂ O ₃Fe_2O_3 .
• Najpierw kation: NaCl, a nie ClNa.
• Cząsteczka neutralna: Li ₂ O, nie LiO ani LiO ^- .
• Najniższe możliwe współczynniki: Fe ₂ O ₃ , a nie Fe ₄ O ₆ .
• Brak indeksów dolnych: NaCl, nie Na ₁ Cl ₁ .
• Bez zmian: NH ₄ OH, nie NH ₅ O.
• Nawiasy warunkowe:
  • Nie należy stosować w nawiasach na jon pojedynczego atomu: MgCl ₂ , nie mg (Cl) ₂ .
  • Nie używaj nawiasów, jeśli na cząsteczkę przypada tylko jeden jon: KClO ₃ , a nie K (ClO ₃ ).
  • NALEŻY używać nawiasów, jeśli występują dwa lub więcej jonów wieloatomowych: Be ₃ (PO ₄ ) ₂ , a nie Be ₃ PO _{4 2} lub Be ₃ P ₂ O ₈ .

Oto kilka dodatkowych przykładowych danych wejściowych i wyjściowych:

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

Ponieważ jest to gra w golfa , wygrywa najkrótsza odpowiedź w bajtach.

APL (Dyalog) , 60 59 61 bajtów

+2, ponieważ opłaty muszą być podpisane.

Anonimowa funkcja poprawki. Pobiera listę jonów (anion, kation) jako lewy argument i listę odpowiadających ładunków jako prawy argument.

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

Wypróbuj online!

{… }∘| Funkcja, w której ⍺argument jest lewy, a ⍵wielkość argumentu prawy:

 ∧/⍵ LCM opłat

 ⍵÷⍨ podziel przez to opłaty

 s← przechowuj w s(dla s skryptu)

 '_',∘⍕¨ sformatuj (stringify) i wstaw do każdego z nich podkreślenie

 (… )/ Powiel każdą literę z odpowiednią wartością z:

  s≠1 Czy sróżni się od 1? (daje 1 lub 0)

  m← przechowuj w m(dla m ultiple)

 (… ),¨ Dołącz odpowiednio następujące:

  ⍺{… }¨m Dla każdego wywołaj tę funkcję z jonami i mjako argumentami:

   ⎕D,⎕A D igits następnie wielkie lphabet

   ⍺∩ przecięcie jonu i tamto

   ≢ oblicz liczbę znaków w tym

   1< Czy jest jeden mniej niż to? (tj. czy mamy jon wieloelementowy?)

   ⍵∧ i czy potrzebujemy wielokrotności tego jonu?

   : jeśli tak, to:

    ')(',⍺ przyłóż łańcuch do jonu

    1⌽ cyklicznie obracaj jeden krok w lewo (kładzie )się po prawej)

   ⋄ jeszcze

    ⍺ zwróć jon niezmodyfikowany

 ∊ ε nlist (spłaszczyć)

C 208 205 175 169 bajtów

argv[1]: kation
argv[2]: anion
Ładunki jonów są pobierane na standardowe 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)}

Siatkówka , 86 80 bajtów

Dzięki Neil za oszczędność 6 bajtów.

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

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

Wypróbuj online!

Dane wejściowe są oddzielone od linii (zestaw testowy wykorzystuje separację przecinkową dla wygody).

Wyjaśnienie

^
(

Zaczynamy od przygotowania (do każdej cząsteczki. Te ^mecze na linii początków ponieważ m)kierunku końca programu ustawia tryb wielowierszowego na wszystkich poprzednich etapach.

\^.+
)_$&$*

Zamieniamy ^[-+]nczęść na )_, a następnie nkopie 1(tj. Przekształcamy opłaty na jednostkowe, zrzucając znaki).

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

Ten etap robi trzy rzeczy: dzieli oba ładunki przez ich GCD, konwertuje je z powrotem na dziesiętne i zamienia. GCD można dość łatwo znaleźć w wyrażeniu regularnym, dopasowując najdłuższy, 1+który pozwala dopasować oba ładunki przy użyciu tylko referencji wstecznej \1. Aby to podzielić, korzystamy z funkcji „liczby przechwytywania” Retiny, która mówi nam, jak często grupa była używana. Podobnie $#2jest z pierwszym ładunkiem podzielonym przez GCD i $#3drugim ładunkiem podzielonym przez GCD (oba w systemie dziesiętnym).

_1$

Usuwamy _1s z końców obu części.

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

I usuwamy nawiasy z linii, które kończą się na a )(tj. Tych, które miały _1tam), a także linii, które zawierają tylko jeden atom.

¶

Na koniec łączymy dwie cząsteczki przez upuszczenie linii.

Haskell , 101 97 bajtów

(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

Wypróbuj online! Przykładowe użycie: Fe^+3, O^-2przyjmuje się jako ("Fe"#"O")3 2.

Python 3 , 131 bajtów

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]

Wypróbuj online!

Python 2 , 196 174 170 155 149 140 136 bajtów

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]

Wypróbuj online!

Python 3 , 129 bajtów

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*

Wypróbuj online!

Jeśli musimy poradzić sobie z ujemnymi ładunkami anionów, to 153 bajty:

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*

Wypróbuj online!

RPL (HP48 S / SX), 294,5 bajtów

Tak, absurdalnie duże zgłoszenie, nie jestem pewien, czy będzie konkurencyjne ...

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 procedury starannie zapakowane w katalogu. Mjest główny. Oczekuje 2 łańcuchów na stosie sformatowanych jako jony i popycha łańcuch cząsteczek na stos.

Sdzieli jon na ładunek jako liczbę, a formułę elementu jako ciąg. Na przykład "PO_4^-3"byłby wzięty ze stosu -3i "PO_4"wrzucony na stos.

Jłączy liczbę jonów ze wzorem i decyduje, czy zawinąć wzór w nawiasy. Trochę wcześniej ELSEdotyczy 1 jonu, pozostawiając ciąg bez zmian. Na przykład, jeśli 1i "PO_4"są na stosie, są one zastępowane przez "PO_4". 1i "H"daje "H".

Reszta dotyczy wielu jonów; jeśli jest to pojedynczy atom, nie ma go w nawiasach, w przeciwnym razie jest. Aby zdecydować, czy tak jest, sprawdzam długość łańcucha i sprawdzam, czy jest to ostatni znak >"Z". Wyrażenia logiczne zwracają 1 dla wartości true i 0 dla wartości false. Odejmując wynik tego porównania od długości łańcucha, otrzymuję 1 lub mniej, gdy jest to pojedynczy atom, w przeciwnym razie więcej: długość 1 to pojedynczy atom; długość 2 będzie miała literę jako ostatni znak; dla pojedynczego atomu jest to mała litera, więc >"Z"wynik 1, w przeciwnym razie 2; długość 3 lub więcej oznacza więcej niż 1 atom, a po odjęciu 0 lub 1 od długości wynik będzie wynosił co najmniej 2. Na przykład 3i "PO_4"daje "(PO_4)_3". 3i "Al"daje "Al_3".

Mnajpierw dzieli każdy jon za pomocą S. Po pierwszym wierszu poziom 5 stosu (czyli najgłębiej zakopanego obiektu) zawiera ładunek drugiego jonu, wzór drugiego jonu poziomu 4, wzór pierwszego jonu poziomu 3, wartość bezwzględna poziomu 2 ładunku pierwszego jonu i wartość bezwzględna poziomu 1 ponownie ładunku drugiego jonu. Na przykład, jeśli podane jony są na stosie "Al^+3", "SO_4^-2"otrzymujemy -2, "SO_4", "Al", 3, 2.

Druga linia oblicza gcd z 2 opłat (pozostawiając nienaruszone opłaty).

Trzecia linia dzieli każdy ładunek przez gcd (w celu obliczenia wielokrotności) i łączy go ze wzorem jonów za pomocą J. Mamy więc dwa łańcuchy, każdy z jednym danym jonem z usuniętym ładunkiem (lub jego wielokrotnością) i ładunkiem drugiego z nich zakopany za nimi. Na przykład -2, "Al_2", "(SO_4)_3"(-2 to ładunek SO_4).

Czwarta linia rozładowuje ładunek, a jeśli jest dodatnia, zamienia dwa łańcuchy (tak, aby kation był pierwszy) przed dołączeniem do nich. Tak więc w powyższym przykładzie, bo to negatywne, są one połączone w kolejności są: "Al_2(SO_4)_3".

JavaScript, 145 bajtów

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

Bierze argumenty, że cjest kationem, ajest anionem, pjest ładunkiem dodatnim, njest ładunkiem ujemnym.