视而不见的ASCII家伙喜欢转移ASCII的字符Ii：

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

给定一串杂乱无章的家伙，这些家伙相互隔开或分开，将的Ii一侧左右移动，向左移墙，向右移天空：

Ii

最短的变速杆赢得了大奖。

说什么？

编写一个程序或函数，该程序或函数接收这四个ASCII表情符号的任意列表的字符串，以空格或换行符分隔（带有可选的尾随换行符）：

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

例如，输入可能是

>_> >_> <_>

要么

>_>
>_>
<_>

（您支持的方法取决于您。）

每个表情符号都会对I和i字符执行不同的操作，总是以如下方式开始：

Ii

• >_>转移I通过一个在右边，如果可能的话，并且然后将i通过一个权。
• <_<I如果可能的话，向左移动一位，然后，如果可能的话，向左移动i一位。
• >_<I如果可能，向右移动一，然后，如果可能，则向左移动i一。
• <_>转移I到由一个，左如果可能的话，并且然后将i被一个到右侧。

I如果它在直线的左边缘，则不能向左移动（如其初始位置）；如果i它直接在其右侧，则不能向右移动（如其初始位置）。

i如果I直接位于左侧，则不能向左移动（如最初一样），但始终可以向右移动。

请注意，使用这些规则，I将始终保留在的左侧i，并I尝试在i所有图释之前进行平移。

您的程序或函数需要Ii按照给定的顺序应用所有移位后，使用空格（ ）或句点（.）表示空白，然后打印或返回最后一行的字符串。输出中可选地允许尾随空格或句点以及一个尾随换行符。不要混用空格和句点。

例如，输入

>_>
>_>
<_>

有输出

I...i

因为这种变化像

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

以字节为单位的最短代码获胜。决胜局是最高投票的答案。

测试用例

#[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答案相同的算法，但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在每一步的目标字符串，所以我只需要规则应用到一个字母永远。这是y/iI/Ii/

我将遍历控制字符串以查找<并>使用替代方法，这通常是perl中逐字符处理某些事物的最短方法。为了避免不得不写，$var =~我希望在perl默认变量中包含控制字符串$_。我也希望有一个简单的方法来区分<从>。所有这些都可以使用

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

我也想使用替换操作目标字符串，出于同样的原因，我也希望使用替换$_。$_同时做两件事似乎是不可能的。

但是，我也可以吃蛋糕，也可以吃，因为$_替代品的内部不必与$_被取代后的相同。一旦perl开始替换字符串，即使您更改了字符串最初来自的变量，该字符串也不会更改。因此，您可以执行以下操作：

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

我只想在第一次执行替换主体时就$_用初始名称替换原始内容"Ii"（否则，我会一直重置目标字符串）。但是，对于空的控制字符串也必须进行这种替换，因此即使对于空的控制字符串，主体也需要至少执行一次。为了确保替换在控制字符串的开头（即使对于空的控制字符串）运行额外的时间，我将替换项更改为：

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

我将y/iI/Ii/在替换代码中首先运行。虽然$_仍然是控制字符串，但它仍然不包含任何内容Ii，因此，如果音译表明未进行任何更改，则这是我的触发器initialize $_：

y/iI/Ii/or$_=Ii

现在，我可以实现字母的实际移动。由于我是从交换开始的，所以所有的动作都应该进行i，而不是I。如果$1设置i为，请向右移动：

s/i |i$/ i/

如果$1未设置i，请向左移动

s/ i/i /

请注意，^ $1将不会设置当我匹配的控制字符串的开头，因此它将尝试向i初始字符串的左侧移动Ii。这是行不通的，因为没有空间存在，所以INTIAL串保持不受干扰（这就是为什么我把()身边>，而不是<）

仅剩下一个问题：外部替换的结尾将$_设置为外部替换的结果，而不管您$_在替换体内进行的操作如何。因此，正确放置了i和的目标字符串I会丢失。在较早的Perls中，这将是致命的缺陷。但是，最新的perls具有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是一个Lua 5.3.6解释器，带有一个附加模块（LittleLua.Lua），以及功能和模块名称均已缩小。这些更改将在第二天或第二天扩展，直到我感到满意为止，但是由于它体现了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的“替换”模式。这意味着第一行是正则表达式，第二行是替换字符串。

$
¶Ii

将首字母添加Ii到输入的末尾。

（`^¶

反引号将阶段与选项分开。选项字符(表示此阶段是阶段循环的开始，该阶段将重复执行，直到完成整个周期而不更改输入为止。由于此开放括号从未关闭，因此其余所有阶段都是此循环的一部分。

实际阶段非常简单，如果字符串的第一个字符是换行符，则将其删除。这只是为了帮助简化空输入的操作，否则将其添加到最后两个阶段会更加困难。

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

在这里，该选项s使Regex元字符.匹配换行符。此阶段导致引线>匹配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个字节

（包括+1 -r）

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

说明

• 前两行将转换<并转换>为I分别向左和向右移动的“替代”命令。
• 然后，我们更改以下_要处理的内容i而不是I
• i 没有任何右手边的边界，因此请勿在其后边添加或占用空间
• 最后，将创建的命令应用于input 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

使用Javascript（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"

脱线（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字节

使用Charlie Wynn的答案，我通过将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'}

（我没有写这本书，Charlie Wynn在这里写过。我只是修改了它以使其更短）

的JavaScript（ES6），115 118

编辑： 3字节保存CharxWynn

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('.',' ')

该程序从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

Javascript（ES5），153125字节

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

具有第一个参数的纯函数#。这个想法是每个<_，>_，<，和>输入对应一个字符串替换规则。"<_"|">_"|">"|"<"是与这四个表达式中的任何一个匹配的字符串模式。StringCases[#,"<_"|">_"|">"|"<"]将找到所有此类匹配项。然后，我们将（/.）分别"<_"替换为字符串替换规则".I"->"I."，将每个">_"规则替换为"I."->".I"，依此类推。然后，我想顺序地将每个替换规则应用于字符串"Ii"，但是StringReplace只会在字符串中尚未替换的部分中查找匹配项，因此我们Fold将函数保留在StringReplace替换规则列表的开头，并将其设为起始值"Ii"。

也许用一个例子会更清楚（这里%指的是前一个单元的输出）：