Sandboxed

Étant donné un ensemble de contours 2D fermés non superposés (séparés par au moins un espace même sur des diagonales) avec des flèches orientées de manière cohérente dans le même sens horaire ou antihoraire (chaque contour a sa propre direction) et un nombre positif n, déplacez les flèches nétapes le long des contours dans la direction respective. Les flèches sont représentées > v < ^respectivement par les directions droite, bas, gauche et haut. Là, les autres caractères sont -(horizontal), |(vertical) et +(coin). Lorsqu'une flèche est sur un coin, elle conserve sa direction actuelle et ne la change qu'après le virage.

Il y aura toujours un segment droit (ou un espace) entre deux coins quelconques (comme +-+pour l'horizontale et similaire pour la verticale) - en d'autres termes, les Uvirages serrés sont interdits. Les segments entre les coins sont verticaux ou horizontaux et le coude dans un coin est toujours à 90 degrés.

Contribution:

• un entier positif - n- nombre d'étapes
• une représentation ASCII des contours - il peut s'agir d'une chaîne multiligne, d'une liste de chaînes, d'une liste de caractères, etc.

Sortie:

Les mêmes contours avec toutes les flèches ont décalé les npas dans la direction globale de chaque contour.

Cas de test:

1.

Contribution:

n = 1

 +----->->            
 |       |            
 |       v---+        
 |           |        
 +---<-------+      

Sortie:

 +------>+
 |       v
 |       +>--+
 |           |
 +--<--------+

2.

Contribution:

n = 2

 +-----+ +---+        
 |     | |   |        
 +-->--+ |   v  
         |   | 
 +--->---+   |        
 |           |         
 +------<<---+       

Sortie:

 +-----+ +---+
 |     | |   |
 +---->+ |   |
         |   | 
 +----->-+   v
 |           |     
 +----<<-----+        

3.

Contribution:

n = 3

 +---+   +---+   +-------+      
 |   |   |   v   |       |      
 ^   |   |   |   +-<-+   |      
 |   |   ^   |       |   v      
 |   +---+   +-->----+   |      
 |                       |      
 |   +-------+   +---+   |      
 |   |       |   v   |   |      
 +---+       +---+   +---+      

Sortie:

 +>--+   ^---+   +-------+
 |   |   |   |   ^       |
 |   |   |   |   +---+   |
 |   |   |   |       |   |
 |   +---+   v----->-+   |
 |                       |
 |   +-------+   +---+   v 
 |   |       |   |   |   |
 +---+       +-<-+   +---+  

4.

Contribution:

n = 1

+--+ 
|  |
|  +---+
|      |     
+----+ |
     | |
     +-+ 

Sortie:

+--+ 
|  |
|  +---+
|      |     
+----+ |
     | |
     +-+ 

5.

Contribution

n = 4

^>>>>
^   v
^   v>>>>
^       v           
<<<<<<<<v

Sortie:

^>>>>
^   v
^   v>>>>
^       v           
<<<<<<<<v

6.

Contribution:

n = 1

^->
^ v
<<v

Sortie:

^>+
^ v
<<v

Écrivez une fonction ou un programme résolvant la tâche ci-dessus. Le code le plus court en octets dans chaque langue gagne. Ne vous laissez pas décourager par les langues de golf. L'explication de l'algorithme et du code est très appréciée.

JavaScript (ES6),  210 ... 182  180 octets

(m)(n)$m$

m=>g=n=>n?g(n-1,m=m.map((r,y)=>r.map((c,x)=>(i=0,h=$=>~$?(m[Y=y+($-2)%2]||0)[X=x+~-$%2]>h?"-|+"[n+=`;m[${Y}][${X}]=S[${$}]`,i?2:$&1]:h($^++i):c)((S="<^>v").indexOf(c)))),eval(n)):m

Essayez-le en ligne!

Comment?

Vous pouvez suivre ce lien pour voir une version formatée de la source.

Wrapper

$g$$n-1$$n=0$

Méthode de mise à jour

Nous ne pouvons pas déplacer chaque flèche en toute sécurité une par une, car nous courrions le risque d'écraser des flèches non mises à jour avec des flèches mises à jour. Au lieu de cela, nous supprimons d'abord toutes les flèches et calculons leurs nouvelles positions. Nous appliquons les nouveaux postes dans un deuxième temps.

$n$

$n$

"1;m[0][7]=S[2];m[1][8]=S[3];m[2][9]=S[2];m[4][3]=S[0]"

$n$

Les nouveaux postes sont appliqués en faisant simplement eval(n).

instructions

$d$$

$dx$$dy$

 d | dx = (d - 1) % 2 | dy = (d - 2) % 2
---+------------------+------------------
 0 |        -1        |         0
 1 |         0        |        -1
 2 |        +1        |         0
 3 |         0        |        +1

Coins

$h$$d$$d\operatorname{xor}1$$d\operatorname{xor}3$

+-|$d$

$h$$$h$"$""$""$"

Version animée

f=
m=>g=n=>n?g(n-1,m=m.map((r,y)=>r.map((c,x)=>(i=0,h=$=>~$?(m[Y=y+($-2)%2]||0)[X=x+~-$%2]>h?"-|+"[n+=`;m[${Y}][${X}]=S[${$}]`,i?2:$&1]:h($^++i):c)((S="<^>v").indexOf(c)))),eval(n)):m

m = [
  [..."+---+   +---+   +-------+"],
  [..."|   |   |   v   |       |"],
  [..."^   |   |   |   +-<-+   |"],
  [..."|   |   ^   |       |   v"],
  [..."|   +---+   +-->----+   |"],
  [..."|                       |"],
  [..."|   +-------+   +---+   |"],
  [..."|   |       |   v   |   |"],
  [..."+---+       +---+   +---+"]
];

(F = _ => (o.innerHTML = m.map(r => r.join('')).join('\n'), m = f(m)(1), window.setTimeout(F, 100)))()

<pre id=o></pre>

K (ngn / k) , 183 161 157 157 octets

{A:"^>v<";D,:-D:(-1 0;!2);s:(#x;#*x);c:~^x;r:" -+|"c*+/'3'0,c,0;$[#p:+s\&~^t:A?,/x;;:r];q:q@'*'&'~^x ./:/:q:+p+/:D@4!(t^0N)+/:0 1 3;s#@[,/r;s/+q;:;A@D?q-p]}/

Essayez-le en ligne!

{ }/lorsqu'il est appelé avec un argument int gauche n, cela appliquera la fonction en { }n fois à l'argument droit

A:"^>v<" flèches

D,:-D:(-1 0;!2) ∆y, ∆x pour les 4 directions cardinales

s:(#x;#*x) forme de l'entrée: hauteur, largeur

c:~^x countours - matrice booléenne montrant où sont les non-espaces

r:" -+|"c*+/'3'0,c,0recréer la matrice de caractères avec un compteur mais sans flèches, en comptant soi + supérieur + inférieur pour chaque cellule dans cet en remplaçant 1-> -, 2-> +, 3->|

t:A?,/xtypes de flèches: 0 1 2 3 pour ^>v<, toutes les autres cellules sont représentées comme 0N(nulles)

p:+s\&~^t coordonnées des flèches

$[#p ;;:r] s'il n'y a pas de flèches, retournez r

q:+p+/:D@4!(t^0N)+/:0 1 3 les 3 nouvelles positions possibles pour chaque flèche - si elle continue d'avancer, si elle tourne à gauche et si elle tourne à droite

q:q@'*'&'~^x ./:/:q pour chaque flèche, choisissez la première option qui atterrit sur le countour

@[,/r;s/+q;:;A@D?q-p]aplatir ret mettre dessus les flèches à leurs nouvelles positions et avec leurs nouvelles directions

s# remodeler à la forme d'origine

Fusain , 105 octets

Ｗ¬ΦυΣκ⊞υＳ≔⊟υη≔⪫υ⸿θ≔⟦⟧υ≔>^<vζＰθＦθ¿№ζι«⊞υ⟦⌕ζιⅉⅈ⟧§+|-↨ＥＫＶ›κ ²»ιＦυ«Ｊ⊟ι⊟ι≔⊟ιιＦＩη«≔⊟Φ⁴∧﹪⁻⊖ι⊕λ⁴›§ＫＶ⁻⁵λ ιＭ✳⊗黧ζι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Comprend 22 octets utilisés pour éviter d'exiger un format d'entrée encombrant. Explication:

Ｗ¬ΦυΣκ⊞υＳ≔⊟υη≔⪫υ⸿θ≔⟦⟧υ

Saisissez facilement les contours et le nombre de pas.

≔>^<vζ

Les caractères de direction sont utilisés plusieurs fois afin que la chaîne soit mise en cache ici. L'index d'un caractère de direction dans cette chaîne est appelé sa direction.

Ｐθ

Imprimez les contours d'origine sans déplacer le curseur.

Ｆθ

Faites une boucle sur les caractères du contour.

¿№ζι«

Si les caractères actuels sont des caractères de direction ...

⊞υ⟦⌕ζιⅉⅈ⟧

... puis enregistrez la direction et la position dans une liste ...

§+|-↨ＥＫＶ›κ ²

... et remplacez le caractère par le caractère de ligne approprié.

»ι

Sinon, affichez le caractère et passez au caractère suivant.

Ｆυ«

Faites une boucle sur les positions enregistrées.

Ｊ⊟ι⊟ι

Aller à la position enregistrée.

≔⊟ιι

Extrayez la direction enregistrée.

ＦＩη«

Faites une boucle sur le nombre approprié d'étapes.

≔⊟Φ⁴∧﹪⁻⊖ι⊕λ⁴›§ＫＶ⁻⁵λ ι

Trouvez la direction de l'étape suivante, qui est une direction qui n'est ni inversée ni vide.

Ｍ✳⊗ι

Faites un pas dans cette direction. (Les indices de direction du charbon de bois pour la Movecommande sont deux fois la valeur de ma direction.)

»§ζι

Imprimez le caractère de direction approprié.

APL (Dyalog Unicode) , 111 octets ^SBCS

{A[D⍳q-p]@q⊢' |+-'[c×3+/0,c,0]⊣q←⊃¨(⍸c←' '≠⍵)∘∩¨↓⍉D[4|0 1 3∘.+4~⍨,t]+⍤1⊢p←⍸4>t←⍵⍳⍨A←'v>^<'⊣D←9 11∘○¨0j1*⍳4}⍣⎕⊢⎕

Essayez-le en ligne!

similaire à ma réponse k