Les gars ASCII décalés aiment changer de ASCII Ii:

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

Avec une série de types décalés, des lignes espacées ou séparées, déplacez-le Iid'un côté à l'autre, à gauche du mur et à droite du ciel:

Ii

Le shifter le plus court remporte le prix.

Tu peux répéter s'il te plait?

Ecrivez un programme ou une fonction prenant une chaîne d'une liste arbitraire de ces quatre émoticônes ASCII, séparés par un espace ou une nouvelle ligne (avec une nouvelle ligne de fin optionnelle):

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

Par exemple, l’entrée peut être

>_> >_> <_>

ou

>_>
>_>
<_>

(La méthode que vous soutenez est à vous.)

Chaque émoticône effectue une action différente sur les caractères Iet i, qui commencent toujours ainsi:

Ii

• >_>décale Ivers la droite par un, si possible, puis vers ila droite par un.
• <_<décale Ià gauche par un, si possible, puis ià gauche par un, si possible.
• >_<décale Isi possible vers la droite, puis si possible ivers la gauche.
• <_>décale Ià gauche par un, si possible, puis ià droite par un.

Ine peut pas être déplacé à gauche s'il se trouve au bord gauche de la ligne (comme il en a été initialement), ni à droite s'il se itrouve directement à sa droite (comme il en était initialement).

ine peut pas être déplacé à gauche s'il Iest directement à sa gauche (comme au début), mais peut toujours être déplacé à droite.

Notez qu'avec ces règles, Irestera toujours à gauche de i, et Iest tenté d'être déplacé avant ipour tous les émoticônes.

Votre programme ou votre fonction doit imprimer ou renvoyer une chaîne de la dernière Iiligne après avoir appliqué tous les décalages dans l'ordre indiqué, en utilisant des espaces ( ) ou des périodes ( .) pour les espaces vides. Les espaces ou les points de fin et un seul nouveau trait sont autorisés dans la sortie. Ne mélangez pas les espaces et les périodes.

Par exemple, l'entrée

>_>
>_>
<_>

a sortie

I...i

parce que les changements s'appliquent comme

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

Le code le plus court en octets gagne. Tiebreaker est la réponse la plus votée.

Cas de test

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

Utiliser .pour plus de clarté.

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

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

Utilise le même algorithme que ma réponse Python , sauf avec l'indexation 0. Essentiellement:

• Ne regardez que les flèches à l’entrée, convertissant <en -1 et >en 1
• Appliquez une mise à jour uniquement si cela ne nous déplace pas vers la position -1 et ne nous déplace pas vers la position de l'autre caractère
• Puisque les flèches alternent entre appliquer Iet appliquer i, nous alternons la position que nous mettons à jour après chaque flèche.

Merci à @ MartinBüttner pour avoir joué 5 octets dans l'étape de sortie.

Essayez-le en ligne | Suite de tests

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 octets

Comprend +1 pour -p

Exécuter avec l'entrée sur STDIN, par exemple perl -p shifty.pl <<< ">_> <_< >_< <_>"

shifty.pl:

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

Explication

La chaîne de contrôle alterne les instructions pour iet Iet la règle est la même pour les deux si vous les formulez comme suit:

• < Déplacer à gauche s'il y a un espace à gauche
• > Déplacer à droite s'il y a un espace ou une fin de chaîne à droite

Donc, je vais échanger iet Idans la chaîne cible à chaque étape, je n'ai donc qu'à appliquer la règle à une lettre. C'est ley/iI/Ii/

Je vais parcourir la chaîne de contrôle en recherchant <et en >utilisant une substitution qui est généralement le moyen le plus court en perl pour traiter un caractère à la fois. Pour éviter d'avoir à écrire, $var =~je veux la chaîne de contrôle dans la variable perl par défaut $_. Et je veux aussi un moyen facile de distinguer <de >. Tout cela peut être accompli en utilisant

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

La chaîne cible que je veux également manipuler à l'aide de substitutions et pour la même raison, je souhaite l'inclure $_également. $_être deux choses à la fois semble impossible.

Cependant, je peux avoir mon gâteau et le manger aussi parce que l' $_intérieur du corps d'une substitution ne doit pas rester identique à celui qui $_est substitué. Une fois que perl a commencé à substituer une chaîne, cette chaîne ne changera pas, même si vous modifiez la variable dont la chaîne est originaire. Donc, vous pouvez faire quelque chose comme:

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

Je souhaite remplacer l'original $_par l'initiale "Ii"uniquement la toute première fois que le corps de substitution est exécuté (sinon, je réinitialise continuellement la chaîne cible). Toutefois, ce remplacement doit également se produire pour une chaîne de contrôle vide. Ainsi, même pour la chaîne de contrôle vide, le corps doit être exécuté au moins une fois. Pour m'assurer que la sous-fonction s'exécute une heure supplémentaire au début de la chaîne de contrôle (même pour les chaînes de contrôle vides), je remplace le remplacement par:

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

Je vais lancer le y/iI/Ii/comme la première chose à l'intérieur du code de substitution. Tant qu'il $_s'agit toujours de la chaîne de contrôle, celle-ci n'en contient pas encore Ii. Par conséquent, si la translittération indique que rien n'a été modifié, c'est l'initialisation de mon déclencheur $_:

y/iI/Ii/or$_=Ii

Maintenant, je peux mettre en œuvre le déplacement réel des lettres. Depuis que je commence par un échange, tous les mouvements doivent être effectués i, pas I. Si $1est défini, déplacez ile curseur vers la droite:

s/i |i$/ i/

Si $1n'est pas défini déplacer ià gauche

s/ i/i /

Remarquez que, au début de la chaîne de contrôle, la correspondance ^ $1ne sera pas définie; le système essaie donc de se déplacer ivers la gauche de la chaîne initiale Ii. Cela ne fonctionnera pas car il n’ya pas d’espace, donc la chaîne initiale reste intacte (c’est pourquoi je mets la ()autour >au lieu de <)

Un seul problème demeure: à la fin de la substitution externe, le $_résultat de la substitution externe doit être pris en compte, indépendamment de ce que vous avez fait $_dans le corps de substitution. Donc, la chaîne cible avec le bon placement de iet Ise perd. Dans les vieux perls, ce serait un défaut fatal. Les perls les plus récents ont cependant le rmodificateur qui signifie "faire une copie de la chaîne d'origine, faites votre substitution sur celle-ci et renvoyez la chaîne résultante (au lieu du nombre de correspondances)". Lorsque j'utilise cela ici, le résultat est que la chaîne de commande modifiée est supprimée alors que l'original $_n'est pas perturbé par Perl et reste après la substitution. Cependant, le dérangement que je fais $_est toujours fait après que Perl soit parti $_seul. Donc à la fin$_ sera la chaîne cible appropriée.

L' -poption s'assure que la chaîne d'origine est dedans $_et imprime également la finale $_.

LittleLua - 178 octets

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

Mise en œuvre directe.

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.

Qu'est-ce que LittleLua?

LittleLua est un travail en cours pour essayer de niveler le terrain de jeu entre la langue de mon choix pour ces défis et les langues ésotériques qui ont souvent des fonctions intégrées extrêmement puissantes.

LittleLua est un interpréteur Lua 5.3.6 avec un module supplémentaire (LittleLua.Lua), ainsi que des noms de fonctions et de modules réduits. Ces changements s’étendront au cours des deux prochains jours, jusqu’à ce que je sois heureux, mais les changements les plus importants entre LittleLua et l’interprète Lua standard sont les suivants:

Les fonctions et les modules sont réduits:

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

Variables intégrées

LittleLua a plusieurs variables intégrées pour réduire certaines tâches:

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

Fonctions intégrées

Actuellement une liste déprimante, mais la voici:

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

La rétine ,101 86

$
¶Ii
(`^¶

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

Essayez-le en ligne

Sauvegardé 15 octets grâce à daavko!

Prend les entrées séparées par des nouvelles lignes et les sorties avec les yeux séparés par des espaces.

Explication:

Je vais expliquer étape par étape, comme d'habitude. Toutes ces étapes sont en mode Remplacer de Retina. Cela signifie que la première ligne est une expression régulière et la deuxième ligne est une chaîne de remplacement.

$
¶Ii

Ajoutez l'initiale Iià la fin de l'entrée.

(`^ ¶

Le backtick sépare la scène des options. Le caractère d'option (indique que cette étape est le début d'une boucle d'étapes à exécuter de manière répétée dans l'ordre jusqu'à la fin d'un cycle complet sans modification de l'entrée. Puisque cette parenthèse ouverte n'est jamais fermée, toutes les étapes restantes font partie de cette boucle.

La phase actuelle est très simple, si le premier caractère de la chaîne est une nouvelle ligne, supprimez-la. Ceci est juste pour aider à faciliter la gestion de l'entrée vide, sinon il serait plus compliqué de l'ajouter aux deux dernières étapes.

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

Ici, l'option sfait en sorte que le métacaractère Regex .corresponde aux nouvelles lignes. Cette étape fait en sorte que l'interligne >corresponde au Isuivi d'un espace facultatif. Ensuite, il remplace la correspondance par le texte après le >, suivi de l’espace facultatif (donc la chaîne vide si l’espace ne peut pas correspondre), puis le I.

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

Cette étape est très similaire à la précédente, seul l’espace optionnel est avant I, et l’ordre et l’œil sont inversés.

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

Le traitement de iest en fait souvent plus simple, car nous n’avons pas à nous soucier d’ajouter ou de supprimer facultativement car nous ipouvons toujours nous déplacer correctement. Pour les icas, nous comparons le trait de soulignement et le signe plus / moins que, mais faisons la même chose. Celui-ci ajoute un espace avant le i.

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

De nouveau semblable au précédent, mais il supprime le caractère avant le isi ce caractère est un espace, sinon il supprime seulement l’émoticône.

Python, 142 141 134 122 121 octets

19 octets sauvés grâce à 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'

Exemple:

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

Explication:

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 octets

(y compris +1 pour le -rdrapeau)

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

Cela crée un nouveau programme sed à partir de l'entrée (ce que vous pouvez voir en supprimant la dernière ligne) et l'applique à l'état de départ Ii.

Explication

• Les deux premières lignes convertissent <et >remplacent des commandes qui se déplacent Irespectivement vers la gauche et la droite.
• Ensuite, nous changeons celui qui suit _pour travailler iplutôt que pourI
• i n'est pas délimité par un bord droit, alors n'ajoutez pas et ne consommez pas d'espace à sa suite
• Enfin, appliquez la commande créée à l’entrée Ii. s///eutilise toujours/bin/sh comme shell, donc je ne pouvais pas le raccourcir sed '&'<<<Iicomme je le souhaitais (c'est une syntaxe de redirection Bash).

Résultats de test

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

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

Usage

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 n'est pas très différent)

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

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

Essayez-le en ligne!

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 octets

Je n’ai probablement pas choisi la meilleure approche, alors on peut probablement jouer davantage au golf. Et non, je n'ai pas copié FryAmTheEggman (je sais que nos approches sont très similaires). Je n'ai même pas vu sa réponse avant d'avoir posté la mienne.

$
¶Ii
(`^¶

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

Essayez-le en ligne

Javascript (ES6) 166 octets

En utilisant la réponse de Charlie Wynn, j'ai réussi à économiser 10 octets en définissant Math.max comme M et en appelant M chaque fois que son script utilise

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

(Je n'ai pas écrit ce golf, Charlie Wynn l'a fait ici . Je l'ai simplement modifié pour le rendre plus court)

JavaScript (ES6), 115 118

Edit: 3 octets enregistrés grâce à 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`

pest le nombre d'espaces avant I; qest le nombre d'espaces entre Ieti . Ni peut être négatif.

Moins joué au 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
)

Tester

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 octets

3 octets enregistrés grâce à @FryAmTheEggman.

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

L'explication vient un peu plus tard.

Essayez-le en ligne!

Code modifié avec test de lot.

Python 2, 96 92 octets

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)

Solution d'assez sournoise pour un défi sournois. Entrée comme f('>_> <_>'), sortie comme 'I i'.

Programme de vérification (en supposant qu'il testss'agisse d'une chaîne de cas de test multiligne):

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

Le programme lit chaque flèche une à la fois, en commençant par les I=1, i=2index basés sur 1 et en les utilisant. Les noms de variable sont un peu trompeurs car ils échangent des rôles - après chaque caractère, Idevient iet idevient Imis à jour. Un caractère n'est mis à jour que s'il ne se déplace pas vers la position de l'autre caractère ni la position 0.

Par exemple, pour >_> <_> >_<nous faire:

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

Cela donne ' Ii'comme souhaité.

Lua, 104 octets

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

Usage:

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

Javascript (ES5), 153 à 125 octets

prend une entrée en définissant une variable aavant de lancer

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"

Un peu non-golfé:

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 octets

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

Fonction pure avec le premier argument #. L'idée est que chaque <_, >_, <et >dans les correspond d'entrée à une règle de remplacement de chaîne. "<_"|">_"|">"|"<"est un modèle de chaîne qui correspond à l'une de ces quatre expressions. StringCases[#,"<_"|">_"|">"|"<"]trouvera tous ces matches. Ensuite, nous remplaçons ( /.) "<_"par la règle de remplacement de chaîne ".I"->"I.", ">_"par la règle "I."->".I", etc. Ensuite, je veux appliquer séquentiellement chaque règle de remplacement à la chaîne "Ii", mais StringReplaceje ne rechercherai que les correspondances dans les parties de la chaîne qui n'ont pas été remplacées. Nous avons donc laissé Foldla fonction StringReplacesur la liste des règles de remplacement avec la valeur de départ "Ii".

Peut-être serait-il plus clair avec un exemple (ici %la sortie de la cellule précédente):