# How many steps does it take from n to 1 by subtracting the greatest divisor?

The Problem

Let n be a natural number ≥ 2. Take the biggest divisor of n – which is different from n itself – and subtract it from n. Repeat until you get 1.

The Question

How many steps does it take to reach 1 for a given number n ≥ 2.

Detailed Example

Let n = 30.

The greatest divisor of:

1.   30 is 15  -->  30 - 15 = 15
2.   15 is  5  -->  15 -  5 = 10
3.   10 is  5  -->  10 -  5 =  5
4.    5 is  1  -->   5 -  1 =  4
5.    4 is  2  -->   4 -  2 =  2
6.    2 is  1  -->   2 -  1 =  1


It takes 6 steps to reach 1.

Input

• Input is an integer n, where n ≥ 2.
• Your program should support input up to the language's maximum integer value.

Output

• Simply output the number of steps, like 6.
• Leading/trailing whitespaces or newlines are fine.

Examples

f(5)        --> 3
f(30)       --> 6
f(31)       --> 7
f(32)       --> 5
f(100)      --> 8
f(200)      --> 9
f(2016^155) --> 2015


Requirements

• You can get input from STDIN, command line arguments, as function parameters or from the closest equivalent.
• You can write a program or a function. If it is an anonymous function, please include an example of how to invoke it.
• This is so shortest answer in bytes wins.
• Standard loopholes are disallowed.

This series can be found on OEIS as well: A064097

A quasi-logarithm defined inductively by a(1) = 0 and a(p) = 1 + a(p-1) if p is prime and a(n*m) = a(n) + a(m) if m,n > 1.

• clarify the input requirement in languages with native arbitrary precision integers? – Sparr May 9 '16 at 22:20
• @Sparr I would say, you should at least support up to 2^32 - 1. The rest is up to you and your system. Hope, this is what you meant with your question. – insertusernamehere May 9 '16 at 23:16
• I like how the title sums it all up – Luis Mendo May 10 '16 at 21:33

# Jelly, 9 bytes

ÆṪÐĿÆFL€S


### Background

The definition of sequence A064097 implies that  where φ denotes Euler's totient function and p varies only over prime numbers.

Combining both, we deduce the property where ω denotes the number of distinct prime factors of n.

Applying the resulting formula k + 1 times, where k is large enough so that φk+1(n) = 1, we get From this property, we obtain the formula where the last equality holds because ω(1) = 0.

### How it works

ÆṪÐĿÆFL€S  Main link. Argument: n

ÐĿ       Repeatedly apply the link to the left until the results are no longer
unique, and return the list of unique results.
ÆṪ           Apply Euler's totient function.
Since φ(1) = 1, This computes φ-towers until 1 is reached.
ÆF     Break each resulting integer into [prime, exponent] pairs.
L€   Compute the length of each list.
This counts the number of distinct prime factors.
S  Add the results.

• Now that is a super clever approach ! – Abr001am May 13 '16 at 15:59
• With the latest version of Jelly, this is 7 bytes, meaning it's still in (joint) first – caird coinheringaahing Nov 2 '20 at 16:42

# 05AB1E, 13 11 bytes

Code:

[DÒ¦P-¼D#]¾


Explanation:

[        ]   # An infinite loop and...
D#        break out of the loop when the value is equal to 1.
D           # Duplicate top of the stack (or in the beginning: duplicate input).
Ò          # Get the prime factors, in the form [2, 3, 5]
¦         # Remove the first prime factor (the smallest one), in order to get
the largest product.
P        # Take the product, [3, 5] -> 15, [] -> 1.
-       # Substract from the current value.
¼      # Add one to the counting variable.
¾  # Push the counting variable and implicitly print that value.


Uses CP-1252 encoding. Try it online!.

• Remove the first prime factor (the smallest one), in order to get the largest product How clever! :-) – Luis Mendo May 9 '16 at 13:58
• I see, you are the language developer – Display Name May 11 '16 at 12:56
• @SargeBorsch Yes, that is correct :) – Adnan May 11 '16 at 16:10
• [¼Ñü-¤ÄD#]¾ - I was close to shaving off a byte with pairwise, oh well... – Magic Octopus Urn Jan 18 '17 at 18:57
• Down to 9: [Ð#Ò¦P-]N. You don't need the counter variable. – Grimmy May 22 '19 at 13:19

# Pyth, 11 bytes

fq1=-Q/QhPQ


Test suite

A straightforward repeat-until-true loop.

Explanation:

fq1=-Q/QhPQ
Implicit: Q = eval(input())
f              Apply the following function until it is truthy,
incrementing T each time starting at 1:
PQ    Take the prime factorization of Q
h      Take its first element, the smallest factor of Q
/Q       Divide Q by that, giving Q's largest factor
-Q         Subtract the result from Q
=           Assign Q to that value
q1            Check if Q is now 1.

• that's a really nice trick with filter. – Maltysen May 9 '16 at 20:49
• I don't understand why this outputs the number of times the function ran. Is this an undocumented feature of f? – corsiKa May 10 '16 at 20:35
• @corsiKa f without a second argument iterates over all positive integers starting from 1 and returns the first value that gives true on the inner statement. This value happens to be unused in this program, so it returns the number of times that it ran. Not undocumented, just unorthodox :) If it helps, you can think of this as a for loop like: for(int i=1; some_condition_unrelated_to_i; i++) { change_stuff_that_affects_condition_but_not_i;} – FryAmTheEggman May 13 '16 at 15:30
• @corsiKa It's documented in the character reference on the right side of the online interpreter. With only one argument (f <l:T> <none>), f is First input where A(_) is truthy over [1, 2, 3, 4...]. – Dennis May 13 '16 at 15:31
• Ah I understand it now. It uses that input but never uses the input in the calculation. That explains @Maltysen comment of "that's a really nice trick" because you only care about the iteration count not using that count anywhere in your filter. I love those ah-ha moments!: ) – corsiKa May 13 '16 at 15:48

## Python 2, 50 49 bytes

f=lambda n,k=1:2/n or n%(n-k)and f(n,k+1)or-~f(k)


This isn't going to finish that last test case any time soon...

Alternatively, here's a 48-byte which returns True instead of 1 for n=2:

f=lambda n,k=1:n<3or n%(n-k)and f(n,k+1)or-~f(k)


# Jelly, 10 bytes

ÆfḊPạµÐĿi2


Try it online! or verify most test cases. The last test cases finishes quickly locally.

### How it works

ÆfḊPạµÐĿi2  Main link. Argument: n (integer)

Æf          Factorize n, yielding a list of primes, [] for 1, or  for 0.
Ḋ         Dequeue; remove the first (smallest) element.
P        Take the product.
This yields the largest proper divisor if n > 1, 1 if n < 2.
ạ       Yield the abs. value of the difference of the divisor (or 1) and n.
µ      Convert the chain to the left into a link.
ÐĿ    Repeatedly execute the link until the results are no longer unique.
Collect all intermediate results in a list.
For each starting value of n, the last results are 2 -> 1 -> 0 (-> 1).
i2  Compute the 1-based index of 2.


# Retina, 12

• 14 bytes saved thanks to @MartinBüttner

# Julia, 565045 39 bytes

f(n)=n>1&&f(n-n÷first(factor(n)))+1


This is a recursive function that accepts an integer and returns an integer.

Ungolfed:

function f(n)
if n < 2
# No decrementing necessary
return 0
else
# As Dennis showed in his Jelly answer, we don't need to
# divide by the smallest prime factor; any prime factor
# will do. Since factor returns a Dict which isn't
# sorted, first doesn't always get the smallest, and
# that's okay.
return f(n - n ÷ first(factor(n))) + 1
end
end


Try it online! (includes all test cases)

Saved 6 bytes thanks to Martin Büttner and 11 thanks to Dennis!

## PowerShell v2+, 81 bytes

param($a)for(;$a-gt1){for($i=$a-1;$i-gt0;$i--){if(!($a%$i)){$j++;$a-=$i;$i=0}}}$j  Brutest of brute force. Takes input $a, enters a for loop until $a is less than or equal to 1. Each loop we go through another for loop that counts down from $a until we find a divisor (!($a%$i). At worst, we'll find $i=1 as a divisor. When we do, increment our counter $j, subtract our divisor $a-=$i and set $i=0 to break out of the inner loop. Eventually, we'll reach a condition where the outer loop is false (i.e., $a has reached 1), so output $j and exit. Caution: This will take a long time on larger numbers, especially primes. Input of 100,000,000 takes ~35 seconds on my Core i5 laptop. Edit -- just tested with [int]::MaxValue (2^32-1), and it took ~27 minutes. Not too bad, I suppose. # Matlab, 58 bytes function p=l(a),p=0;if(a-1),p=1+l(a-a/min(factor(a)));end  ## Japt, 12 bytes (non-competing) @!(UµUk Å×}a  Test it online! Non-competing because it uses a bunch of features that were added way after the challenge was posted. ### How it works @ !(Uµ Uk Å × }a XYZ{!(U-=Uk s1 r*1 }a // Implicit: U = input integer XYZ{ }a // Return the smallest non-negative integer X which returns // a truthy value when run through this function: Uk // Take the prime factorization of U. s1 // Slice off the first item. // Now we have all but the smallest prime factor of U. r*1 // Reduce the result by multiplication, starting at 1. // This takes the product of the array, which is the // largest divisor of U. U-= // Subtract the result from U. !( // Return !U (which is basically U == 0). // Since we started at 0, U == 1 after 1 less iteration than // the desired result. U == 0 works because the smallest // divisor of 1 is 1, so the next term after 1 is 0. // Implicit: output result of last expression  This technique was inspired by the 05AB1E answer. A previous version used ²¤ (push a 2, slice off the first two items) in place of Å because it's one byte shorter than s1  (note trailing space); I only realized after the fact that because this appends a 2 to the end of the array and slices from the beginning, it in fact fails on any odd composite number, though it works on all given test cases. # Python 3, 75, 70, 67 bytes. g=lambda x,y=0:y*(x<2)or[g(x-z,y+1)for z in range(1,x)if x%z<1][-1]  This is a pretty straight forward recursive solution. It takes a VERY long time for the high number test cases. # ><>, 32 bytes <\?=2:-$@:$/: 1-$:@@:@%?!\
;/ln


Expects the input number, n, on the stack.

This program builds the complete sequence on the stack. As the only number that can lead to 1 is 2, building the sequence stops when 2 is reached. This also causes the size of the stack to equal the number of steps, rather than the number of steps +1.

# Ruby, 43 bytes

f=->x{x<2?0:1+f[(1..x).find{|i|x%(x-i)<1}]}


Find the smallest number i such that x divides x-i and recurse until we reach 1.

# Haskell, 67 bytes

Here's the code:

a&b|b<2=0|a==b=1+2&(b-1)|mod b a<1=1+2&(b-div b a)|1<2=(a+1)&b
(2&)


And here's one reason why Haskell is awesome:

f = (2&)

(-->) :: Eq a => a -> a -> Bool
(-->) = (==)

h=[f(5)        --> 3
,f(30)       --> 6
,f(31)       --> 7
,f(32)       --> 5
,f(100)      --> 8
,f(200)      --> 9
,f(2016^155) --> 2015
]


Yes, in Haskell you can define --> to be equivalent to ==.

# Matlab, 107 bytes

a=input('');b=factor(a-isprime(a));c=log2(a);while(max(b)>1),b=max(factor(max(b)-1));c=c+1;end,disp(fix(c))

• Non-competing, this is not the iterative translation of my last submission, just another direct algerbraic method, it sums up all binary-logs of all prime factors, kinda ambiguous to illustrate.
• I will golf this more when i have time.

# MATL, 17 16 bytes

tttYfl)/-tq]vnq


Try it Online

Explanation

        % Implicitly grab input
% Do while loop
ttt % Make three copies of top stack element
Yf  % Compute all prime factors
l)  % Grab the smallest one
/   % Divide by this to get the biggest divisor
-   % Subtract the biggest divisor
t   % Duplicate the result
q   % Subtract one (causes loop to terminate when the value is 1). This
% is functionally equivalent to doing 1> (since the input will always be positive)
% with fewer bytes
]       % End do...while loop
v       % Vertically concatenate stack contents (consumes entire stack)
n       % Determine length of the result
q       % Subtract 1 from the length
% Implicitly display result


# C99, 62 61 bytes

1 byte golfed off by @Alchymist.

f(a,c,b)long*c,a,b;{for(*c=0,b=a;a^1;a%--b||(++*c,b=a-=b));}


Call as f(x,&y), where x is the input and y is the output.

• If you test a%--b then you can avoid the b-- at the end. A whole one byte saving. – Alchymist May 11 '16 at 15:06

# Julia, 39 36 bytes

\(n,k=2)=n%k>0?n>1&&n\-~k:\(n-n/k)+1


Try it online!

# Clojure, 116 104 bytes

(fn[n](loop[m n t 1](let[s(- m(last(filter #(=(rem m %)0)(range 1 m))))](if(< s 2)t(recur s (inc t))))))


-12 bytes by filtering a range to find multiples, then using last one to get the greatest one

Naïve solution that basically just solves the problem as it's described by the OP. Unfortunately, finding the greatest divisor alone takes up like half the bytes used. At least I should have lots of room to golf from here.

Pregolfed and test:

(defn great-divider [n]
; Filter a range to find multiples, then take the last one to get the largest
(last
(filter #(= (rem n %) 0)
(range 1 n))))

(defn sub-great-divide [n]
(loop [m n
step 1]
(let [g-d (great-divider m) ; Find greatest divisor of m
diff (- m g-d)] ; Find the difference
(println m " is " g-d " --> " m " - " g-d " = " diff)
(if (< diff 2)
step
(recur diff (inc step))))))

(sub-great-divide 30)

30  is  15  -->  30  -  15  =  15
15  is  5  -->  15  -  5  =  10
10  is  5  -->  10  -  5  =  5
5  is  1  -->  5  -  1  =  4
4  is  2  -->  4  -  2  =  2
2  is  1  -->  2  -  1  =  1
6

• @insertusernamehere No, unfortunately, because those are all valid identifiers. I've removed all the possible whitespace. If I want to golf it further, I'll need to rework the algorithm. – Carcigenicate Jan 18 '17 at 17:38

# Perl 6, 35 bytes

{+({$_ -first$_%%*,[R,] ^$_}...1)}  Try it online! ### How it works { } # A bare block lambda. [R,] ^$_          # Construct range from arg minus 1, down to 0.
first $_%%*, # Get first element that is a divisor of the arg.$_ -                              # Subtract it from the arg.
{                        }...1     # Do this iteratively, until 1 is reached.
+(                              )    # Return the number of values generated this way.


# Jelly, 8 bytes

ÆḌṀạƊƬL’


Try it online!

A different approach that takes advantage of Jelly's newer features.

## How it works

ÆḌṀạƊƬL’ - Main link. Takes n on the left
Ɗ    - Group the previous 3 links as a monad f(n):
ÆḌ       -   Proper divisors of n
Ṁ      -   The largest
ạ     -   Absolute different with n
Ƭ   - Repeatedly run f(n) on n, updating n with the result, until
reaching a fixed point (1), collecting intermediate steps
L  - Take the length
’ - Decrement to account for the 1


# Pyth, 17 16 bytes

L?tbhy-b*F+1tPb0


Try it online! (The y.v at the end is for function calling)

### Original 17 bytes:

L?tb+1y-b*F+1tPb0


Try it online! (The y.v at the end is for function calling)

(I actually answered that question with this Pyth program.)

• I didn't actually bother going through your program, but if you're using the recursive definition in the OP, u is probably shorter than actual recursion. – Maltysen May 9 '16 at 13:46

## Pyke, 11 bytes (noncompeting)

D3Phf-oRr;o


This uses a new behaviour where if there is an exception raised after a goto, it restores the state from before the goto (except variable definitions) and continues. In this case it is equivalent to the following python code:

# Implicit input and variable setup
inp = input()
o = 0
# End implicit
try:
while 1:
inp -= factors(inp) # If factors is called on the value 1, it returns an empty
# list which when the first element tries to be accessed
# raises an exception
o += 1 # Using o returns the current value of o and increments it
except:
print o # This in effect gets the number of times the loop went


This is all possible using Pyke without a while loop construction - yay goto!

Try it here!

## JavaScript (ES6), 70 54 bytes

f=(n,i=2)=>n<i?0:n%i?f(n,i+1):n>i?f(i)+f(n/i):1+f(n-1)


Implementation of the provided recursive formula, but now updated to use recursion to find the divisor too.

## Perl, 57 + 1 (-p flag) = 58 bytes

$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n),$\++while$n>1}{


Usage:

> echo 31 | perl -pe '$n=$_;$n-=$n/(grep!($n%$_),2..$n/2,$n),$\++while$n>1}{'


Ungolfed:

while (<>) {
# code above added by -p
# $_ has input value #$\ has undef (or 0)
my $n =$_;
while ($n > 1) { my$d = 1;
for (2 .. ($n / 2)) { if ($n % $_ == 0) {$d = $n /$_;
last;
}
}
$n -=$d;
$\++; } } { # code below added by -p print; # prints$_ (undef here) and \$\
}