Data update

Task/Blum-integer/BASIC256/blum-integer.basic

@@ -0,0 +1,40 @@
+global Prime1
+n = 3
+c = 0
+
+print "The first 50 Blum integers:"
+while True
+	if isSemiprime(n) then
+		if Prime1 % 4 = 3 then
+			Prime2 = n / Prime1
+			if (Prime2 <> Prime1) and (Prime2 % 4 = 3) then
+				c += 1
+				if c <= 50 then
+					print rjust(string(n), 4);
+					if c % 10 = 0 then print
+				end if
+				if c >= 26828 then
+					print : print "The 26828th Blum integer is: "; n
+					exit while
+				end if
+			end if
+		end if
+	end if
+	n += 2
+end while
+end
+
+function isSemiprime(n)
+	d = 3
+	c = 0
+	while d*d <= n
+		while n % d = 0
+			if c = 2 then return false
+			n /= d
+			c += 1
+		end while
+		d += 2
+	end while
+	Prime1 = n
+	return c = 1
+end function

Task/Blum-integer/Gambas/blum-integer.gambas

@@ -0,0 +1,44 @@
+Public Prime1 As Integer
+
+Public Sub Main()
+
+  Dim n As Integer = 3, c As Integer = 0, Prime2 As Integer
+
+  Print "The first 50 Blum integers:"
+  Do
+    If isSemiprime(n) Then
+      If Prime1 Mod 4 = 3 Then
+        Prime2 = n / Prime1
+        If (Prime2 <> Prime1) And (Prime2 Mod 4 = 3) Then
+          c += 1
+          If c <= 50 Then
+            Print Format$(n, "####");
+            If c Mod 10 = 0 Then Print
+          End If
+          If c >= 26828 Then
+            Print "\nThe 26828th Blum integer is: "; n
+            Break
+          End If
+        End If
+      End If
+    End If
+    n += 2
+  Loop
+
+End
+
+Function isSemiprime(n As Integer) As Boolean
+
+  Dim d As Integer = 3, c As Integer = 0
+  While d * d <= n
+    While n Mod d = 0
+      If c = 2 Then Return False
+      n /= d
+      c += 1
+    Wend
+    d += 2
+  Wend
+  Prime1 = n
+  Return c = 1
+
+End Function

Task/Blum-integer/Haskell/blum-integer.hs

@@ -0,0 +1,114 @@
+{-# LANGUAGE BangPatterns        #-}
+{-# LANGUAGE DeriveFunctor       #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module Rosetta.BlumInteger
+    ( Stream (..)
+    , Stats (..)
+    , toList
+    , blumIntegers
+    , countLastDigits
+    ) where
+
+import           GHC.Natural              (Natural)
+import           Math.NumberTheory.Primes (Prime (..), nextPrime)
+
+-- | A stream is an infinite list.
+data Stream a = a :> Stream a
+    deriving Functor
+
+-- | Converts a stream to the corresponding infinite list.
+toList :: Stream a -> [a]
+toList (x :> xs) = x : toList xs
+
+unsafeFromList :: [a] -> Stream a
+unsafeFromList = foldr (:>) $ error "fromList: finite list"
+
+primes3mod4 :: Stream (Prime Natural)
+primes3mod4 = unsafeFromList [nextPrime 3, nextPrime 7 ..]
+
+-- Assume:
+--   * All numbers in all the streams are distinct.
+--   * Each stream is sorted.
+--   * In the stream of streams, the first element of each stream is less than the first element of the next stream.
+sortStreams :: forall a. Ord a => Stream (Stream a) -> Stream a
+sortStreams ((x :> xs) :> xss) = x :> sortStreams (insert xs xss)
+  where
+    insert :: Stream a -> Stream (Stream a) -> Stream (Stream a)
+    insert ys@(y :> _) zss@(zs@(z :> _) :> zss')
+        | y < z     = ys :> zss
+        | otherwise = zs :> insert ys zss'
+
+-- | The
+blumIntegers :: Stream Natural
+blumIntegers = sortStreams $ go $ unPrime <$> primes3mod4
+  where
+    go :: Stream Natural -> Stream (Stream Natural)
+    go (p :> ps) = ((p *) <$> ps) :> go ps
+
+data Stats a = Stats
+    { s1 :: !a
+    , s3 :: !a
+    , s7 :: !a
+    , s9 :: !a
+    } deriving (Show, Eq, Ord, Functor)
+
+lastDigit :: Natural -> Int
+lastDigit n = fromIntegral $ n `mod` 10
+
+updateCount :: Stats Int -> Natural -> Stats Int
+updateCount !dc n = case lastDigit n of
+    1 -> dc { s1 = s1 dc + 1 }
+    3 -> dc { s3 = s3 dc + 1 }
+    7 -> dc { s7 = s7 dc + 1 }
+    9 -> dc { s9 = s9 dc + 1 }
+    _ -> error "updateCount: impossible"
+
+countLastDigits :: forall a. Fractional a => Int -> Stream Natural -> Stats a
+countLastDigits n = fmap f . go Stats { s1 = 0, s3 = 0, s7 = 0, s9 = 0 } n
+  where
+    go :: Stats Int -> Int -> Stream Natural -> Stats Int
+    go !dc 0 _         = dc
+    go !dc m (x :> xs) = go (updateCount dc x) (m - 1) xs
+
+    f :: Int -> a
+    f m = fromIntegral m / fromIntegral n
+
+
+{-# LANGUAGE NumericUnderscores #-}
+{-# LANGUAGE TypeApplications   #-}
+
+module Main
+    ( main
+    ) where
+
+import           Control.Monad       (forM_)
+import           Text.Printf         (printf)
+
+import           Numeric.Natural     (Natural)
+
+import           Rosetta.BlumInteger
+
+main :: IO ()
+main = do
+    let xs = toList blumIntegers
+
+    printf "The first 50 Blum integers are:\n\n"
+    forM_ (take 50 xs) $ \x -> do
+        printf "%3d\n" x
+    printf "\n"
+
+    nth xs 26_828
+    forM_ [100_000, 200_000 .. 400_000] $ nth xs
+    printf "\n"
+
+    printf "Distribution by final digit for the first 400000 Blum integers:\n\n"
+    let Stats r1 r3 r7 r9 = countLastDigits @Double 400_000 blumIntegers
+    forM_ [(1 :: Int, r1), (3, r3), (7, r7), (9, r9)] $ \(d, r) ->
+        printf "%d: %6.3f%%\n" d $ r * 100
+    printf "\n"
+
+  where
+
+    nth :: [Natural] -> Int -> IO ()
+    nth xs n = printf "The %6dth Blum integer is %8d.\n" n $ xs !! (n - 1)

Task/Blum-integer/Perl/blum-integer.pl

@@ -1,43 +1,23 @@
 use v5.36;
-use enum <false true>;
-use ntheory <is_prime gcd>;
+use ntheory qw(is_square is_semiprime factor vecall);
 
-sub comma { reverse ((reverse shift) =~ s/.{3}\K/,/gr) =~ s/^,//r }
-sub table ($c, @V) { my $t = $c * (my $w = 5); ( sprintf( ('%'.$w.'d')x@V, @V) ) =~ s/.{1,$t}\K/\n/gr }
+sub comma          { reverse((reverse shift) =~ s/.{3}\K/,/gr)                      =~ s/^,//r }
+sub table ($c, @V) { my $t = $c * (my $w = 5); (sprintf(('%' . $w . 'd') x @V, @V)) =~ s/.{1,$t}\K/\n/gr }
 
 sub is_blum ($n) {
-    return false if $n < 2 or is_prime $n;
-    my $factor = find_factor($n);
-    my $div = int($n / $factor);
-    return true if is_prime($factor) && is_prime($div) && ($div != $factor) && ($factor%4 == 3) && ($div%4 == 3);
-    false;
+    ($n % 4) == 1 && is_semiprime($n) && !is_square($n) && vecall { ($_ % 4) == 3 } factor($n);
 }
 
-sub find_factor ($n, $constant = 1) {
-    my($x, $rho, $factor) = (2, 1, 1);
-    while ($factor == 1) {
-        $rho *= 2;
-        my $fixed = $x;
-        for (0..$rho) {
-            $x = ( $x * $x + $constant ) % $n;
-            $factor = gcd(($x-$fixed), $n);
-            last if 1 < $factor;
-        }
-    }
-    $factor = find_factor($n, $constant+1) if $n == $factor;
-    $factor;
-}
-
-my($i, @blum, %C);
 my @nth = (26828, 1e5, 2e5, 3e5, 4e5);
 
-while (++$i) {
+my (@blum, %C);
+for (my $i = 1 ; ; ++$i) {
     push @blum, $i if is_blum $i;
-    last if $nth[-1] == scalar @blum;
+    last if $nth[-1] == @blum;
 }
-$C{substr $_, -1, 1}++ for @blum;
+$C{$_ % 10}++ for @blum;
 
-say "The first fifty Blum integers:\n" . table 10, @blum[0..49];
-printf "The %7sth Blum integer: %9s\n", comma($_), comma $blum[$_-1] for @nth;
+say "The first fifty Blum integers:\n" . table 10, @blum[0 .. 49];
+printf "The %7sth Blum integer: %9s\n", comma($_), comma $blum[$_ - 1] for @nth;
 say '';
-printf "$_: %6d (%.3f%%)\n", $C{$_}, 100*$C{$_}/scalar @blum for <1 3 7 9>;
+printf "$_: %6d (%.3f%%)\n", $C{$_}, 100 * $C{$_} / scalar @blum for <1 3 7 9>;

Task/Blum-integer/Sidef/blum-integer.sidef

@@ -0,0 +1,47 @@
+func blum_integers(upto) {
+
+    var L = []
+    var P = idiv(upto, 3).primes.grep{ .is_congruent(3, 4) }
+
+    for i in (1..P.end) {
+        var p = P[i]
+        for j in (^i) {
+            var t = p*P[j]
+            break if (t > upto)
+            L << t
+        }
+    }
+
+    L.sort
+}
+
+func blum_first(n) {
+    var upto = int(4.5*n*log(n) / log(log(n)))
+    loop {
+        var B = blum_integers(upto)
+        if (B.len >= n) {
+            return B.first(n)
+        }
+        upto *= 2
+    }
+}
+
+with (50) {|n|
+    say "The first #{n} Blum integers:"
+    blum_first(n).slices(10).each { .map{ "%4s" % _ }.join.say }
+}
+
+say ''
+
+for n in (26828, 1e5, 2e5, 3e5, 4e5) {
+    var B = blum_first(n)
+    say "#{n.commify}th Blum integer: #{B.last}"
+
+    if (n == 4e5) {
+        say ''
+        for k in (1,3,7,9) {
+            var T = B.grep { .is_congruent(k, 10) }
+            say "#{k}: #{'%6s' % T.len} (#{T.len / B.len * 100}%)"
+        }
+    }
+}