Những anh chàng ASCII có đôi mắt sắc sảo muốn thay đổi ASCII Ii:

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

Đưa ra một chuỗi những kẻ nhút nhát, cách nhau hoặc tách các dòng, chuyển Iibên này sang bên kia, rời khỏi bức tường và bên phải bầu trời:

Ii

Các shifter ngắn nhất sẽ giành giải thưởng.

Nói gì cơ?

Viết chương trình hoặc hàm lấy một chuỗi danh sách tùy ý của bốn biểu tượng cảm xúc ASCII này, được phân cách bằng dấu cách hoặc dấu cách (với một dòng mới theo dõi tùy chọn):

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

Ví dụ: đầu vào có thể là

>_> >_> <_>

hoặc là

>_>
>_>
<_>

(Phương pháp bạn hỗ trợ tùy thuộc vào bạn.)

Mỗi biểu tượng cảm xúc thực hiện một hành động khác nhau trên Ivà các iký tự, luôn bắt đầu như thế này:

Ii

• >_>dịch chuyển Isang phải một, nếu có thể, và sau đó dịch chuyển isang phải một.
• <_<dịch chuyển Isang trái bởi một, nếu có thể, và sau đó dịch chuyển isang trái bởi một, nếu có thể.
• >_<dịch chuyển Isang phải một, nếu có thể, và sau đó dịch chuyển isang trái một, nếu có thể.
• <_>dịch chuyển Isang trái một, nếu có thể, và sau đó dịch chuyển isang phải một.

Ikhông thể được dịch chuyển sang trái nếu nó ở cạnh trái của dòng (như ban đầu) và không thể được dịch chuyển sang phải nếu itrực tiếp bên phải (như ban đầu).

ikhông thể được dịch chuyển sang trái nếu Itrực tiếp bên trái (như ban đầu), nhưng luôn có thể được dịch chuyển sang phải.

Lưu ý rằng với các quy tắc này, Isẽ luôn ở bên trái ivà Iđược cố gắng thay đổi trước icho tất cả các biểu tượng cảm xúc.

Chương trình hoặc chức năng của bạn cần in hoặc trả về một chuỗi của Iidòng cuối cùng sau khi áp dụng tất cả các ca theo thứ tự đã cho, sử dụng khoảng trắng ( ) hoặc dấu chấm ( .) cho không gian trống. Không gian lưu trữ hoặc dấu chấm và một dòng mới duy nhất được tùy chọn cho phép trong đầu ra. Không trộn lẫn không gian và thời gian.

Ví dụ: đầu vào

>_>
>_>
<_>

có đầu ra

I...i

bởi vì sự thay đổi áp dụng như

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

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là câu trả lời bình chọn cao hơn.

Các trường hợp thử nghiệm

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

Sử dụng .cho rõ ràng.

#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

Sử dụng thuật toán tương tự như câu trả lời Python của tôi , ngoại trừ với chỉ mục 0. Bản chất:

• Chỉ nhìn vào các mũi tên trong đầu vào, chuyển đổi <thành -1 và >1
• Chỉ áp dụng bản cập nhật nếu nó không di chuyển chúng tôi đến vị trí -1 và không chuyển chúng tôi đến vị trí của char khác
• Vì các mũi tên xen kẽ giữa áp dụng Ivà áp dụng cho i, chúng tôi thay thế vị trí chúng tôi cập nhật sau mỗi mũi tên

Cảm ơn @ MartinBüttner đã đánh golf bước đầu ra, lấy ra 5 byte.

Dùng thử trực tuyến | Bộ kiểm tra

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

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN, vd perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Giải trình

Chuỗi điều khiển thay thế các hướng dẫn cho ivà Iquy tắc là giống nhau cho cả hai nếu bạn xây dựng chúng là:

• < Di chuyển sang trái nếu có khoảng trống ở bên trái
• > Di chuyển sang phải nếu có khoảng trắng hoặc cuối chuỗi bên phải

Vì vậy, tôi sẽ trao đổi ivà Itrong chuỗi mục tiêu ở mỗi bước vì vậy tôi chỉ cần áp dụng quy tắc cho một chữ cái bao giờ. Đây lày/iI/Ii/

Tôi sẽ đi theo chuỗi điều khiển tìm kiếm <và >sử dụng một sự thay thế thường là cách ngắn nhất trong perl để xử lý một cái gì đó theo từng ký tự. Để tránh phải viết $var =~tôi muốn chuỗi điều khiển trong biến mặc định perl $_. Và tôi cũng muốn một cách dễ dàng để phân biệt <từ >. Tất cả điều này có thể được thực hiện bằng cách sử dụng

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

Chuỗi mục tiêu tôi cũng muốn thao tác bằng cách sử dụng thay thế và vì lý do tương tự tôi cũng muốn điều đó $_. $_là hai điều cùng một lúc dường như là không thể.

Tuy nhiên tôi có thể có bánh của mình và ăn nó vì $_cơ thể của người thay thế không phải giữ nguyên như người $_được thay thế. Khi perl bắt đầu thay thế một chuỗi, chuỗi này sẽ không thay đổi ngay cả khi bạn thay đổi biến mà chuỗi ban đầu đến từ đó. Vì vậy, bạn có thể làm một cái gì đó như:

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

Tôi muốn thay thế bản gốc $_bằng bản gốc "Ii"chỉ lần đầu tiên cơ thể thay thế được thực thi (nếu không tôi tiếp tục đặt lại chuỗi mục tiêu). Tuy nhiên, sự thay thế này cũng phải xảy ra đối với một chuỗi điều khiển trống, do đó, ngay cả đối với chuỗi điều khiển trống, phần thân cần phải được thực thi ít nhất một lần. Để đảm bảo trạm biến áp chạy thêm thời gian khi bắt đầu chuỗi điều khiển (ngay cả đối với chuỗi điều khiển trống) tôi thay đổi thay thế thành:

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

Tôi sẽ chạy y/iI/Ii/như là điều đầu tiên bên trong mã thay thế. Mặc dù $_vẫn là chuỗi điều khiển nhưng điều này sẽ không chứa bất kỳ chuỗi nào Ii, vì vậy nếu phiên âm cho thấy không có gì thay đổi thì đó là kích hoạt khởi tạo của tôi $_:

y/iI/Ii/or$_=Ii

Bây giờ tôi có thể thực hiện việc di chuyển thực tế của các chữ cái. Vì tôi bắt đầu với một trao đổi, tất cả các di chuyển nên được thực hiện trên i, không I. Nếu $1được đặt di chuyển isang phải:

s/i |i$/ i/

Nếu $1không được đặt di chuyển isang trái

s/ i/i /

Lưu ý rằng khi bắt đầu chuỗi điều khiển khi tôi khớp ^ $1sẽ không được đặt, vì vậy nó cố gắng di chuyển isang bên trái trên chuỗi ban đầu Ii. Điều này sẽ không hoạt động vì không có không gian ở đó, vì vậy chuỗi intial vẫn không bị xáo trộn (đây là lý do tại sao tôi đặt ()xung quanh >thay vì <)

Chỉ còn một vấn đề: ở cuối sự thay thế bên ngoài $_được đặt thành kết quả của sự thay thế bên ngoài bất kể bạn đã làm gì $_bên trong cơ thể thay thế. Vì vậy, chuỗi mục tiêu với vị trí thích hợp ivà Ibị mất. Trong những cái cũ hơn, đây sẽ là một lỗ hổng chết người. Tuy nhiên, các perls gần đây hơn có bộ rsửa đổi có nghĩa là "tạo một bản sao của chuỗi gốc, thay thế chuỗi đó và trả về chuỗi kết quả (thay vì số lượng khớp)". Khi tôi sử dụng ở đây, kết quả là chuỗi lệnh đã sửa đổi sẽ bị loại bỏ trong khi bản gốc $_không bị xáo trộn bởi perl và bị bỏ lại sau khi thay thế. Tuy nhiên, làm phiền tôi làm trên $_vẫn thực hiện sau khi perl trái $_một mình. Cuối cùng$_ sẽ là chuỗi mục tiêu thích hợp.

Các -ptùy chọn đảm bảo chuỗi ban đầu là trong $_và cũng in trận chung kết $_.

LittleLua - 178 byte

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

Thẳng tiến thực hiện.

Ung dung:

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 là gì?

LittleLua là một công việc đang tiến triển để cố gắng san bằng các sân chơi giữa ngôn ngữ mà tôi lựa chọn cho những thách thức này và các ngôn ngữ bí truyền thường có những tích hợp cực kỳ mạnh mẽ.

LittleLua là một trình thông dịch Lua 5.3.6 với một mô-đun bổ sung (LittleLua.Lua), cũng như tên hàm và mô-đun bị thu hẹp. Những thay đổi này sẽ mở rộng trong một hoặc hai ngày tiếp theo, cho đến khi tôi hài lòng, nhưng vì nó có một số thay đổi lớn nhất giữa LittleLua và trình thông dịch Lua tiêu chuẩn là:

Các chức năng và mô-đun được thu hẹp:

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

Được xây dựng trong các biến

LittleLua có một số biến được tích hợp để thu nhỏ một số tác vụ:

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

Chức năng tích hợp sẵn

Hiện tại là một danh sách nhỏ đáng buồn, nhưng đây là:

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

Võng mạc ,101 86

$
¶Ii
(`^¶

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

Dùng thử trực tuyến

Đã lưu 15 byte nhờ daavko!

Đưa đầu vào được phân tách bằng dòng mới và đầu ra với mắt cách nhau bởi khoảng trắng.

Giải trình:

Tôi sẽ giải thích từng giai đoạn như bình thường. Tất cả các giai đoạn này đều ở chế độ Thay thế của Retina. Điều đó có nghĩa là dòng đầu tiên là một biểu thức chính quy và dòng thứ hai là một chuỗi thay thế.

$
¶Ii

Thêm chữ cái đầu Iivào cuối đầu vào.

(`^

Backtick tách giai đoạn từ các tùy chọn. Ký tự tùy chọn (chỉ ra rằng giai đoạn này là bắt đầu một vòng các giai đoạn được thực hiện lặp lại theo thứ tự cho đến khi hoàn thành một chu kỳ đầy đủ mà không thay đổi đầu vào. Vì dấu ngoặc đơn mở này không bao giờ đóng, tất cả các giai đoạn còn lại là một phần của vòng lặp này.

Giai đoạn thực tế rất đơn giản, nếu ký tự đầu tiên của chuỗi là một dòng mới thì xóa nó. Điều này chỉ để giúp xử lý đầu vào trống dễ dàng hơn, nếu không, sẽ tốt hơn khi thêm nó vào hai giai đoạn cuối.

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

Ở đây, tùy chọn slàm cho vi khuẩn Regex metacharacter .khớp với dòng mới. Giai đoạn này gây ra một sự dẫn đầu >phù hợp với Itiếp theo là một không gian tùy chọn. Sau đó, nó thay thế khớp đó với các thứ sau >, theo sau là khoảng trắng tùy chọn (vì vậy chuỗi trống nếu không gian không thể được khớp), và sau đó là I.

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

Giai đoạn này rất giống với giai đoạn trước, chỉ có không gian tùy chọn ở trước Ivà thứ tự và mắt bị đảo ngược.

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

Việc xử lý ithực sự thường đơn giản hơn, bởi vì chúng ta không phải lo lắng về việc tùy chọn thêm hoặc xóa vì iluôn có thể di chuyển đúng. Đối với các itrường hợp, chúng tôi khớp với dấu gạch dưới cũng như dấu lớn hơn / nhỏ hơn dấu, nhưng nếu không thì làm logic tương tự. Điều này thêm một không gian trước i.

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

Một lần nữa tương tự như trên, nhưng nó xóa ký tự trước inếu ký tự đó là khoảng trắng, nếu không, nó chỉ xóa biểu tượng cảm xúc.

Python, 142 141 134 122 121 byte

Đã lưu 19 byte nhờ 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'

Thí dụ:

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

Giải trình:

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

(bao gồm +1 cho -rcờ)

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

Điều này tạo ra một chương trình sed mới từ đầu vào (mà bạn có thể thấy bằng cách xóa dòng cuối cùng) và áp dụng nó cho trạng thái bắt đầu Ii.

Giải trình

• Hai dòng đầu tiên chuyển đổi <và >thành các lệnh 'thay thế' thay đổi Itrái và phải tương ứng.
• Sau đó, chúng tôi thay đổi một trong những sau đây _để làm việc ihơn làI
• i không bị giới hạn bởi bất kỳ cạnh phải nào, vì vậy đừng thêm hoặc tiêu thụ không gian theo sau nó
• Cuối cùng, áp dụng lệnh đã tạo cho đầu vào Ii. s///eluôn luôn sử dụng /bin/shnhư vỏ của nó, vì vậy tôi không thể rút ngắn nó sed '&'<<<Iinhư tôi muốn (đó là cú pháp chuyển hướng Bash).

Kết quả kiểm tra

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

Sử dụng

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 không khác nhiều)

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

Hãy thử trực tuyến!

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

Võng mạc, 91 86 byte

Tôi có lẽ đã không thực hiện phương pháp tốt nhất, vì vậy nó có thể được chơi gôn nhiều hơn. Và không, tôi đã không sao chép FryAmTheEggman (Tôi biết chúng thực sự giống nhau trong cách tiếp cận của chúng tôi). Tôi thậm chí không nhìn thấy câu trả lời của anh ấy cho đến khi tôi đăng bài của tôi.

$
¶Ii
(`^¶

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

Dùng thử trực tuyến

Javascript (ES6) 166 byte

Sử dụng câu trả lời của Charlie Wynn, tôi đã cố gắng tiết kiệm 10 byte bằng cách định nghĩa Math.max là M và gọi M mỗi khi tập lệnh của anh ấy sử dụng

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

(Tôi đã không viết golf này, Charlie Wynn đã làm ở đây . Tôi chỉ sửa đổi nó để làm cho nó ngắn hơn)

JavaScript (ES6), 115 118

Chỉnh sửa: 3 byte đã lưu 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`

plà số lượng không gian trước đó I; qlà số lượng khoảng cách giữa Ivà i. Không thể tiêu cực.

Ít chơi gôn

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
)

Kiểm tra

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>

Võng mạc, 61 58 byte

3 byte được lưu nhờ @FryAmTheEggman.

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

Giải thích đến một chút sau.

Hãy thử trực tuyến!

Mã sửa đổi với kiểm tra hàng loạt.

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)

Giải pháp khá đẹp mắt cho một thách thức shifty. Đầu vào như thế f('>_> <_>'), đầu ra như thế nào 'I i'.

Chương trình xác minh (giả sử testslà chuỗi trường hợp thử nghiệm đa dòng):

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

Chương trình đọc từng mũi tên một, bắt đầu bằng I=1, i=2và sử dụng các chỉ số dựa trên 1. Các tên biến là một chút sai lệch vì họ hoán đổi vai trò - sau mỗi char, Itrở thành ivà itrở nên Icập nhật. Một char chỉ được cập nhật nếu nó sẽ chuyển sang vị trí của char khác cũng như vị trí 0.

Ví dụ: đối với >_> <_> >_<chúng tôi:

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

Điều này cho ' Ii'như mong muốn.

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)

Sử dụng:

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

Javascript (ES5), 153 125 byte

nhận đầu vào bằng cách đặt biến atrước khi chạy

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"

Hơi vô dụng:

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"

Toán học, 125 byte

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

Hàm thuần túy với đối số đầu tiên #. Ý tưởng là mỗi <_, >_, <, và >trong tương ứng với đầu vào cho một quy tắc chuỗi thay thế. "<_"|">_"|">"|"<"là một mẫu chuỗi khớp với bất kỳ biểu thức nào trong bốn biểu thức đó. StringCases[#,"<_"|">_"|">"|"<"]sẽ tìm thấy tất cả các trận đấu như vậy. Sau đó, chúng tôi thay thế ( /.) từng "<_"quy tắc thay thế chuỗi ".I"->"I.", từng ">_"quy tắc "I."->".I"và vv. Sau đó, tôi muốn áp dụng tuần tự từng quy tắc thay thế cho chuỗi "Ii", nhưng StringReplacesẽ chỉ tìm kiếm các kết quả khớp trong các phần của chuỗi chưa được thay thế, vì vậy chúng tôi đã để lại Foldchức năng StringReplacetrong danh sách các quy tắc thay thế có giá trị bắt đầu "Ii".

Có lẽ nó sẽ rõ ràng hơn với một ví dụ (ở đây %đề cập đến đầu ra của ô trước đó):