in modalità sandbox

Dato un insieme di contorni 2d chiusi non sovrapposti (separati da almeno uno spazio anche sulle diagonali) con le frecce orientate coerentemente nella stessa direzione in senso orario o antiorario (ogni contorno ha la propria direzione) e un numero positivo n, spostare le frecce npassi lungo i contorni nella rispettiva direzione. Le frecce sono rappresentate > v < ^rispettivamente dalle direzioni destra, giù, sinistra e su. Lì gli altri personaggi sono -(orizzontale), |(verticale) e +(angolo). Quando una freccia si trova su un angolo, mantiene la direzione corrente e la cambia solo dopo aver effettuato la svolta.

Ci sarà sempre un segmento rettilineo (o uno spazio) tra due angoli qualsiasi (come +-+per l'orizzontale e simile per la verticale) - in altre parole Usono vietate le curve strette. I segmenti tra gli angoli sono verticali o orizzontali e la curva in un angolo è sempre di 90 gradi.

Ingresso:

• un numero intero positivo - n- numero di passi
• una rappresentazione ASCII dei contorni: può essere una stringa multilinea, un elenco di stringhe, un elenco di caratteri e così via.

Produzione:

Gli stessi contorni con tutte le frecce hanno spostato i npassaggi nella direzione generale di ciascun contorno.

Casi test:

1.

Ingresso:

n = 1

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

Produzione:

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

2.

Ingresso:

n = 2

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

Produzione:

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

3.

Ingresso:

n = 3

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

Produzione:

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

4.

Ingresso:

n = 1

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

Produzione:

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

5.

Ingresso

n = 4

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

Produzione:

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

6.

Ingresso:

n = 1

^->
^ v
<<v

Produzione:

^>+
^ v
<<v

Scrivi una funzione o un programma risolvendo l'attività sopra. Vince il codice più breve in byte in ogni lingua. Non lasciarti scoraggiare dalle lingue del golf. La spiegazione dell'algoritmo e del codice è molto apprezzata.

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

(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

Provalo online!

Come?

Puoi seguire questo link per vedere una versione formattata della fonte.

involucro

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

Metodo di aggiornamento

Non possiamo spostare ogni freccia in modo sicuro una alla volta perché rischieremmo di sovrascrivere frecce non aggiornate con quelle aggiornate. Invece, prima rimuoviamo tutte le frecce e calcoliamo le loro nuove posizioni. Applichiamo le nuove posizioni in una seconda volta.

Questo viene fatto riutilizzando $n$

Ad esempio, nel primo caso di test, $n$

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

(Si noti che il numero iniziale - che è il valore originale di $n$

Le nuove posizioni vengono applicate semplicemente facendo eval(n).

Indicazioni

$d$$

$dx$$dy$ vengono calcolati in questo modo:

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

angoli

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

+-|$d$

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

Versione animata

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 byte

{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]}/

Provalo online!

{ }/quando viene chiamato con un int left arg n, questo applicherà la funzione in { }n volte all'arg destro

A:"^>v<" frecce

D,:-D:(-1 0;!2) Sì, x per le 4 direzioni cardinali

s:(#x;#*x) forma dell'input: altezza, larghezza

c:~^x countours - matrice booleana che mostra dove si trovano i non spazi

r:" -+|"c*+/'3'0,c,0ricreare la matrice di caratteri con un countour ma senza frecce, contando self + upper + lower per ogni cella ce sostituendo 1-> -, 2-> +, 3->|

t:A?,/xtipi di frecce: 0 1 2 3 per ^>v<, tutte le altre celle sono rappresentate come 0N(null)

p:+s\&~^t coordinate delle frecce

$[#p ;;:r] se non ci sono frecce, ritorna r

q:+p+/:D@4!(t^0N)+/:0 1 3 tutte e 3 le possibili nuove posizioni per ogni freccia: se continua ad andare avanti, se gira a sinistra e se gira a destra

q:q@'*'&'~^x ./:/:q per ogni freccia scegliere la prima opzione che atterra sul countour

@[,/r;s/+q;:;A@D?q-p]appiattire re mettere su di esso le frecce nelle loro nuove posizioni e con le loro nuove direzioni

s# rimodellare alla forma originale

Carbone , 105 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Include 22 byte utilizzati per evitare la necessità di un formato di input ingombrante. Spiegazione:

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

Inserire comodamente i contorni e il numero di passaggi.

≔>^<vζ

I caratteri di direzione vengono utilizzati più volte, quindi la stringa viene memorizzata nella cache qui. L'indice di un carattere di direzione in questa stringa è noto come direzione.

Ｐθ

Stampa i contorni originali senza spostare il cursore.

Ｆθ

Passa sopra i personaggi nel contorno.

¿№ζι«

Se i caratteri correnti sono un carattere di direzione ...

⊞υ⟦⌕ζιⅉⅈ⟧

... quindi salva la direzione e la posizione in un elenco ...

§+|-↨ＥＫＶ›κ ²

... e sostituisci il carattere con il carattere di linea appropriato.

»ι

Altrimenti emetti il ​​personaggio e passa al personaggio successivo.

Ｆυ«

Passa sopra le posizioni salvate.

Ｊ⊟ι⊟ι

Passa alla posizione salvata.

≔⊟ιι

Estrai la direzione salvata.

ＦＩη«

Passa il numero appropriato di passaggi.

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

Trova la direzione del passaggio successivo, ovvero qualsiasi direzione che non sia né inversa né vuota.

Ｍ✳⊗ι

Fai un passo in quella direzione. (Gli indici di direzione del carbone per il Movecomando sono il doppio del valore della mia direzione.)

»§ζι

Stampa il carattere di direzione appropriato.

APL (Dyalog Unicode) , 111 byte ^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}⍣⎕⊢⎕

Provalo online!

simile alla mia risposta k