Rosetta Code

Primes which contain only one odd digit: Difference between revisions

Page Discussion

Primes which contain only one odd digit (view source)

Revision as of 16:06, 28 January 2024

30,378 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added Algol 68)
m (→‎{{header|Wren}}: Minor tidy)
 
(42 intermediate revisions by 23 users not shown)
Line 2:
 
;Task
Show on this page those primes under   '''1,000'''   which when expressed in decimal containscontain only one odd digit.
 
 
;Stretch goal:
Show on this page only the &nbsp; <u>count</u> &nbsp; of those primes under &nbsp; '''1,000,000''' &nbsp; which when expressed in decimal containscontain only one odd digit.
<br><br>
 
=={{header|11l}}==
{{trans|Nim}}
<syntaxhighlight lang="11l">F is_prime(n)
I n == 2
R 1B
I n < 2 | n % 2 == 0
R 0B
L(i) (3 .. Int(sqrt(n))).step(2)
I n % i == 0
R 0B
R 1B
 
F hasLastDigitOdd(=n)
n I/= 10
L n != 0
I ((n % 10) [&] 1) != 0
R 0B
n I/= 10
R 1B
 
V l = (1.<1000).step(2).filter(n -> hasLastDigitOdd(n) & is_prime(n))
print(‘Found ’l.len‘ primes with only one odd digit below 1000:’)
L(n) l
print(‘#3’.format(n), end' I (L.index + 1) % 9 == 0 {"\n"} E ‘ ’)
 
V count = 0
L(n) (1.<1'000'000).step(2)
I hasLastDigitOdd(n) & is_prime(n)
count++
print("\nFound "count‘ primes with only one odd digit below 1000000.’)</syntaxhighlight>
 
{{out}}
<pre>
Found 45 primes with only one odd digit below 1000:
3 5 7 23 29 41 43 47 61
67 83 89 223 227 229 241 263 269
281 283 401 409 421 443 449 461 463
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
Found 2560 primes with only one odd digit below 1000000.
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Sieve of Eratosthenes}}
<syntaxhighlight lang="action!">INCLUDE "H6:SIEVE.ACT"
 
BYTE FUNC OddDigitsCount(INT x)
BYTE c,d
 
c=0
WHILE x#0
DO
d=x MOD 10
IF (d&1)=1 THEN
c==+1
FI
x==/10
OD
RETURN (c)
 
PROC Main()
DEFINE MAX="999"
BYTE ARRAY primes(MAX+1)
INT i,count=[0]
 
Put(125) PutE() ;clear the screen
Sieve(primes,MAX+1)
FOR i=2 TO MAX
DO
IF primes(i)=1 AND OddDigitsCount(i)=1 THEN
PrintI(i) Put(32)
count==+1
FI
OD
PrintF("%E%EThere are %I primes",count)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Primes_which_contain_only_one_odd_digit.png Screenshot from Atari 8-bit computer]
<pre>
3 5 7 23 29 41 43 47 61 67 83 89 223 227 229 241 263 269 281 283 401 409 421 443
449 461 463 467 487 601 607 641 643 647 661 683 809 821 823 827 829 863 881 883 887
 
There are 45 primes
</pre>
 
=={{header|ALGOL 68}}==
{{libheader|ALGOL 68-primes}}
<lang algol68>BEGIN # find primes whose decimal representation contains only one odd digit #
<syntaxhighlight lang="algol68">BEGIN # find primes whose decimal representation contains only one odd digit #
INT max prime = 1 000 000;
# sieve the primes to max1 prime000 000 #
PR read "primes.incl.a68" PR
[ 1 : max prime ]BOOL prime;
prime[]BOOL 1prime ] := FALSE;PRIMESIEVE prime[1 2 ] :=000 TRUE000;
FOR i FROM 3 BY 2 TO UPB prime DO prime[ i ] := TRUE OD;
FOR i FROM 4 BY 2 TO UPB prime DO prime[ i ] := FALSE OD;
FOR i FROM 3 BY 2 TO ENTIER sqrt( UPB prime ) DO
IF prime[ i ] THEN FOR s FROM i * i BY i + i TO UPB prime DO prime[ s ] := FALSE OD FI
OD;
# show a count of primes #
PROC show total = ( INT count, INT limit, STRING name )VOID:
Line 26 ⟶ 107:
# 2 is the only even prime, so the final digit must be odd for primes > 2 #
# so we only need to check that the digits other than the last are all even #
INT show max = 1 000;
INT p1odd count := 0;
FOR n FROM 3 TO UPB prime DO
Line 50 ⟶ 131:
OD;
show total( p1odd count, UPB prime, "single-odd-digit" )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 61 ⟶ 142:
 
Found 2560 single-odd-digit primes upto 1000000
</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">onlyOneOddDigit?: function [n][
and? -> prime? n
-> one? select digits n => odd?
]
 
primesWithOnlyOneOddDigit: select 1..1000 => onlyOneOddDigit?
 
loop split.every: 9 primesWithOnlyOneOddDigit 'x ->
print map x 's -> pad to :string s 4
 
nofPrimesBelow1M: enumerate 1..1000000 => onlyOneOddDigit?
 
print ""
print ["Found" nofPrimesBelow1M "primes with only one odd digit below 1000000."]</syntaxhighlight>
 
{{out}}
 
<pre> 3 5 7 23 29 41 43 47 61
67 83 89 223 227 229 241 263 269
281 283 401 409 421 443 449 461 463
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
Found 2560 primes with only one odd digit below 1000000.</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f PRIMES_WHICH_CONTAIN_ONLY_ONE_ODD_NUMBER.AWK
BEGIN {
start = 1
stop = 999
for (i=start; i<=stop; i++) {
if (is_prime(i)) {
if (gsub(/[13579]/,"&",i) == 1) {
rec_odd = sprintf("%s%5d%1s",rec_odd,i,++count_odd%10?"":"\n")
}
if (gsub(/[02468]/,"&",i) == 1) {
rec_even = sprintf("%s%5d%1s",rec_even,i,++count_even%10?"":"\n")
}
}
}
printf("%s\nPrimes which contain only one odd number %d-%d: %d\n\n",rec_odd,start,stop,count_odd)
printf("%s\nPrimes which contain only one even number %d-%d: %d\n\n",rec_even,start,stop,count_even)
exit(0)
}
function is_prime(x, i) {
if (x <= 1) {
return(0)
}
for (i=2; i<=int(sqrt(x)); i++) {
if (x % i == 0) {
return(0)
}
}
return(1)
}
</syntaxhighlight>
{{out}}
<pre>
3 5 7 23 29 41 43 47 61 67
83 89 223 227 229 241 263 269 281 283
401 409 421 443 449 461 463 467 487 601
607 641 643 647 661 683 809 821 823 827
829 863 881 883 887
Primes which contain only one odd number 1-999: 45
 
2 23 29 41 43 47 61 67 83 89
101 103 107 109 127 149 163 167 181 211
233 239 251 257 271 277 293 307 347 349
367 383 389 419 431 433 439 457 479 491
499 503 509 521 523 541 547 563 569 587
613 617 619 631 653 659 673 677 691 701
709 727 743 761 769 787 811 839 853 857
859 877 907 929 941 947 967 983
Primes which contain only one even number 1-999: 78
</pre>
 
=={{header|C#|CSharp}}==
Modifies a conventional prime sieve to cull the items with more than one odd digit.
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
 
class Program
{
// starts as an ordinary odds-only prime sieve, but becomes
// extraordinary after the else statement...
static List<uint> sieve(uint max, bool ordinary = false)
{
uint k = ((max - 3) >> 1) + 1,
lmt = ((uint)(Math.Sqrt(max++) - 3) >> 1) + 1;
var pl = new List<uint> { };
var ic = new bool[k];
for (uint i = 0, p = 3; i < lmt; i++, p += 2) if (!ic[i])
for (uint j = (p * p - 3) >> 1; j < k; j += p) ic[j] = true;
if (ordinary)
{
pl.Add(2);
for (uint i = 0, j = 3; i < k; i++, j += 2)
if (!ic[i]) pl.Add(j);
}
else
for (uint i = 0, j = 3, t = j; i < k; i++, t = j += 2)
if (!ic[i])
{
while ((t /= 10) > 0)
if (((t % 10) & 1) == 1) goto skip;
pl.Add(j);
skip:;
}
return pl;
}
 
static void Main(string[] args)
{
var pl = sieve((uint)1e9);
uint c = 0, l = 10, p = 1;
Console.WriteLine("List of one-odd-digit primes < 1,000:");
for (int i = 0; pl[i] < 1000; i++)
Console.Write("{0,3}{1}", pl[i], i % 9 == 8 ? "\n" : " ");
string fmt = "\nFound {0:n0} one-odd-digit primes < 10^{1} ({2:n0})";
foreach (var itm in pl)
if (itm < l) c++;
else Console.Write(fmt, c++, p++, l, l *= 10);
Console.Write(fmt, c++, p++, l);
}
}
</syntaxhighlight>
{{out}}
<pre>List of one-odd-digit primes < 1,000:
3 5 7 23 29 41 43 47 61
67 83 89 223 227 229 241 263 269
281 283 401 409 421 443 449 461 463
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
Found 3 one-odd-digit primes < 10^1 (10)
Found 12 one-odd-digit primes < 10^2 (100)
Found 45 one-odd-digit primes < 10^3 (1,000)
Found 171 one-odd-digit primes < 10^4 (10,000)
Found 619 one-odd-digit primes < 10^5 (100,000)
Found 2,560 one-odd-digit primes < 10^6 (1,000,000)
Found 10,774 one-odd-digit primes < 10^7 (10,000,000)
Found 46,708 one-odd-digit primes < 10^8 (100,000,000)
Found 202,635 one-odd-digit primes < 10^9 (1,000,000,000)</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
 
 
 
procedure GetDigits(N: integer; var IA: TIntegerDynArray);
{Get an array of the integers in a number}
var T: integer;
begin
SetLength(IA,0);
repeat
begin
T:=N mod 10;
N:=N div 10;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=T;
end
until N<1;
end;
 
 
 
procedure ShowOneOddDigitPrime(Memo: TMemo);
var I,Cnt1,Cnt2: integer;
var IA: TIntegerDynArray;
var S: string;
 
function HasOneOddDigit(N: integer): boolean;
var I,Odd: integer;
begin
Odd:=0;
GetDigits(N,IA);
for I:=0 to High(IA) do
if (IA[I] and 1)=1 then Inc(Odd);
Result:=Odd=1;
end;
 
begin
Cnt1:=0; Cnt2:=0;
S:='';
for I:=0 to 1000000-1 do
if IsPrime(I) then
if HasOneOddDigit(I) then
begin
Inc(Cnt1);
if I<1000 then
begin
Inc(Cnt2);
S:=S+Format('%4D',[I]);
If (Cnt2 mod 5)=0 then S:=S+CRLF;
end;
end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count < 1,000 = '+IntToStr(Cnt2));
Memo.Lines.Add('Count < 1,000,000 = '+IntToStr(Cnt1));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
3 5 7 23 29
41 43 47 61 67
83 89 223 227 229
241 263 269 281 283
401 409 421 443 449
461 463 467 487 601
607 641 643 647 661
683 809 821 823 827
829 863 881 883 887
 
Count < 1,000 = 45
Count < 1,000,000 = 2560
Elapsed Time: 171.630 ms.
</pre>
 
=={{header|F_Sharp|F#}}==
This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]
<lang fsharp>
<syntaxhighlight lang="fsharp">
// Primes which contain only one odd number. Nigel Galloway: July 28th., 2021
let rec fN g=function 2->false |n when g=0->n=1 |n->fN (g/10) (n+g%2)
primes32()|>Seq.takeWhile((>)1000)|>Seq.filter(fun g->fN g 0)|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
3 5 7 23 29 41 43 47 61 67 83 89 223 227 229 241 263 269 281 283 401 409 421 443 449 461 463 467 487 601 607 641 643 647 661 683 809 821 823 827 829 863 881 883 887
</pre>
 
=={{header|Factor}}==
{{libheader|Factor-numspec}}
{{works with|Factor|0.99 2021-06-02}}
<syntaxhighlight lang="factor">USING: grouping io lists lists.lazy literals math math.primes
numspec prettyprint ;
 
<<
DIGIT: o 357
DIGIT: q 1379
DIGIT: e 2468
DIGIT: E 02468
 
NUMSPEC: one-odd-candidates o eq eEq ... ;
>>
 
CONSTANT: p $[ one-odd-candidates [ prime? ] lfilter ]
 
"Primes with one odd digit under 1,000:" print
p [ 1000 < ] lwhile list>array 9 group simple-table.
 
"\nCount of such primes under 1,000,000:" print
p [ 1,000,000 < ] lwhile llength .
 
"\nCount of such primes under 1,000,000,000:" print
p [ 1,000,000,000 < ] lwhile llength .</syntaxhighlight>
{{out}}
<pre>
Primes with one odd digit under 1,000:
3 5 7 23 29 41 43 47 61
67 83 89 223 227 229 241 263 269
281 283 401 409 421 443 449 461 463
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
Count of such primes under 1,000,000:
2560
 
Count of such primes under 1,000,000,000:
202635
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
#include "isprime.bas"
 
function b(j as uinteger, n as uinteger) as uinteger
'auxiliary function for evendig below
dim as uinteger m = int(log(n-1)/log(5))
return int((n-1-5^m)/5^j)
end function
 
function evendig(n as uinteger) as uinteger
'produces the integers with only even digits
dim as uinteger m = int(log(n-1)/log(5)), a
a = ((2*b(m, n)) mod 8 + 2)*10^m
if n<=1 or m=0 then return a
for j as uinteger = 0 to m-1
a += ((2*b(j, n)) mod 10)*10^j
next j
return a
end function
 
dim as uinteger n=1, count = 0, p=1
while p<1000000
p = 1 + evendig(n) 'if it's a prime the odd digit must be the last one
if isprime(p) then
count += 1
if p<1000 then print p
end if
n+=1
wend
 
print "There are ";count;" such primes below one million."</syntaxhighlight>
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 100 ⟶ 501:
const (
LIMIT = 999
LIMIT2 = 9999999999999999
MAX_DIGITS = 3
)
Line 117 ⟶ 518:
}
}
fmt.Println("\nFound", len(results), "such primes.\n")
 
primes = rcu.Primes(LIMIT2)
count := 0
pow := 10
for _, prime := range primes[1:] {
if allButOneEven(prime) {
count = count + 1+
}
if prime > pow {
fmt.Printf("There are %7s such primes under %s\n", rcu.Commatize(count), rcu.Commatize(pow))
pow *= 10
}
}
csfmt.Printf("There :=are %7s such primes under %s\n", rcu.Commatize(count), rcu.Commatize(pow))
}</syntaxhighlight>
ls := rcu.Commatize(LIMIT2 + 1)
fmt.Println("\nThere are", cs, "primes under", ls, "which contain only one odd digit.")
}</lang>
 
{{out}}
Line 142 ⟶ 546:
Found 45 such primes.
 
There are 2,560 primes under 1,000,000 which contain only3 onesuch oddprimes under digit.10
There are 12 such primes under 100
There are 45 such primes under 1,000
There are 171 such primes under 10,000
There are 619 such primes under 100,000
There are 2,560 such primes under 1,000,000
There are 10,774 such primes under 10,000,000
There are 46,708 such primes under 100,000,000
There are 202,635 such primes under 1,000,000,000
There are 904,603 such primes under 10,000,000,000
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.List (intercalate, maximum, transpose)
import Data.List.Split (chunksOf)
import Data.Numbers.Primes (primes)
import Text.Printf (printf)
 
 
------------------ ONE ODD DECIMAL DIGIT -----------------
 
oneOddDecimalDigit :: Int -> Bool
oneOddDecimalDigit =
(1 ==) . length . filter odd . digits
 
digits :: Int -> [Int]
digits = fmap (read . return) . show
 
 
--------------------------- TEST -------------------------
main :: IO ()
main = do
putStrLn "Below 1000:"
(putStrLn . table " " . chunksOf 10 . fmap show) $
sampleBelow 1000
 
putStrLn "Count of matches below 10E6:"
(print . length) $
sampleBelow 1000000
 
sampleBelow :: Int -> [Int]
sampleBelow =
filter oneOddDecimalDigit
. flip takeWhile primes
. (>)
 
------------------------- DISPLAY ------------------------
 
table :: String -> [[String]] -> String
table gap rows =
let ws = maximum . fmap length <$> transpose rows
pw = printf . flip intercalate ["%", "s"] . show
in unlines $ intercalate gap . zipWith pw ws <$> rows</syntaxhighlight>
{{out}}
<pre>Below 1000:
3 5 7 23 29 41 43 47 61 67
83 89 223 227 229 241 263 269 281 283
401 409 421 443 449 461 463 467 487 601
607 641 643 647 661 683 809 821 823 827
829 863 881 883 887
 
Count of matches below 10E6:
2560</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> getOneOdds=. #~ 1 = (2 +/@:| "."0@":)"0
primesTo=. i.&.(p:inv)
 
_15 ]\ getOneOdds primesTo 1000
3 5 7 23 29 41 43 47 61 67 83 89 223 227 229
241 263 269 281 283 401 409 421 443 449 461 463 467 487 601
607 641 643 647 661 683 809 821 823 827 829 863 881 883 887
 
# getOneOdds primesTo 1e6
2560</syntaxhighlight>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
As noted in the [[#Julia|Julia entry]], if only one digit of a prime is odd, then that digit is in the ones place. The first solution presented here uses this observation to generate plausible candidates. The second solution is more brutish and slower but simpler.
 
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
 
===Fast solution===
<syntaxhighlight lang="jq">### Preliminaries
 
def count(s): reduce s as $x (null; .+1);
 
def emit_until(cond; stream):
label $out | stream | if cond then break $out else . end;
 
# Output: an unbounded stream
def primes_with_exactly_one_odd_digit:
# Output: a stream of candidate strings, in ascending numerical order
def candidates:
# input is $width
def evens:
. as $width
| if $width == 0 then ""
else ("0","2","4","6","8") as $i
| ((.-1)|evens) as $j
| "\($i)\($j)"
end;
("2","4","6","8") as $leading
| evens as $even
| ("1","3","5","7","9") as $odd
| "\($leading)\($even)\($odd)";
 
(3,5,7),
(range(0; infinite)
| candidates | tonumber
| select(is_prime)) ;
 
### The Task
emit_until(. > 1000; primes_with_exactly_one_odd_digit),
 
"\nThe number of primes less than 1000000 with exactly one odd digits is \(count(emit_until(. > 1000000; primes_with_exactly_one_odd_digit)))."</syntaxhighlight>
{{out}}
<pre>
3
5
7
23
29
41
43
47
61
67
83
89
223
227
229
241
263
269
281
283
401
409
421
443
449
461
463
467
487
601
607
641
643
647
661
683
809
821
823
827
829
863
881
883
887
 
The number of primes less than 1000000 with exactly one odd digits is 2560.
</pre>
===A simpler but slower solution===
<syntaxhighlight lang="jq"># Input is assumed to be prime.
# So we only need check the other digits are all even.
def prime_has_exactly_one_odd_digit:
if . == 2 then false
# The codepoints for the odd digits are also odd: [49,51,53,55,57]
else all(tostring | explode[:-1][]; . % 2 == 0)
end;
 
def primes_with_exactly_one_odd_digit_crudely:
# It is much faster to check for primality afterwards.
range(3; infinite; 2)
| select(prime_has_exactly_one_odd_digit and is_prime);</syntaxhighlight>
 
=={{header|Julia}}==
If only one digit of a prime is odd, then that odd digit is the ones place digit. We don't actually need to check for an odd first digit once we exclude 2.
<langsyntaxhighlight lang="julia">using Primes
 
function isoneoddprime(n, base = 10)
Line 157 ⟶ 740:
println("Found $(length(found)) primes with one odd digit in base 10:")
foreach(p -> print(rpad(last(p), 5), first(p) % 9 == 0 ? "\n" : ""), enumerate(found))
 
</lang>{{out}}
println("\nThere are ", count(isoneoddprime, primes(1_000_000)),
" primes with only one odd digit in base 10 between 1 and 1,000,000.")
</syntaxhighlight>{{out}}
<pre>
Found 45 primes with one odd digit in base 10:
Line 165 ⟶ 751:
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
There are 2560 primes with only one odd digit in base 10 between 1 and 1,000,000.
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Labeled[Cases[
NestWhileList[NextPrime,
2, # <
1000 &], _?(Total[Mod[IntegerDigits@#, 2]] ==
1 &)], "Primes < 1000 with one odd digit", Top]
Labeled[Length@
Cases[NestWhileList[NextPrime,
2, # <
1000000 &], _?(Total[Mod[IntegerDigits@#, 2]] ==
1 &)], "Number of primes < 1,000,000 with one odd digit", Top]</syntaxhighlight>
 
{{out}}<pre>
Primes < 1000 with one odd digit
{3,5,7,23,29,41,43,47,61,67,83,89,223,227,229,241,263,269,281,283,401,409,421,443,449,461,463,467,487,601,607,641,643,647,661,683,809,821,823,827,829,863,881,883,887}
 
Number of primes < 1,000,000 with one odd digit
2560
</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import sequtils, strutils
 
func isPrime(n: Positive): bool =
Line 205 ⟶ 813:
 
var count = 0
for _ in primesOneOdd(100_000_0001_000_000):
inc count
echo "\nFound $# primes with only one odd digit below 1_000_000.".format(count)</langsyntaxhighlight>
 
{{out}}
Line 218 ⟶ 826:
 
Found 2560 primes with only one odd digit below 1_000_000.</pre>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict;
use warnings;
use ntheory qw( primes );
 
my @singleodd = grep tr/13579// == 1, @{ primes(1e3) };
my $million = grep tr/13579// == 1, @{ primes(1e6) };
print "found " . @singleodd .
"\n\n@singleodd\n\nfound $million in 1000000\n" =~ s/.{60}\K /\n/gr;</syntaxhighlight>
{{out}}
<pre>
found 45
 
3 5 7 23 29 41 43 47 61 67 83 89 223 227 229 241 263 269 281
283 401 409 421 443 449 461 463 467 487 601 607 641 643 647 661
683 809 821 823 827 829 863 881 883 887
 
found 2560 in 1000000
</pre>
 
=={{header|Phix}}==
Relies on the fact that '0', '1', '2', etc are just as odd/even as 0, 1, 2, etc.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">oneodddigit</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: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">odd</span><span style="color: #0000FF;">))=</span><span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1_000</span><span style="color: #0000FF;">),</span><span style="color: #000000;">oneodddigit</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;">"Found %d one odd digit primes &lt; 1,000: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Found 45 one odd digit primes < 1,000: {3,5,7,23,29,"...",829,863,881,883,887}
</pre>
=== stretch ===
Fast skip from 11 direct to 20+, from 101 direct to 200+, etc. Around forty times faster than the above would be, but less than twice as fast as it would be without such skipping.<br>
Of course the last digit must/will be odd for all primes (other than 2 which has no odd digit anyway), and ''all'' digits prior to that must be even, eg 223 or 241, and not 257 or 743.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">?</span><span style="color: #000000;">8</span><span style="color: #0000FF;">:</span><span style="color: #000000;">9</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">m10</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">primes</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m10</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;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">primes</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">skip</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span>
<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">/</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">odd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)*</span><span style="color: #000000;">skip</span>
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">binary_search</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">primes</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">p</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">skip</span> <span style="color: #0000FF;">*=</span><span style="color: #000000;">10</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"Found %,d one odd digit primes &lt; %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m10</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Found 3 one odd digit primes < 10
Found 12 one odd digit primes < 100
Found 45 one odd digit primes < 1,000
Found 171 one odd digit primes < 10,000
Found 619 one odd digit primes < 100,000
Found 2,560 one odd digit primes < 1,000,000
Found 10,774 one odd digit primes < 10,000,000
Found 46,708 one odd digit primes < 100,000,000
Found 202,635 one odd digit primes < 1,000,000,000
</pre>
 
=={{header|Quackery}}==
<code>isprime</code> is defined at [[Primality by trial division#Quackery]].
 
<code>evendigits</code> returns the nth number which has only even digits and ends with zero. There are self-evidently 5^5 of them less than 1000000.
 
We know that the only prime ending with a 5 is 5. So we can omit generating candidate numbers that end with a 5, and stuff the 5 into the right place in the nest (i.e. as item #1; item #0 will be 3) afterwards. This explains the lines <code>' [ 1 3 7 9 ] witheach</code> and <code>5 swap 1 stuff</code>.
 
<syntaxhighlight lang="Quackery"> [ [] swap
[ 5 /mod
rot join swap
dup 0 = until ]
drop
0 swap witheach
[ swap 10 * + ]
20 * ] is evendigits ( n --> n )
 
[]
5 5 ** times
[ i^ evendigits
' [ 1 3 7 9 ] witheach
[ over +
dup isprime iff
[ swap dip join ]
else drop ]
drop ]
5 swap 1 stuff
dup say "Qualifying primes < 1000:"
dup findwith [ 999 > ] [ ]
split drop unbuild
1 split nip -1 split drop
nest$ 44 wrap$ cr cr
say "Number of qualifying primes < 1000000: "
size echo</syntaxhighlight>
 
{{out}}
 
<pre>Qualifying primes < 1000:
3 5 7 23 29 41 43 47 61 67 83 89 223 227 229
241 263 269 281 283 401 409 421 443 449 461
463 467 487 601 607 641 643 647 661 683 809
821 823 827 829 863 881 883 887
 
Number of qualifying primes < 1000000: 2560
</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>put display ^1000 .grep: { ($_ % 2) && .is-prime && (.comb[^(*-1)].all %% 2) }
 
sub display ($list, :$cols = 10, :$fmt = '%6d', :$title = "{+$list} matching:\n" ) {
cache $list;
$title ~ $list.batch($cols)».fmt($fmt).join: "\n"
}</langsyntaxhighlight>
{{out}}
<pre>45 matching:
Line 235 ⟶ 964:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds & displays primes (base ten) that contain only one odd digit (< 1,000).*/
parse arg hi cols . /*obtain optional argument from the CL.*/
if hi=='' | hi=="," then hi= 1000 /*Not specified? Then use the default.*/
Line 279 ⟶ 1,008:
end /*k*/ /* [↑] only process numbers ≤ √ J */
#= #+1; @.#= j; sq.#= j*j /*bump # of Ps; assign next P; P square*/
end /*j*/; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 300 ⟶ 1,029:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 309 ⟶ 1,038:
odd = 0
str = string(n)
for m = 1 to len(str)
if number(str[m])%2 = 1
odd++
Line 325 ⟶ 1,054:
see "Found " + row + " prime numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 341 ⟶ 1,070:
Found 45 prime numbers
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49g}}
≪
→STR 0
1 3 PICK SIZE '''FOR''' j
OVER j DUP SUB NUM 2 MOD + '''NEXT'''
NIP
≫ ≫ '<span style="color:blue>ODDCNT</span>' STO
≪
{ } 1
'''DO'''
NEXTPRIME
'''IF''' DUP <span style="color:blue>ODDCNT</span> 1 == '''THEN''' SWAP OVER + SWAP '''END'''
'''UNTIL''' DUP 1000 ≥ '''END'''
DROP
≫ ≫ '<span style="color:blue>TASK</span>' STO
{{out}}
<pre>
1: {3 5 7 23 29 41 43 47 61 67 83 89 223 227 229 241 263 269 281 283 401 409 421 443 449 461 463 467 487 601 607 641 643 647 661 683 809 821 823 827 829 863 881 883 887}
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">require 'prime'
 
def single_odd?(pr)
d = pr.digits
d.first.odd? && d[1..].all?(&:even?)
end
 
res = Prime.each(1000).select {|pr| single_odd?(pr)}
res.each_slice(10){|s| puts "%4d"*s.size % s}
 
n = 1_000_000
count = Prime.each(n).count{|pr| single_odd?(pr)}
puts "\nFound #{count} single-odd-digit primes upto #{n}."
</syntaxhighlight>
{{out}}
<pre> 3 5 7 23 29 41 43 47 61 67
83 89 223 227 229 241 263 269 281 283
401 409 421 443 449 461 463 467 487 601
607 641 643 647 661 683 809 821 823 827
829 863 881 883 887
 
Found 2560 single-odd-digit primes upto 1000000.
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func primes_with_one_odd_digit(upto, base = 10) {
 
upto = prev_prime(upto+1)
 
var list = []
var digits = @(^base)
 
var even_digits = digits.grep { .is_even }
var odd_digits = digits.grep { .is_odd && .is_coprime(base) }
 
list << digits.grep { .is_odd && .is_prime && !.is_coprime(base) }...
 
for k in (0 .. upto.ilog(base)) {
even_digits.variations_with_repetition(k, {|*a|
next if (a.last == 0)
var v = a.digits2num(base)
odd_digits.each {|d|
var n = (v*base + d)
list << n if (n.is_prime && (n <= upto))
}
})
}
 
list.sort
}
 
with (1e3) {|n|
var list = primes_with_one_odd_digit(n)
say "There are #{list.len} primes under #{n.commify} which contain only one odd digit:"
list.each_slice(9, {|*a| say a.map { '%3s' % _ }.join(' ') })
}
 
say ''
 
for k in (1..8) {
var count = primes_with_one_odd_digit(10**k).len
say "There are #{'%6s' % count.commify} such primes <= 10^#{k}"
}</syntaxhighlight>
{{out}}
<pre>
There are 45 primes under 1,000 which contain only one odd digit:
3 5 7 23 29 41 43 47 61
67 83 89 223 227 229 241 263 269
281 283 401 409 421 443 449 461 463
467 487 601 607 641 643 647 661 683
809 821 823 827 829 863 881 883 887
 
There are 3 such primes <= 10^1
There are 12 such primes <= 10^2
There are 45 such primes <= 10^3
There are 171 such primes <= 10^4
There are 619 such primes <= 10^5
There are 2,560 such primes <= 10^6
There are 10,774 such primes <= 10^7
There are 46,708 such primes <= 10^8
</pre>
 
Line 346 ⟶ 1,180:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./math" for Int
{{libheader|Wren-seq}}
<lang ecmascript>import "./mathfmt" for IntFmt
import "/fmt" for Fmt
import "/seq" for Lst
 
var limit = 999
Line 359 ⟶ 1,191:
}
Fmt.print("Primes under $,d which contain only one odd digit:", limit + 1)
for (chunk in Lst.chunks(results, 9)) Fmt.printtprint("$,%(maxDigits)d", chunkresults, 9)
System.print("\nFound %(results.count) such primes.\n")
 
limit = 9999991e9 - 1
primes = Int.primeSieve(limit)
var count = 0
var pow = 10
for (prime in primes.skip(1)) {
if (Int.digits(prime)[0...-1].all { |d| d & 1 == 0 }) count = count + 1
if (prime > pow) {
Fmt.print("There are $,7d such primes under $,d", count, pow)
pow = pow * 10
}
}
Fmt.print("\nThereThere are $,d7d such primes under $,d which contain only one odd digit.", count, limit + 1pow)</langsyntaxhighlight>
 
{{out}}
Line 381 ⟶ 1,218:
Found 45 such primes.
 
There are 2,560 primes under 1,000,000 which contain only3 onesuch oddprimes under digit.10
There are 12 such primes under 100
There are 45 such primes under 1,000
There are 171 such primes under 10,000
There are 619 such primes under 100,000
There are 2,560 such primes under 1,000,000
There are 10,774 such primes under 10,000,000
There are 46,708 such primes under 100,000,000
There are 202,635 such primes under 1,000,000,000
</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func IsPrime(N); \Return 'true' if N is a prime number
int N, I;
[if N <= 1 then return false;
Line 409 ⟶ 1,254:
Text(0, " such numbers found.
");
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/314209...354939"