Ребята с резким взором 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

Самый короткий код в байтах побеждает. Ответ 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 , за исключением 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, однако, имеют 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')

Прямая реализация.

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.

Что такое 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

Попробуйте онлайн

Сэкономили 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 байт

Сохранено 19 байтов благодаря 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'

Пример:

>>> 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 не ограничен никаким правым краем, поэтому не добавляйте и не занимайте пространство после него
• Наконец, примените созданную команду к вводу 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

Retina, 91 86 байт

Я, вероятно, не выбрал лучший подход, поэтому он может быть больше в гольфе. И нет, я не копировал FryAmTheEggman (я знаю, что они действительно похожи в наших подходах). Я даже не видел его ответ, пока не опубликовал свой.

$
¶Ii
(`^¶

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

Попробуйте онлайн

Javascript (ES6) 166 байт

Используя ответ Чарли Уинна, мне удалось сохранить 10 байтов, определив Math.max как M и вызывая M каждый раз, когда его скрипт использует

_=>{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 байта сохранены, спасибо Чарли Винн

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>

Retina, 61 58 байт

3 байта сохранены благодаря @FryAmTheEggman.

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

Чистая функция с первым аргументом #. Идея заключается в том , что каждый <_, >_, <, и >во входных соответствует правилу замены строки. "<_"|">_"|">"|"<"является строковым шаблоном, который соответствует любому из этих четырех выражений. StringCases[#,"<_"|">_"|">"|"<"]найдете все такие совпадения. Затем мы заменяем ( /.) каждое "<_"на правило замены строки ".I"->"I.", каждое ">_"на правило "I."->".I"и так далее. Затем я хочу последовательно применить каждое правило замены к строке "Ii", но StringReplaceбуду искать только совпадения в тех частях строки, которые не были заменены, поэтому мы оставили Foldфункцию StringReplaceв списке правил замены с начальным значением "Ii".

Возможно, это было бы более понятно с примером (здесь %относится к выводу предыдущей ячейки):