ผู้ชายที่มีรสนิยมดี 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"เฉพาะครั้งแรกที่เนื้อหาการแทนที่ถูกเรียกใช้งาน (ไม่เช่นนั้นฉันจะรีเซ็ตสตริงเป้าหมาย) อย่างไรก็ตามการแทนที่นี้จะต้องเกิดขึ้นสำหรับสตริงควบคุมที่ว่างเปล่าดังนั้นแม้สำหรับสตริงควบคุมที่ว่างเปล่าร่างกายจะต้องดำเนินการอย่างน้อยหนึ่งครั้ง เพื่อให้แน่ใจว่า substition รันเวลาพิเศษที่จุดเริ่มต้นของสตริงควบคุม (แม้แต่สำหรับสตริงควบคุมว่าง) ฉันเปลี่ยนการแทนที่เป็น:

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สิ่งนี้จะไม่ทำงานเพราะไม่มีที่ว่างดังนั้นสตริง 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 ไบต์ขอบคุณ daavko!

ใช้อินพุตแยกจากกันโดยขึ้นบรรทัดใหม่และเอาต์พุตด้วยตาคั่นด้วยช่องว่าง

คำอธิบาย:

ฉันจะอธิบายทีละขั้นตอนตามปกติ ทุกขั้นตอนเหล่านี้อยู่ในโหมดแทนที่ของ Retina นั่นหมายความว่าบรรทัดแรกคือนิพจน์ทั่วไปและบรรทัดที่สองคือสตริงแทนที่

$
¶Ii

เพิ่มค่าเริ่มต้นIiไปยังจุดสิ้นสุดของอินพุต

( `^ ¶

backtick แยกเวทีออกจากตัวเลือก อักขระตัวเลือก(ระบุว่าสเตจนี้เป็นจุดเริ่มต้นของลูปของสเตจที่จะดำเนินการซ้ำ ๆ ตามลำดับจนกระทั่งครบวงจรโดยไม่ต้องเปลี่ยนอินพุต เนื่องจากเครื่องหมายวงเล็บเปิดนี้ไม่เคยถูกปิดระยะที่เหลือทั้งหมดจึงเป็นส่วนหนึ่งของการวนซ้ำนี้

สเตจที่แท้จริงนั้นง่ายมากถ้าอักขระตัวแรกของสตริงเป็นบรรทัดใหม่ให้ลบออก นี่เป็นเพียงเพื่อช่วยให้การจัดการอินพุตว่างง่ายขึ้นมิฉะนั้นจะเป็นนักกอล์ฟเพื่อเพิ่มลงในสองขั้นตอนสุดท้าย

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

ที่นี่ตัวเลือกsทำให้ตัวmetach ตัวละคร Regex .ตรงกับขึ้นบรรทัดใหม่ ขั้นตอนนี้ทำให้ผู้นำ>ในการจับคู่Iตามด้วยพื้นที่ที่ไม่จำเป็น จากนั้นก็จะเข้ามาแทนที่การแข่งขันกับสิ่งที่หลังจากนั้น>ตามด้วยพื้นที่ที่เลือกได้ (ดังนั้นสตริงว่างหากพื้นที่ไม่สามารถจับคู่) Iและจากนั้น

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

ขั้นตอนนี้คล้ายกันมากกับพื้นที่ก่อนหน้านี้มีเพียงพื้นที่ที่เป็นตัวเลือกอยู่ก่อนหน้าIและลำดับและสายตาจะกลับด้าน

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

การจัดการiมักจะง่ายกว่าเพราะเราไม่ต้องกังวลกับการเพิ่มหรือลบทางเลือกซึ่งiสามารถเคลื่อนที่ได้เสมอ สำหรับiกรณีที่เราจับคู่ขีดเส้นใต้และเครื่องหมายมากกว่า / น้อยกว่า แต่ทำตรรกะที่คล้ายกัน iหนึ่งในนี้จะเพิ่มพื้นที่ก่อน

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

คล้ายกับด้านบนอีกครั้ง แต่จะลบอักขระก่อนอักขระiif นั้นคือช่องว่างมิฉะนั้นจะลบเฉพาะไอคอนแสดงอารมณ์

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"

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 ไบต์

ใช้คำตอบของ Charlie Wynn ฉันจัดการเพื่อบันทึก 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'}

(ฉันไม่ได้เขียนกอล์ฟนี้ Charlie Wynn ทำที่นี่ฉันเพิ่งแก้ไขเพื่อทำให้สั้นลง)

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ไม่สามารถเป็นค่าลบ

น้อย golfed

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 61ไบต์

บันทึก 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"

ค่อนข้าง ungolfed:

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"

บางทีมันอาจจะชัดเจนขึ้นด้วยตัวอย่าง (ที่นี่%หมายถึงผลลัพธ์ของเซลล์ก่อนหน้า):