Shifty-eyes ASCII 녀석은 ASCII를 이동하는 것을 좋아합니다 Ii.

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

시시한 사람들이 줄을 지어 서로 떨어져 있거나 별도의 줄이 있으면 Ii의 측면을 좌우로 옮기고 벽을 왼쪽으로, 하늘을 오른쪽으로 이동하십시오.

Ii

최단 시프터가 상을받습니다.

뭐라고?

공백 또는 개행 문자로 구분 된이 네 가지 ASCII 이모티콘 중 임의의 목록으로 구성된 문자열을 프로그램이나 함수로 작성하십시오 (선택적 후행 개행 문자 포함).

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

예를 들어, 입력은

>_> >_> <_>

또는

>_>
>_>
<_>

(지원하는 방법은 귀하에게 달려 있습니다.)

각 이모티콘은 I및 i문자 에 대해 서로 다른 작업을 수행하며 항상 다음과 같이 시작합니다.

Ii

• >_>이동 I가능한 한만큼 오른쪽으로, 다음 이동 i하나 오른쪽으로.
• <_<이동 I이동 한 후 가능하면, 하나의 왼쪽과에 i가능하다면, 하나 왼쪽으로.
• >_<이동 I가능한 한만큼 오른쪽으로, 다음 이동 i가능하면, 하나 왼쪽으로.
• <_>교대 I당시, 가능하면 하나 떠났고,에가 이동 i한만큼 오른쪽으로.

I라인의 왼쪽 가장자리에 있으면 왼쪽으로 이동할 수 없으며 (처음 그대로) 오른쪽 i에 직접 있으면 오른쪽으로 이동할 수 없습니다 .

iI직접 왼쪽에있는 경우 (초기 그대로) 왼쪽으로 이동할 수 없지만 항상 오른쪽으로 이동할 수 있습니다.

이러한 규칙, 참고 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

0- 인덱싱을 제외하고는 Python answer 와 동일한 알고리즘을 사용 합니다. 본질적으로 :

• 입력의 화살표 <만보고 -1과 >1 로 변환하십시오.
• -1 위치로 이동하지 않고 다른 문자의 위치로 이동하지 않는 경우에만 업데이트를 적용하십시오.
• 적용 I과 적용 사이에 화살표가 번갈아 표시되므로 i각 화살표 다음에 업데이트 할 위치를 번갈아 가며

출력 단계를 골프화하여 5 바이트를 제거하는 @ MartinBüttner에게 감사드립니다.

온라인으로 사용해보십시오 | 테스트 스위트

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

펄, 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/

나는 찾고 제어 문자열을 안내합니다 <및 >보통 문자로 어떤 문자를 처리하기 위해 펄에서 가장 짧은 방법입니다 대체를 사용하여. 쓰지 않으려면 $var =~perl 기본 변수에 제어 문자열이 필요합니다 $_. 그리고 나는 또한 구별 할 수있는 쉬운 방법 원하는 <에서를 >. 이 모든 것을 사용하여 수행 할 수 있습니다

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

대상 문자열도 대체를 사용하여 조작하고 싶습니다. 같은 이유로 나는 그것을 원합니다 $_. $_한 번에 두 가지가되는 것은 불가능 해 보입니다.

그러나 $_대체 체 내부가 미숙 한 것과 동일하게 유지 될 필요가 없기 때문에 케이크를 가지고 먹을 수도 있습니다 $_. 펄이 문자열을 대체하기 시작하면 문자열이 원래 나온 변수를 변경하더라도이 문자열은 변경되지 않습니다. 따라서 다음과 같은 작업을 수행 할 수 있습니다.

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. 어떤 공간이 없기 때문에 intial 문자열이 그대로 유지되도록이 (내가 넣어 이유가 작동하지 않습니다 ()주위를 >대신 <)

하나의 문제 만 남아 있습니다. 외부 대체의 끝에는 대체 본문 내부에서 $_수행 한 작업에 관계없이 외부 대체의 결과로 설정됩니다 $_. 그래서의 적절한 배치와 대상 캐릭터 i와는 I손실됩니다. 오래된 perls에서는 치명적인 결함이 될 것입니다. 그러나 가장 최근의 perls에는 r"원본 문자열의 사본을 작성하고 그에 대한 대체를 수행하고 결과 문자열 (일치 횟수 대신)을 반환"을 의미 하는 수정자가 있습니다. 여기서 사용하면 수정 된 명령 문자열이 삭제되고 원본 $_은 perl에 의해 방해받지 않고 대체 후에 남습니다. 그러나 방해 나 에 할 수는 $_펄이 떠난 후 아직 이루어집니다 $_만. 그래서 결국$_ 적절한 대상 문자열이됩니다.

이 -p옵션을 사용하면 원래 문자열이 입력되고 $_final 문자열 도 인쇄 $_됩니다.

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는 추가 모듈 (LittleLua.Lua)과 기능 및 모듈 이름이 축소 된 Lua 5.3.6 인터프리터입니다. 이 변경 사항은 다음날 2 ~ 2 일 동안 확장 될 것입니다.하지만 행복 할 때까지 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

온라인으로 사용해보십시오

daavko 덕분에 15 바이트가 절약되었습니다!

줄 바꿈으로 구분 된 입력을 가져오고 공백으로 구분 된 눈으로 출력합니다.

설명:

평소처럼 단계별로 설명하겠습니다. 이 모든 단계는 Retina의 교체 모드에 있습니다. 즉, 첫 번째 줄은 정규식이고 두 번째 줄은 대체 문자열입니다.

$
¶Ii

Ii입력의 끝에 이니셜 을 추가하십시오 .

(`^ ¶

백틱은 옵션과 스테이지를 분리합니다. 옵션 문자 (는이 단계가 입력을 변경하지 않고 전체 사이클이 완료 될 때까지 반복적으로 실행될 단계 루프의 시작임을 나타냅니다. 이 열린 괄호는 닫히지 않기 때문에 나머지 모든 단계는이 루프의 일부입니다.

문자열의 첫 번째 문자가 줄 바꿈이면 실제 단계는 매우 간단합니다. 이것은 빈 입력을보다 쉽게 ​​처리 할 수 ​​있도록하기위한 것입니다. 그렇지 않으면 마지막 두 단계에 추가하는 것이 골퍼입니다.

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

이 옵션을 사용 s하면 정규식 메타 문자 .가 줄 바꿈과 일치합니다. 이 단계에서는 행간 >과 그 I뒤에 선택적인 공백이 일치합니다 . 그런 다음 해당 일치 항목을 >뒤에 공백으로 대체 하고 옵션 공백 (공백을 일치시킬 수없는 경우 빈 문자열)을 입력 한 다음 I.

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

이 단계는 이전 단계와 매우 유사하며 선택적 공간 만 앞에 I있으며 순서와 눈이 반전됩니다.

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

항상 올바르게 이동할 수 있으므로 i선택적으로 추가하거나 제거 할 필요가 없기 때문에 처리 가 실제로 더 간단 i합니다. 경우에 i따라 밑줄뿐만 아니라 부호보다 크거나 작지만 비슷한 논리를 수행합니다. 이것은 앞에 공백을 추가합니다 i.

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

위와 유사하지만 i해당 문자가 공백이면 문자를 삭제하고 그렇지 않으면 이모티콘 만 제거합니다.

파이썬 142 141 134 122 121 바이트

xnor 덕분에 19 바이트를 절약했습니다.

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 바이트

( -r플래그에 +1 포함 )

#!/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 오른쪽 가장자리에 묶이지 않으므로 그 뒤에 공백을 추가하거나 소비하지 마십시오.
• 마지막으로 작성된 명령을 input에 적용하십시오 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

자바 (ES6) 176 171 168 155 148 147 142 141 바이트

//v8 - I was sure saving off math was saving a byte, thanks ETF
_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v7 - not checking first char when I can check whole string - changed how I create end string (stolen from edc65)
_=>_.split` `.map(m=>(I=m<'='?I-1||0:M.min(i-1,I+1))+(i=m[2]=='<'?M.max(I+1,i-1):i+1),i=1,I=0,M=Math)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'

//v6 - one more byte
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)+((a=Array(i))[I]='I')&&a.join`.`+'i'

//v5 - not filling array with '.', just joining with . later
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i))[I]='I')&&a.join`.`+'i'

//v4 - realized I didn't need to split >_> on _, just use the 0th and 2nd index
_=>_.split` `.map(m=>(I=m[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[2]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v3 - saving Math to a var (thanks @Verzio)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?M(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?M(I+1,i-1):i+1),i=1,I=0,M=Math.max)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//v2 - as a single expression! (thanks @Downgoat)
_=>_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&((a=Array(i).fill`.`)[I]='I')&&a.join``+'i'

//version 1
_=>{I=0;i=1;_.split` `.map(m=>(I=(m=m.split`_`)[0]=='<'?Math.max(0,I-1):Math.min(i-1,I+1))+(i=m[1]=='<'?Math.max(I+1,i-1):i+1));(a=Array(i).fill`.`)[I]='I';return a.join``+'i'}

용법

f=_=>_.split` `.map(m=>(I=m<'='?I-1||0:Math.min(i-1,I+1))+(i=m[2]=='<'?Math.max(I+1,i-1):i+1),i=1,I=0)&&'.'.repeat(I)+'I'+'.'.repeat(--i-I)+'i'


f(">_> >_< >_> >_> >_> >_> >_> >_> <_> <_> <_<")
//"...I.....i"

디고 프드 (v6, v7은 크게 다르지 않음)

//my solution has changed slightly, but not significantly enough to redo the below

_=>                   //take an input
  _.split` `          //split to each command <_<
   .map(              //do something for each command (each command being called m)
     m=>              
       (I=            //set I to.... 'I will be the index of the letter I'
         m[0]=='<'?   //is the first char of the command '<'?
           Math.max(0,I-1)   //yes => move I to the left (but don't move past 0)
           :
           Math.min(i-1,I+1)  //no => move I to the right one, but keep it one less than i
       )

       +              //also we need to mess with i
       (i=
        m[2]=='<'?    //is the 3rd char of the command '<'?
          Math.max(I+1,i-1)  //yes => move i to the left, but keep it one right of I
          :
          i+1         //move i to the right (no bounds on how far right i can go)
       )

       ,i=1,I=0       //set I to 0 and i to 1 initially
     )
   +                  //this just lets us chain commands into one expression, not really adding
   (
    (a=Array(i))[I]='I') //create an array of length i (will be one shorter than we really need)
                         //set element I to 'I'

   &&                    //last chained command, we know the array creation will be true
                         //so javascript will just output the next thing as the return for the function
   a.join`.`+'i'         //join the array with '.' (into a string) and append i
                         //i will always be the last element

MATL , 56 55 50 49 47 바이트

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

온라인으로 사용해보십시오!

1           % push 1: initial position of 'I'
H           % push 2: initial position of 'i'
j           % take input as a string
4\q         % modulo 3 and subtract 1: this gives -1 for '<', 1 for '>'
4Zc         % arrange blocks of length 4 as columns of 2D array. This pads last 
            % block with a zero (because the separating space won't be there).
            % Only first and third and last rows will be used
"           % for each column
  w         %   swap: move position of 'I' to top of stack
  @1)       %   first number (+/-1) of current column: tells where the 'I' moves
  +         %   add
  lhX>      %   max with 1: 'I' cannot move left past position 1
  y         %   duplicate position of 'i'
  qhX<      %   max with that number minus 1: 'I' cannot collide with 'i'
  w         %   swap: move position of 'i' to top of stack
  @3)       %   last number (+/-1) of current column: tells where the 'i' moves
  +         %   add
  y         %   duplicate position of 'I'
  QhX>      %   max with that number plus 1: 'i' cannot collide with 'I'
]           % end for each
t           % duplicate position of 'I'. This is the output string length
Z"          % string with that many spaces
105b(       % set 'i' at its computed position in that string
73b(        % set 'I' at its computed position in that string

레티 나, 91 86 바이트

아마 최선의 접근 방식을 취하지 않았기 때문에 골프를 더 많이 할 수 있습니다. 그리고 아니요, FryAmTheEggman을 복사하지 않았습니다 (우리의 접근 방식에서 실제로 유사하다는 것을 알고 있습니다). 내 게시물을 게시하기 전까지는 그의 답변을 보지 못했습니다.

$
¶Ii
(`^¶

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

온라인으로 사용해보십시오

자바 스크립트 (ES6) 166 바이트

Charlie Wynn의 답변을 사용하여 Math.max를 M으로 정의하고 스크립트가 사용될 때마다 M을 호출하여 10 바이트를 절약했습니다.

_=>{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은 여기에서했습니다 . 단지 짧게 만들기 위해 단순히 수정했습니다)

자바 스크립트 (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사이의 공백 수입니다 . 둘 다 음수가 될 수 없습니다.Ii

덜 골프

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 바이트

@FryAmTheEggman 덕분에 3 바이트가 절약되었습니다.

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

설명이 조금옵니다.

온라인으로 사용해보십시오!

배치 테스트로 수정 된 코드.

파이썬 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=21 기준 인덱스로 시작 하고 사용하여 한 번에 하나씩 각 화살표를 읽습니다 . 그들이 역할을 교환하기 때문에 변수 이름은 약간 오해의 소지가 있습니다 - 모든 문자 후 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

자바 (ES5) 153 125 바이트

a실행하기 전에 변수 를 설정하여 입력을받습니다.

I=i=0;for(b of a.split(" "))b[0]==">"?i!=I&&I++:I>0&&I--,b[2]==">"?i++:I!=i&&i--;r=Array(i).fill(".");r[I]="I";r.join("")+"i"

언 골프 :

I=i=0;
for(b of a.split(" "))
   b[0]==">" 
       ? i!=I && I++ 
       : I>0 && I--,
   b[2]==">" 
       ? i++ 
       : I!=i && i--
;
r=Array(i).fill(".");
r[I]="I";
r.join("")+"i"

Mathematica, 125 바이트

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

첫 번째 인수를 가진 순수한 기능 #. 아이디어는 각각이다 <_, >_, <, 및 >상기 입력 문자열의 교체 규칙에 대응한다. "<_"|">_"|">"|"<"이 네 식 중 하나와 일치하는 문자열 패턴입니다. StringCases[#,"<_"|">_"|">"|"<"]그러한 모든 일치를 찾을 수 있습니다. 그런 다음 /.각각 "<_"을 문자열 교체 규칙으로 바꾸고 ".I"->"I."각각 ">_"을 규칙 "I."->".I"등으로 바꿉니다. 그럼 난 순차적으로 문자열로 각각 대체 규칙을 적용 할 "Ii",하지만 StringReplace단지 대체되지 않은 문자열의 부분에서 일치를 찾을 것입니다, 그래서 우리는 왼쪽 Fold기능을 StringReplace값을 시작으로 교체 규칙 목록을 통해 "Ii".

아마도 예제를 통해 더 명확해질 것입니다 ( %이전 셀의 출력 참조).