Shifty-Eyes ASCII-Leute lieben es, ASCIIs zu verschieben Ii:

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

Verschieben Sie bei einer Reihe von Shifty-Typen in Abständen oder mit getrennten Linien die IiSeite zu Seite, lassen Sie die Wand links und den Himmel rechts:

Ii

Der kürzeste Schalthebel gewinnt den Preis.

Sag was?

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge einer beliebigen Liste dieser vier ASCII-Emoticons enthält, entweder durch Leerzeichen oder durch Zeilenumbrüche getrennt (mit optionalem abschließendem Zeilenumbruch):

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

Zum Beispiel könnte die Eingabe sein

>_> >_> <_>

oder

>_>
>_>
<_>

(Die von Ihnen unterstützte Methode liegt bei Ihnen.)

Jedes Emoticon führt eine andere Aktion für die Zeichen Iund aus i, die immer so beginnen:

Ii

• >_>verschiebt sich Inach Möglichkeit um eins nach rechts und dann ium eins nach rechts.
• <_<verschiebt Isich, wenn möglich, um eins nach links und dann, wenn möglich, ium eins nach links.
• >_<verschiebt sich Inach Möglichkeit um eins nach rechts und dann inach Möglichkeit um eins nach links.
• <_>verschiebt sich Inach Möglichkeit um eins nach links und dann ium eins nach rechts.

Ikann nicht nach links verschoben werden, wenn es sich am linken Rand der Linie befindet (wie es anfänglich ist), und kann nicht nach rechts verschoben werden, wenn ies sich direkt nach rechts befindet (wie es anfänglich ist).

iKann nicht nach links verschoben werden, wenn er Idirekt nach links liegt (wie am Anfang), kann aber immer nach rechts verschoben werden.

Beachten Sie, dass diese Regeln Iimmer links von bleiben iund Iversucht werden, sie ifür alle Emoticons vorher zu verschieben .

Ihr Programm oder Ihre Funktion muss eine Zeichenfolge der letzten IiZeile drucken oder zurückgeben , nachdem alle Verschiebungen in der angegebenen Reihenfolge angewendet wurden, wobei Leerzeichen ( ) oder Punkte ( .) als Leerzeichen verwendet werden. Nachgestellte Leerzeichen oder Punkte und eine einzelne nachgestellte Zeile sind in der Ausgabe optional zulässig. Mischen Sie keine Leerzeichen und Punkte.

Zum Beispiel die Eingabe

>_>
>_>
<_>

hat ausgegeben

I...i

da gelten die verschiebungen gerne

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

Der kürzeste Code in Bytes gewinnt. Tiebreaker ist höher gestimmte Antwort.

Testfälle

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

Gebrauch .für Klarheit.

#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

Verwendet den gleichen Algorithmus wie meine Python-Antwort , außer mit 0-Indizierung. Im Wesentlichen:

• Schauen Sie sich nur die Pfeile in der Eingabe an, die <in -1 und >in 1 konvertieren
• Wende ein Update nur an, wenn es uns nicht auf Position -1 und nicht auf die Position des anderen Zeichens bringt
• Da die Pfeile zwischen Anwenden auf Iund Anwenden auf iwechseln, wechseln wir die Position, die wir nach jedem Pfeil aktualisieren

Vielen Dank an @ MartinBüttner für das Golfen des Ausgabeschritts und das Abheben von 5 Bytes.

Versuchen Sie es online | Testsuite

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

Beinhaltet +1 für -p

Führen Sie mit der Eingabe auf STDIN, z perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Erläuterung

Die Steuerzeichenfolge wechselt die Anweisungen für iund Iund die Regel ist für beide gleich, wenn Sie sie wie folgt formulieren:

• < Bewegen Sie sich nach links, wenn links ein Leerzeichen ist
• > Bewegen Sie sich nach rechts, wenn rechts ein Leerzeichen oder ein Ende der Zeichenfolge ist

Also ich Swap werde iund Ibei jedem Schritt in der Zielzeichenfolge so dass ich immer nur die Regel auf einen Buchstaben anwenden muß. Dies ist dasy/iI/Ii/

Ich gehe den Kontrollstring durch <und suche und >benutze eine Substitution, die normalerweise der kürzeste Weg in Perl ist, um etwas Zeichen für Zeichen zu verarbeiten. Um nicht schreiben zu müssen, $var =~möchte ich die Steuerzeichenfolge in der Perl-Standardvariablen $_. Und ich möchte auch eine einfache Möglichkeit , zu unterscheiden <von >. All dies kann mit erreicht werden

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

Die Zielzeichenfolge möchte ich auch mit Substitutionen manipulieren und aus dem gleichen Grund möchte ich das $_auch. $_Zwei Dinge gleichzeitig zu sein, scheint unmöglich.

Ich kann jedoch meinen Kuchen haben und ihn auch essen, weil das $_Innere eines Substitutionskörpers nicht dasselbe bleiben muss wie das $_Substituierte. Sobald Perl mit dem Ersetzen eines Strings begonnen hat, ändert sich dieser String nicht mehr, selbst wenn Sie die Variable ändern, aus der der String ursprünglich stammt. Sie können also Folgendes tun:

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

Ich möchte das Original nur dann $_durch das Initiale ersetzen, "Ii"wenn der Ersetzungskörper zum ersten Mal ausgeführt wird (ansonsten setze ich die Zielzeichenfolge weiter zurück). Dieser Austausch muss jedoch auch für eine leere Kontrollzeichenfolge erfolgen, sodass der Body selbst für die leere Kontrollzeichenfolge mindestens einmal ausgeführt werden muss. Um sicherzustellen, dass die Substitution am Anfang der Kontrollzeichenfolge eine zusätzliche Zeit lang ausgeführt wird (auch bei leeren Kontrollzeichenfolgen), ändere ich die Substitution in:

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

Ich werde das y/iI/Ii/als erstes im Ersetzungscode ausführen. Solange $_es sich noch um die Steuerzeichenfolge handelt, enthält diese noch keine Ii. Wenn die Transliteration also anzeigt, dass nichts geändert wurde, ist dies mein Auslöser. Initialisieren Sie $_:

y/iI/Ii/or$_=Ii

Jetzt kann ich das eigentliche Verschieben der Buchstaben durchführen. Da ich mit einem Swap beginne, sollten alle Züge am gemacht werden i, nicht I. Wenn gesetzt $1ist, gehe inach rechts:

s/i |i$/ i/

Wenn $1nicht gesetzt, gehe inach links

s/ i/i /

Beachten Sie, dass am Anfang der Steuerzeichenfolge, wenn ich übereinstimme ^ $1, nicht festgelegt wird, so dass versucht wird, iauf der ursprünglichen Zeichenfolge nach links zu verschieben Ii. Dies wird nicht funktionieren, da dort kein Platz ist, so dass die Anfangszeichenfolge ungestört bleibt (aus diesem Grund habe ich die ()herum >statt <)

Es bleibt nur ein Problem: Am Ende der äußeren Ersetzung $_wird das Ergebnis der äußeren Ersetzung angezeigt, unabhängig davon, was Sie $_im Ersetzungskörper angestellt haben. Also die Zielzeichenfolge mit der richtigen Platzierung iund Igeht verloren. In älteren Perls wäre dies ein fataler Fehler. Neuere Perls haben jedoch den rModifikator " Erstelle eine Kopie der ursprünglichen Zeichenfolge, ersetze diese und gib die resultierende Zeichenfolge zurück (anstelle der Anzahl der Übereinstimmungen)". Wenn ich das hier benutze, ist das Ergebnis, dass der geänderte Befehlsstring verworfen wird, während das Original $_nicht durch Perl gestört wird und nach dem Ersetzen übrig bleibt. Jedoch ist das störende, was ich an tue, $_immer noch erledigt, nachdem Perl in $_Ruhe gelassen wurde. Also am Ende$_ wird die richtige Zielzeichenfolge sein.

Die -pOption stellt sicher, dass sich die ursprüngliche Zeichenfolge in befindet, $_und druckt auch das Finale $_.

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

Einfache Implementierung.

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.

Was ist LittleLua?

LittleLua ist in Arbeit, um zu versuchen, die Wettbewerbsbedingungen zwischen meiner bevorzugten Sprache für diese Herausforderungen und esoterischen Sprachen, die oft über extrem leistungsfähige Funktionen verfügen, auszugleichen.

LittleLua ist ein Lua 5.3.6-Interpreter mit einem zusätzlichen Modul (LittleLua.Lua) sowie eingeschränkten Funktions- und Modulnamen. Diese Änderungen werden sich in den nächsten ein oder zwei Tagen ausweiten, bis ich zufrieden bin, aber derzeit sind einige der größten Änderungen zwischen LittleLua und einem Standard-Lua-Interpreter:

Funktionen und Module sind geschrumpft:

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

Eingebaute Variablen

LittleLua verfügt über mehrere eingebaute Variablen, um einige Aufgaben zu verkleinern:

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

Eingebaute Funktionen

Derzeit eine bedrückend kleine Liste, aber hier ist es:

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

Netzhaut ,101 86

$
¶Ii
(`^¶

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

Probieren Sie es online aus

Dank daavko 15 Bytes gespart!

Nimmt Eingaben getrennt durch Zeilenumbrüche und Ausgaben mit durch Leerzeichen getrennten Augen.

Erläuterung:

Ich werde wie gewohnt Schritt für Schritt erklären. Alle diese Stufen befinden sich im Retina-Ersetzungsmodus. Das bedeutet, dass die erste Zeile ein regulärer Ausdruck und die zweite Zeile eine Ersatzzeichenfolge ist.

$
¶Ii

Fügen Sie die Initiale Iian das Ende der Eingabe an.

(`^ ¶

Das Backtick trennt die Bühne von den Optionen. Das Optionszeichen (gibt an, dass diese Stufe der Beginn einer Schleife von Stufen ist, die wiederholt ausgeführt werden müssen, bis ein vollständiger Zyklus abgeschlossen ist, ohne die Eingabe zu ändern. Da diese offene Klammer niemals geschlossen wird, sind alle verbleibenden Stufen Teil dieser Schleife.

Die eigentliche Phase ist sehr einfach: Wenn das erste Zeichen der Zeichenfolge eine neue Zeile ist, löschen Sie sie. Dies dient nur dazu, die Handhabung der leeren Eingabe zu vereinfachen, andernfalls wäre es besser, sie zu den beiden letzten Stufen hinzuzufügen.

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

Hier sbewirkt die Option, dass das Regex-Metazeichen .mit den Zeilenumbrüchen übereinstimmt. Diese Stufe bewirkt, dass ein >Lead dem Igefolgt von einem optionalen Leerzeichen entspricht. Dann wird diese Übereinstimmung durch das Zeug nach dem ersetzt >, gefolgt von dem optionalen Leerzeichen (also der leeren Zeichenfolge, wenn das Leerzeichen nicht übereinstimmen konnte) und dann dem I.

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

Diese Phase ist der vorherigen sehr ähnlich, nur das optionale Leerzeichen befindet sich vor dem I, und die Reihenfolge und das Auge sind vertauscht.

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

Die Handhabung iist tatsächlich oftmals einfacher, da wir uns nicht um das optionale Hinzufügen oder Entfernen kümmern müssen, da iimmer nach rechts gewechselt werden kann. Für die iFälle stimmen wir sowohl den Unterstrich als auch das Größer / Kleiner-Zeichen ab, machen aber ansonsten eine ähnliche Logik. Dieser fügt ein Leerzeichen vor dem ein i.

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

Ähnlich wie oben, löscht jedoch das Zeichen vor dem Zeichen, iwenn es sich um ein Leerzeichen handelt. Andernfalls wird nur das Emoticon entfernt.

Python, 142 141 134 122 121 Bytes

Dank xnor 19 Bytes gespart.

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'

Beispiel:

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

Erläuterung:

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

(einschließlich +1 für -rFlagge)

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

Dadurch wird aus der Eingabe ein neues sed-Programm erstellt (das durch Entfernen der letzten Zeile angezeigt wird) und auf den Startstatus angewendet Ii.

Erläuterung

• Die ersten beiden Zeilen konvertieren <und >ersetzen Befehle, die nach Ilinks bzw. rechts verschoben werden.
• Dann ändern wir den folgenden, um daran _zu arbeiten iund nichtI
• i wird nicht durch eine rechte Kante begrenzt, fügen Sie also keinen darauf folgenden Platz hinzu oder belegen Sie ihn nicht
• Wenden Sie abschließend den erstellten Befehl auf die Eingabe an Ii. s///ewird immer /bin/shals Shell verwendet, daher konnte ich dies nicht so verkürzen, sed '&'<<<Iiwie ich wollte (das ist eine Bash-Umleitungssyntax).

Testergebnisse

$ 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'}

Verwendungszweck

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 ist nicht viel anders)

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

Probieren Sie es 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

Ich habe wahrscheinlich nicht die beste Herangehensweise gewählt, also kann man wahrscheinlich mehr Golf spielen. Und nein, ich habe FryAmTheEggman nicht kopiert (ich weiß, dass sie in unseren Ansätzen wirklich ähnlich sind). Ich habe seine Antwort erst gesehen, nachdem ich meine gepostet hatte.

$
¶Ii
(`^¶

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

Probieren Sie es online aus

Javascript (ES6) 166 Bytes

Mit der Antwort von Charlie Wynn konnte ich 10 Bytes einsparen, indem ich Math.max als M definierte und jedes Mal M aufrief, wenn sein Skript verwendet wurde

_=>{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'}

(Ich habe diesen Golf nicht geschrieben, Charlie Wynn hier . Ich habe ihn nur modifiziert, um ihn kürzer zu machen.)

JavaScript (ES6), 115 118

Edit: 3 Bytes gespeichert dank 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`

pist die Anzahl der Leerzeichen vor I; qist die Anzahl der Leerzeichen zwischen Iund i. Beides kann nicht negativ sein.

Weniger golfen

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
)

Prüfung

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 gespart dank @FryAmTheEggman.

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

Erklärung kommt etwas später.

Probieren Sie es online!

Geänderter Code mit Chargentest.

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)

Ziemlich zwielichtig aussehende Lösung für eine zwielichtige Herausforderung. Eingabe wie f('>_> <_>'), Ausgabe wie 'I i'.

Überprüfungsprogramm (unter testsder Annahme, dass es sich um die mehrzeilige Testfallzeichenfolge handelt):

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

Das Programm liest jeden Pfeil einzeln, beginnend mit I=1, i=2und unter Verwendung von 1-basierten Indizes. Die Variablennamen sind ein bisschen irreführend, da sie die Rollen tauschen - nach jedem Zeichen Iwird iund iwird Iaktualisiert. Ein Zeichen wird nur aktualisiert, wenn es sich weder an die Position des anderen Zeichens noch an die Position 0 bewegen würde.

Zum Beispiel machen >_> <_> >_<wir:

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

Dies gibt ' Ii'wie gewünscht.

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)

Verwendungszweck:

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

Javascript (ES5), 153 bis 125 Byte

Nimmt eine Eingabe durch Setzen einer Variablen avor dem Ausführen

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"

Etwas 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 Bytes

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

Reine Funktion mit erstem Argument #. Die Idee ist , dass jeder <_, >_, <, und >in dem Eingang entspricht einen String Ersetzungsregel. "<_"|">_"|">"|"<"ist ein Zeichenfolgenmuster, das mit einem dieser vier Ausdrücke übereinstimmt. StringCases[#,"<_"|">_"|">"|"<"]findet alle diese Übereinstimmungen. Dann ersetzen wir ( /.) jeweils "<_"durch die String-Ersetzungsregel ".I"->"I.", jede ">_"durch die Regel "I."->".I"und so weiter. Dann möchte ich nacheinander jede Ersetzungsregel auf die Zeichenfolge anwenden "Ii", StringReplacesuche jedoch nur nach Übereinstimmungen in den Teilen der Zeichenfolge, die nicht ersetzt wurden. Daher haben wir Folddie Funktion StringReplaceüber der Liste der Ersetzungsregeln mit dem Startwert belassen "Ii".

Vielleicht wäre es mit einem Beispiel klarer ( %bezieht sich hier auf die Ausgabe der vorherigen Zelle):