Solución:
Python 2, 1088987 86 bytes
x=y=0
for m in map(int,raw_input()):x+=m*y and(m-y)%3*3/2;y^=m
print"--i"[~x%4::2]+`y`
(Gracias a @grc y @xnor por la ayuda)
Explicación
Dividamos el coeficiente y la matriz base. Si nos enfocamos solo en la matriz base, obtenemos esta tabla de multiplicar (p. Ej. 13 es -i2, entonces ponemos 2):
0123
0 0123
1 1032
2 2301
3 3210
que resulta ser lo mismo que hacer xor bit a bit.
Ahora centrémonos en los coeficientes. Si dejamos 0123 denotar 1,i,-1,-i respectivamente, obtenemos:
0123
0 0000
1 0031
2 0103
3 0310
Para esto, primero verificamos si alguno de los números es 0 haciendo m*y, cuidando la columna izquierda y la fila superior. Añadiendo (m-y)%3 luego da:
0123
0 0000
1 0021
2 0102
3 0210
que está cerca, excepto que tenemos 2 en lugar de 3. Contamos esto realizando *3/2.
Para la indexación, notamos que si tomamos el string "--i" y seleccione cada segundo carácter a partir de índices 0123 obtenemos "-i","-","i","".
Retina, 77 bytes
Pensé que aprovecharía esta oportunidad para mostrar una nueva función de Retina: bucles de varias etapas. Esto debería acortar muchas tareas considerablemente (especialmente el reemplazo condicional).
ii
-
+`(.)1|0
(.)-|(d)(d)
-$1$3$2
12
i3
23
i1
31
i2
)`(d)i
i$1
^D*$
$&0
Retina es mi propio lenguaje de programación basado en expresiones regulares. El código fuente se puede agrupar en etapas: cada etapa consta de dos líneas donde la primera contiene la expresión regular (y posiblemente alguna configuración) y la segunda línea es el reemplazo string. Luego, las etapas se aplican a STDIN en orden y el resultado final se imprime en STDOUT.
Puede utilizar lo anterior directamente como archivo fuente con el -s conmutador de línea de comandos. Sin embargo, no estoy contando el cambio, porque también puede poner cada línea en un archivo separado (luego pierde 15 bytes para las nuevas líneas, pero agrega +15 para los archivos adicionales).
Explicación
Lo nuevo de esta solución es la ) en la penúltima etapa. Esto cierra un bucle de varias etapas. No hay coincidencia (, lo que significa que el ciclo comienza implícitamente en la primera etapa. Por lo tanto, las primeras 7 etapas se repiten hasta que una pasada completa a través de las 7 deja de cambiar el resultado. Estas 7 etapas simplemente realizan varias transformaciones que reducen gradualmente el número de matrices en el string y combinar fases. Una vez que llegamos al resultado final, ninguno de los siete patrones coincide y el ciclo termina. Luego, agregamos un 0 si aún no hay ningún dígito en el resultado (ya que las etapas anteriores simplemente eliminan todas las identidades, incluido el resultado).
Esto es lo que hacen las etapas individuales:
ii
-
Combina todos los pares de i dentro - para reducir los caracteres de fase.
+`(.)1|0
Ahora bien, si quedan dos caracteres idénticos consecutivos, es -- o dos matrices idénticas. En cualquier caso, multiplicarlos da la identidad. Pero no necesitamos identidades, así que simplemente las eliminamos todas y las identidades explícitas (la 0s) también. Esta etapa se repite en sí misma con + hasta que el resultado deje de cambiar. Esto asegura que cosas como 123321 se resuelven por completo, de modo que en el siguiente paso se puede suponer que todos los pares de dígitos son distintos.
(.)-|(d)(d)
-$1$3$2
En realidad, se trata de dos transformaciones separadas en una (para golfitude). Tenga en cuenta que si la primera alternativa coincide, $2 y $3 están vacíos, y si el segundo coincide $1 esta vacio. Entonces esto se puede descomponer en estos dos pasos:
(d)(d)
-$2$1
Esto simplemente intercambia todos los pares de dígitos y agrega un signo menos. Desde que quitamos todo 0sy todos los pares idénticos, esto solo coincidirá 12, 23, 31, 21, 32, 13. Este paso puede parecer extraño, pero me permite verificar solo la mitad de estos casos más adelante, porque los que no puedo procesar se intercambiarán aquí en la siguiente iteración.
La otra parte de la etapa anterior fue:
(.)-
-$1
Esto se mueve gradualmente - signos hasta el final a la izquierda (una posición por iteración). Hago esto de manera que, en última instancia, todos estén uno al lado del otro y se resuelvan en el paso anterior.
12
i3
23
i1
31
i2
Estas tres etapas ahora simplemente resuelven los tres pares de productos. Como dije anteriormente, esto solo detectará la mitad de los casos relevantes, pero la otra mitad se solucionará en la siguiente iteración, después de que el paso anterior intercambiara todos los pares.
)`(d)i
i$1
Esta es la última etapa del ciclo. Es similar al que cambia - a la izquierda, excepto por i. La principal diferencia es que este intercambia i solo con dígitos. Si yo usara (.)i luego, en los casos en que obtengo un -i o i- los dos se intercambiarían indefinidamente y el programa no terminaría. Así que esto solo los cambia a la derecha del - señales. Esto es suficiente, siempre y cuando todos - y i aparecen juntos en algún momento, se pueden resolver correctamente.
^D*$
$&0
El paso final (fuera del ciclo). Recuerde que siempre eliminamos todas las identidades, por lo que si el resultado es realmente la identidad (multiplicada por una fase), entonces ya no tendremos el dígito requerido en la salida, así que lo volvemos a agregar.
Como ejemplo, aquí están todas las formas intermedias de 0223202330203313021301011023230323 (omitiendo etapas que no realizan ningún cambio):
0223202330203313021301011023230323
321321312 # Remove identities
-23-31-12-132 # Swap all pairs
-23-31-i3-132 # Resolve 12
-i1-31-i3-132 # Resolve 23
-i1-i2-i3-132 # Resolve 31
-i-1i-2i-3-312 # Move - to the left and swap pairs
-i-1i-2i-3-3i3 # Resolve 12
-i-i1-i2-3-i33 # Move i to the left
-i-i1-i2-3-i # Remove identities
--ii-1i-2-3i # Move - to the left
--ii-i1-2-i3 # Move i to the left
----i1-2-i3 # Resolve ii
i1-2-i3 # Remove identities
i-1-2i3 # Move - to the left
i-1-i23 # Move i to the left
-i-1i-32 # Move - to the left and swap pairs
-i-i1-32 # Move i to the left
--ii-1-23 # Move - to the left and swap pairs
--ii-1-i1 # Resolve 23
----1-i1 # Resolve ii
1-i1 # Remove identities
-1i1 # Move - to the left
-i11 # Move i to the left
-i # Remove identities. Now the loop can't change this any longer.
-i0 # Fix the result by adding in the 0.
CJam, 58 56 bytes
Estoy seguro de que se puede jugar mucho al golf, pero aquí va:
L'i'-"-i"]q+:G$i:XAPruébelo en línea aquí o ejecute la suite completa aquí
Si te animas, tienes la opción de dejar un enunciado acerca de qué le añadirías a esta sección.