Principle and Implementation of the integer division algorithm

The integer division problem is to split a positive integer N into a group of numbers plus N, and the maximum number of integers in this group is not greater than N.
For example, 6 is divided into Integers

6
5 + 1
4 + 2, 4 + 1 + 1
3 + 3, 3 + 2 + 1, 3 + 1 + 1 + 1
2 + 2 + 2, 2 + 2 + 1 + 1, 2 + 1 + 1 + 1 + 1
1 + 1 + 1 + 1 + 1 + 1

A total of 11 types. The following describes a recursive method to obtain the number of partitions of a positive integer.

The declaration of recursive functions is int split (int n, int m), where N is the positive integer to be divided, and m is the maximum addition in the Division (when m> N, n ),
1 When n = 1 or M = 1, the split value is 1. As shown in the preceding example, only one partition is 1 or 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
Available Program If (n = 1 | M = 1) return 1;

2. Let's take a look at the relationship between M and N. They have three relationships.
(1) m> N
In integer division, the maximum addition number cannot be greater than N. Therefore, this can be equivalent to split (N, N );
Available programs are represented as if (M> N) return split (N, N );
(2) M = N
In this case, it can be recursively expressed as split (n, m-1) + 1. From the above example, we can see that
The sum of the numbers 6 and less than 6
Expressed as if (M = N) Return (split (n, m-1) + 1) using a program );
(3) M <n
This is the most common case.
As shown in the preceding example, if M is set to 4, the split (6, 4) value is the sum of the number of splits whose maximum number is less than 4 and integer 2.
Therefore, split (n, m) can be expressed as split (n, m-1) + split (n-M, m)

Based on the above description, the source code is as follows:

# Include < Stdio. h >

Int Split ( Int N, Int M)
{
If (N <   1   | M <   1 ) Return   0 ;
If (N =   1   | M =   1 ) Return   1 ;
If (N < M) Return Split (N, N );
If (N = M) Return (Split (n, m -   1 ) +   1 );
If (N > M) Return (Split (n, m -   1 ) + Split (n - M), m ));
}

int main ()
{< br> printf ( " 12: % d " , split ( 12 , 12 ));
return 0 ;
}

Divide a positive integer into the sum of consecutive positive integers.
For example, 15 can be divided into four forms of continuous integer addition:
15
7 8
4 5 6
1 2 3 4 5

First consider the general form, set N to the positive integer to be divided, and X to the smallest integer after division. If n has a division, then
The result is X. If there are two types of division, X and x + 1. If there are m types, is x, x + 1, x + 1 x + 2 ,..., x + 1 x + 2... X + m-1
Add each result to obtain a formula (I * x + I * (I-1)/2) = n, and I is the number of integers added after the current division.
The Division that satisfies the condition is all the conditions that make X a positive integer.
In the above example, when I = 1, it is divided into a positive integer, x = 15, and when I = 2, x = 7.
If X = 3, x = 4, and X = 4, 4/9 is not a positive integer. Therefore, 15 cannot be divided into four integers.
When x = 5, x = 1.

There is another question: what is the maximum I value? However, it must be smaller than N. We can make a hypothesis,
Assume that N can be split into a division with a minimum value of 1. In the preceding example, 1 2 3 4 5. This is the maximum number of N. If this assumption is not met,
Then I must be smaller than the number of positive integers in this division. Therefore, we can obtain the formula I * (I + 1)/2 <= N, that is, when I satisfies
In this formula, N can be divided.

Based on the above, the source program is as follows:

Int Split1 ( Int N)
{
Int I, j, m =   0 , X, T1, T2;
// Here I + 1 is changed to I-1 because I * (I-1)/2 is used multiple times below,
// To avoid repeated computation, the value is saved in T1 after calculation. And change <= to <.
For (I =   1 ; (T1 = I * (I -   1 ) /   2 ) < N; I ++ )
{
T2 = (N - T1 );
X = T2 / I;
If (X <=   0 ) Break ;
If (N - T1) % I =   0 )
{
Printf ( " % D " , X );
For (J =   1 ; J < I; j ++ )
Printf ( " % D " , X + J );
Printf ( " \ N " );
M ++ ;
}
}
Return M;
}