Rosetta Code

Magnanimous numbers: Difference between revisions

Page Discussion

Magnanimous numbers (view source)

Revision as of 16:09, 30 December 2023

17,594 bytes added ,  4 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added BASIC256)
m (→‎{{header|Wren}}: Minor tidy)
 
(18 intermediate revisions by 7 users not shown)
Line 240:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
Last magnanimous number found: 434 = 999994
</pre>
 
 
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="c">
#include <basico.h>
 
#proto encontrarunMagnanimouspara(_X_)
#synon _encontrarunMagnanimouspara siencontréunMagnanimousen
 
algoritmo
 
decimales '0'
res={}, i=0
iterar grupo( ++i, #(length(res)<400), \
i, meter según ( si encontré un Magnanimous en 'i', res ))
 
#(utf8("Primeros 45 números magnánimos:\n")), #(res[1:45])
#(utf8("\n\nNúmeros magnánimos 241 - 250:\n")), #(res[241:250])
#(utf8("\n\nNúmeros magnánimos 391 - 400:\n")), #(res[391:400]), NL
luego imprime esto
 
terminar
 
subrutinas
 
encontrar un Magnanimous para(n)
tn=n, d=0, i=0, pd=0
iterar
último dígito de 'tn', mover a 'd,tn'
cuando ' tn ' { #( pd += ( d * 10^i ) ) }
mientras ' #( tn && is prime(tn+pd) ); ++i '
 
retornar ' #(not(tn)) '
</syntaxhighlight>
{{out}}
<pre>
Primeros 45 números magnánimos:
0,1,2,3,4,5,6,7,8,9,11,12,14,16,20,21,23,25,29,30,32,34,38,41,43,47,49,50,52,56,58,61,65,67,70,74,76,83,85,89,92,94,98,101,110
 
Números magnánimos 241 - 250:
17992,19972,20209,20261,20861,22061,22201,22801,22885,24407
 
Números magnánimos 391 - 400:
486685,488489,515116,533176,551558,559952,595592,595598,600881,602081
</pre>
 
Line 293 ⟶ 339:
391-400: 486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
</pre>
 
=={{header|BASIC}}==
<syntaxhighlight lang="gwbasic">10 DEFINT A-Z
20 L = N : R = 0 : S = 1
30 IF L < 10 GOTO 140
40 R = R + (L MOD 10) * S
50 L = L \ 10
60 S = S * 10
70 P = R + L
80 IF P = 1 GOTO 120 ELSE FOR D = 2 TO SQR(P)
90 IF P MOD D = 0 GOTO 120
100 NEXT D
110 GOTO 30
120 N = N + 1
130 GOTO 20
140 I = I + 1
150 IF I = 1 THEN PRINT "1 - 45:" ELSE IF I = 241 THEN PRINT "241 - 250:"
160 IF I <= 45 OR I > 240 THEN PRINT N,
170 N = N + 1
180 IF I < 250 GOTO 20
190 END</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407</pre>
 
=={{header|BASIC256}}==
Line 329 ⟶ 410:
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> DIM Sieve% 1E5
Prime%=2
WHILE Prime%^2 < 1E5
FOR S%=Prime%*2 TO 1E5 STEP Prime% Sieve%?S%=1 NEXT
REPEAT Prime%+=1 UNTIL Sieve%?Prime%=0
ENDWHILE
Sieve%?1=1
 
PRINT "First 45 magnanimous numbers"
REPEAT
IF M% > 9 THEN
FOR I%=LOGM% TO 1 STEP -1
IF Sieve%?((M% DIV 10^I%) + (M% MOD 10^I%)) EXIT FOR
NEXT
ENDIF
IF I% == 0 THEN
N%+=1
IF N% == 240 OR N% == 390 PRINT '"Magnanimous numbers ";N% + 1 "-";N% + 10
IF N% < 46 OR (N% > 240 AND N% < 251) OR (N% > 390 AND N% < 401) PRINT;M% " ";
ENDIF
M%+=1
UNTIL N% > 400</syntaxhighlight>
{{out}}
<pre>First 45 magnanimous numbers
0 1 2 3 4 5 6 7 8 9 11 12 14 16 20 21 23 25 29 30 32 34 38 41 43 47 49 50 52 56 58 61 65 67 70 74 76 83 85 89 92 94 98 101 110
Magnanimous numbers 241-250
17992 19972 20209 20261 20861 22061 22201 22801 22885 24407
Magnanimous numbers 391-400
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081</pre>
 
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
 
let prime(n) = valof
$( let d = 5
if n<2 resultis false
if n rem 2=0 resultis n=2
if n rem 3=0 resultis n=3
while d*d <= n
$( if n rem d=0 resultis false
d := d+2
if n rem d=0 resultis false
d := d+4
$)
resultis true
$)
 
let magnanimous(n) = valof
$( let left = n and right = 0 and shift = 1
while left >= 10
$( right := right + (left rem 10) * shift
shift := shift * 10
left := left / 10
unless prime(left + right) resultis false
$)
resultis true
$)
 
let start() be
$( let n = -1
for i = 1 to 250
$( n := n+1 repeatuntil magnanimous(n)
if i=1 then writes("1 - 45:*N")
if i=241 then writes("241 - 250:*N")
if 0<i<=45 | 240<i<=250
$( writed(n, 7)
if i rem 5=0 then wrch('*N')
$)
$)
$)</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407</pre>
 
=={{header|C}}==
Line 551 ⟶ 719:
486685, 488489, 515116, 533176, 551558, 559952, 595592, 595598, 600881, 602081
</pre>
 
=={{header|CLU}}==
<syntaxhighlight lang="clu">prime = proc (n: int) returns (bool)
if n < 2 then return(false) end
if n//2 = 0 then return(n=2) end
if n//3 = 0 then return(n=3) end
d: int := 5
while d*d <= n do
if n//d = 0 then return(false) end
d := d+2
if n//d = 0 then return(false) end
d := d+4
end
return(true)
end prime
 
sum_parts = iter (l: int) yields (int)
r: int := 0
s: int := 0
while l >= 10 do
r := r + (l // 10) * 10 ** s
s := s + 1
l := l / 10
yield(l + r)
end
end sum_parts
 
magnanimous = proc (n: int) returns (bool)
for s: int in sum_parts(n) do
if ~prime(s) then return(false) end
end
return(true)
end magnanimous
 
start_up = proc ()
po: stream := stream$primary_output()
n: int := 0
i: int := 0
c: int := 0
 
while i <= 400 do
while ~magnanimous(n) do n := n+1 end
i := i+1
 
if i=1 then stream$putl(po, "1-45:") c := 0
elseif i=241 then stream$putl(po, "\n241-250:") c := 0
elseif i=391 then stream$putl(po, "391-400:") c := 0
end
 
if i <= 45 cor (i > 240 cand i <= 250) cor (i > 390 cand i <= 400) then
stream$putright(po, int$unparse(n), 7)
c := c+1
if c = 10 then stream$putl(po, "") c := 0 end
end
n := n+1
end
end start_up</syntaxhighlight>
{{out}}
<pre>1-45:
0 1 2 3 4 5 6 7 8 9
11 12 14 16 20 21 23 25 29 30
32 34 38 41 43 47 49 50 52 56
58 61 65 67 70 74 76 83 85 89
92 94 98 101 110
241-250:
17992 19972 20209 20261 20861 22061 22201 22801 22885 24407
391-400:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081</pre>
 
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub prime(n: uint32): (r: uint32) is
r := 0;
if n <= 4 or n & 1 == 0 or n % 3 == 0 then
if n == 2 or n == 3 then
r := 1;
end if;
return;
end if;
 
var d: uint32 := 5;
while d*d <= n loop
if n % d == 0 then return; end if;
d := d+2;
if n % d == 0 then return; end if;
d := d+4;
end loop;
r := 1;
end sub;
 
sub magnanimous(n: uint32): (r: uint32) is
r := 1;
var left: uint32 := n;
var right: uint32 := 0;
var shift: uint32 := 1;
 
while left >= 10 loop
right := right + (left % 10) * shift;
shift := shift * 10;
left := left / 10;
if prime(left + right) == 0 then
r := 0;
break;
end if;
end loop;
end sub;
 
var i: uint16 := 0;
var n: uint32 := 0;
 
while i <= 400 loop
while magnanimous(n) == 0 loop n := n+1; end loop;
i := i + 1;
 
if i == 1 then print("1 - 45:\n");
elseif i == 241 then print("241 - 250:\n");
elseif i == 391 then print("390 - 400:\n");
end if;
 
if i<=45 or (i>240 and i<=250) or (i>390 and i<=400) then
print_i32(n);
if i % 5 == 0 then print_nl();
else print_char('\t');
end if;
end if;
n := n + 1;
end loop;</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407
390 - 400:
486685 488489 515116 533176 551558
559952 595592 595598 600881 602081</pre>
 
 
=={{header|Delphi}}==
Line 654 ⟶ 968:
</pre>
 
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc isprime(word n) bool:
word d;
bool prime;
if n<2 then false
elif n%2=0 then n=2
elif n%3=0 then n=3
else
prime := true;
d := 5;
while prime and d*d <= n do
if n%d=0 then prime := false fi;
d := d+2;
if n%d=0 then prime := false fi;
d := d+4
od;
prime
fi
corp
 
proc magnanimous(word n) bool:
word left, right, shift;
bool magn;
left := n;
right := 0;
shift := 1;
magn := true;
while magn and left >= 10 do
right := right + (left % 10) * shift;
shift := shift * 10;
left := left / 10;
magn := magn and isprime(left + right)
od;
magn
corp
 
proc main() void:
word n, i;
n := 0;
for i from 1 upto 250 do
while not magnanimous(n) do n := n+1 od;
if i=1 then writeln("1 - 45:") fi;
if i=241 then writeln("241 - 250:") fi;
if i<=45 or i>=241 then
write(n:7);
if i%5 = 0 then writeln() fi
fi;
n := n+1
od
corp</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407</pre>
 
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight>
fastfunc isprim num .
if num < 2
return 0
.
i = 2
while i <= sqrt num
if num mod i = 0
return 0
.
i += 1
.
return 1
.
func ismagnan n .
if n < 10
return 1
.
p = 10
repeat
q = n div p
r = n mod p
if isprim (q + r) = 0
return 0
.
until q < 10
p *= 10
.
return 1
.
proc magnan start stop . .
write start & "-" & stop & ":"
while count < stop
if ismagnan i = 1
count += 1
if count >= start
write " " & i
.
.
i += 1
.
print ""
.
magnan 1 45
magnan 241 250
magnan 391 400
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
Line 694 ⟶ 1,122:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
</pre>
 
=={{header|Factor}}==
{{trans|Julia}}
Line 922 ⟶ 1,351:
listMags(391, 400, 1, 10)
}</syntaxhighlight>
 
{{out}}
<pre>
Line 936 ⟶ 1,364:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
</pre>
 
=={{header|GW-BASIC}}==
{{works with|PC-BASIC|any}}
{{works with|BASICA}}
<syntaxhighlight lang="qbasic">100 DEFINT A-Z
110 CLS
120 LET L = N
130 LET R = 0
140 LET S = 1
150 IF L < 10 THEN GOTO 300
160 LET R = R+(L MOD 10)*S
170 LET L = L\10
180 LET S = S*10
190 LET P = R+L
200 IF P = 1 THEN GOTO 280 ELSE FOR D = 2 TO SQR(P)
210 IF P MOD D = 0 THEN GOTO 280
250 NEXT D
270 GOTO 150
280 LET N = N+1
290 GOTO 120
300 LET I = I+1
310 IF I = 1 THEN PRINT "1 - 45:" ELSE IF I = 241 THEN PRINT : PRINT "241 - 250:"
320 IF I <= 45 OR I > 240 THEN PRINT N,
330 LET N = N+1
340 IF I < 250 THEN GOTO 120
350 PRINT
360 END</syntaxhighlight>
 
=={{header|Haskell}}==
Line 1,384 ⟶ 1,839:
{17992,19972,20209,20261,20861,22061,22201,22801,22885,24407}
{486685,488489,515116,533176,551558,559952,595592,595598,600881,602081}</pre>
 
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE MagnanimousNumbers;
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
 
VAR n, i: CARDINAL;
 
PROCEDURE prime(n: CARDINAL): BOOLEAN;
VAR d: CARDINAL;
BEGIN
IF n<2 THEN RETURN FALSE END;
IF n MOD 2 = 0 THEN RETURN n = 2 END;
IF n MOD 3 = 0 THEN RETURN n = 3 END;
d := 5;
WHILE d*d <= n DO
IF n MOD d = 0 THEN RETURN FALSE END;
INC(d, 2);
IF n MOD d = 0 THEN RETURN FALSE END;
INC(d, 4)
END;
RETURN TRUE
END prime;
 
PROCEDURE magnanimous(n: CARDINAL): BOOLEAN;
VAR left, right, shift: CARDINAL;
BEGIN
left := n;
right := 0;
shift := 1;
WHILE left >= 10 DO
INC(right, (left MOD 10) * shift);
shift := shift * 10;
left := left DIV 10;
IF NOT prime(left + right) THEN RETURN FALSE END
END;
RETURN TRUE
END magnanimous;
 
BEGIN
n := 0;
FOR i := 1 TO 250 DO
WHILE NOT magnanimous(n) DO INC(n) END;
 
IF i=1 THEN WriteString("1 - 45:"); WriteLn
ELSIF i=240 THEN WriteString("241 - 250:"); WriteLn
END;
 
IF (i <= 45) OR (i > 240) THEN
WriteCard(n, 7);
IF i MOD 5 = 0 THEN WriteLn END
END;
INC(n)
END
END MagnanimousNumbers.</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407</pre>
 
=={{header|Nim}}==
Line 1,444 ⟶ 1,967:
391st through 400th magnanimous numbers:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081</pre>
 
=={{header|Pascal}}==
{{works with|Free Pascal}}
Line 2,725 ⟶ 3,249:
MAGANIMOUS NUMBERS 241-250:
17992 19972 20209 20261 20861 22061 22201 22801 22885 24407
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">""" rosettacode.orgwiki/Magnanimous_numbers """
 
from sympy import isprime
 
 
def is_magnanimous(num):
""" True is num is a magnanimous number """
if num < 10:
return True
for i in range(1, len(str(num))):
quo, rem = divmod(num, 10**i)
if not isprime(quo + rem):
return False
return True
 
 
if __name__ == '__main__':
 
K, MCOUNT = 0, 0
print('First 45 magnanimous numbers:')
while MCOUNT < 400:
if is_magnanimous(K):
if MCOUNT < 45:
print(f'{K:4d}', end='\n' if (MCOUNT + 1) % 15 == 0 else '')
elif MCOUNT == 239:
print('\n241st through 250th magnanimous numbers:')
elif 239 < MCOUNT < 250:
print(f'{K:6d}', end='')
elif MCOUNT == 389:
print('\n\n391st through 400th magnanimous numbers:')
elif 389 < MCOUNT < 400:
print(f'{K:7d}', end='')
MCOUNT += 1
K += 1
</syntaxhighlight>{{out}}
<pre>
First 45 magnanimous numbers:
0 1 2 3 4 5 6 7 8 9 11 12 14 16 20
21 23 25 29 30 32 34 38 41 43 47 49 50 52 56
58 61 65 67 70 74 76 83 85 89 92 94 98 101 110
 
241st through 250th magnanimous numbers:
17992 19972 20209 20261 20861 22061 22201 22801 22885 24407
 
391st through 400th magnanimous numbers:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
</pre>
 
=={{header|Quackery}}==
 
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="Quackery"> [ 10
[ 2dup /mod
over 0 = iff
[ 2drop true ]
done
+ isprime not iff
false done
10 * again ]
unrot 2drop ] is magnanimous ( n --> b )
 
[] 0
[ dup magnanimous
if [ tuck join swap ]
1+
over size 250 =
until ]
drop
say "First 45 magnanimous numbers:" cr
45 split swap echo cr cr
say "Magnanimous numbers 241-250:" cr
-10 split echo cr cr
drop</syntaxhighlight>
 
{{out}}
 
<pre>First 45 magnanimous numbers:
[ 0 1 2 3 4 5 6 7 8 9 11 12 14 16 20 21 23 25 29 30 32 34 38 41 43 47 49 50 52 56 58 61 65 67 70 74 76 83 85 89 92 94 98 101 110 ]
 
Magnanimous numbers 241-250:
[ 17992 19972 20209 20261 20861 22061 22201 22801 22885 24407 ]
</pre>
 
Line 3,091 ⟶ 3,700:
486685 488489 515116 533176 551558 559952 595592 595598 600881 602081
</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program magnanimous;
n := -1;
loop for i in [1..400] do
loop until magnanimous(n) do n +:= 1; end loop;
case i of
(1): print("1 - 45:");
(241): print; print("241 - 250:");
(391): print; print("391 - 400:");
end case;
if i in [1..45] or i in [241..250] or i in [391..400] then
putchar(lpad(str n, 7));
if i mod 5 = 0 then print; end if;
end if;
end loop;
 
proc magnanimous(n);
return forall k in splitsums(n) | prime(k);
end proc;
 
proc splitsums(n);
s := str n;
return [val s(..i) + val s(i+1..) : i in [1..#s-1]];
end proc;
proc prime(n);
if n<2 then return false;
elseif even n then return(n = 2);
elseif n mod 3=0 then return(n = 3);
else
d := 5;
loop while d*d <= n do
if n mod d=0 then return false; end if;
d +:= 2;
if n mod d=0 then return false; end if;
d +:= 4;
end loop;
return true;
end if;
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>1 - 45:
0 1 2 3 4
5 6 7 8 9
11 12 14 16 20
21 23 25 29 30
32 34 38 41 43
47 49 50 52 56
58 61 65 67 70
74 76 83 85 89
92 94 98 101 110
 
241 - 250:
17992 19972 20209 20261 20861
22061 22201 22801 22885 24407
 
391 - 400:
486685 488489 515116 533176 551558
559952 595592 595598 600881 602081</pre>
 
=={{header|Sidef}}==
Line 3,242 ⟶ 3,914:
{{libheader|Wren-math}}
{{trans|Go}}
<syntaxhighlight lang="ecmascriptwren">import "./fmt" for Conv, Fmt
import "./math" for Int
var isMagnanimous = Fn.new { |n|
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/341361...354135"