Os caras ASCII de olhos esquisitos gostam de trocar de ASCII Ii:

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

Dada uma série de caras safados, espaçados ou linhas separadas, mude o Iilado para o outro, deixou a parede e endireitou o céu:

Ii

O menor shifter ganha o prêmio.

Diga o quê?

Escreva um programa ou função que inclua uma sequência de uma lista arbitrária desses quatro emoticons ASCII, separados por espaço ou nova linha (com uma nova linha opcional à direita):

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

Por exemplo, a entrada pode ser

>_> >_> <_>

ou

>_>
>_>
<_>

(O método que você apoia depende de você.)

Cada emoticon executa uma ação diferente nos caracteres Ie i, que sempre começam assim:

Ii

• >_>desloca-se Ipara a direita em um, se possível, e desloca-se ipara a direita em um.
• <_<desloca Ipara a esquerda em um, se possível, e desloca ipara a esquerda em um, se possível.
• >_<desloca Ipara a direita em um, se possível, e desloca ipara a esquerda em um, se possível.
• <_>muda Ipara a esquerda em um, se possível, e depois ipara a direita em um.

Inão pode ser deslocado para a esquerda se estiver na borda esquerda da linha (como está inicialmente) e não pode ser deslocado para a direita se iestiver diretamente à sua direita (como está inicialmente).

inão pode ser deslocado para a esquerda se Iestiver diretamente para a esquerda (como é inicialmente), mas sempre pode ser deslocado para a direita.

Observe que, com essas regras, Isempre permanecerá à esquerda de ie tentará Iser alterado antes ipara todos os emoticons.

Seu programa ou função precisa imprimir ou retornar uma sequência da Iilinha final após aplicar todos os turnos na ordem indicada, usando espaços ( ) ou pontos ( .) para espaço vazio. Espaços ou períodos finais e uma nova linha final são opcionalmente permitidos na saída. Não misture espaços e períodos.

Por exemplo, a entrada

>_>
>_>
<_>

tem saída

I...i

porque as mudanças se aplicam como

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

O código mais curto em bytes vence. O desempatador é a resposta votada mais alta.

Casos de teste

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

Usando .para maior clareza.

#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

Usa o mesmo algoritmo da minha resposta Python , exceto com a indexação 0. Essencialmente:

• Observe apenas as setas na entrada, convertendo <para -1 e >para 1
• Aplique uma atualização apenas se não nos mover para a posição -1 e não nos mover para a posição do outro caractere
• Como as setas alternam entre aplicar Ie aplicar a i, alternamos qual posição atualizamos após cada seta

Obrigado a @ MartinBüttner por jogar a etapa de saída e decolar 5 bytes.

Experimente online | Suíte de teste

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

Inclui +1 para -p

Corra com a entrada no STDIN, por exemplo perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Explicação

As instruções suplentes string de controle para ie Ie a regra é a mesma para ambos se você formulá-las como:

• < Mover para a esquerda se houver um espaço à esquerda
• > Mova para a direita se houver um espaço ou final de corda à direita

Então, eu vou trocar ie Ina sequência de destino em cada etapa, então só preciso aplicar a regra a uma letra de cada vez. Isto é oy/iI/Ii/

Vou percorrer a cadeia de controle procurando <e >usando uma substituição que geralmente é a maneira mais curta em perl para processar algo caractere por caractere. Para evitar ter que escrever $var =~, quero a string de controle na variável padrão perl $_. E eu também quero uma maneira fácil de distinguir <a partir >. Tudo isso pode ser realizado usando

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

A sequência de destino que eu também quero manipular usando substituições e, pelo mesmo motivo, também quero isso $_. $_ser duas coisas ao mesmo tempo parece impossível.

No entanto, posso pegar meu bolo e comê-lo também porque o $_interior de uma substituição não precisa permanecer igual ao de $_substituição. Uma vez que o perl começou a substituir uma string, essa string não será alterada, mesmo se você alterar a variável da qual a string veio originalmente. Então você pode fazer algo como:

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

Quero substituir o original $_pela inicial "Ii"apenas na primeira vez em que o corpo de substituição é executado (caso contrário, continuo redefinindo a sequência de destino). Porém, essa substituição também deve ocorrer para uma cadeia de controle vazia, portanto, mesmo para a cadeia de controle vazia, o corpo precisa ser executado pelo menos uma vez. Para garantir que a subestação execute um tempo extra no início da cadeia de controle (mesmo para cadeias de controle vazias), altero a substituição para:

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

Vou executar o y/iI/Ii/como a primeira coisa dentro do código de substituição. Embora $_ainda seja a string de controle, isso ainda não conterá nenhuma Ii, portanto, se a transliteração indicar que nada foi alterado, essa é a minha inicialização do gatilho $_:

y/iI/Ii/or$_=Ii

Agora eu posso implementar o movimento real das letras. Desde que eu começo com uma troca, todos os movimentos devem ser feitos i, não I. Se $1estiver definido, mova ipara a direita:

s/i |i$/ i/

Se $1não estiver definido, mova ipara a esquerda

s/ i/i /

Observe que no início da sequência de controle quando eu corresponder ^ $1não será definido, portanto, ele tenta se mover ipara a esquerda na sequência inicial Ii. Isso não funcionará porque não há espaço lá; portanto, a string inicial permanece intacta (é por isso que eu dou a ()volta em >vez de <)

Apenas um problema permanece: no final da substituição externa, $_é definido o resultado da substituição externa, independentemente do que você fez no $_interior do corpo de substituição. Portanto, a cadeia de destino com o posicionamento correto de ie Ise perde. Nos perigos mais antigos, isso seria uma falha fatal. Perls mais recentes, no entanto, têm o rmodificador que significa "faça uma cópia da string original, faça sua substituição e retorne a string resultante (em vez do número de correspondências)". Quando eu uso isso aqui, o resultado é que a string de comando modificada é descartada enquanto o original $_não é perturbado pelo perl e deixado após a substituição. No entanto, a perturbação que eu faço $_ainda é feita depois que o perl é deixado em $_paz. Então no final$_ será a sequência de destino adequada.

A -popção garante que a sequência original esteja inserida $_e também imprime a 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')

Implementação direta.

Ungolfed:

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.

O que é LittleLua?

LittleLua é um trabalho em andamento para tentar nivelar os campos de jogo entre o meu idioma de escolha para esses desafios e os idiomas esotéricos que geralmente têm recursos extremamente poderosos.

LittleLua é um intérprete Lua 5.3.6 com um módulo adicional (LittleLua.Lua), bem como os nomes das funções e dos módulos diminuídos. Essas alterações serão expandidas nos próximos dias ou dois, até que eu esteja feliz, mas, como estão várias das maiores mudanças entre LittleLua e um interpretador Lua padrão, são:

Funções e módulos são reduzidos:

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

Variáveis ​​incorporadas

LittleLua tem várias variáveis ​​embutidas para reduzir algumas tarefas:

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

Funções incorporadas

Atualmente, uma lista deprimente pequena, mas aqui 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

Experimente online

Economizou 15 bytes graças a daavko!

Pega entrada separada por novas linhas e saídas com os olhos separados por espaços.

Explicação:

Vou explicar estágio por estágio, como de costume. Todos esses estágios estão no modo Substituir da Retina. Isso significa que a primeira linha é uma expressão regular e a segunda linha é uma sequência de substituição.

$
¶Ii

Adicione a inicial Iiao final da entrada.

(`^ ¶

O backtick separa o palco das opções. O caractere de opção (indica que esse estágio é o início de um loop de estágios a serem executados repetidamente em ordem até que um ciclo completo seja concluído sem alterar a entrada. Como esse parêntese aberto nunca é fechado, todos os estágios restantes fazem parte desse loop.

O estágio atual é muito simples, se o primeiro caractere da string for uma nova linha, exclua-a. Isso é apenas para ajudar a facilitar o manuseio da entrada vazia, caso contrário, seria mais fácil adicioná-la às duas últimas etapas.

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

Aqui, a opção sfaz com que o metacaractere Regex .corresponda às novas linhas. Esse estágio faz com que um líder >corresponda ao Iseguido por um espaço opcional. Em seguida, substitui a correspondência com o material após o >, seguido pelo espaço opcional (portanto, a cadeia vazia se o espaço não puder ser correspondido) e, em seguida, o I.

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

Este estágio é muito semelhante ao anterior, apenas o espaço opcional é anterior ao I, e a ordem e o olho são invertidos.

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

O manuseio de imuitas vezes é mais simples, porque não precisamos nos preocupar em adicionar ou remover opcionalmente, pois isempre podemos mover para a direita. Nos icasos, comparamos o sublinhado e o sinal maior / menor que, mas, de outro modo, fazemos uma lógica semelhante. Este adiciona um espaço antes do i.

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

Novamente semelhante ao anterior, mas ele exclui o caractere antes do icaractere se for um espaço, caso contrário, ele remove apenas o emoticon.

Python, 142 141 134 122 121 121 bytes

Economizou 19 bytes graças ao 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'

Exemplo:

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

Explicação:

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

(incluindo +1 para -rsinalizador)

#!/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

Isso cria um novo programa sed a partir da entrada (que você pode ver removendo a última linha) e o aplica ao estado inicial Ii.

Explicação

• As duas primeiras linhas convertem <e >substituem comandos que mudam para Iesquerda e direita, respectivamente.
• Em seguida, alteramos o seguinte _para trabalhar em ivez deI
• i não estiver delimitado por nenhuma borda direita, portanto, não adicione ou consuma espaço após ela
• Por fim, aplique o comando criado à entrada Ii. s///esempre usa /bin/shcomo shell, então não pude reduzi-lo sed '&'<<<Iicomo queria (essa é uma sintaxe de redirecionamento do Bash).

Resultado dos testes

$ 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"

Degolfado (v6, v7 não é muito 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(

Experimente online!

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

Provavelmente não adotei a melhor abordagem, por isso provavelmente pode ser mais praticada. E não, eu não copiei o FryAmTheEggman (eu sei que eles são realmente semelhantes em nossas abordagens). Eu nem vi a resposta dele até depois de postar a minha.

$
¶Ii
(`^¶

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

Experimente online

Javascript (ES6) 166 bytes

Usando a resposta de Charlie Wynn, consegui economizar 10 bytes definindo Math.max como M e chamando M cada vez que seu 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'}

(Eu não escrevi esse golfe, Charlie Wynn fez aqui . Apenas o modifiquei para torná-lo mais curto)

JavaScript (ES6), 115 118

Editar: 3 bytes salvos thx 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`

pé o número de espaços anteriores I; qé o número de espaços entre Ie i. Nem pode ser negativo.

Menos golfe

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
)

Teste

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 salvos graças a @FryAmTheEggman.

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

A explicação vem um pouco mais tarde.

Experimente online!

Código modificado com teste em 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)

Solução bonita para um desafio difícil. Entrada como f('>_> <_>'), saída como 'I i'.

Programa de verificação (supondo que testsseja a sequência de casos de teste com várias linhas):

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

O programa lê cada seta uma de cada vez, começando com I=1, i=2e usando índices baseados em 1. Os nomes das variáveis ​​são um pouco enganadores, pois trocam de papéis - após cada caractere, Itorna i- ise e torna - se Iatualizado. Um caractere é atualizado apenas se não se mover para a posição do outro caractere nem para a posição 0.

Por exemplo, para o >_> <_> >_<que fazemos:

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

Isso dá ' Ii'como desejado.

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), 153 125 bytes

recebe uma entrada definindo uma variável aantes de executar

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"

Um pouco não-destruído:

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"}]&

Função pura com o primeiro argumento #. A idéia é que cada um <_, >_, <, e >nos corresponde entrada para uma regra de substituição de string. "<_"|">_"|">"|"<"é um padrão de sequência que corresponde a qualquer uma dessas quatro expressões. StringCases[#,"<_"|">_"|">"|"<"]encontrará todas essas correspondências. Em seguida, substituímos ( /.) cada um "<_"pela regra de substituição de cadeia ".I"->"I.", cada um ">_"pela regra "I."->".I"e assim por diante. Desejo aplicar sequencialmente cada regra de substituição à sequência "Ii", mas StringReplaceprocurarei apenas correspondências nas partes da sequência que não foram substituídas. Portanto, deixamos Folda função StringReplacesobre a lista de regras de substituição com valor inicial "Ii".

Talvez seja mais claro com um exemplo (aqui %se refere à saída da célula anterior):