Хлопці з високими очима 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

Виграє найкоротший код у байтах. Tiereaker є вищою відповіді.

Випробування

#[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, тому якщо транслітерація вказує, що нічого не змінилося, це мій тригер $_:

y/iI/Ii/or$_=Ii

Тепер я можу реалізувати власне переміщення листів. Оскільки я починаю зі свопу, всі рухи слід робити i, а не I. Якщо $1встановлено, рухайтесь iправоруч:

s/i |i$/ i/

Якщо $1не встановлено, рухайтесь iліворуч

s/ i/i /

Зауважте, що на початку контрольного рядка, коли я збігаюся ^ $1, не буде встановлено, тому він намагається перейти iвліво на початковий рядок Ii. Це не спрацює, тому що місця там немає, тому рядок рядка залишається непорушеним (саме тому я ставлю ()навколо >замість <)

Залишається лише одна проблема: наприкінці зовнішньої заміни $_встановлюється результат зовнішньої заміни незалежно від того, що ви зробили $_всередині тіла заміщення. Тож цільовий рядок при правильному розміщенні 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')

Пряма реалізація вперед.

Безголівки:

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 байт завдяки daavko!

Здійснює введення, розділене новими рядками, а виходи очима, розділеними пробілами.

Пояснення:

Я поясню поетапно, як завжди. Усі ці етапи знаходяться в режимі заміни 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якщо цей символ є пробілом, інакше він видаляє лише смайлик.

Пітон, 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як хотів (це синтаксис перенаправлення Баша).

Результати тесту

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

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 байт

Використовуючи відповідь Чарлі Вінна, мені вдалося зберегти 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 байти збережено в 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 байт

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'за бажанням.

Луа, 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"

Математика, 125 байт

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

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

Можливо, це було б зрозуміліше з прикладом (тут %йдеться про вихід попередньої комірки):