Ai ragazzi di ASCII con gli occhi sfuggiti piace spostare quelli di ASCII Ii:

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

Data una serie di ragazzi shifty, distanziati o separati da linee, sposta il Iilato da un lato, lascia il muro e destra il cielo:

Ii

Il cambio più corto vince il premio.

Che cosa?

Scrivi un programma o una funzione che includa una stringa di un elenco arbitrario di queste quattro emoticon ASCII, separate da spazio o newline (con una newline finale opzionale):

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

Ad esempio, l'input potrebbe essere

>_> >_> <_>

o

>_>
>_>
<_>

(Il metodo che supporti dipende da te.)

Ogni emoticon esegue un'azione diversa sui personaggi Ie i, che iniziano sempre così:

Ii

• >_>si sposta Ia destra di uno, se possibile, quindi si sposta ia destra di uno.
• <_<si sposta Ia sinistra di uno, se possibile, quindi si sposta ia sinistra di uno, se possibile.
• >_<sposta Ia destra di uno, se possibile, quindi sposta ia sinistra di uno, se possibile.
• <_>sposta Ia sinistra di uno, se possibile, quindi sposta ia destra di uno.

Inon può essere spostato a sinistra se si trova sul bordo sinistro della linea (com'è inizialmente) e non può essere spostato a destra se si itrova direttamente alla sua destra (com'è inizialmente).

inon può essere spostato a sinistra se Iè direttamente alla sua sinistra (com'è inizialmente), ma può sempre essere spostato a destra.

Nota che con queste regole Irimarrà sempre alla sinistra di i, e Isi tenta di essere spostato prima iper tutte le emoticon.

Il programma o la funzione deve stampare o restituire una stringa della Iiriga finale dopo aver applicato tutti i turni nell'ordine indicato, utilizzando spazi ( ) o punti ( .) per spazio vuoto. Spazi o periodi finali e una sola nuova riga finale sono consentiti nell'output. Non mescolare spazi e punti.

Ad esempio, l'input

>_>
>_>
<_>

ha prodotto

I...i

perché i turni si applicano come

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

Vince il codice più breve in byte. Tiebreaker è la risposta più votata.

Casi test

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

Usando .per chiarezza.

#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 byte

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

Utilizza lo stesso algoritmo della mia risposta Python , tranne per l'indicizzazione 0. Essenzialmente:

• Guarda solo le frecce nell'input, convertendole <in -1 e >in 1
• Applica un aggiornamento solo se non ci sposta nella posizione -1 e non ci sposta nella posizione dell'altro carattere
• Poiché le frecce si alternano tra l'applicazione Ie l'applicazione i, alterniamo la posizione che aggiorniamo dopo ogni freccia

Grazie a @ MartinBüttner per il golf del passaggio di output, togliendo 5 byte.

Provalo online | Suite di test

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 byte

Include +1 per -p

Esegui con l'ingresso su STDIN, ad es perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Spiegazione

Le istruzioni alterna stringa di controllo per ie Ie la regola è la stessa per entrambi se li a formulare come:

• < Sposta a sinistra se c'è uno spazio a sinistra
• > Sposta a destra se c'è uno spazio o una fine della stringa a destra

Quindi eseguirò lo scambio ie Ila stringa di destinazione in ogni passaggio, quindi devo applicare la regola a una sola lettera. Questo è ily/iI/Ii/

Camminerò sulla stringa di controllo cercando <e >usando una sostituzione che di solito è il modo più breve in perl di elaborare qualcosa carattere per carattere. Per evitare di dover scrivere $var =~voglio la stringa di controllo nella variabile predefinita perl $_. E voglio anche un modo semplice per distinguere <da >. Tutto ciò può essere realizzato utilizzando

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

La stringa di destinazione che voglio anche manipolare usando le sostituzioni e per lo stesso motivo lo voglio $_anche in. $_essere due cose contemporaneamente sembra impossibile.

Tuttavia, posso avere la mia torta e mangiarla anche perché l' $_interno di un corpo sostitutivo non deve rimanere lo stesso $_dell'essere sostituito. Una volta che il perl ha iniziato a sostituire una stringa, questa stringa non cambierà anche se si cambia la variabile da cui proviene originariamente la stringa. Quindi puoi fare qualcosa come:

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

Voglio sostituire l'originale $_con l'iniziale "Ii"solo la prima volta che viene eseguito il corpo di sostituzione (altrimenti continuo a reimpostare la stringa di destinazione). Questa sostituzione deve tuttavia avvenire anche per una stringa di controllo vuota, quindi anche per la stringa di controllo vuota il corpo deve essere eseguito almeno una volta. Per essere sicuro che la sottostazione esegua un tempo extra all'inizio della stringa di controllo (anche per stringhe di controllo vuote) cambio la sostituzione in:

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

Eseguirò la y/iI/Ii/prima cosa all'interno del codice di sostituzione. Mentre $_è ancora la stringa di controllo, questa non ne contiene ancora nessuna Ii, quindi se la traslitterazione indica che non è stato modificato nulla, l'inizializzazione del mio trigger è $_:

y/iI/Ii/or$_=Ii

Ora posso implementare l'effettivo spostamento delle lettere. Da quando comincio con uno scambio, tutte le mosse dovrebbero essere fatte i, no I. Se $1impostato, sposta ia destra:

s/i |i$/ i/

Se $1non impostato, spostarsi ia sinistra

s/ i/i /

Si noti che all'inizio della stringa di controllo quando corrisponderò ^ $1non verrà impostato, quindi tenta di spostarsi ia sinistra sulla stringa iniziale Ii. Questo non funzionerà perché non c'è spazio lì, quindi la stringa iniziale rimane indisturbata (è per questo che ho messo il ()giro >invece di <)

Rimane solo un problema: alla fine della sostituzione esterna $_è impostato il risultato della sostituzione esterna indipendentemente da ciò che hai fatto $_all'interno del corpo di sostituzione. Quindi la stringa di destinazione con il corretto posizionamento ie Isi perde. Nei vecchi perl questo sarebbe un difetto fatale. Perls più recenti hanno comunque il rmodificatore che significa "crea una copia della stringa originale, fai la tua sostituzione e restituisci la stringa risultante (invece del numero di corrispondenze)". Quando lo uso qui, il risultato è che la stringa di comando modificata viene scartata mentre l'originale $_non è disturbato da perl e lasciato dopo la sostituzione. Comunque il disturbo che faccio $_è ancora fatto dopo che il Perl è rimasto $_solo. Quindi alla fine$_ sarà la stringa target corretta.

L' -popzione assicura che la stringa originale sia inserita $_e stampa anche il finale $_.

LittleLua - 178 byte

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')

Implementazione diretta.

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.

Cos'è LittleLua?

LittleLua è un lavoro in corso per cercare di livellare i campi di gioco tra la mia lingua preferita per queste sfide e le lingue esoteriche che spesso hanno incorporazioni estremamente potenti.

LittleLua è un interprete Lua 5.3.6 con un modulo aggiuntivo (LittleLua.Lua), così come i nomi di funzioni e moduli ridotti. Queste modifiche si espanderanno nel corso del prossimo giorno o due, fino a quando non sarò contento, ma per ora alcune delle maggiori modifiche tra LittleLua e un interprete Lua standard sono:

Funzioni e moduli sono ridotti:

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

Variabili integrate

LittleLua ha diverse variabili integrate per ridurre alcune attività:

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

Funzioni integrate

Attualmente un elenco deprimentemente piccolo, ma eccolo qui:

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

Provalo online

15 byte salvati grazie a daavko!

Accetta input separati da newline e output con gli occhi separati da spazi.

Spiegazione:

Spiegherò fase per fase come al solito. Tutte queste fasi sono in modalità Sostituisci di Retina. Ciò significa che la prima riga è un'espressione regolare e la seconda riga è una stringa di sostituzione.

$
¶Ii

Aggiungi l'iniziale Iialla fine dell'input.

( `^ ¶

Il backtick separa il palco dalle opzioni. Il carattere dell'opzione (indica che questa fase è l'inizio di un ciclo di fasi da eseguire ripetutamente in ordine fino al completamento di un ciclo completo senza modificare l'ingresso. Poiché questa parentesi aperta non è mai chiusa, tutte le fasi rimanenti fanno parte di questo ciclo.

Lo stage effettivo è molto semplice, se il primo carattere della stringa è una nuova riga, eliminalo. Questo serve solo per facilitare la gestione dell'input vuoto, altrimenti sarebbe più golfoso aggiungerlo alle ultime due fasi.

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

Qui, l'opzione sfa sì che il metacarattere Regex .corrisponda alle nuove righe. Questa fase fa sì che un lead >corrisponda al Iseguito da uno spazio opzionale. Quindi sostituisce quella corrispondenza con le cose dopo la >, seguita dallo spazio opzionale (quindi la stringa vuota se lo spazio non può essere abbinato), e quindi la I.

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

Questo stadio è molto simile al precedente, solo lo spazio opzionale è prima di I, e l'ordine e l'occhio sono invertiti.

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

La gestione di in irealtà è spesso più semplice, perché non dobbiamo preoccuparci di aggiungere o rimuovere facoltativamente, poiché ipuò sempre spostarsi a destra. Per i icasi abbiniamo il carattere di sottolineatura e il segno maggiore / minore di, ma altrimenti facciamo una logica simile. Questo aggiunge uno spazio prima di i.

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

Ancora una volta simile al precedente, ma cancella il personaggio prima iche quel personaggio sia uno spazio, altrimenti rimuove solo l'emoticon.

Python, 142 141 134 122 121 byte

Risparmiato 19 byte grazie 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'

Esempio:

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

Spiegazione:

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 byte

(incluso +1 per la -rbandiera)

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

Questo crea un nuovo programma sed dall'input (che puoi vedere rimuovendo l'ultima riga) e lo applica allo stato iniziale Ii.

Spiegazione

• Le prime due righe vengono convertite <e >per "sostituire" i comandi che spostano Irispettivamente a sinistra e a destra.
• Quindi cambiamo quello che segue _per lavorare ipiuttosto cheI
• i non è delimitato da alcun bordo destro, quindi non aggiungere o consumare spazio dopo di esso
• Infine, applica il comando creato all'input Ii. s///eusa sempre /bin/shcome shell, quindi non ho potuto accorciarlo sed '&'<<<Iicome volevo (questa è una sintassi di reindirizzamento di Bash).

Risultati del test

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

//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 non è molto diverso)

//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 byte

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

Provalo 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 byte

Probabilmente non ho adottato l'approccio migliore, quindi probabilmente è possibile giocare a golf di più. E no, non ho copiato FryAmTheEggman (so che sono molto simili nei nostri approcci). Non ho nemmeno visto la sua risposta fino a quando non ho pubblicato la mia.

$
¶Ii
(`^¶

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

Provalo online

Javascript (ES6) 166 byte

Usando la risposta di Charlie Wynn, sono riuscito a salvare 10 byte definendo Math.max come M e chiamando M ogni volta che il suo 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'}

(Non ho scritto questo golf, Charlie Wynn ha fatto qui . Ho semplicemente modificato per renderlo più breve)

JavaScript (ES6), 115 118

Modifica: 3 byte salvati grazie 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`

pè il numero di spazi prima I; qè il numero di spazi tra Ie i. Nessuno dei due può essere negativo.

Meno 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
)

Test

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 byte

3 byte salvati grazie a @FryAmTheEggman.

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

La spiegazione arriva un po 'più tardi.

Provalo online!

Codice modificato con batch test.

Python 2, 96 92 byte

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)

Soluzione piuttosto sfuggente per una sfida sfuggente. Input simile f('>_> <_>'), output simile 'I i'.

Programma di verifica (supponendo che testssia la stringa del test case multilinea):

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

Il programma legge ciascuna freccia una alla volta, a partire da I=1, i=2e utilizzando indici basati su 1. I nomi delle variabili sono un po 'fuorvianti poiché scambiano ruoli - dopo ogni carattere, Idiventa ie isi Iaggiorna. Un carattere viene aggiornato solo se non si sposta né sulla posizione dell'altro carattere né sulla posizione 0.

Ad esempio, per >_> <_> >_<noi:

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

Questo dà ' Ii'come desiderato.

Lua, 104 byte

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 byte

accetta un input impostando una variabile aprima di eseguire

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"

Abbastanza ungolfed:

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 byte

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

Funzione pura con il primo argomento #. L'idea è che ogni <_, >_, <, e >nelle corrisponde ingresso ad una regola sostituzione della stringa. "<_"|">_"|">"|"<"è uno schema di stringhe che corrisponde a una di quelle quattro espressioni. StringCases[#,"<_"|">_"|">"|"<"]troverà tutte queste corrispondenze. Quindi sostituiamo ( /.) ciascuno "<_"con la regola di sostituzione della stringa ".I"->"I.", ciascuno ">_"con la regola "I."->".I"e così via. Quindi voglio applicare sequenzialmente ogni regola di sostituzione alla stringa "Ii", ma StringReplacecercherò solo corrispondenze nelle parti della stringa che non sono state sostituite, quindi abbiamo lasciato Foldla funzione StringReplacesull'elenco delle regole di sostituzione con il valore iniziale "Ii".

Forse sarebbe più chiaro con un esempio (qui si %riferisce all'output della cella precedente):