Shifty-eyes ASCIIの人はASCIIをシフトしたいIi：

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

ずんぐりした男の列を、間隔をあけて、または別々の線で与えて、を左右に動かしIi、壁を左に、空を右に：

Ii

最短のシフターが賞を獲得します。

何だって？

これらの4つのASCII絵文字の任意のリストの文字列を、スペースまたは改行で区切った（オプションの末尾改行で）取り込むプログラムまたは関数を作成します。

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

たとえば、入力は

>_> >_> <_>

または

>_>
>_>
<_>

（サポートする方法はあなた次第です。）

それぞれの顔文字は、上の別のアクションを実行Iし、i常にこのよう始めるの文字を、：

Ii

• >_>シフトI1右に、可能な場合は、その後、シフトi1だけ右へ。
• <_<I可能であれば、左に1つシフトし、可能であれば、i左に1つシフトします。
• >_<I可能であれば、右に1つシフトし、可能であれば、i左に1つシフトします。
• <_>シフトI1左に、可能な場合は、その後、シフトi1だけ右へ。

I線の左端にある場合（最初の場合）iは左にシフトできません。また、右に直接ある場合（最初の場合）は右にシフトできません。

iが左にI直接ある場合（最初の場合）は左にシフトできませんが、常に右にシフトできます。

注は、これらのルールで、というIいつもの左に残るi、とI前にシフトしようとするiすべての顔文字のために。

プログラムまたは関数は、空のスペースにIiスペース（ ）またはピリオド（.）を使用して、指定された順序ですべてのシフトを適用した後、最終行のストリングを印刷または返す必要があります。出力では、オプションで後続のスペースまたはピリオドと単一の後続改行を使用できます。スペースとピリオドを混在させないでください。

たとえば、入力

>_>
>_>
<_>

出力があります

I...i

シフトは次のように適用されるため

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

バイト単位の最短コードが優先されます。Tiebreakerは、より高い投票数の回答です。

テストケース

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

.明確にするために使用します。

#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バイト

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

Pythonのanswerと同じアルゴリズムを使用しますが、 0インデックスを使用します。基本的に：

• 入力の矢印のみを見て、<-1と>1に変換します
• 位置-1に移動せず、他の文字の位置に移動しない場合にのみ、更新を適用します
• 矢印はに適用するIとに適用するiことを交互に繰り返すため、各矢印の後に更新する位置を交互に切り替えます

@MartinBüttnerに、5バイトを取り出して出力ステップをゴルフしていただきありがとうございます。

オンラインで試す | テストスイート

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バイト

+1を含む -p

STDINの入力で実行します。例えば perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl：

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

説明

制御文字列はiとの命令を交互にします。Iルールを次のように定式化すると、両方の規則は同じになります。

• < 左にスペースがある場合は左に移動します
• > 右側にスペースまたは文字列の終わりがある場合は右に移動します

私はスワップに行くよだから、iとI私は今まで1つの文字にルールを適用する必要があるので、各ステップでターゲット文字列に。これはy/iI/Ii/

私は、制御文字列を探して歩いていく<と>、通常の文字で何か文字を処理するためのperlで最短の道である置換を使用します。書く$var =~必要を避けるために、perlのデフォルト変数に制御文字列が必要です$_。そして、私はまた、区別する簡単な方法たい<からと>。これはすべて、次を使用して実現できます。

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

ターゲット文字列も、置換を使用して操作したいのですが、同じ理由でそれも必要です$_。$_一度に2つのことをすることは不可能に思えます。

しかし、私は自分のケーキを持って食べることもできます。なぜなら、$_代替品の体内は、服従しているものと同じままである必要はないからです$_。perlが文字列の置換を開始すると、この文字列は元の変数を変更しても変更されません。次のようなことができます：

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

私はオリジナルを交換したい$_初期により"Ii"置換体が実行されますのみ、非常に最初の時間（それ以外の場合は、私がターゲット文字列をリセットしておきます）。ただし、この置換は空の制御文字列に対しても発生する必要があるため、空の制御文字列であっても、本体を少なくとも1回実行する必要があります。（空の制御文字列であっても）制御文字列の開始時に置換が余分に実行されるようにするには、置換を次のように変更します。

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

y/iI/Ii/置換コード内で最初に実行します。while $_はまだ制御文字列ですが、これにはまだ何も含まれていませんIiので、音訳が何も変更されていないことを示している場合、それは私のトリガーinitialize $_です：

y/iI/Ii/or$_=Ii

これで、文字の実際の移動を実装できます。私はスワップを開始するので、すべての動きは、上で行われるべきiではありませんI。$1設定されている場合i、右に移動します。

s/i |i$/ i/

$1設定さiれていない場合は左に移動します

s/ i/i /

一致^ $1するときの制御文字列の先頭では設定されないためi、最初の文字列で左に移動しようとしますIi。そこにスペースがないため、これは機能しません。したがって、最初の文字列は邪魔されずに残ります（これがの代わりに()周りを置く理由>です<）

問題は1つだけ残っています。外部置換の最後に、置換本体内部$_で何をしたかに関係なく、外部置換の結果に設定されます$_。適切な配置とターゲット文字列だから、iとI失われます。古いperlでは、これは致命的な欠陥になります。しかし、最近のperlには、r「元の文字列のコピーを作成し、置換を行って、一致する数ではなく結果の文字列を返す」という修飾子があります。ここでそれを使用すると、変更されたコマンド文字列は破棄されますが、オリジナル$_はperlによって妨害されず、置換後に残されます。しかし、私がやるの$_は、perlが放っておかれた後でもまだ$_です。最後に$_ 適切なターゲット文字列になります。

この-pオプションは、元の文字列が含まれていることを確認し$_、最終文字列も出力し$_ます。

LittleLua -178バイト

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

簡単な実装。

ゴルフをしていない：

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.

LittleLuaとは何ですか？

LittleLuaは、これらの課題に最適な言語と、非常に強力なビルトイン機能を持つことが多い難解な言語との間で競争条件を平準化しようとする作業中です。

LittleLuaは、追加のモジュール（LittleLua.Lua）、および関数名とモジュール名が縮小されたLua 5.3.6インタープリターです。これらの変更は、私が満足するまで次の1〜2日で拡大しますが、LittleLuaと標準のLuaインタープリターとの間の最大の変更のいくつかは次のとおりです。

関数とモジュールは縮小されています。

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

組み込み変数

LittleLuaには、いくつかのタスクを縮小するための組み込み変数がいくつかあります。

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

組み込み関数

現在、気のめいるほど小さなリストですが、ここにあります：

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

網膜、101 86

$
¶Ii
(`^¶

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

オンラインで試す

daavkoのおかげで15バイト節約できました！

入力を改行で区切り、出力をスペースで区切って出力します。

説明：

通常どおり、段階ごとに説明します。これらのステージはすべて、Retinaの置換モードです。つまり、1行目は正規表現であり、2行目は置換文字列です。

$
¶Ii

Ii入力の末尾にイニシャルを追加します。

（ `^¶

バックティックは、ステージをオプションから分離します。オプション文字(は、このステージが入力を変更せずに完全なサイクルが完了するまで順番に繰り返し実行されるステージのループの開始であることを示します。この開き括弧は閉じられないため、残りのすべてのステージはこのループの一部です。

実際の段階は非常に単純です。文字列の最初の文字が改行の場合は削除します。これは、空の入力を簡単に処理できるようにするためのものです。そうしないと、最後の2つのステージに追加する方がゴルファーになります。

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

ここでは、このオプションsにより、正規表現のメタ文字.が改行と一致します。この段階では、先頭>とI末尾にオプションのスペースが続きます。次に、その一致をの後にあるもので置き換え>、その後にオプションのスペース（スペースが一致しなかった場合は空の文字列）が続きIます。

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

この段階は前の段階と非常によく似ています。オプションのスペースのみがの前Iにあり、順序と目が逆になっています。

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

の処理iは実際にはしばしば単純ですi。これは、常に適切に移動できるため、オプションで追加または削除することを心配する必要がないためです。このi場合、アンダースコアと大なり記号と小なり記号を一致させますが、それ以外は同様のロジックを実行します。これはの前にスペースを追加しますi。

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

再び上記と同様ですが、iその文字がスペースの場合はその前の文字を削除し、そうでない場合は顔文字のみを削除します。

Python、142 141 134 122 121バイト

xnorのおかげで19バイト節約されました。

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'

例：

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

説明：

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バイト

（-rフラグの+1を含む）

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

これにより、入力から新しいsedプログラムが作成され（最後の行を削除することで確認できます）、開始状態に適用されIiます。

説明

• 最初の2行は変換<と>シフトすることを「代替」コマンドにIそれぞれ左右と。
• その後、我々は、次のうち1つを変更_上で動作するようにするiのではなくI
• i 右端に囲まれていないため、それに続くスペースを追加または消費しないでください
• 最後に、作成したコマンドを入力に適用しますIi。 s///e常に/bin/shシェルとして使用するため、これsed '&'<<<Iiを希望どおりに短縮できませんでした（これはBashリダイレクト構文です）。

試験結果

$ 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

ジャバスクリプト（ES6） 176 171 168 155 148 147の142 141バイト

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

使用法

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はそれほど変わりません）

//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バイト

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

オンラインでお試しください！

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

網膜、91 86バイト

私はおそらく最善のアプローチを取らなかったので、おそらくもっとゴルフができるでしょう。いいえ、私はFryAmTheEggmanをコピーしませんでした（私たちのアプローチでそれらが本当に似ていることは知っています）。私が投稿した後まで、私は彼の答えさえ見ませんでした。

$
¶Ii
(`^¶

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

オンラインで試す

Javascript（ES6）166バイト

チャーリー・ウィンの答えを使用して、Math.maxをMとして定義し、スクリプトが使用するたびにMを呼び出すことにより、10バイトを節約することができました。

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

（私はこのゴルフを書きませんでした、チャーリー・ウィンはここで書きました。私はそれを短くするためにそれを単に修正しました）

JavaScript（ES6）、115 118

編集： 3バイト保存された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は前のスペースの数Iです。q間のスペースの数であるIとはi。どちらも負になることはできません。

少ないゴルフ

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
)

テスト

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>

網膜、61 58バイト

@FryAmTheEggmanのおかげで3バイト節約されました。

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

説明は少し後になります。

オンラインでお試しください！

バッチテストで変更されたコード。

Python 2、96 92バイト

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)

移行困難な課題に対する非常に移行困難な外観のソリューション。のような入力、のようなf('>_> <_>')出力'I i'。

検証プログラム（tests複数行のテストケース文字列であると仮定）：

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

プログラムは、1から始まるI=1, i=2インデックスを使用して、各矢印を1つずつ読み取ります。変数名は、彼らが役割を交換するので、少しは誤解されている-すべての文字の後に、IなりiとiなっI更新します。文字は、他の文字の位置にも位置0にも移動しない場合にのみ更新されます。

たとえば、次のよう>_> <_> >_<にします。

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

これは' Ii'、必要に応じて提供されます。

Lua、104バイト

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

使用法：

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

ジャバスクリプト（ES5）、153の 125バイト

a実行する前に変数を設定して入力を取得します

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"

やや自由：

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バイト

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

最初の引数を持つ純粋な関数#。考え方は、それぞれ<_、>_、<、および>文字列交換規則に入力相当します。"<_"|">_"|">"|"<"これらの4つの式のいずれかに一致する文字列パターンです。StringCases[#,"<_"|">_"|">"|"<"]そのような一致をすべて検索します。次に、/.それぞれ（）"<_"を文字列置換ルールに".I"->"I."、それぞれ">_"をルール"I."->".I"に、というように置き換えます。それから私は、順次文字列に、各置換ルールを適用したい"Ii"、しかし、StringReplace我々は左だけなので、交換されていない文字列の部分で一致を検索しますFold機能をStringReplace開始値に置き換えるルールのリストの上に"Ii"。

おそらく、例があればより明確になるでしょう（ここで%は前のセルの出力を参照しています）：