Rosetta Code

Numbers with prime digits whose sum is 13: Difference between revisions

Page Discussion

Numbers with prime digits whose sum is 13 (view source)

Revision as of 00:07, 28 August 2022

1,222 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(→‎{{header|jq}}: add analytic solution)
m (syntax highlighting fixup automation)
Line 6:
{{trans|C}}
 
<langsyntaxhighlight lang="11l">F primeDigitsSum13(=n)
V sum = 0
L n > 0
Line 23:
c = 0
print()
print()</langsyntaxhighlight>
 
{{out}}
Line 34:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">DEFINE PRIMECOUNT="4"
BYTE ARRAY primedigits(PRIMECOUNT)=[2 3 5 7]
 
Line 103:
FI
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Numbers_with_prime_digits_whose_sum_is_13.png Screenshot from Atari 8-bit computer]
Line 114:
=={{header|ALGOL 68}}==
Based on the Algol W sample.
<langsyntaxhighlight lang="algol68">BEGIN
# find numbers whose digits are prime and whose digit sum is 13 #
# as noted by the Wren sample, the digits can only be 2, 3, 5, 7 #
Line 156:
OD # d2 #
OD # d1 #
END</langsyntaxhighlight>
{{out}}
<pre>
Line 167:
=={{header|ALGOL W}}==
Uses the observations about the digits and numbers in the Wren solution to generate the sequence.
<langsyntaxhighlight lang="algolw">begin
% find numbers whose digits are prime and whose digit sum is 13 %
% as noted by the Wren sample, the digits can only be 2, 3, 5, 7 %
Line 201:
end for_d2
end for_d1
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 212:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">pDigits: [2 3 5 7]
lst: map pDigits 'd -> @[d]
Line 234:
 
loop split.every: 10 result 'a ->
print map a => [pad to :string & 6]</langsyntaxhighlight>
 
{{out}}
Line 245:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f NUMBERS_WITH_PRIME_DIGITS_WHOSE_SUM_IS_13.AWK
BEGIN {
Line 276:
return(sum == 13)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 288:
=={{header|C}}==
Brute force
<langsyntaxhighlight lang="c">#include <stdbool.h>
#include <stdio.h>
 
Line 327:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 337:
{{Trans|Phix}}
Same recursive method.
<langsyntaxhighlight lang="csharp">using System;
using static System.Console;
using LI = System.Collections.Generic.SortedSet<int>;
Line 351:
static void Main(string[] args) { WriteLine(string.Join(" ",
unl(new LI {}, new LI { 2, 3, 5, 7 }, 13))); }
}</langsyntaxhighlight>
{{out}}
<pre style="white-space:pre-wrap;">337 355 373 535 553 733 2227 2272 2335 2353 2533 2722 3235 3253 3325 3352 3523 3532 5233 5323 5332 7222 22225 22252 22333 22522 23233 23323 23332 25222 32233 32323 32332 33223 33232 33322 52222 222223 222232 222322 223222 232222 322222
Line 357:
=== Alternate ===
Based in '''Nigel Galloway's''' suggestion from the discussion page.
<langsyntaxhighlight lang="csharp">class Program {
 
static void Main(string[] args) { int[] lst; int sum;
Line 367:
else if (sum < 12)
w.Add((i.digs * 10 + j, sum)); } }
}</langsyntaxhighlight>
Same output.
 
=={{header|C++}}==
{{trans|C#}}(the alternate version)
<langsyntaxhighlight lang="cpp">#include <cstdio>
#include <vector>
#include <bits/stdc++.h>
Line 385:
printf("%d%d ", get<0>(i), x);
else if (sum < 12) w.push_back({get<0>(i) * 10 + x, sum}); }
return 0; }</langsyntaxhighlight>
Same output as C#.
 
=={{header|D}}==
{{trans|C}}
<langsyntaxhighlight lang="d">import std.stdio;
 
bool primeDigitsSum13(int n) {
Line 421:
}
writeln;
}</langsyntaxhighlight>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 429:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// prime digits whose sum is 13. Nigel Galloway: October 21st., 2020
let rec fN g=let g=[for n in [2;3;5;7] do for g in g->n::g]|>List.groupBy(fun n->match List.sum n with 13->'n' |n when n<12->'g' |_->'x')|>Map.ofSeq
[yield! (if g.ContainsKey 'n' then g.['n'] else []); yield! (if g.ContainsKey 'g' then fN g.['g'] else [])]
fN [[]] |> Seq.iter(fun n->n|>List.iter(printf "%d");printf " ");printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 443:
===Filtering selections===
Generate all selections of the prime digits in the only possible lengths whose sum can be 13, then filter for sums that equal 13.
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.combinatorics
math.functions math.ranges sequences sequences.extras ;
 
Line 450:
"Numbers whose digits are prime and sum to 13:" print
{ 2 3 5 7 } 3 6 [a,b] [ selections [ sum 13 = ] filter ] with
map-concat [ digits>number ] map "%[%d, %]\n" printf</langsyntaxhighlight>
{{out}}
<pre>
Line 458:
===F# translation===
The following is based on Nigel Galloway's algorithm as described [http://rosettacode.org/wiki/Talk:Numbers_with_prime_digits_whose_sum_is_13#Nice_recursive_solution here] on the talk page. It's about 10x faster than the previous method.
<langsyntaxhighlight lang="factor">USING: io kernel math prettyprint sequences sequences.extras ;
 
{ } { { 2 } { 3 } { 5 } { 7 } } [
{ 2 3 5 7 } [ suffix ] cartesian-map concat
[ sum 13 = ] partition [ append ] dip [ sum 11 > ] reject
] until-empty [ bl ] [ [ pprint ] each ] interleave nl</langsyntaxhighlight>
{{out}}
<pre>
Line 472:
Ho hum. Another prime digits task.
 
<langsyntaxhighlight lang="freebasic">
function digit_is_prime( n as integer ) as boolean
select case n
Line 502:
for i as uinteger = 1 to 322222
if all_digits_prime(i) andalso digit_sum_13(i) then print i,
next i</langsyntaxhighlight>
{{out}}
<pre>
Line 517:
=={{header|Go}}==
Reuses code from some other tasks.
<langsyntaxhighlight lang="go">package main
 
import (
Line 590:
fmt.Println("Those numbers whose digits are all prime and sum to 13 are:")
fmt.Println(res2)
}</langsyntaxhighlight>
 
{{out}}
Line 599:
===only counting===
See Julia [http://rosettacode.org/wiki/Numbers_with_prime_digits_whose_sum_is_13#Julia]
<syntaxhighlight lang="go">
<lang go>
package main
 
Line 688:
fmt.Println("The count of numbers whose digits are all prime and sum to",mySum,"is",gblCount)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 725:
=={{header|Haskell}}==
As an unfold, in the recursive pattern described by Nigel Galloway on the Talk page.
<langsyntaxhighlight lang="haskell">import Data.List.Split (chunksOf)
import Data.List (intercalate, transpose, unfoldr)
import Text.Printf
Line 774:
 
unDigits :: [Int] -> Int
unDigits = foldl ((+) . (10 *)) 0</langsyntaxhighlight>
{{Out}}
<pre>43 numbers with prime digits summing to 13:
Line 786:
=={{header|Java}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="java">public class PrimeDigits {
private static boolean primeDigitsSum13(int n) {
int sum = 0;
Line 814:
System.out.println();
}
}</langsyntaxhighlight>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 823:
=={{header|JavaScript}}==
As an unfold, in the recursive pattern described by Nigel Galloway on the Talk page.
<langsyntaxhighlight lang="javascript">(() => {
'use strict';
 
Line 1,003:
 
return main();
})();</langsyntaxhighlight>
{{Out}}
<pre>337,355,373,535,553,733
Line 1,027:
 
====Simple Generate-and-Test Solution====
<langsyntaxhighlight lang="jq"># Output: a stream
def simple:
range(2; 7) as $n
Line 1,035:
| join("") | tonumber;
 
count(simple)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,041:
</pre>
====A Faster Solution====
<langsyntaxhighlight lang="jq">def faster:
def digits: [2, 3, 5, 7];
def wide($max):
Line 1,056:
 
count(faster)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,064:
As indicated above, this third solution is analytical (combinatoric),
and requires gojq for accuracy for relatively large target sums.
<langsyntaxhighlight lang="jq"># Input should be a sorted array of distinct positive integers
# Output is a stream of distinct arrays, each of which is sorted, and each sum of which is $sum
def sorted_combinations($sum):
Line 1,096:
 
number_of_interesting_numbers(13),
number_of_interesting_numbers(199)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,104:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Combinatorics, Primes
 
function primedigitsums(targetsum)
Line 1,151:
 
foreach(countprimedigitsums, nextprimes(17, 40))
</langsyntaxhighlight>{{out}}
<pre>
There are 3 prime-digit-only numbers summing to 5 : [5, 32, 23]
Line 1,201:
=={{header|Kotlin}}==
{{trans|D}}
<langsyntaxhighlight lang="scala">fun primeDigitsSum13(n: Int): Boolean {
var nn = n
var sum = 0
Line 1,228:
}
println()
}</langsyntaxhighlight>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 1,237:
=={{header|Lua}}==
{{trans|C}}
<langsyntaxhighlight lang="lua">function prime_digits_sum_13(n)
local sum = 0
while n > 0 do
Line 1,262:
end
end
print()</langsyntaxhighlight>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 1,270:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import math, sequtils, strutils
 
type Digit = 0..9
Line 1,297:
for i, n in result:
stdout.write ($n).align(6), if (i + 1) mod 9 == 0: '\n' else: ' '
echo()</langsyntaxhighlight>
 
{{out}}
Line 1,308:
=={{header|Pascal}}==
{{Works with|Free Pascal}} Only counting.<BR>Extreme fast in finding the sum of primesdigits = value.<BR>Limited by Uint64
<langsyntaxhighlight lang="pascal">program PrimSumUpTo13;
{$IFDEF FPC}
{$MODE DELPHI}
Line 1,451:
writeln(num:6,gblCount:25,' ');
until num > MAXNUM;
END.</langsyntaxhighlight>
{{Out}}
<pre> Sum Count of arrangements
Line 1,487:
</pre>
===using gmp===
<langsyntaxhighlight lang="pascal">program PrimSumUpTo13_GMP;
{$IFDEF FPC}
{$OPTIMIZATION ON,ALL}
Line 1,702:
z_clear(gblSum);
z_clear(gbldelta);
END.</langsyntaxhighlight>
{{out}}
<pre>
Line 1,756:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict;
Line 1,775:
}
}
print $numbers =~ s/.{1,80}\K /\n/gr;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,784:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="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;">unlucky</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">set</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">needed</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">={})</span>
Line 1,799:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">unlucky</span><span style="color: #0000FF;">({</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">},</span><span style="color: #000000;">13</span><span style="color: #0000FF;">))</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,809:
===iterative===
Queue-based version of Nigel's recursive algorithm, same output.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- uses latest apply() mods, rest is fine</span>
Line 1,831:
<span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%6d"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">11</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
 
I've archived a slightly more OTT version: [[Numbers_with_prime_digits_whose_sum_is_13/Phix]].
 
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
<lang Prolog>
digit_sum(N, M) :- digit_sum(N, 0, M).
digit_sum(0, A, B) :- !, A = B.
Line 1,861:
 
?- main.
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,869:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>put join ', ', sort +*, unique flat
< 2 2 2 2 2 3 3 3 5 5 7 >.combinations
.grep( *.sum == 13 )
.map( { .join => $_ } )
.map: { .value.permutations».join }</langsyntaxhighlight>
{{Out}}
<pre>337, 355, 373, 535, 553, 733, 2227, 2272, 2335, 2353, 2533, 2722, 3235, 3253, 3325, 3352, 3523, 3532, 5233, 5323, 5332, 7222, 22225, 22252, 22333, 22522, 23233, 23323, 23332, 25222, 32233, 32323, 32332, 33223, 33232, 33322, 52222, 222223, 222232, 222322, 223222, 232222, 322222</pre>
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds and displays all decimal numbers whose digits are prime and sum to 13. */
parse arg LO HI COLS . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 337 /*Not specified? Then use the default.*/
Line 1,912:
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the internal default inputs:}}
<pre>
Line 1,928:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,962:
next
? "[" + left(svect, len(svect) - 1) + "]"
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,971:
=={{header|Ruby}}==
{{trans|C}}
<langsyntaxhighlight lang="ruby">def primeDigitsSum13(n)
sum = 0
while n > 0
Line 1,997:
end
print "\n"
</syntaxhighlight>
</lang>
{{out}}
<pre> 337 355 373 535 553 733 2227 2272 2335 2353 2533
Line 2,005:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func generate_from_prefix(sum, p, base, digits) {
 
var seq = [p]
Line 2,024:
}
 
say numbers_with_digitsum(13)</langsyntaxhighlight>
{{out}}
<pre>
Line 2,033:
{{Trans|Phix}}
Same recursive method.
<langsyntaxhighlight lang="vbnet">Imports System
Imports System.Console
Imports LI = System.Collections.Generic.SortedSet(Of Integer)
Line 2,053:
unl(new LI From {}, new LI From { 2, 3, 5, 7 }, 13)))
End Sub
End Module</langsyntaxhighlight>
{{out}}
<pre style="white-space:pre-wrap;">337 355 373 535 553 733 2227 2272 2335 2353 2533 2722 3235 3253 3325 3352 3523 3532 5233 5323 5332 7222 22225 22252 22333 22522 23233 23323 23332 25222 32233 32323 32332 33223 33232 33322 52222 222223 222232 222322 223222 232222 322222
Line 2,059:
=== Alternate ===
Thanks to '''Nigel Galloway's''' suggestion from the discussion page.
<langsyntaxhighlight lang="vbnet">Imports Tu = System.Tuple(Of Integer, Integer)
 
Module Module1
Line 2,074:
End Sub
 
End Module</langsyntaxhighlight>
Same output.
 
Line 2,082:
{{libheader|Wren-sort}}
As the only digits which are prime are [2, 3, 5, 7], it is clear that a number must have between 3 and 6 digits for them to sum to 13.
<langsyntaxhighlight lang="ecmascript">import "/math" for Nums
import "/seq" for Lst
import "/sort" for Sort
Line 2,128:
Sort.quick(res)
System.print("Those numbers whose digits are all prime and sum to 13 are:")
System.print(res)</langsyntaxhighlight>
 
{{out}}
Line 2,137:
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">
<lang XPL0>
int N, M, S, D;
[for N:= 2 to 322222 do
Line 2,152:
until M=0; \all digits in N tested or digit not prime
];
]</langsyntaxhighlight>
 
{{out}}
Thundergnat
10,327

edits

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