Rosetta Code

Brazilian numbers: Difference between revisions

Page Discussion

Brazilian numbers (view source)

Revision as of 19:16, 9 March 2024

9,137 bytes added ,  2 months ago
m
→‎{{header|Fōrmulæ}}
(→‎{{header|Moula-2}}: Added a solution.)
 
(10 intermediate revisions by 7 users not shown)
Line 514:
 
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{trans|Modula-2}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
1000 REM Brazilian numbers
1010 DECLARE EXTERNAL FUNCTION IsBrazilian
1020 DECLARE EXTERNAL FUNCTION SameDigits
1030 DECLARE EXTERNAL FUNCTION IsPrime
1040 PRINT "First 20 Brazilian numbers:"
1050 LET C = 0
1060 LET N = 7
1070 DO WHILE C < 20
1080 IF IsBrazilian(N) <> 0 THEN
1090 PRINT N;
1100 LET C = C + 1
1110 END IF
1120 LET N = N + 1
1130 LOOP
1140 PRINT
1150 PRINT
1160 PRINT "First 20 odd Brazilian numbers:"
1170 LET C = 0
1180 LET N = 7
1190 DO WHILE C < 20
1200 IF IsBrazilian(N) <> 0 THEN
1210 PRINT N;
1220 LET C = C + 1
1230 END IF
1240 LET N = N + 2
1250 LOOP
1260 PRINT
1270 PRINT
1280 PRINT "First 20 prime Brazilian numbers:"
1290 LET C = 0
1300 LET N = 7
1310 DO WHILE C < 20
1320 IF IsBrazilian(N) <> 0 THEN
1330 PRINT N;
1340 LET C = C + 1
1350 END IF
1360 DO
1370 LET N = N + 2
1380 LOOP WHILE IsPrime(N) = 0
1390 LOOP
1400 PRINT
1410 END
1420 REM
1430 EXTERNAL FUNCTION IsBrazilian(N)
1440 REM Result: 1 if N is Brazilian, 0 otherwise
1450 IF N < 7 THEN
1460 LET IsBrazilian = 0
1470 ELSEIF (MOD(N, 2) = 0) AND (N >= 8) THEN
1480 LET IsBrazilian = 1
1490 ELSE
1500 FOR B = 2 TO N - 2
1510 IF SameDigits(N, B) <> 0 THEN
1520 LET IsBrazilian = 1
1530 EXIT FUNCTION
1540 END IF
1550 NEXT B
1560 LET IsBrazilian = 0
1570 END IF
1580 END FUNCTION
1590 REM
1600 EXTERNAL FUNCTION SameDigits(N, B)
1610 REM Result: 1 if N has same digits in the base B, 0 otherwise
1620 LET NL = N ! Local N
1630 LET F = MOD(NL, B)
1640 LET NL = INT(NL / B)
1650 DO WHILE NL > 0
1660 IF MOD(NL, B) <> F THEN
1670 LET SameDigits = 0
1680 EXIT FUNCTION
1690 END IF
1700 LET NL = INT(NL / B)
1710 LOOP
1720 LET SameDigits = 1
1730 END FUNCTION
1740 REM
1750 EXTERNAL FUNCTION IsPrime(N)
1760 REM Result: non-zero if N is prime, 0 otherwise
1770 IF N < 2 THEN
1780 LET IsPrime = 0
1790 ELSEIF MOD(N, 2) = 0 THEN
1800 REM IsPrime = (N = 2)
1810 IF N = 2 THEN
1820 LET IsPrime = 1
1830 ELSE
1840 LET IsPrime = 0
1850 END IF
1860 ELSEIF MOD(N, 3) = 0 THEN
1870 REM IsPrime = (N = 3)
1880 IF N = 3 THEN
1890 LET IsPrime = 1
1900 ELSE
1910 LET IsPrime = 0
1920 END IF
1930 ELSE
1940 LET D = 5
1950 DO WHILE D * D <= N
1960 IF MOD(N, D) = 0 THEN
1970 LET IsPrime = 0
1980 EXIT FUNCTION
1990 ELSE
2000 LET D = D + 2
2010 IF MOD(N, D) = 0 THEN
2020 LET IsPrime = 0
2030 EXIT FUNCTION
2040 ELSE
2050 LET D = D + 4
2060 END IF
2070 END IF
2080 LOOP
2090 LET IsPrime = 1
2100 END IF
2110 END FUNCTION
</syntaxhighlight>
{{out}}
<pre>
First 20 Brazilian numbers:
7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33
 
First 20 odd Brazilian numbers:
7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77
 
First 20 prime Brazilian numbers:
7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801
</pre>
 
==={{header|FreeBASIC}}===
{{trans|Visual Basic .NET}}
Line 559 ⟶ 688:
Next i
Sleep</syntaxhighlight>
 
==={{header|Nascom BASIC}}===
{{trans|Modula-2}}
{{works with|Nascom ROM BASIC|4.7}}
This version shows only the first 12 prime Brazilian numbers because of slow work.
<syntaxhighlight lang="basic">
10 REM Brazilian numbers
20 PRINT "First 20 Brazilian numbers:"
30 C=0:N=7
40 IF C>=20 THEN 90
50 GOSUB 320
60 IF BR THEN PRINT N;:C=C+1
70 N=N+1
80 GOTO 40
90 PRINT:PRINT
100 PRINT "First 20 odd Brazilian numbers:"
110 C=0:N=7
120 IF C>=20 THEN 170
130 GOSUB 320
140 IF BR THEN PRINT N;:C=C+1
150 N=N+2
160 GOTO 120
170 PRINT:PRINT
180 PRINT "First 12 prime Brazilian numbers:"
190 C=0:N=7
200 IF C>=12 THEN 270
210 GOSUB 320
220 IF BR THEN PRINT N;:C=C+1
230 N=N+2
240 GOSUB 530
250 IF NOT PRM THEN 230
260 GOTO 200
270 PRINT
280 END
290 REM ** Is Brazilian?
300 REM Result: BR=-1 if N is Brazilian
310 REM 0 otherwise
320 IF N<7 THEN BR=0:RETURN
330 IF INT(N/2)*2=N AND N>=8 THEN BR=-1:RETURN
340 FOR B=2 TO N-2
350 GOSUB 430
360 IF SMD THEN BR=-1:RETURN
370 NEXT B
380 BR=0
390 RETURN
400 REM ** Same digits?
410 REM Result: SMD=-1 if N has same digits in B,
420 REM 0 otherwise
430 NL=N:REM "Local" N
440 NDB=INT(NL/B)
450 F=NL-NDB*B
460 NL=NDB:NDB=INT(NL/B)
470 IF NL<=0 THEN SMD=-1:RETURN
480 IF NL-NDB*B<>F THEN SMD=0:RETURN
490 NL=INT(NL/B):NDB=INT(NL/B)
500 GOTO 470
510 REM ** Is prime?
520 REM Result: PRM=-1 if N prime, 0 otherwise
530 IF N<2 THEN PRM=0:RETURN
540 IF INT(N/2)*2=N THEN PRM=N=2:RETURN
550 IF INT(N/3)*3=N THEN PRM=N=3:RETURN
560 D=5
570 IF D*D>N THEN PRM=-1:RETURN
580 IF INT(N/D)*D=N THEN PRM=0:RETURN
590 D=D+2
600 IF INT(N/D)*D=N THEN PRM=0:RETURN
610 D=D+4
620 GOTO 570
</syntaxhighlight>
{{out}}
<pre>
First 20 Brazilian numbers:
7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33
 
First 20 odd Brazilian numbers:
7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77
 
First 12 prime Brazilian numbers:
7 13 31 43 73 127 157 211 241 307 421 463
</pre>
 
==={{header|Visual Basic .NET}}===
Line 1,445 ⟶ 1,654:
{{trans|C}}
<syntaxhighlight lang="easylang">
procfunc sameDigits n b . r .
r = 1
f = n mod b
repeat
Line 1,452 ⟶ 1,660:
until n = 0
if n mod b <> f
r =return 0
break 1
.
.
return 1
.
procfunc isBrazilian7 n . r .
# n >= 7
r = 0
if n mod 2 = 0
r =return 1
break 1
.
for b = 2 to n - 2
callif sameDigits n b h= 1
if h = return 1
r = 1
break 2
.
.
return 0
.
procfunc isPrime4prime n . r .
#if n >mod 2 = 40 and n > 2
r = return 0
if n mod 2 = 0 or n mod 3 = 0
break 1
.
di = 53
whilesq d= * d <=sqrt n
while i if n mod d <= 0sq
if n mod breaki 2= 0
return 0
.
di += 2
if n mod d = 0
break 2
.
d += 4
.
r =return 1
.
for kind$ in [ "" "odd" "prime" ]
Line 1,496 ⟶ 1,696:
cnt = 1
while cnt <= 20
callif isBrazilian7 n r= 1
if r = 1
write n & " "
cnt += 1
Line 1,508 ⟶ 1,707:
repeat
n += 2
calluntil isPrime4prime n r= 1
until r = 1
.
.
Line 3,088 ⟶ 3,286:
{7, 13, 15, 21, 27, 31, 33, 35, 39, 43, 45, 51, 55, 57, 63, 65, 69, 73, 75, 77}
{7, 13, 31, 43, 73, 127, 157, 211, 241, 307, 421, 463, 601, 757, 1093, 1123, 1483, 1723, 2551, 2801}</pre>
 
=={{header|MATLAB}}==
{{trans|Mathematica_/_Wolfram_Language}}
<syntaxhighlight lang="MATLAB">
clear all;close all;clc;
 
% Find the first 20 Brazilian numbers in the range 7 to 100.
brazilian_numbers = [];
for num = 7:100
if brazilianQ(num)
brazilian_numbers = [brazilian_numbers, num];
if length(brazilian_numbers) == 20
break;
end
end
end
% For Brazilian numbers
fprintf('% 8d', brazilian_numbers);
fprintf("\n");
 
 
% Find the first 20 odd Brazilian numbers in the range 7 to 100.
odd_brazilian_numbers = [];
for num = 7:100
if brazilianQ(num) && mod(num, 2) ~= 0
odd_brazilian_numbers = [odd_brazilian_numbers, num];
if length(odd_brazilian_numbers) == 20
break;
end
end
end
% For odd Brazilian numbers
fprintf('% 8d', odd_brazilian_numbers);
fprintf("\n");
 
 
% Find the first 20 Brazilian prime numbers in the range 7 to 10000.
brazilian_prime_numbers = [];
for num = 7:10000
if brazilianQ(num) && isprime(num)
brazilian_prime_numbers = [brazilian_prime_numbers, num];
if length(brazilian_prime_numbers) == 20
break;
end
end
end
% For Brazilian prime numbers
fprintf('% 8d', brazilian_prime_numbers);
fprintf("\n");
 
 
 
function isBrazilian = brazilianQ(n)
% Function to check if a number is a Brazilian number.
if n <= 6
error('Input must be greater than 6.');
end
isBrazilian = false;
for b = 2:(n-2)
base_b_digits = custom_dec2base(n, b) - '0'; % Convert number to base b and then to digits
if all(base_b_digits == base_b_digits(1))
isBrazilian = true;
break;
end
end
end
 
function digits = custom_dec2base(num, base)
% Custom function to convert number to any base representation
if base < 2 || base > num
error('Base must be at least 2 and less than the number itself.');
end
digits = [];
while num > 0
remainder = mod(num, base);
digits = [remainder, digits];
num = floor(num / base);
end
end
</syntaxhighlight>
{{out}}
<pre>
7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33
7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77
7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801
</pre>
 
 
=={{header|Modula-2}}==
{{trans|C|<code>CARDINAL</code> (unsigned integer) used instead of signed integer.<code>ELSIF</code> used instead of sequential <code>IF</code>s with <code>RETURN</code> s. In the main program, the loop <code>for (i = 0; i < 3; ++i) </code> is replaced by subsequent actions, because the actions vary depending on <code>i</code>.}}
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<syntaxhighlight lang="modula2">
Line 3,098 ⟶ 3,384:
FROM SWholeIO IMPORT
WriteInt;
 
TYPE
TString7 = ARRAY [0 .. 6] OF CHAR;
TKinds = ARRAY [0 .. 2] OF TString7;
 
CONST
Kinds = TKinds {" ", " odd ", " prime "};
 
VAR
I, C, N: CARDINAL;
 
PROCEDURE SameDigits(N, B: CARDINAL): BOOLEAN;
Line 3,171 ⟶ 3,450:
 
BEGIN
WriteString("First 20 Brazilian numbers:");
FOR I := 0 TO 2 DO
WriteLn;
WriteString("First 20");
C := 0; N := 7;
WriteString(Kinds[I]);
WHILE C < 20 DO
WriteString("Brazilian numbers:");
IF IsBrazilian(N) THEN
WriteLn;
C := 0WriteInt(N, 1);
N := 7WriteString(" ");
LOOP C := C + 1;
END;
IF IsBrazilian(N) THEN
N := N WriteInt(N,+ 1);
END;
WriteString(" ");
WriteLn; WriteLn;
C := C + 1;
WriteString("First 20 odd Brazilian numbers:");
IF C = 20 THEN
WriteLn;
C := 0; N := WriteLn7;
WHILE C < 20 EXITDO
IF IsBrazilian(N) END;THEN
ENDWriteInt(N, 1);
CASEWriteString(" I OF");
0: NC := NC + 1;
|END;
1: N := N + 2;
|END;
WriteLn; WriteLn;
2:
WriteString("First 20 prime Brazilian numbers:");
REPEAT
WriteLn;
N := N + 2
C := 0; N := UNTIL IsPrime(N)7;
WHILE C < 20 END (* CASE *)DO
ENDIF IsBrazilian(*N) LOOP *)THEN
WriteInt(N, 1);
END (* FOR *)
WriteString(" ");
C := C + 1;
END;
REPEAT
N := N + 2
UNTIL IsPrime(N);
END;
WriteLn;
END BrazilianNumbers.
</syntaxhighlight>
Line 3,931 ⟶ 4,218:
First 20 prime Brazilians:
[7,13,31,43,73,127,157,211,241,307,421,463,601,757,1093,1123,1483,1723,2551,2801]</pre>
 
=={{header|Quackery}}==
 
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<syntaxhighlight lang="Quackery"> [ dup base put
/mod temp put
true swap
[ dup 0 > while
base share /mod
temp share != iff
[ dip not ]
done
again ]
drop
temp release
base release ] is allsame ( n n --> b )
 
[ false swap
dup 3 - times
[ dup i 2 +
allsame iff
[ dip not
conclude ]
done ]
drop ] is brazilian ( n --> b )
 
say "First 20 Brazilian numbers:" cr
[] 0
[ dup brazilian if
[ dup dip join ]
1+
over size 20 = until ]
drop echo
cr
cr
say "First 20 odd Brazilian numbers:" cr
[] 1
[ dup brazilian if
[ dup dip join ]
2 +
over size 20 = until ]
drop echo
cr
cr
say "First 20 prime Brazilian numbers:" cr
[] 1
[ dup isprime not iff
[ 2 + ] again
dup brazilian if
[ dup dip join ]
2 +
over size 20 = until ]
drop echo</syntaxhighlight>
 
{{out}}
 
<pre>First 20 Brazilian numbers:
[ 7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33 ]
 
First 20 odd Brazilian numbers:
[ 7 13 15 21 27 31 33 35 39 43 45 51 55 57 63 65 69 73 75 77 ]
 
First 20 prime Brazilian numbers:
[ 7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801 ]
</pre>
 
=={{header|Racket}}==
 
Line 4,553 ⟶ 4,907:
println("be a little patient, it will take some time")
val bigElement = LazyList.from(7).filter(isBrazilian(_)).drop(bigLimit - 1).take(1).head
println(s"brazilian($bigLimit): $bigElement")
}</syntaxhighlight>
Line 4,563 ⟶ 4,917:
brazilian(100000): 110468
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func is_Brazilian_prime(q) {
Line 4,751 ⟶ 5,106:
{{trans|Go}}
{{libheader|Wren-math}}
<syntaxhighlight lang="ecmascriptwren">import "./math" for Int
 
var sameDigits = Fn.new { |n, b|
Laurence
2,120

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/347730...361477"