Shifty-eyes ASCII suka menggeser ASCII Ii:

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

Diberikan string orang-orang licik, berjarak atau memisahkan garis, menggeser Iisisi ke sisi, meninggalkan dinding dan ke kanan langit:

Ii

Shifter terpendek memenangkan hadiah.

Katakan apa?

Tulis sebuah program atau fungsi yang mengambil string daftar sembarang dari empat emotikon ASCII ini, baik spasi atau baris baru dipisahkan (dengan baris tambahan opsional):

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

Misalnya, inputnya mungkin

>_> >_> <_>

atau

>_>
>_>
<_>

(Metode yang Anda dukung terserah Anda.)

Setiap emotikon melakukan tindakan berbeda pada Idan ikarakter, yang selalu dimulai seperti ini:

Ii

• >_>bergeser Ike kanan satu per satu, jika mungkin, dan kemudian bergeser ike kanan satu per satu.
• <_<bergeser Ike kiri satu per satu, jika mungkin, dan kemudian bergeser ike kiri satu per satu, jika mungkin.
• >_<bergeser Ike kanan satu per satu, jika mungkin, dan kemudian bergeser ike kiri satu per satu, jika mungkin.
• <_>bergeser Ike kiri satu per satu, jika mungkin, lalu bergeser ike kanan satu per satu.

Itidak dapat digeser ke kiri jika berada di tepi kiri garis (seperti pada awalnya), dan tidak dapat digeser ke kanan jika ilangsung ke kanannya (seperti pada awalnya).

itidak dapat digeser ke kiri jika Ilangsung ke kiri (seperti pada awalnya), tetapi selalu dapat digeser ke kanan.

Perhatikan bahwa dengan aturan ini, Iakan selalu tetap di sebelah kiri i, dan Idicoba digeser sebelumnya iuntuk semua emotikon.

Program atau fungsi Anda perlu mencetak atau mengembalikan string Iigaris akhir setelah menerapkan semua pergeseran dalam urutan yang diberikan, menggunakan spasi ( ) atau titik ( .) untuk ruang kosong. Ruang atau periode yang tertinggal dan satu baris baru yang dibuntuti secara opsional diizinkan dalam output. Jangan mencampur ruang dan titik.

Misalnya input

>_>
>_>
<_>

memiliki output

I...i

karena shift berlaku suka

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

Kode terpendek dalam byte menang. Tiebreaker adalah jawaban dengan suara lebih tinggi.

Uji Kasus

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

Menggunakan .untuk kejelasan.

#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 byte

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

Menggunakan algoritma yang sama dengan jawaban Python saya , kecuali dengan pengindeksan 0. Pada dasarnya:

• Hanya lihat panah di input, konversikan <ke -1 dan >ke 1
• Hanya terapkan pembaruan jika itu tidak memindahkan kita ke posisi -1 dan tidak memindahkan kita ke posisi karakter lain
• Karena panah berganti antara melamar ke Idan melamar i, kami berganti posisi yang kami perbarui setelah setiap panah

Terima kasih kepada @ MartinBüttner untuk bermain golf pada langkah output, melepas 5 byte.

Cobalah online | Suite uji

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 byte

Termasuk +1 untuk -p

Jalankan dengan input pada STDIN, mis perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Penjelasan

String kontrol bergantian instruksi untuk idan Idan aturannya sama untuk keduanya jika Anda merumuskannya sebagai:

• < Bergerak ke kiri jika ada ruang ke kiri
• > Pindah ke kanan jika ada spasi atau ujung tali ke kanan

Jadi saya akan menukar idan Idalam string target pada setiap langkah jadi saya hanya perlu menerapkan aturan untuk satu huruf. Ini adalahy/iI/Ii/

Saya akan menjalankan string kontrol mencari <dan >menggunakan substitusi yang biasanya merupakan cara terpendek dalam perl untuk memproses sesuatu karakter demi karakter. Untuk menghindari keharusan menulis, $var =~saya ingin string kontrol dalam variabel default perl $_. Dan saya juga ingin cara mudah untuk membedakan <dari >. Semua ini dapat dicapai dengan menggunakan

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

Target string saya juga ingin memanipulasi menggunakan pergantian dan untuk alasan yang sama saya ingin itu $_juga. $_menjadi dua hal sekaligus tampaknya mustahil.

Namun saya dapat memiliki kue dan memakannya juga karena bagian $_dalam tubuh pengganti tidak harus tetap sama dengan $_yang diganti. Begitu perl mulai mengganti string, string ini tidak akan berubah bahkan jika Anda mengubah variabel dari mana string tersebut berasal. Jadi Anda dapat melakukan sesuatu seperti:

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

Saya ingin mengganti yang asli $_dengan yang pertama "Ii"hanya saat pertama kali badan substitusi dieksekusi (kalau tidak saya tetap mengatur ulang string target). Namun penggantian ini juga harus terjadi untuk string kontrol kosong, sehingga bahkan untuk string kontrol kosong tubuh perlu dieksekusi setidaknya sekali. Untuk memastikan substitusi menjalankan waktu ekstra di awal string kontrol (bahkan untuk string kontrol kosong) saya mengubah substitusi ke:

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

Saya akan menjalankan y/iI/Ii/sebagai hal pertama di dalam kode substitusi. Meskipun $_masih merupakan string kontrol, ini belum akan berisi apa pun Ii, jadi jika transliterasi menunjukkan tidak ada yang berubah, itulah pemicu saya menginisialisasi $_:

y/iI/Ii/or$_=Ii

Sekarang saya bisa menerapkan pemindahan huruf yang sebenarnya. Karena saya mulai dengan swap semua gerakan harus dilakukan i, bukan I. Jika $1diatur, pindah ike kanan:

s/i |i$/ i/

Jika $1tidak diatur, pindah ike kiri

s/ i/i /

Perhatikan bahwa pada awal string kontrol ketika saya cocok ^ $1tidak akan diatur, jadi mencoba untuk bergerak ike kiri pada string awal Ii. Ini tidak akan berfungsi karena tidak ada ruang di sana, jadi string awal tetap tidak terganggu (ini sebabnya saya meletakkan ()sekitar >bukan <)

Hanya satu masalah yang tersisa: di akhir substitusi luar $_diatur ke hasil dari substitusi luar terlepas dari apa yang Anda lakukan $_di dalam tubuh substitusi. Jadi target string dengan penempatan yang tepat idan Itersesat. Dalam perl yang lebih tua ini akan menjadi kesalahan fatal. Namun perl yang lebih baru memiliki rpengubah yang berarti "membuat salinan dari string asli, lakukan substitusi pada itu dan kembalikan string yang dihasilkan (bukan jumlah kecocokan)". Ketika saya menggunakan itu di sini hasilnya adalah bahwa string perintah yang dimodifikasi akan dibuang sementara yang asli $_tidak terganggu oleh perl dan dibiarkan setelah substitusi. Namun gangguan yang saya lakukan $_masih dilakukan setelah perl dibiarkan $_sendiri. Jadi pada akhirnya$_ akan menjadi target string yang tepat.

The -ppilihan memastikan string asli dalam $_dan juga mencetak final $_.

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

Implementasi lurus ke depan.

Tidak Disatukan:

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.

Apa itu LittleLua?

LittleLua adalah pekerjaan yang sedang berjalan untuk mencoba menyejajarkan bidang bermain antara bahasa pilihan saya untuk tantangan ini dan bahasa esoterik yang sering memiliki built-in yang sangat kuat.

LittleLua adalah juru bahasa Lua 5.3.6 dengan modul tambahan (LittleLua.Lua), serta nama fungsi dan modul menyusut. Perubahan-perubahan ini akan berkembang selama satu atau dua hari berikutnya, sampai saya bahagia, tetapi karena berdiri beberapa perubahan terbesar antara LittleLua dan juru bahasa Lua standar adalah:

Fungsi dan modul menyusut:

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

Dibangun dalam variabel

LittleLua memiliki beberapa variabel bawaan untuk menyusutkan beberapa tugas:

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

Dibangun pada Fungsi

Saat ini daftar kecil yang menyedihkan, tapi ini dia:

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

Retina ,101 86

$
¶Ii
(`^¶

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

Cobalah online

Disimpan 15 byte berkat daavko!

Mengambil input yang dipisahkan oleh baris baru dan keluaran dengan mata dipisahkan oleh spasi.

Penjelasan:

Saya akan menjelaskan tahap demi tahap seperti biasa. Semua tahapan ini dalam mode Ganti Retina. Itu berarti baris pertama adalah ekspresi reguler dan baris kedua adalah string pengganti.

$
¶Ii

Tambahkan inisial Iike akhir input.

(`^ ¶

Backtick memisahkan stage dari opsi. Karakter opsi (menunjukkan bahwa tahap ini adalah awal dari loop tahapan yang akan dieksekusi berulang kali hingga siklus penuh selesai tanpa mengubah input. Karena tanda kurung terbuka ini tidak pernah ditutup, semua tahapan yang tersisa adalah bagian dari loop ini.

Tahap sebenarnya sangat sederhana, jika karakter pertama dari string adalah baris baru maka hapuslah. Ini hanya untuk membantu mempermudah penanganan input kosong, jika tidak maka akan lebih mudah menambahkannya ke dua tahap terakhir.

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

Di sini, opsi smenyebabkan metacharacter Regex .untuk mencocokkan baris baru. Tahapan ini menyebabkan pemimpin >mencocokkan Idiikuti oleh ruang opsional. Kemudian itu menggantikan yang cocok dengan barang setelah >, diikuti oleh ruang opsional (jadi string kosong jika ruang tidak dapat dicocokkan), dan kemudian I.

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

Tahap ini sangat mirip dengan yang sebelumnya, hanya ruang opsional sebelum I, dan urutan dan mata dibalik.

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

Penanganan isebenarnya sering kali lebih sederhana, karena kita tidak perlu khawatir tentang opsi menambahkan atau menghapus karena iselalu dapat bergerak ke kanan. Untuk ikasus - kasus kami mencocokkan garis bawah serta tanda lebih besar / kurang dari, tetapi sebaliknya lakukan logika yang sama. Yang ini menambahkan ruang sebelum i.

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

Sekali lagi mirip dengan di atas, tetapi menghapus karakter sebelum ijika karakter itu adalah spasi, jika tidak hanya menghilangkan emotikon.

Python, 142 141 134 122 121 byte

Disimpan 19 byte berkat 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'

Contoh:

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

Penjelasan:

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 byte

(termasuk +1 untuk -rbendera)

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

Ini menciptakan program sed baru dari input (yang dapat Anda lihat dengan menghapus baris terakhir), dan menerapkannya ke status awal Ii.

Penjelasan

• Dua baris pertama mengkonversi <dan >untuk 'mengganti' perintah yang bergeser ke Ikiri dan kanan masing-masing.
• Kemudian kami mengubah yang berikut _untuk dikerjakan ialih-alihI
• i tidak dibatasi oleh tepi kanan mana pun, jadi jangan tambahkan atau gunakan ruang untuk mengikutinya
• Akhirnya, terapkan perintah yang dibuat ke input Ii. s///eselalu menggunakan /bin/shshell, jadi saya tidak bisa mempersingkat ini sed '&'<<<Iiseperti yang saya inginkan (itu adalah sintaks pengalihan Bash).

Hasil tes

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

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

Pemakaian

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 tidak jauh berbeda)

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

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

Cobalah 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 byte

Saya mungkin tidak mengambil pendekatan terbaik, jadi mungkin bisa bermain golf lebih banyak. Dan tidak, saya tidak menyalin FryAmTheEggman (saya tahu mereka sangat mirip dalam pendekatan kami). Saya bahkan tidak melihat jawabannya sampai saya memposting jawaban saya.

$
¶Ii
(`^¶

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

Cobalah online

Javascript (ES6) 166 byte

Menggunakan jawaban Charlie Wynn, saya berhasil menghemat 10 byte dengan mendefinisikan Math.max sebagai M dan memanggil M setiap kali skripnya menggunakan

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

(Saya tidak menulis golf ini, Charlie Wynn melakukannya di sini . Saya hanya memodifikasinya agar lebih pendek)

JavaScript (ES6), 115 118

Sunting: 3 byte disimpan 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`

padalah jumlah spasi sebelumnya I; qadalah jumlah spasi antara Idan i. Tidak ada yang negatif.

Kurang golf

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
)

Uji

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 byte

3 byte disimpan berkat @FryAmTheEggman.

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

Penjelasan datang sedikit kemudian.

Cobalah online!

Kode yang dimodifikasi dengan uji batch.

Python 2, 96 92 byte

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)

Solusi yang tampak licik untuk tantangan yang licik. Input like f('>_> <_>'), output like 'I i'.

Program verifikasi (dengan asumsi testsadalah string kasus uji multiline):

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

Program membaca setiap panah satu per satu, dimulai dengan I=1, i=2dan menggunakan indeks berbasis 1. Nama-nama variabel anak laki-laki menyesatkan karena mereka menukar peran - setelah setiap char, Imenjadi idan imenjadi Idiperbarui. Char hanya diperbarui jika ia tidak akan bergerak ke posisi char lain atau posisi 0.

Misalnya, untuk >_> <_> >_<kita lakukan:

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

Ini memberi ' Ii'seperti yang diinginkan.

Lua, 104 byte

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

Pemakaian:

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

Javascript (ES5), 153 125 byte

mengambil input dengan mengatur variabel asebelum berjalan

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"

Agak tidak terserang:

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 byte

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

Fungsi murni dengan argumen pertama #. Idenya adalah bahwa setiap <_, >_, <, dan >dalam berkorespondensi masukan untuk aturan string pengganti. "<_"|">_"|">"|"<"adalah pola string yang cocok dengan salah satu dari empat ekspresi itu. StringCases[#,"<_"|">_"|">"|"<"]akan menemukan semua kecocokan tersebut. Kemudian kita ganti ( /.) masing "<_"- masing dengan aturan penggantian string ".I"->"I.", masing ">_"- masing dengan aturan "I."->".I", dan sebagainya. Lalu saya ingin secara berurutan menerapkan setiap aturan penggantian ke string "Ii", tetapi StringReplacehanya akan mencari kecocokan di bagian-bagian string yang belum diganti, jadi kami meninggalkan Foldfungsi di StringReplaceatas daftar aturan penggantian dengan nilai awal "Ii".

Mungkin akan lebih jelas dengan contoh (di sini %merujuk pada keluaran sel sebelumnya):