Complete factorization in >
First off, I'd like to say that you're asking two questions which are at odds with each other. Having readable >&lt;> code usually requires a decent amount of whitespace, but minimising the number of ticks requires reducing the amount of whitespace and a bit of golfing. I'll assume that you're primarily aiming for the latter, while keeping the code as readable as possible under this constraint.

General comments

Less than

A minor one about your explanation - ( is second &lt; top, so by having n, s at the top of the stack you're checking whether square &gt; n, not square &gt;= n. If it were the latter, your code would fail for numbers like 9! (no factorial)

Floats

Just a note of warning: both the online interpreter and the official Python interpreter use floats for division, so this program would most likely fail for large numbers. Unfortunately, I don't know of any good way to perform integer division as efficiently.

Wrapping and reading direction

Wrapping the last line doesn't affect efficiency, so it's more readable to have the , follow the @. Also, if we wanted to save every tick, we could have this part on the second-last line instead:

:?!;:2%?v2n2,30.
        &gt;:3:02.
::*$}(?v::{:@%?!v2+
       &gt;:1=?;n; &gt;:@,:r~:n:02.


Note that I've also flipped the :1=?;n; for readability since it fits going left-to-right.

Print if not 1

Speaking of :1=?;n;, this reads as "halt immediately if the number is 1, else print the number then halt". This could be more clearly expressed as

:1=?!n;


to "print the number if it's not 1, then halt". Alternatively, you can use -? as an idiom for "if not equals", and do

:1-?n;


to save a tick.

Division by 2 loop

It's a bit more logical to separate the initial zero check from the rest of the first line, which divides out factors of 2. This is also a bit more efficient, since we save on the 30. jump.

:?!;v
2n2,&gt;:2%?v


Main loop efficiency

To get from the stack state [n, n, i] to [i, n, n, s], you currently do

::*}$


Instead, you can do

:}:*


Putting all of the above notes together, we get the slightly more efficient version:

:?!;v
2n2,&gt;:2%?v
         &gt;:3:03.
:}:*(?v::{:@%?!v2+
      &gt;:1-?n;  &gt;:@,:r~:n:03.


Outputting characters

This only concerns your testing code, but outputting single characters should be done with quotes for readability, i.e. ','o rather than 4b*o to output a comma.

Would-be readability comments

In terms of general >&lt;> readability, I wouldn't call this particularly readable, but under the constraint of efficiency it's pretty good. However, if the goal were strictly readability, here are a few comments:


Whitespace should be used to group logical components, e.g. :2%?v 2n 2, 30..
It makes more sense logically to enter the main loop starting with [n, i] rather than [n, n, i].
Because 02. starts execution of the main loop from the second : of ::*, you have an extra : to compensate before both instances of 02.. To cut down on repetition, the main loop should be indented. (You could also move the + from the end to the start so as to not lose efficiency, but that comes at a cost to readability).


Extra: using l as a counter

For extra efficiency and sheer stupidity, we can use l (which pushes the length of the stack) as a counter to save on stack manipulation. Granted, this would run into memory problems for large numbers and is terrible for readability, but I'm sure that's the least of our worries if we're factorising in >&lt;>!

:?!;v
2n2,&gt;:2%?v
         &gt;:f3.
:l:*(?v:l%?!v::
;n?-1:&lt;     &gt;:lnl,$~f3.