You need to write a program that searches among integers belonging to a numerical segment [125 256; 125 330], numbers having exactly six different nominal divisors. For each number found, write these six divisors in six adjacent columns on the screen from a new line. Dividers in the row must follow in ascending order.
for example, in the range [2; 48] Exactly six point different natural divisors have numbers 24, 36 and 40, so for this range the output on the screen must contain the following values:
2 4 6 8 12 24
2 4 6 12 18 36
2 4 8 10 20 40
How I tried to solve this task:
a = 125256
B = 125330.
For n in Range (A, B + 1):
DS = []
For D in Range (2, N // 2 + 1): Honestly, I do not fully understand what function does N // 2 + 1 perform here.
IF N% d == 0:
DS.APPEND (D)
IF LEN (DS) & GT; 6:
Break
IF LEN (DS) == 6:
Print (DS [0], DS [1], DS [2], DS [3], DS [4], DS [5])
In my opinion, the 7th line should look like this: if n% d == 0 and d% 2 == 0:
# But then nothing is displayed at all
I would like to hear from people who are trying in Pajton, what I do wrong.
Answer 1, Authority 100%
Well, this option is correctly running your test example:
a = 2 # 125256
B = 48 # 125330
k = 0.
For n in Range (A, B + 1, 2):
DS = []
For D in Range (2, N // 2 + 1, 2):
IF N% d == 0:
DS.APPEND (D)
IF LEN (DS) & GT; 6:
Break
DS.APPEND (N)
IF LEN (DS) == 6:
Print (n, '', ds [0], ds [1], ds [2], ds [3], ds [4], ds [5])
Conclusion:
24  2 4 6 8 12 24
36  2 4 6 12 18 36
40  2 4 8 10 20 40
Explanations:
 Catching makes sense only for even numbers, in odd numbers there will not be aware divisors, so the step
2
in the cycle byN
(reducing the bust 2 times)  Dividers also makes sense to sore only – because such a condition, therefore, in the cycle by
D
, I also put a step2
(reducing the bust 2 times)  The number itself is also considered to be its divider, judging by the above example, so I added it to the list manually after the cycle end. You can do this before the start of the cycle, but then the list of numbers do not turn out in order, so I add at the end, just for beauty.
 Bruep made to
n // 2 + 1
Because if the number is exactly, it means it is divided into2
, dividers less than2
It cannot be, it means that the bust makes sense to lead only ton // 2
(and I addN
later),+1
Due to the features of theRange
– the final value is not included in the bust, so you need to add1
(total – again reduce the bust by 2 times).
Result for numbers from the title:
125262  2 6 18 13918 41754 125262
125288  2 4 8 31322 62644 125288
125298  2 6 18 13922 41766 125298
Answer 2, Authority 100%
for d in range (2, n // 2 + 1): # Honestly, I do not fully understand, What function performs here n // 2 + 1
i.e. You wrote the code and do not understand what you wrote? Or did you write it off?
Well, you first need to figure out how the algorithm
should look like
If we assume that 1 is not a divider, then you need

For each number
N
Go from the numberI
from 2 ton
inclusive and try to divide the numberN
oni

If the division occurs without a residue (the module is 0) and the divider is even, then +1 to the number of found divisors
for n in range (a, b + 1): Count = 0. For j in Range (2, n + 1): IF N% j == 0 and j% 2 == 0: Count + = 1 IF Count == 6: Print ("found")
Obviously, N
is a divider for himself, and the nearest smaller divider is n / 2
, just because 0 & lt; n / (n / 2 + j) & lt; 1
Therefore, the divider counter can be started with 1 and sort out the numbers only to N / 2
:
The only thing that first need to check whether N
is even
count = int (n% 2 == 0)
not to do a lot of if else
just translated boolean value to integer
for n in range (a, b + 1):
Count = int (N% 2 == 0)
For j in Range (2, N // 2 + 1):
IF N% j == 0 and j% 2 == 0:
Count + = 1
IF Count == 6:
Print ("found")
In this case,
n // 2 + 1
To guarantee half of the number N
when proeding
If you need to withdraw dividers, then only in the code it is necessary to add their collection (take into account that 1 divider we always know – this is N
)
for n in range (a, b + 1):
Count = int (n% 2 == 0)
Dividers = [N] IF N% 2 == 0 ELSE []
For j in Range (2, N // 2 + 1):
IF N% j == 0 and j% 2 == 0:
Count + = 1
Dividers.APPEND (J)
IF Count == 6:
Print (* Sorted (Dividers))
Answer 3
If you edit your code, the following is:
a = 125256
B = 125330.
For n in Range (A, B + 1):
DS = []
For D in Range (2, n + 1): # because a and b small, you can consider all dividers of the number
IF N% d == 0:
if d% 2 == 0: ds.append (D) # Right, in this step we check that the divider is even
# If Len (DS) & GT; 6: Excessive code, slightly accelerates the decision
# Break
IF LEN (DS) == 6:
Print (DS [0], DS [1], DS [2], DS [3], DS [4], DS [5])
The optimal solution is:
 go through all numbers
 each number divide on all numbers to the root inclusive.
 Every time we get two divisors (divider and private), if some of them are even – we save.
for n in range (125256, 125330 +1):
Counter = Set () # Most instead of the list, avoid repeats
For D in Range (1, int (n ** 0.5) + 1): # Bruel to root inclusive
if n% d == d% 2 == 0: counter.add (D) # save the divider if it is even
if n% d == n // D% 2 == 0: counter.add (N // D) # save the private (it is also divided into it), if it is even
If Len (Counter) == 6: # If divisters six
Print (* Sorted (Counter) # withdraw them in ascending order