Brazilian numbers: Difference between revisions

{{trans|Nim}}

 

I n % 2 == 0

R n == 2

printList(‘First 20 Brazilian numbers:’, n -> 1B)

printList(‘First 20 odd Brazilian numbers:’, n -> (n [&] 1) != 0)

 

{{out}}

Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.

{{libheader|Action! Sieve of Eratosthenes}}

 

BYTE FUNC SameDigits(INT x,b)

PutE() PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Brazilian_numbers.png Screenshot from Atari 8-bit computer]

=={{header|ALGOL W}}==

Constructs a sieve of Brazilian numbers from the definition.

% base B ( 1 < B < N-1 ) has all the same digits %

% set b( 1 :: n ) to a sieve of Brazilian numbers where b( i ) is true %

end_1000000:

end

{{out}}

<pre>

=={{header|AppleScript}}==

 

repeat with b from 2 to n - 2

set d to n mod b

end runTask

 

 

{{output}}

 

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:

 

=={{header|Arturo}}==

 

if n < 7 -> return false

if zero? and n 1 -> return true

printFirstByRule [i: i+1] ""

printFirstByRule [i: i+2] "odd "

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f BRAZILIAN_NUMBERS.AWK

# converted from C

return(1)

}

{{out}}

<pre>

=={{header|C}}==

{{trans|Go}}

 

typedef char bool;

printf("The 100,000th Brazilian number: %d\n", n - 1);

return 0;

 

{{out}}

=={{header|C sharp|C#}}==

{{trans|Go}}

class Program {

}

}

{{out}}

<pre>First 20 Brazilian numbers:

===Speedier Version===

Based on the Pascal version, with some shortcuts. Can calculate to one billion in under 4 1/2 seconds (on a core i7). This is faster than the Pascal version because the sieve is an array of '''SByte''' (8 bits) and not a '''NativeUInt''' (32 bits). Also this code does not preserve the base of each Brazilain number in the array, so the Pascal version is more flexible if desiring to quickly verify a quantity of Brazilian numbers.

 

class Program

if (System.Diagnostics.Debugger.IsAttached) Console.ReadKey();

}

{{out}}

<pre>Sieving took 3009.2927 ms

=={{header|C++}}==

{{trans|D}}

 

bool sameDigits(int n, int b) {

 

return 0;

{{out}}

<pre>First 20 Brazillian numbers:

=={{header|D}}==

{{trans|C#}}

 

bool sameDigits(int n, int b) {

if (kind == "") writefln("The %sth Brazillian number is: %s\n", BigLim + 1, n);

}

{{out}}

<pre>First 20 Brazillion numbers:

=={{header|Delphi}}==

{{Trans|Go}}

program Brazilian_numbers;

 

end.

 

 

{{out}}

=={{header|F_Sharp|F#}}==

===The functions===

// Generate Brazilian sequence. Nigel Galloway: August 13th., 2019

let isBraz α=let mutable n,i,g=α,α+1,1 in (fun β->(while (i*g)<β do if g<α-1 then g<-g+1 else (n<-n*α; i<-n+i; g<-1)); β=i*g)

yield! fN (n+1) ((isBraz (n-1))::g)}

fN 4 [isBraz 2]

===The Tasks===

;the first 20 Brazilian numbers

Brazilian() |> Seq.take 20 |> Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

</pre>

;the first 20 odd Brazilian numbers

Brazilian() |> Seq.filter(fun n->n%2=1) |> Seq.take 20 |> Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

;the first 20 prime Brazilian numbers

Using [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_function Extensible Prime Generator (F#)]

Brazilian() |> Seq.filter isPrime |> Seq.take 20 |> Seq.iter(printf "%d "); printfn ""

{{out}}

<pre>

</pre>

;finally that which the crowd really want to know: What is the 100,000^th Brazilian number?

printfn "%d" (Seq.item 99999 Brazilian)

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 development release 2019-07-10}}

math.parser math.primes.lists math.ranges namespaces prettyprint

prettyprint.config sequences ;

1 [ 2 + ] lfrom-by "First 20 odd Brazilian numbers:"

lprimes "First 20 prime Brazilian numbers:"

{{out}}

<pre>

 

=={{header|Forth}}==

dup 2 < if drop false exit then

dup 2 mod 0= if 2 = exit then

0 20 print_brazilian

 

 

{{out}}

 

=={{header|Fortran}}==

!Constructs a sieve of Brazilian numbers from the definition.

!From the Algol W algorithm, somewhat "Fortranized"

 

 

{{out}}

=={{header|FreeBASIC}}==

{{trans|Visual Basic .NET}}

Dim f As Integer = n Mod b : n \= b

While n > 0

Loop While Limit > 0

Next i

 

 

=={{header|Go}}==

===Version 1===

 

import "fmt"

}

fmt.Println("The 100,000th Brazilian number:", n-1)

 

{{out}}

 

Running a bit quicker than the .NET versions though not due to any further improvements on my part.

 

import (

}

fmt.Printf("\nTotal elapsed was %.4f ms\n", toMs(time.Since(st0)))

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

 

class Brazilian {

}

}

{{out}}

<pre>First 20 Brazilian numbers:

 

=={{header|Haskell}}==

 

isBrazil :: Int -> Bool

, "\n"

])

{{Out}}

<pre>First 20 Brazilians:

Not the most beautiful proofs and the theorem about "R*S >= 8, with S+1 > R, are Brazilian" is missing.

 

imports Main

begin

(*TODO: the first 20 prime Brazilian numbers*)

 

 

=={{header|J}}==

The brazilian verb checks if 1 is the tally of one of the sets of values in the possible base representations.

Doc=: conjunction def 'u :: (n"_)'

 

20 {. brazilian Filter p: 2 + i. 500

7 13 31 43 73 127 157 211 241 307 421 463 601 757 1093 1123 1483 1723 2551 2801

 

=={{header|Java}}==

import java.util.List;

 

}

}

{{out}}

<pre>First 20 Brazilian numbers:

See [[Erdős-primes#jq]] for a suitable definition of `is_prime` as used here.

 

def to_base($base):

def butlast(s):

task(20)

 

{{out}}

As elsewhere, e.g. [[#Python]].

=={{header|Julia}}==

{{trans|Go}}

 

function samedigits(n, b)

 

println("The first 20 prime Brazilian numbers are: ", take(20, primebrazilians))

<pre>

The first 20 Brazilian numbers are: (7 8 10 12 13 14 15 16 18 20 21 22 24 26 27 28 30 31 32 33)

 

There has been some discussion of larger numbers in the sequence. See below:

count, intervalcount, icount = 0, 0, 0

intervalcounts = Int[]

braziliandensities(100000, 1000)

plot(1:1000:1000000, braziliandensities(1000000, 1000))

<pre>

The 10000 th brazilian is 11364.

=={{header|Kotlin}}==

{{trans|C#}}

var n2 = n

val f = n % b

if (kind == "") println("The %,dth Brazilian number is: %,d".format(bigLim + 1, n))

}

{{out}}

<pre>First 20 Brazilian numbers:

=={{header|Lua}}==

{{trans|C}}

local f = n % b

n = math.floor(n / b)

end

 

{{out}}

<pre>First 20 Brazillion numbers:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Range[2, n-2],

MatchQ[IntegerDigits[n, #], {x_ ...}] &

Select[Range[100], brazilianQ@# && OddQ@# &, 20]

Select[Range[10000], brazilianQ@# && PrimeQ@# &, 20]

{{out}}

<pre>{7, 8, 10, 12, 13, 14, 15, 16, 18, 20, 21, 22, 24, 26, 27, 28, 30, 31, 32, 33}

 

=={{header|Nim}}==

## Check if a number is prime.

if n mod 2 == 0:

inc n, 2

while not n.isPrime():

 

{{out}}

extreme reduced runtime time for space.<BR>

At the end only primes and square of primes need to be tested, all others are Brazilian.

 

{$IFDEF FPC}

 

setlength(isPrime, 0);

{{out}}

<pre>first 20 brazilian numbers

{{libheader|ntheory}}

{{trans|Raku}}

use warnings;

use ntheory qw<is_prime>;

print "\n\nFirst $upto prime Brazilian numbers:\n";

$n = 0;

{{out}}

<pre>First 20 Brazilian numbers:

=={{header|Phix}}==

{{trans|C}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">same_digits</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The %,dth Brazilian number: %d\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">c</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>

{{out}}

Not very fast, takes about 4 times as long as Go(v1), at least on desktop/Phix, however under pwa/p2js it is about the same speed.

 

=={{header|Python}}==

 

from itertools import count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 20 Brazilians:

=={{header|Racket}}==

 

 

(require math/number-theory)

(stream->list (stream-take (stream-filter brazilian? (stream-filter odd? (in-naturals))) 20))

(displayln "First 20 prime Brazilian numbers:")

 

{{out}}

{{works with|Rakudo|2019.07.1}}

 

 

multi is-Brazilian (Int $n) {

put "\nFirst $upto odd Brazilian numbers:\n", (^Inf).hyper.map( * * 2 + 1 ).grep( &is-Brazilian )[^$upto];

 

{{out}}

<pre>First 20 Brazilian numbers:

=={{header|REXX}}==

{{trans|GO}}

parse arg t.1 t.2 t.3 t.4 . /*obtain optional arguments from the CL*/

if t.4=='' | t.4=="," then t.4= 0 /*special test case of Nth Brazilian #.*/

end /*while*/; return 1 /*it has all the same dig*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> , &nbsp; , &nbsp; , &nbsp; 100000 </tt>}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

txt = left(txt,len(txt)-1)

see txt + nl

Output:

<pre>

=={{header|Ruby}}==

{{trans|C++}}

f = n % b

while (n /= b) > 0 do

end

 

{{out}}

<pre>First 20 Brazilian numbers:

 

=={{header|Rust}}==

fn same_digits(x: u64, base: u64) -> bool {

let f = x % base;

println!("\nThe {}th Brazilian number: {}", big_limit, big_result);

}

{{out}}

<pre>

=={{header|Scala}}==

{{trans|Java}}

private val PRIME_LIST = List(

2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,

}

}

{{out}}

<pre>First 20 Brazilian numbers:

===functional===

use Scala 3

def oddPrimes =

val bigElement = LazyList.from(7).filter(isBrazilian(_)).drop(bigLimit - 1).take(1).head

println(s"brazilian($bigLimit): $bigElement")

{{out}}

<pre>brazilian: List(7, 8, 10, 12, 13, 14, 15, 16, 18, 20, 21, 22, 24, 26, 27, 28, 30, 31, 32, 33)

 

=={{header|Sidef}}==

 

static L = Set()

say "\nFirst #{n} prime Brazilian numbers"

say (^Inf -> lazy.grep(is_Brazilian).grep{.is_prime}.first(n))

{{out}}

<pre>

 

Extra:

say ("#{10**n->commify}th Brazilian number = ", is_Brazilian.nth(10**n))

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function sameDigits(ByVal n As Integer, ByVal b As Integer) As Boolean

End Sub

 

{{out}}

<pre>First 20 Brazilian numbers:

===Speedier Version===

Based on the C# speedier version, performance is just as good, one billion Brazilian numbers counted in 4 1/2 seconds (on a core i7).

 

Module Module1

 

End Module

{{out}}

<pre>Sieving took 2967.834 ms

=={{header|Vlang}}==

{{trans|Go}}

f := nn % b

mut n := nn/b

}

println("The 100,000th Brazilian number: ${n-1}")

 

{{out}}

{{trans|Go}}

{{libheader|Wren-math}}

 

var sameDigits = Fn.new { |n, b|

n = n + 1

}

 

{{out}}

 

=={{header|zkl}}==

foreach b in ([2..n-2]){

f,m := n%b, n/b;

False

}

[1..].tweak(isBrazilianW).walk(20).println();

 

println("\nFirst 20 odd Brazilian numbers:");

{{out}}

<pre>

 

[[Extensible prime generator#zkl]] could be used instead.

 

println("\nFirst 20 prime Brazilian numbers:");

p:=BI(1);

Walker.zero().tweak('wrap{ p.nextPrime().toInt() })

{{out}}

<pre>

L(7,13,31,43,73,127,157,211,241,307,421,463,601,757,1093,1123,1483,1723,2551,2801)

</pre>

{{out}}

<pre>