Shifty-gözler ASCII adamlar ASCII Ii's kaydırmak ister :

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

Bir dizi kaymaz adam göz önüne alındığında, birbirinden ayrık veya ayrı çizgiler olacak şekilde, Iiyan yana kaydırın, duvardan ayrılın ve gökyüzünü sağa çevirin:

Ii

En kısa kaydırıcı ödülü kazanır.

Ne dedin?

Bu dört ASCII ifadesinin rastgele bir listesini içeren bir programı veya işlevi yazın (boşluk veya newline ayrılmış (isteğe bağlı izleyen bir yeni satırla):

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

Örneğin, giriş

>_> >_> <_>

veya

>_>
>_>
<_>

(Desteklediğiniz yöntem size bağlıdır.)

Her ifade, Ive ikarakterleri üzerinde her zaman şöyle başlayan farklı bir eylem gerçekleştirir :

Ii

• >_>kaydırır Imümkünse birer sağa ve sonra vardiya iteker sağa.
• <_<kaydırır Ikayar sonra mümkünse birer sola ve imümkünse birer sola.
• >_<kaydırır Imümkünse birer sağa ve sonra vardiya imümkünse birer sola.
• <_>kaymalar Isonra mümkünse birer ayrıldı ve geçer ibirer sağa.

Ihattın sol kenarındaysa (başlangıçta olduğu gibi) sola kaydırılamaz ve idoğrudan sağına ise (başlangıçta olduğu gibi) sağa kaydırılamaz .

iIdoğrudan sola doğru kaydırıldığında sola kaydırılamaz (başlangıçta olduğu gibi), ancak her zaman sağa kaydırılabilir.

Bu kurallarla, Iher zaman solunda kalacak ive tüm ifadeler için daha Iönce kaydırılmaya çalışılacağına dikkat edin i.

Program veya işlevin, Iitüm vardiyaları verilen sırada uyguladıktan sonra, boşluk ( ) veya nokta ( .) kullanarak boş satır için son satırın bir dizesini yazdırması veya döndürmesi gerekir . Çıktıda iz bırakma boşlukları veya süreleri ve izlemenin tek bir yeni satırına isteğe bağlı olarak izin verilir. Boşlukları ve periyotları karıştırmayın.

Örneğin, giriş

>_>
>_>
<_>

çıktı var

I...i

çünkü vardiya gibi uygulanır

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

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha yüksek oyla cevap verdi.

Test Kılıfları

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

Kullanılması .netlik için.

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

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

0-indexing hariç Python cevabımla aynı algoritmayı kullanır . esasen:

• Sadece girdideki oklara bakın, <-1 ve >1'e dönüştürün
• Bir güncelleme uygulayın, ancak bizi -1 konumuna getirmezse ve diğer karakterin konumuna getirmezse
• Oklar, uygulamak Ive uygulamak arasında değiştiğinden, her oktan isonra hangi konumu güncellediğimizi değiştiririz.

5 byte çıkartarak çıkış adımını yönlendiren @ MartinBüttner'e teşekkürler.

Çevrimiçi deneyin | Test odası

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 bayt

İçin +1 içerir -p

STDIN'deki giriş ile çalıştırın, örn. perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

açıklama

Kontrol dizesi, yönergeleri değiştirir ive Ikural olarak, her ikisini de aynı şekilde düzenlerseniz, kural aynıdır:

• < Sola doğru bir boşluk varsa sola git
• > Dizginin sağında bir boşluk veya son varsa, sağa hareket et

Bu yüzden her adımda hedef dizgede yer değiştireceğim ive Ibu yüzden kuralı sadece bir harfe uygulamam gerekiyor. Buy/iI/Ii/

Bir karaktere göre karakterleri işlemek için genellikle perl'de en kısa yoldan bir ikame aramak <ve >kullanmak için kontrol dizesini yürüyeceğim . Yazmak zorunda kalmamak için $var =~, kontrol dizgesinin perl varsayılan değişkeninde olmasını istiyorum $_. Ve ayrıca ayırt etmek kolay bir yolunu arayan <dan >. Bütün bunlar kullanılarak başarılabilir

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

Hedef dizgede de ikame kullanarak manipüle etmek istiyorum ve aynı sebepten dolayı ben de istiyorum $_. $_aynı anda iki şey olmak imkansız görünüyor.

Ancak kekimi alabilirim ve onu da yiyebilirim çünkü $_ikame gövdesinin içi ikame edilenle aynı kalmak zorunda değildir $_. Perl bir dizgiyi değiştirmeye başladığında, dizge başlangıçta gelen değişkeni değiştirseniz bile bu dizge değişmeyecektir. Böylece şöyle bir şey yapabilirsiniz:

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

Orjinali $_, "Ii"yalnızca değiştirme gövdesinin ilk çalıştırılışında ilk defa değiştirmek istiyorum (aksi halde hedef dizgiyi sıfırlamaya devam ederim). Bununla birlikte, bu değiştirme boş bir kontrol dizesi için de yapılmalıdır, bu nedenle boş kontrol dizesi için bile gövdenin en az bir kez yürütülmesi gerekir. Alt bölümün kontrol dizesinin başlangıcında fazladan bir süre çalıştığından emin olmak için (boş kontrol dizeleri için bile) değiştirmeyi şu şekilde değiştirdim:

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

y/iI/Ii/İkame kodunun içindeki ilk şey olarak çalışacağım . $_Hala kontrol dizgisi olsa da , bu henüz bir şey içermez Ii, eğer harf çevirisi hiçbir şeyin değişmediğini gösterirse, bu benim tetiklemem $_:

y/iI/Ii/or$_=Ii

Şimdi harflerin gerçek hareketini uygulayabilirim. Bir takas ile başladığımdan beri, tüm hareketler yapılmalı ideğil I. Ayarlandıysa sağa $1hareket ettirin i:

s/i |i$/ i/

Eğer $1hareket ayarlanmamış isola

s/ i/i /

Kontrol dizesinin başlangıcında eşleştiğimde ^ $1ayarlanmayacağına dikkat edin, bu nedenle iilk dizgede sola hareket etmeye çalışır Ii. Bu işe yaramaz çünkü orada boş alan yoktur, bu yüzden intial string rahatsız edilmeden kalır (bu yüzden ()etrafa >koyarım <)

Sadece bir problem kalıyor: dış ikame $_işleminin sonunda $_ikame gövdesinde ne yaptığınıza bakılmaksızın dış ikame işleminin sonucu olarak belirlenir . Böylece uygun dize ile hedef dize ive Ikaybolur. Eski perls'de bu ölümcül bir kusur olacaktır. Ancak daha yeni perls r"değiştirici," orijinal dizgenin bir kopyasını alın, üzerinde değişiklik yapın ve sonuçtaki dizgiyi (eşleşme sayısı yerine) döndürün "anlamına gelir. Bunu kullandığımda sonuç, değiştirilen komut dizesinin, orijinal $_perl tarafından rahatsız edilmediğinde ve değiştirme işleminden sonra bırakılmadığı zaman atılmasıdır . Ancak rahatsız edici ben yapmak $_perl gittikten sonra hala yapılıyor $_yalnız. Yani sonunda$_ uygun hedef dize olacak.

-pSeçenek orijinal dize olduğundan emin olur $_ve aynı zamanda nihai basar $_.

LittleLua - 178 Bayt

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

Dümdüz ileri uygulama.

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 Nedir?

LittleLua, bu zorluklar için benim tercih ettiğim dil ile genellikle çok güçlü yerleşik yapılara sahip ezoterik diller arasındaki oyun alanlarını dengelemeye çalışan bir çalışma.

LittleLua, ek bir modüle (LittleLua.Lua) ek olarak bir Lua 5.3.6 yorumlayıcısıdır, ayrıca işlev ve modül adları daraltılmıştır. Bu değişiklikler, mutlu olana kadar ertesi gün ya da iki gün içerisinde genişleyecektir, ancak LittleLua ve standart Lua tercümanı arasındaki en büyük değişikliklerin birkaçında olduğu gibi:

İşlevler ve modüller küçülür:

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

Değişkenler inşa

LittleLua, bazı görevleri küçültmek için çeşitli yerleşik değişkenlere sahiptir:

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

Dahili İşlevler

Şu anda iç karartıcı küçük bir liste, ancak burada:

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

Çevrimiçi deneyin

Daavko sayesinde 15 byte kurtarıldı!

Girdileri yeni çizgilerle ayırarak alır ve gözleri boşluklarla ayrılmış olarak görüntüler.

Açıklama:

Her zamanki gibi aşama aşama açıklayacağım. Bu aşamaların tümü Retina'nın Değiştir modundadır. Bu, ilk satırın normal bir ifade ve ikinci satırın yeni bir dize olduğu anlamına gelir.

$
¶Ii

İlkini Iigirişin sonuna ekleyin .

( `^ ¶

Backtick, sahneyi seçeneklerden ayırır. Seçenek karakteri (, bu aşamanın, girişi değiştirmeden tam bir çevrim tamamlanana kadar art arda yürütülecek aşama döngüsünün başlangıcı olduğunu gösterir. Bu açık parantez asla kapalı olmadığından, kalan tüm evreler bu döngünün bir parçasıdır.

Asıl aşama çok basittir; dizgenin ilk karakteri yeni bir satır ise onu silin. Bu sadece boş girdilerin kullanılmasını kolaylaştırmaya yardımcı olmak içindir, aksi takdirde son iki aşamaya eklemek daha golfcü olurdu.

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

Burada seçenek s, Regex meta karakterinin .yeni satırlarla eşleşmesine neden olur . Bu aşama, öncülüğün ardından isteğe bağlı bir alanla >eşleşmesine neden olur I. Sonra >, ardından gelenlerle eşleşir , ardından isteğe bağlı boşluk (boşluk eşleştirilemediğinde boş dize) ve ardından I.

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

Bu aşama öncekine çok benziyor, sadece isteğe bağlı alan öncekinden önce Ive sıra ile göz tersine çevriliyor.

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

Kullanımı igenellikle daha basittir, çünkü iher zaman doğru hareket edebildiğinden isteğe bağlı olarak ekleme veya çıkarma konusunda endişelenmemize gerek yoktur . İçin idurumlarda biz çizgi yanı sıra büyüktür / küçüktür işareti, ama aksi yapmak benzer bir mantık uzakta maç. Bu daha önce bir boşluk ekler i.

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

Yine yukarıdakine benzer, ancak bu ikarakter boşluk bırakmadan önce karakteri siler , aksi halde yalnızca ifadeyi kaldırır.

Python, 142 141 134 122 121 bayt

Xnor sayesinde 19 bayt kurtarıldı.

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'

Örnek:

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

Açıklama:

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 bayt

( -rbayrak için +1 dahil )

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

Bu, girişten (son satırı kaldırarak görebileceğiniz) yeni bir sed programı oluşturur ve bunu başlangıç ​​durumuna uygular Ii.

açıklama

• İlk iki satır sırasıyla sola ve sağa kayan komutları dönüştürür <ve >'yerine koyar' I.
• Sonra _üzerinde çalışmak iyerine aşağıdakileri değiştiriyoruz.I
• i herhangi bir sağ kenar tarafından sınırlandırılmadığından, bundan sonra boşluk eklemeyin veya kullanmayın
• Son olarak, oluşturulan komutu girişe uygulayın Ii. s///eher zaman /bin/shkabuğu olarak kullanır , bu yüzden sed '&'<<<Iiistediğim kadar bunu kısaltamazdım (bu bir Bash yeniden yönlendirme sözdizimidir).

Test sonuçları

$ 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 147 142 141 bayt

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

kullanım

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 çok farklı değil)

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

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

Çevrimiçi deneyin!

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 bayt

Muhtemelen en iyi yaklaşımı almadım, bu yüzden muhtemelen daha fazla golf oynayabilir. Ve hayır, FryAmTheEggman'i kopyalamadım (onların yaklaşımlarımızda gerçekten benzer olduklarını biliyorum). Cevabını benim gönderene kadar görmedim.

$
¶Ii
(`^¶

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

Çevrimiçi deneyin

Javascript (ES6) 166 bayt

Charlie Wynn'in cevabını kullanarak, Math.max'i M olarak tanımlayarak ve senaryosunu her kullandığında M'yi arayarak 10 bayt kurtarmayı başardı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'}

(Bu golfü ben yazmadım, Charlie Wynn burada yaptı . Sadece kısaltmak için değiştirdim)

JavaScript (ES6), 115 118

Düzenleme: 3 bayt thx CharlieWynn kurtardı

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önceki boşlukların sayısı I; ve qarasındaki boşlukların sayısıdır . İkisi de negatif olamaz.Ii

Daha az golf oynadı

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
)

Ölçek

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 bayt

@FryAmTheEggman sayesinde 3 bayt kaydedildi.

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

Açıklama biraz sonra gelir.

Çevrimiçi deneyin!

Toplu test ile değiştirilmiş kod.

Python 2, 96 92 bayt

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)

Kaygısız bir meydan okuma için oldukça kayıtsız görünümlü bir çözüm. Gibi giriş f('>_> <_>'), çıkış gibi 'I i'.

Doğrulama programı ( testsçok satırlı test durum dizesi olduğu varsayılarak ):

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

Program, her ok için birer birer okur, I=1, i=21 temelli dizinlerden başlayarak ve bunları kullanarak. Onlar rolleri takas beri değişken adları biraz yanıltıcı - Her Char sonra Iolur ive iolur Igüncellendi. Bir karakter sadece ne diğer karakterin konumuna ne de 0 konumuna gidemediğinde güncellenir.

Örneğin, >_> <_> >_<biz yapmak için:

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

Bu ' Ii'istenildiği gibi verir .

Lua, 104 bayt

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

Kullanımı:

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

Javascript (ES5), 153 125 bayt

açalıştırmadan önce değişken ayarlayarak giriş yapar

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"

Biraz unungolfed:

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 bayt

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

İlk argüman ile saf fonksiyon #. Amaç, her olmasıdır <_, >_, <ve >girişteki bir string değiştirme kuralına karşılık gelir. "<_"|">_"|">"|"<"bu dört ifadeden herhangi biriyle eşleşen bir dize desenidir. StringCases[#,"<_"|">_"|">"|"<"]Tüm bu eşleşmeleri bulacaktır. Daha sonra /.her birini bir "<_"kural dizisi ile değiştirelim ".I"->"I.", her ">_"ikisini de kuralla değiştirelim "I."->".I". Ardından her değiştirme kuralını dizeye sırayla uygulamak istiyorum "Ii", ancak StringReplaceyalnızca dizenin değiştirilmemiş bölümlerindeki eşleşmeleri arayacağız, bu nedenle Foldişlevi StringReplacebaşlangıç ​​değeri olan değiştirme kuralları listesi üzerinde bıraktık "Ii".

Belki bir örnekle daha açık olacaktır (burada %önceki hücrenin çıktısına atıfta bulunulur):