Hướng dẫn composite number in range python - số tổng hợp trong dãy python

Composite Numbers in the range

You are given two integers 

M, N as input. Write a program to print all the composite numbers present in the given range (including M and N).

Input

The first line of input is an integer 

M. The second line of input is an integer N.

Explanation

In the given example, the composite numbers present in the range between 

2 to 9 are 4, 6, 8, 9.

So, the output should be

4
6
8
9
Sample Input 1
2
9
Sample Output 1
4
6
8
9
Sample Input 2
1
4
Sample Output 2
4

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Tìm hiểu thêm về sự giúp đỡ của chúng tôi với các bài tập: Python

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Ví dụ: & nbsp; 

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Giải pháp là ít khó khăn. Vì có nhiều câu trả lời có thể, chúng tôi thảo luận về một giải pháp tổng quát ở đây. & Nbsp; & nbsp;

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Ví dụ cho thuật toán trên & nbsp;

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

C++

#include <bits/stdc++.h>

using namespace std;

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Java

[122, 124]

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

using2

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

________ 91 ________ 10 & nbsp; std;3std;4std;5__94

________ 91 ________ 10 & nbsp;

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

std;1

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Python3

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

C#

using

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

________ 91 ________ 10 & nbsp; std;3std;4std;5__94

________ 91 ________ 10 & nbsp;

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

std;1

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)5M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)39 M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)40M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)41 M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)42M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)43__

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)5M = int(input()) N = int(input()) for number in range(M,N+1):    count = 0    #divisor search, do not count the number itself and 1    for divider in range(2,number//2+1):      if number%divider == 0:        count+=1    if count >= 1:      print(number)0 n = 3 Then a = (n+2)! + 2 a = 5! + 2 a + 1 = 5! + 3 a + 2 = 5! + 4 Here a is divisible by 2 Here a + 1 is divisible by 3 Here a + 2 is divisible by 4 Hence a, a+1, a+2 are all composites9

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

n = 3
Then a = (n+2)! + 2
a = 5! + 2
a + 1 = 5! + 3
a + 2 = 5! + 4
Here a is divisible by 2
Here a + 1 is divisible by 3
Here a + 2 is divisible by 4
Hence a, a+1, a+2 are all composites

Input : 3
Output : [122, 124]
Explanation 122, 123, 124 are all composite numbers

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

[122, 124]

Let the length of range be n and range starts 
from a then, a, a+1, a+2, ...., a+n-1 all should 
be composite. So the problem boils down to finding
such 'a'.

If we closely observe p! (where p is a positive 
integers) then we will find that, p! has factors of
2, 3, 4, ..., p-1,
Hence if we add i to p! such that 1 < i < p,
then p! + i has a factor i, so p! + i must be 
composite. So we end up finding p! + 2, p! + 3,
 .... p! + p-1 are all composite and continuous 
integers forming a range [p! + 2, p! + p-1]
The above range consists of p-2 elements.
For a range of n elements we need to consider (n+2)!

If we take a = (n+2)! + 2, 
Then, a + 1 = (n+2)! + 3
Then, a + 2 = (n+2)! + 4
...
Then, a + n-1 = (n+2)! + n+1
Hence,
a = (n+2)! + 2 = 2*3*....*(n+2) + 2
a has 2 as its divisor because (n+2)! and 2 
both divides 2
a + 1 = 2*3*....*(n+2) + 3
a + 1 has 3 as its divisor because (n+2)! 
and 3 both divides 3
...
a + n-1 = 2*3*....*(n+2) + n+1
a + n-1 has n+1 as its divisor because (n+2)! 
and n+1 both divides n+1

Therefore range will be [ (n+2)! + 2, ( (n+2)! + 2 ) + n-1]

Java 

[122, 124]

[122, 124]

[122, 124]

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

M = int(input())
N = int(input())

for number in range(M,N+1):
    count = 0
    #divisor search, do not count the number itself and 1
    for divider in range(2,number//2+1):
        if number%divider == 0:
            count+=1
    if count >= 1:
        print(number)

Làm thế nào để bạn tìm thấy một số tổng hợp trong Python?

Làm thế nào để bạn tìm thấy phạm vi của một số nguyên tố trong Python?

Làm thế nào để bạn kiểm tra một số là số nguyên tố hoặc tổng hợp trong Python?

Làm thế nào để bạn tìm thấy một số tổng hợp giữa hai số?