Make a snake fill any maze (until it gets stuck).

The snake

The snake starts at a given starting point, pointing EAST. It moves by always having a wall or a part of its body immediately to the LEFT of its head ("left-hand rule wall follower"), until it gets stuck because all four directions around its head are occupied.
(Note: a stuck snake can possibly not fill all the reachable space, but that is not the goal!)

The challenge

Write a program or function that accepts a maze as input in the form of a 2D text:

• The input can be in any reasonable format: e.g. a list of strings, a single string with newlines, a file.


• The maze has walls ("#"), empty spaces ("") and exactly one starting point ("o").


• 
  

  You can choose to

  
  
  
  • either assume that the first and last row and column are entirely walls;
  
  
  • or assume that every input is considered to have an implicit outer layer of walls
  
  



• You can assume that the starting point has a wall (or an implicit wall) directly above it (NORTH) and that the snake can make a valid starting move in the EAST or SOUTH direction.



• You can assume that no other characters are present in the text (except newlines if your input needs them).


• You can assume that all lines are the same length.

and prints / returns a "filled maze" as output, with a snapshot of the snake at the moment it got stuck:

• The body of the snake is represented by the characters >v<^ pointing to where its next segment is


• The starting point of the snake is either its direction at the start (">" unless it had to turn immediately) or an o character (no need to be consistent)


• The end point of the snake is an o character

Scoring

Usual code golf: the shortest code wins

Example

in:
#################################
# o #
# #
# ## ### ## #
# ## ## ## ## #
# ## ## ## ## #
# ## ## ## ## #
# ## ## ## ## #
# ## ### ## #
# ## ##### ## #
# ## ##### ## #
# ## ### ## #
# ## ## #
# #
# #
#################################

out:
#################################
#>>>>>>>>>>>>>>>>>>>v>>>>>>>>>>v#
#^>>>>>>>>>>>>>>>>>v>>>>>>>>>>vv#
#^^ ##>>>>>>v###o>>>>>v## vv#
#^^ ##>^ ##>>>>^## >v## vv#
#^^ ##^ ## ## v## vv#
#^^ ##^ ## ## v## vv#
#^^ ##>^ ## ## >v## vv#
#^^ ##^< ### v<## vv#
#^^ ##^ ##### v## vv#
#^^ ##^ ##### v## vv#
#^^ ##^< ### v<## vv#
#^^ ##^<<<<<<<<<<<<<<<<## vv#
#^^<<<<<<<<<<<<<<<<<<<<<<<<<<<<v#
#^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<#
#################################

Animated (for illustration purposes):

Other examples

in:
####################
# o# # 
# ###
# #
# ## #
# ###
####################

out:
####################
#>>>>>>>>>>>>>>vv# #
#^>>>>>>>>>>>>vvv###
#^^ v<<<o<<<<v>>v#
#^^<<<<##^<<<<<<v<<#
#^<<<<<<<<<<<<<<<###
####################

in:
####################
# o ##### 
# #####
# #
# ##
####################

out:
####################
# >>>>v#####
# v#####
# >>>>o#
# ##
####################

in:
################
#o #
# ########## #
# # # #
# # # #
# # # #
# # # # #
# # # #
# # # #
# # # #
# ############ #
# #
################

out:
################
#>>>>>>>>>>>>>v#
#>>v##########v#
#^#>>>>>>>>>v#v#
#^#>>>>>>>>vv#v#
#^#^>>>>>>vvv#v#
#^#^^# vvv#v#
#^#^^o<<<<<vv#v#
#^#^^<<<<<<<v#v#
#^#^<<<<<<<<<#v#
#^############v#
#^<<<<<<<<<<<<<#
################

Charcoal, 94 bytes

Ｆ²⊞υＳＷ¬⁼§υ⁰§υ±¹⊞υＳ≔⪫υ¶θＰθ…θ⌕θo≔⁰θＷ№ＫＶ «≔⊗⁺³⌕ＫＶ ι⟲Ｔι≧⁻ιθ╶»⟲ＴθoＵＭＫＡ§#<>^ov ⌕”y#╴╶╵o╷”ι

Try it online! Link is to verbose version of code. Explanation:

Ｆ²⊞υＳＷ¬⁼§υ⁰§υ±¹⊞υＳ≔⪫υ¶θ

Slurp the input into a string. This could be avoided by using a less convenient input format.

Ｐθ…θ⌕θo

Print the input without moving the cursor, and then print up to the o again, so that the cursor ends up under it.

≔⁰θ

Initialise a variable to keep track of how much we've rotated the canvas.

Ｗ№ＫＶ «

Repeat while there's still a free space in some direction.

≔⊗⁺³⌕ＫＶ ι

Calculate whether the snake can turn left, or whether it is forced to turn right.

⟲Ｔι≧⁻ιθ

Rotate the canvas so that the desired direction is horizontal, and keep track of the total rotations.

╶»

Output a box drawing half line. This has the property that it is transformed by the rotation.

⟲Ｔθ

Rotate back to the original orientation.

o

Output the head.

ＵＭＫＡ§#<>^ov ⌕”y#╴╶╵o╷”ι

Transform the box drawing half lines into <>^v characters, while leaving the other characters alone.

Python 3, 347 bytes

import sys
X=0,1,0,-1
F,*Y=*X,0
L=3
g=[*map(list,sys.stdin.read().split("n"))]
e=enumerate
r,c=[[r,c]for r,R in e(g)for c,C in e(R)if C=="o"][0]
while 1:
	if g[r+X[L]][c+Y[L]]==" ":F,L=L,~-L%4
	elif g[r+X[F]][c+Y[F]]>" ":
		if g[r-X[L]][c-Y[L]]>" ":g[r][c]="o";break
		L,F=F,-~F%4
	g[r][c]=">v<^"[F];r,c=r+X[F],c+Y[F]
for r in g:print("".join(r))

Try it online!

-11 bytes thanks to ArBo

Python 2, 273 253 bytes

g=input()
d=0;j=''.join
t=lambda g,k=1:'n'.join(map(j,zip(*g.split('n')[::k])[::-k]))
h='o '
while 1:
 l,r=t(g,-1),t(g)
 if h in l:g=l;d-=1
 elif h in g:g=g.replace(h,'>v<^'[d%4]+'o')
 elif h in r:g=r;d+=1
 else:break
for _ in(-d%4)*' ':g=t(g)
print g

Try it online!

This working by searching the string 'o ', and replacing it by '[>v<^]o', if it is in the maze.

The same check will also be made on the rotated maze, printing the filled maze when the string isn't there anymore.

The function t=lambda g,k=1:'n'.join(map(j,zip(*g.split('n')[::k])[::-k])) is used to rotate the grid

Ruby, 126 bytes

->sd=[q=1,1+l=s=~/$/,-1,~l];i=s=~/o/;(s[i]=">v<^"[q];s[i+d[q]]=?o;i=s=~/o/)while q=[~-q%4,q,-~q%4].find;s

Try it online!

Jelly, 72 bytes

œṣ€⁾o j€ṛị“v<^>”;”oʋ,
1ịZU$,ṭ@UZ$Ʋż2ị+-r1¤Ʋżç/€$EÐḟḢṪßƊṛ¹?
,0ÇZU$ṛ%4ɗ¡/$

Try it online!

A full program that takes the input as a list of strings and returns a list of strings with the final snake. Note the footer on TIO converts a single newline separated string into the desired input and restores the newlines at the end; this is merely for convenience.

Solution somewhat inspired by the method used by @Rod’s Python 2 answer, though implementation is very different.