A los chicos ASCII de ojos temblorosos les gusta cambiar de ASCII Ii:

>_> <_< >_< <_>

Dada una cadena de personas cambiantes, separadas o líneas separadas, desplace el Iilado a lado, deje la pared y los cielos a la derecha:

Ii

La palanca de cambio más corta gana el premio.

¿Que qué?

Escriba un programa o función que incluya una cadena de una lista arbitraria de estos cuatro emoticones ASCII, separados por espacio o por nueva línea (con una nueva línea final opcional):

>_>
<_<
>_<
<_>

Por ejemplo, la entrada podría ser

>_> >_> <_>

o

>_>
>_>
<_>

(El método que admite depende de usted).

Cada emoticón realiza una acción diferente en los caracteres Iy i, que siempre comienzan así:

Ii

• >_>se desplaza Ihacia la derecha por uno, si es posible, y luego se desplaza ihacia la derecha por uno.
• <_<se desplaza Ihacia la izquierda por uno, si es posible, y luego se desplaza ihacia la izquierda por uno, si es posible.
• >_<se desplaza Ihacia la derecha por uno, si es posible, y luego se desplaza ihacia la izquierda por uno, si es posible.
• <_>se desplaza Ihacia la izquierda por uno, si es posible, y luego se desplaza ihacia la derecha por uno.

Ino puede desplazarse a la izquierda si está en el borde izquierdo de la línea (como está inicialmente), y no puede desplazarse a la derecha si iestá directamente a su derecha (como está inicialmente).

ino se puede desplazar hacia la izquierda si Iestá directamente a su izquierda (como es inicialmente), pero siempre se puede desplazar hacia la derecha.

Tenga en cuenta que con estas reglas, Isiempre permanecerá a la izquierda de i, y Ise intenta cambiar antes ipara todos los emoticones.

Su programa o función necesita imprimir o devolver una cadena de la Iilínea final después de aplicar todos los cambios en el orden dado, usando espacios ( ) o puntos ( .) para el espacio vacío. Los espacios o puntos finales y una nueva línea final opcional se permiten opcionalmente en la salida. No mezcle espacios y períodos.

Por ejemplo, la entrada

>_>
>_>
<_>

tiene salida

I...i

porque los turnos se aplican como

start  |Ii
>_>    |I.i 
>_>    |.I.i
<_>    |I...i

El código más corto en bytes gana. Tiebreaker es la respuesta más votada.

Casos de prueba

#[id number]
[space separated input]
[output]

Utilizando .para mayor claridad.

#0
[empty string]
Ii

#1
>_>
I.i

#2
<_<
Ii

#3
>_<
Ii

#4
<_>
I.i

#5
>_> >_>
.I.i

#6
>_> <_<
Ii

#7
>_> >_<
.Ii

#8
>_> <_>
I..i

#9
<_< >_>
I.i

#10
<_< <_<
Ii

#11
<_< >_<
Ii

#12
<_< <_>
I.i

#13
>_< >_>
I.i

#14
>_< <_<
Ii

#15
>_< >_<
Ii

#16
>_< <_>
I.i

#17
<_> >_>
.I.i

#18
<_> <_<
Ii

#19
<_> >_<
.Ii

#20
<_> <_>
I..i

#21
>_> >_> <_>
I...i

#22
<_> >_> >_> >_> <_> <_<
.I...i

#23
<_> >_> >_> >_> <_> <_< >_< <_< >_<
..Ii

#24
>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<
...I.....i

CJam, 33 bytes

0Xq2%{'=-_3$+[2$W]-,*@+}/S*'i+'It

Utiliza el mismo algoritmo que mi respuesta de Python , excepto con la indexación 0. Esencialmente:

• Solo mire las flechas en la entrada, convirtiendo <a -1 y >a 1
• Solo aplique una actualización si no nos mueve a la posición -1 y no nos mueve a la posición del otro personaje
• Como las flechas alternan entre aplicar Iy aplicar i, alternamos qué posición actualizamos después de cada flecha

Gracias a @ MartinBüttner por jugar golf en el paso de salida, quitando 5 bytes.

Pruébalo en línea | Banco de pruebas

0X                 Initialise the two positions a = 0, b = 1
q2%                Read input and take every second char, leaving just the arrows

{ ... }/           For each arrow in the input...
  '=-              Subtract '=, leaving -1 for '< and 1 for '>
  _3$+             Duplicate and add a. Stack looks like [a b diff a+diff]
  [2$W]-           Perform setwise subtraction, [a+diff] - [b -1]
                   The result is empty list if a+diff is either b or -1, else [a+diff]
  ,                Length, yielding 0 or 1 respectively
                   0 means we don't want to update the char, 1 means we do
  *                Multiply diff by this result
  @+               Add to a. Stack now looks like [b a'] where a' is a updated

                   After the above loop, the stack ends with [(I position) (i position)]

S*                 Create (i position) many spaces
'i+                Stick an 'i at the end - this is the right place due to 0-indexing
'It                Set (I position) to 'I

Perl, 59 56 54 bytes

Incluye +1 para -p

Ejecutar con la entrada en STDIN, p. Ej. perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

s%^|<|(>)%y/iI/Ii/or$_=Ii;$1?s/i |i$/ i/:s/ i/i /%reg

Explicación

La cadena de control alterna las instrucciones para iy Iy la regla es la misma para ambos si las formula como:

• < Mover a la izquierda si hay un espacio a la izquierda
• > Muévase a la derecha si hay un espacio o final de cadena a la derecha

Así que voy a intercambiar iy Ien la cadena de destino en cada paso, así que solo necesito aplicar la regla a una letra. Este es ely/iI/Ii/

Recorreré la cadena de control buscando <y >usando una sustitución, que generalmente es la forma más corta en perl para procesar algo carácter por carácter. Para evitar tener que escribir $var =~, quiero la cadena de control en la variable predeterminada perl $_. Y también quiero una manera fácil de distinguir <de >. Todo esto se puede lograr usando

s%<|(>)%  code using $1 to distinguish < from > %eg

La cadena de destino también quiero manipular usando sustituciones y, por la misma razón, también quiero eso $_. $_ser dos cosas a la vez parece imposible.

Sin embargo, puedo tener mi pastel y comerlo también porque el $_interior del cuerpo de una sustitución no tiene que ser el mismo que el $_sustituido. Una vez que Perl comenzó a sustituir una cadena, esta cadena no cambiará incluso si cambia la variable de la que proviene originalmente la cadena. Entonces puedes hacer algo como:

s%<|(>)% change $_ here without disturbing the running substitution %eg

Quiero reemplazar el original $_por el inicial "Ii"solo la primera vez que se ejecuta el cuerpo de sustitución (de lo contrario, sigo restableciendo la cadena de destino). Sin embargo, este reemplazo también tiene que suceder para una cadena de control vacía, por lo que incluso para la cadena de control vacía, el cuerpo debe ejecutarse al menos una vez. Para asegurarme de que la substición se ejecute un tiempo extra al comienzo de la cadena de control (incluso para cadenas de control vacías), cambio la sustitución a:

s%^|<|(>)% change $_ here without disturbing the running substitution %eg

Ejecutaré y/iI/Ii/como lo primero dentro del código de sustitución. Si bien $_todavía es la cadena de control, esto todavía no contendrá ninguna Ii, por lo que si la transliteración indica que no se cambió nada, ese es mi desencadenante de inicialización $_:

y/iI/Ii/or$_=Ii

Ahora puedo implementar el movimiento real de las letras. Desde que comienzo con un intercambio, todos los movimientos deben hacerse i, no I. Si $1está configurado, muévase ia la derecha:

s/i |i$/ i/

Si $1no está configurado, muévase ia la izquierda

s/ i/i /

Tenga en cuenta que al comienzo de la cadena de control cuando coincida ^ $1no se establecerá, por lo que intenta moverse ihacia la izquierda en la cadena inicial Ii. Esto no funcionará porque no hay espacio allí, por lo que la cadena inicial permanece intacta (es por eso que puse el ()alrededor en >lugar de <)

Solo queda un problema: al final de la sustitución externa $_se establece como resultado de la sustitución externa, independientemente de lo que haya hecho $_dentro del cuerpo de sustitución. Entonces, la cadena de destino con la colocación adecuada de iy Ise pierde. En perls más antiguos esto sería un defecto fatal. Sin embargo, los perls más recientes tienen el rmodificador que significa "hacer una copia de la cadena original, hacer su sustitución en eso y devolver la cadena resultante (en lugar del número de coincidencias)". Cuando uso eso aquí, el resultado es que la cadena de comando modificada se descarta mientras que el original $_no se ve afectado por Perl y se deja después de la sustitución. Sin embargo, lo inquietante que hago $_todavía se hace después de que Perl se haya quedado $_solo. Entonces al final$_ será la cadena objetivo adecuada.

La -popción asegura que la cadena original esté dentro $_y también imprime la final $_.

LittleLua - 178 bytes

r()l=sw(I)o=1 D='.'f q=1,#l do i l[q]:s(1,1)=='>'t i z+1~=o t z=z+1 e else i z-1>0 t z=z-1 e e i l[q]:s(3)=='>'t o=o+1 else i o-1~=z t o=o-1 e e e p(D:r(z).."I"..D:r(o-z-1)..'i')

Implementación directa.

Sin golf:

r()                             --call for input
l=sw(I)                         --Split input by spaces
o=1                             --Hold i position (z holds I position)
D='.'                           --Redundant character
f q=1,#l do                     --Foreach table entry
    i l[q]:s(1,1)=='>' t        --If the first eye points right
        i z+1~=o t z=z+1 e      --Verify no collision and move the I
    else
        i z-1>0 t z=z-1 e       --If it points left.. .same...
    e                           --yatta yatta...
    i l[q]:s(3)=='>' t
        o=o+1
    else
        i o-1~=z t o=o-1 e
    e
e
p(D:r(z).."I"..D:r(o-z-1)..'i')--String repeats to print correct characters.

¿Qué es LittleLua?

LittleLua es un trabajo en progreso para tratar de nivelar los campos de juego entre mi idioma de elección para estos desafíos y lenguajes esotéricos que a menudo tienen incorporados extremadamente poderosos.

LittleLua es un intérprete Lua 5.3.6 con un módulo adicional (LittleLua.Lua), así como nombres de funciones y módulos reducidos. Estos cambios se expandirán durante el próximo día o dos, hasta que esté contento, pero tal como está, varios de los cambios más grandes entre LittleLua y un intérprete estándar de Lua son:

Las funciones y los módulos se reducen:

io.read() -> r() (Value stored in built in variable "I")
string -> s
string.sub -> s.s or stringvalue:s
etc.

Construido en variables

LittleLua tiene varias variables integradas para reducir algunas tareas:

z=0
o=10
h1="Hello, World!"
h2="Hello, World"
h3="hello, world"
h4=hello, world!"
etc.

Funciones integradas

Actualmente una lista deprimentemente pequeña, pero aquí está:

d(N) -> Prints NxN identity matrix
sw(str) -> Splits string at spaces and returns table of results
sc(str) -> Splits string at commas and returns table of results
sd(str) -> Removes white space from a string (not including tabs)
ss(str,n) -> Swap N characters from beginning and end of string
sr(str,n) -> Swap N characters from beginning and end of string retaining order
sd(str) -> Split string into array of characters
co(ta) -> Concatenate table with no delimiter
co(ta, delim) -> Concatenate table with delimiter: delim

retina ,101 86

$
¶Ii
(`^¶

s`^>(.*)I( )?
$1$2I
s`^<(.*?)( )?I
$1I$2
s`^_>(.*)i
$1 i
s`^_<(.*?) ?i
$1i

Pruébalo en línea

¡Guardado 15 bytes gracias a daavko!

Toma entradas separadas por nuevas líneas y salidas con los ojos separados por espacios.

Explicación:

Explicaré paso a paso como de costumbre. Todas estas etapas están en el modo Reemplazar de Retina. Eso significa que la primera línea es una expresión regular y la segunda línea es una cadena de reemplazo.

$
¶Ii

Agregue la inicial Iial final de la entrada.

(`^ ¶

El backtick separa el escenario de las opciones. El carácter de opción (indica que esta etapa es el inicio de un ciclo de etapas que se ejecutarán repetidamente en orden hasta que se complete un ciclo completo sin cambiar la entrada. Dado que este paréntesis abierto nunca se cierra, todas las etapas restantes son parte de este ciclo.

La etapa real es muy simple, si el primer carácter de la cadena es una nueva línea, elimínela. Esto es solo para ayudar a facilitar el manejo de la entrada vacía, de lo contrario sería más divertido agregarlo a las dos últimas etapas.

s`^>(.*)I( )?
$1$2I

Aquí, la opción shace que el metacarácter .Regex coincida con las nuevas líneas. Esta etapa hace que un inicio >coincida con el Iseguido por un espacio opcional. Luego reemplaza esa coincidencia con las cosas después del >, seguido por el espacio opcional (por lo que la cadena vacía si el espacio no puede coincidir), y luego el I.

s`^<(.*?)( )?I
$1I$2

Esta etapa es muy similar a la anterior, solo el espacio opcional está antes del I, y el orden y el ojo están invertidos.

s`^_>(.*)i
$1 i

El manejo de la irealidad es a menudo más simple, porque no tenemos que preocuparnos de agregar o quitar opcionalmente, ya ique siempre se puede mover a la derecha. Para los icasos, eliminamos el guión bajo y el signo mayor / menor que, pero de lo contrario hacemos una lógica similar. Este agrega un espacio antes del i.

s`^_<(.*?) ?i
$1i

De nuevo similar al anterior, pero elimina el carácter antes de isi ese carácter es un espacio, de lo contrario solo elimina el emoticón.

Python, 142 141 134 122 121 bytes

Guardado 19 bytes gracias a xnor.

def f(l,I=0,i=1):
    for a,_,b in l.split():I-=[I>0,-(i!=I+1)][a>'='];i-=[i!=I+1,-1][b>'=']
    return'.'*I+'I'+'.'*(i+~I)+'i'

Ejemplo:

>>> assert f('<_> >_> >_> >_> <_> <_<') == '.I...i'
>>> 

Explicación:

def f(l, I=0, i=1):
    for a, _, b in l.split():
        I-= -(i!=I+1) if a == '>' else I > 0
        i-= -1 if b == '>' else i!=I+1

    return '.'*I + 'I' + '.'*(i-I-1) + 'i'

GNU sed, 81 bytes

(incluido +1 para -rbandera)

#!/bin/sed -rf
s!<!s/ I/I /;!g
s!>!s/I / I/;!g
s!_(.{9})!\L\1!g
s!i !i!g
s/.*/echo Ii|sed '&'/e

Esto crea un nuevo programa sed a partir de la entrada (que puede ver eliminando la última línea) y lo aplica al estado inicial Ii.

Explicación

• Las dos primeras líneas convierten <y >'sustituyen' comandos que se desplazan hacia la Iizquierda y hacia la derecha, respectivamente.
• Luego cambiamos el siguiente _para trabajar en ilugar deI
• i no está delimitado por ningún borde derecho, así que no agregue ni consuma espacio a continuación
• Finalmente, aplique el comando creado a la entrada Ii. s///esiempre se usa /bin/shcomo shell, por lo que no pude acortar esto sed '&'<<<Iicomo quería (esa es una sintaxis de redireccionamiento de Bash).

Resultados de la prueba

$ for i in '' '>_>' '<_<' '>_<' '<_>' '>_> >_>' '>_> <_<' '>_> >_<' '>_> <_>' '<_< >_>' '<_< <_<' '<_< >_<' '<_< <_>' '>_< >_>' '>_< <_<' '>_< >_<' '>_< <_>' '<_> >_>' '<_> <_<' '<_> >_<' '<_> <_>' '>_> >_> <_>' '<_> >_> >_> >_> <_> <_<' '<_> >_> >_> >_> <_> <_< >_< <_< >_<' '>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<'
> do printf '%s => ' "$i"; ./74719.sed <<<"$i" | tr \  .; done | cat -n
     1   => Ii
     2  >_> => I.i
     3  <_< => Ii
     4  >_< => Ii
     5  <_> => I.i
     6  >_> >_> => .I.i
     7  >_> <_< => Ii
     8  >_> >_< => .Ii
     9  >_> <_> => I..i
    10  <_< >_> => I.i
    11  <_< <_< => Ii
    12  <_< >_< => Ii
    13  <_< <_> => I.i
    14  >_< >_> => I.i
    15  >_< <_< => Ii
    16  >_< >_< => Ii
    17  >_< <_> => I.i
    18  <_> >_> => .I.i
    19  <_> <_< => Ii
    20  <_> >_< => .Ii
    21  <_> <_> => I..i
    22  >_> >_> <_> => I...i
    23  <_> >_> >_> >_> <_> <_< => .I...i
    24  <_> >_> >_> >_> <_> <_< >_< <_< >_< => ..Ii
    25  >_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_< => ...I.....i

Javascript (ES6) 176 171 168 155 148 147 142 141 bytes

//v8 - I was sure saving off math was saving a byte, thanks ETF
_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v7 - not checking first char when I can check whole string - changed how I create end string (stolen from edc65)
_=>_.split` `.map(m=>(I=m<'='?I-1||0:M.min(i-1,I+1))+(i=m[2]=='<'?M.max(I+1,i-1):i+1),i=1,I=0,M=Math)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v6 - one more byte
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)+((a=Array(i))[I]='I')&&a.join`.`+'i'

//v5 - not filling array with '.', just joining with . later
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i))[I]='I')&&a.join`.`+'i'

//v4 - realized I didn't need to split >_> on _, just use the 0th and 2nd index
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v3 - saving Math to a var (thanks @Verzio)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v2 - as a single expression! (thanks @Downgoat)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//version 1
_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

Uso

f=_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'


f(">_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<")
//"...I.....i"

Degolfed (v6, v7 no es muy diferente)

//my solution has changed slightly, but not significantly enough to redo the below

_=>                   //take an input
  _.split` `          //split to each command <_<
   .map(              //do something for each command (each command being called m)
     m=>              
       (I=            //set I to.... 'I will be the index of the letter I'
         m[0]=='<'?   //is the first char of the command '<'?
           Math.max(0,I-1)   //yes => move I to the left (but don't move past 0)
           :
           Math.min(i-1,I+1)  //no => move I to the right one, but keep it one less than i
       )

       +              //also we need to mess with i
       (i=
        m[2]=='<'?    //is the 3rd char of the command '<'?
          Math.max(I+1,i-1)  //yes => move i to the left, but keep it one right of I
          :
          i+1         //move i to the right (no bounds on how far right i can go)
       )

       ,i=1,I=0       //set I to 0 and i to 1 initially
     )
   +                  //this just lets us chain commands into one expression, not really adding
   (
    (a=Array(i))[I]='I') //create an array of length i (will be one shorter than we really need)
                         //set element I to 'I'

   &&                    //last chained command, we know the array creation will be true
                         //so javascript will just output the next thing as the return for the function
   a.join`.`+'i'         //join the array with '.' (into a string) and append i
                         //i will always be the last element

MATL , 56 55 50 49 47 bytes

1Hj3\q4ZC"w@1)+lhX>yqhX<w@3)+yQhX>]tZ"105b(73b(

Pruébalo en línea!

1           % push 1: initial position of 'I'
H           % push 2: initial position of 'i'
j           % take input as a string
4\q         % modulo 3 and subtract 1: this gives -1 for '<', 1 for '>'
4Zc         % arrange blocks of length 4 as columns of 2D array. This pads last 
            % block with a zero (because the separating space won't be there).
            % Only first and third and last rows will be used
"           % for each column
  w         %   swap: move position of 'I' to top of stack
  @1)       %   first number (+/-1) of current column: tells where the 'I' moves
  +         %   add
  lhX>      %   max with 1: 'I' cannot move left past position 1
  y         %   duplicate position of 'i'
  qhX<      %   max with that number minus 1: 'I' cannot collide with 'i'
  w         %   swap: move position of 'i' to top of stack
  @3)       %   last number (+/-1) of current column: tells where the 'i' moves
  +         %   add
  y         %   duplicate position of 'I'
  QhX>      %   max with that number plus 1: 'i' cannot collide with 'I'
]           % end for each
t           % duplicate position of 'I'. This is the output string length
Z"          % string with that many spaces
105b(       % set 'i' at its computed position in that string
73b(        % set 'I' at its computed position in that string

Retina, 91 86 bytes

Probablemente no tomé el mejor enfoque, por lo que probablemente se pueda jugar más al golf. Y no, no copié FryAmTheEggman (sé que son realmente similares en nuestros enfoques). Ni siquiera vi su respuesta hasta después de que publiqué la mía.

$
¶Ii
(`^¶

sr`^<_(.*)( |)I
$1I$2
s`^>_(.*)I( ?)
$1$2I
sr`^<(.*) ?i
$1i
s`^>(.*)i
$1 i

Pruébalo en línea

Javascript (ES6) 166 bytes

Usando la respuesta de Charlie Wynn, logré guardar 10 bytes definiendo Math.max como M y llamando a M cada vez que su script usa

_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M=Math.max;M(0,I-1):M(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

(No escribí este golf, Charlie Wynn lo hizo aquí . Simplemente lo modifiqué para hacerlo más corto)

JavaScript (ES6), 115 118

Editar: 3 bytes guardados gracias a CharlieWynn

a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

pes el número de espacios antes I; qes el número de espacios entre Iy i. Ninguno de los dos puede ser negativo.

Menos golf

a=>(
  a.split(' ').map( x=> (
    x>'='?q&&(--q,++p):p&&(--p,++q), // try to move I based on 1st char of x
    x[2]>'='?++q:q&&--q // try to move i based on 3rd char of x
  ) 
  , p=q=0), // starting values of p and q
  '.'.repeat(p)+'I' + '.'.repeat(q) +'i' // return value
)

Prueba

f=a=>a.split` `.map(x=>x[x>'='?q&&(--q,++p):p&&(--p,++q),2]>'='?++q:q&&--q,p=q=0)&&'.'.repeat(p)+`I${'.'.repeat(q)}i`

console.log=x=>O.textContent+=x+'\n'

;[['','Ii'],
['>_>','I.i'],
['<_<','Ii'],
['>_<','Ii'],
['<_>','I.i'],
['>_> >_>','.I.i'],
['>_> <_<','Ii'],
['>_> >_<','.Ii'],
['>_> <_>','I..i'],
['<_< >_>','I.i'],
['<_< <_<','Ii'],
['<_< >_<','Ii'],
['<_< <_>','I.i'],
['>_< >_>','I.i'],
['>_< <_<','Ii'],
['>_< >_<','Ii'],
['>_< <_>','I.i'],
['<_> >_>','.I.i'],
['<_> <_<','Ii'],
['<_> >_<','.Ii'],
['<_> <_>','I..i'],
['>_> >_> <_>','I...i'],
['<_> >_> >_> >_> <_> <_<','.I...i'],
['<_> >_> >_> >_> <_> <_< >_< <_< >_<','..Ii'],
['>_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<','...I.....i']]
.forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i +' -> '+r + (r==k?' OK':' KO (exp '+k+')'))
})

<pre id=O></pre>

Retina, 61 58 bytes

3 bytes guardados gracias a @FryAmTheEggman.

^
Ii 
(`( ?)I(.*i) <|I( ?)(.*i) >
$3I$1$2$4
 ?i_<
i
i_>
 i

La explicación llega un poco más tarde.

Pruébalo en línea!

Código modificado con prueba de lote.

Python 2, 96 92 bytes

f=lambda s,I=1,i=2:s and f(s[2:],i,I+cmp(s,'=')*(0<I+cmp(s,'=')!=i))or'%*c'*2%(I,73,i-I,105)

Solución bastante atractiva para un desafío inestable. Entrada como f('>_> <_>'), salida como 'I i'.

Programa de verificación (suponiendo que testses la cadena de caso de prueba multilínea):

for test in zip(*[iter(tests.replace("[empty string]", "").splitlines())]*4):
    assert f(test[1]) == test[2].replace('.',' ')

El programa lee cada flecha una a la vez, comenzando I=1, i=2y utilizando índices basados ​​en 1. Los nombres de las variables son un poco engañosos ya que intercambian roles, después de cada char, se Ivuelve iy ise Iactualiza. Un personaje solo se actualiza si no se movería a la posición del otro personaje ni a la posición 0.

Por ejemplo, para >_> <_> >_<nosotros hacemos:

Char     I (= i from previous iteration)        i
-----------------------------------------------------------------------------------------
         1                                      2
>        2                                      1+1 = 2 would overlap, so remain 1
>        1                                      2+1 = 3
<        3                                      1-1 = 0 is too low, so remain 1
>        1                                      3+1 = 4
>        4                                      1+1 = 2
<        2                                      4-1 = 3

Esto da ' Ii'lo deseado.

Lua, 104 bytes

s='Ii'for v in(...):gmatch'%S_?'do
s=s:gsub(('>i$ i< ii>_I  I<_ II '):match(v..'(..)(%P+)'))end
print(s)

Uso:

$ lua shifter.lua "<_> >_> >_> >_> <_> <_<"
 I   i

Javascript (ES5), 153125 bytes

toma una entrada estableciendo una variable aantes de ejecutar

I=i=0;for(b of a.split(" "))b[0]==">"?i!=I&&I++:I>0&&I--,b[2]==">"?i++:I!=i&&i--;r=Array(i).fill(".");r[I]="I";r.join("")+"i"

Algo no golfista:

I=i=0;
for(b of a.split(" "))
   b[0]==">" 
       ? i!=I && I++ 
       : I>0 && I--,
   b[2]==">" 
       ? i++ 
       : I!=i && i--
;
r=Array(i).fill(".");
r[I]="I";
r.join("")+"i"

Mathematica, 125 bytes

Fold[StringReplace,"Ii",StringCases[#,"<_"|">_"|">"|"<"]/.{"<_"->".I"->"I.",">_"->"I."->".I","<"->".i"->"i",">"->"i"->".i"}]&

Función pura con primer argumento #. La idea es que cada uno <_, >_, <, y >en los corresponde entrada a una regla de sustitución de cadenas. "<_"|">_"|">"|"<"es un patrón de cadena que coincide con cualquiera de esas cuatro expresiones. StringCases[#,"<_"|">_"|">"|"<"]encontrará todos esos partidos. Luego reemplazamos ( /.) cada uno "<_"con la regla de reemplazo de cadena ".I"->"I.", cada uno ">_"con la regla "I."->".I", y así sucesivamente. Luego, quiero aplicar secuencialmente cada regla de reemplazo a la cadena "Ii", pero StringReplacesolo buscaré coincidencias en las partes de la cadena que no han sido reemplazadas, por lo que dejamos Foldla función StringReplacesobre la lista de reglas de reemplazo con un valor inicial "Ii".

Quizás sería más claro con un ejemplo (aquí se %refiere a la salida de la celda anterior):