Rosetta Code

Strange plus numbers: Difference between revisions

Page Discussion

Strange plus numbers (view source)

Revision as of 10:53, 10 February 2024

6,377 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(Add VTL-2)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(16 intermediate revisions by 10 users not shown)
Line 13:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F is_strange_plus(n)
V xs = String(n).map(c -> Int(c))
R all(zip(xs, xs[1..]).map((a, b) -> a + b C (2, 3, 5, 7, 11, 13, 17)))
Line 23:
print(el, end' ‘ ’)
I L.index % 10 == 9
print()</langsyntaxhighlight>
 
{{out}}
Line 42:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">BYTE Func IsStrangePlusNumber(INT i)
BYTE ARRAY primes=[0 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0]
BYTE d,prev,first,sum
Line 77:
OD
PrintF("%E%EThere are %I strange plus numbers",count)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strange_plus_numbers.png Screenshot from Atari 8-bit computer]
Line 90:
=={{header|ALGOL 68}}==
Does not attempt to generalise beyond 3 digit numbers.
<langsyntaxhighlight lang="algol68">BEGIN # find numbers where the sum of the first 2 digits is prime and also #
# the sum of the second 2 digits is prime #
# considers numbers n where 100 < n < 500 #
Line 105:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 119:
=={{header|ALGOL W}}==
{{Trans|ALGOL 68}}
<langsyntaxhighlight lang="pascal">begin % find numbers where the sum of the first 2 digits is prime and also %
% the sum of the second 2 digits is prime %
% considers numbers n where 100 < n < 500 %
Line 139:
end for_n
end.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 153:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(∧⌿ 2 3 5 7 11 13 17 ∊⍨ 2 +⌿ 10 (⊥⍣¯1) X)/X←100+⍳399</langsyntaxhighlight>
 
{{out}}
Line 163:
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">------------------- STRANGE PLUS NUMBERS -----------------
 
-- isStrangePlus :: Int -> Bool
Line 362:
end tell
end if
end zipWith</langsyntaxhighlight>
{{Out}}
<pre>'Strange Plus' numbers found in range [100..500]
Line 377:
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498</pre>
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">strangeNums: select 101..499 'x ->
and? -> prime? sum first.n:2 digits x
-> prime? sum last.n:2 digits x
 
loop split.every: 5 strangeNums 'x ->
print map x 's -> pad to :string s 3</syntaxhighlight>
 
{{out}}
 
<pre>111 112 114 116 120
121 123 125 129 141
143 147 149 161 165
167 202 203 205 207
211 212 214 216 230
232 234 238 250 252
256 258 292 294 298
302 303 305 307 320
321 323 325 329 341
343 347 349 383 385
389 411 412 414 416
430 432 434 438 470
474 476 492 494 498</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f STRANGE_PLUS_NUMBERS.AWK
BEGIN {
Line 405 ⟶ 430:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 419 ⟶ 444:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="gwbasic">10 DEFINT A-Z
20 FOR I=100 TO 500
30 N=I
Line 428 ⟶ 453:
80 R=N MOD 10
90 IF INSTR("CDFHLNR",CHR$(L+R+65)) THEN 50
100 NEXT I</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120
Line 445 ⟶ 470:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let smallprime(n) = n=2 | n=3 | n=5 | n=7 | n=11 | n=13 | n=17
Line 462 ⟶ 487:
$)
wrch('*N')
$) </langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 473 ⟶ 498:
 
=={{header|BQN}}==
<langsyntaxhighlight lang="bqn">∘‿13⥊(∧´2‿3‿5‿7‿11‿13‿17∊˜(+˝∘⍉2↕•Fmt-'0'˙))¨⊸/100+↕400</langsyntaxhighlight>
{{out}}
<pre>┌─
Line 486 ⟶ 511:
Generalized solution: a number is strange iff the sum of two consecutive digits is always prime. Numbers < 10 are considered non-strange.
 
<langsyntaxhighlight lang="c">#include <stdio.h>
 
static int p[19] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
Line 509 ⟶ 534:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 523 ⟶ 548:
=={{header|C++}}==
{{trans|Java}}
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <vector>
 
Line 563 ⟶ 588:
test(101, 499);
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 574 ⟶ 599:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">small_prime = proc (n: int) returns (bool)
small_primes = sequence[int]$[2,3,5,7,11,13,17]
for p: int in sequence[int]$elements(small_primes) do
Line 602 ⟶ 627:
end
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 613 ⟶ 638:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. STRANGE-PLUS-NUMBERS.
 
Line 651 ⟶ 676:
DISPLAY ROW,
MOVE SPACES TO ROW,
MOVE 1 TO PTR.</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 662 ⟶ 687:
 
=={{header|Comal}}==
<langsyntaxhighlight lang="comal">0010 FUNC small'prime#(n#)
0020 RETURN n#=2 OR (n# MOD 2<>0 AND n#<>1 AND n#<>9 AND n#<>15)
0030 ENDFUNC small'prime#
Line 687 ⟶ 712:
0240 ENDFOR i#
0250 PRINT
0260 END</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 698 ⟶ 723:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub small_prime(n: uint8): (p: uint8) is
Line 731 ⟶ 756:
cand := cand + 1;
end loop;
print_nl();</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 742 ⟶ 767:
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
<lang Delphi>
program Strange_plus_numbers;
 
Line 787 ⟶ 811:
writeln(#10, count, ' strange plus numbers in all.');
readln;
end.</langsyntaxhighlight>
 
=== Alternate solution ===
 
<syntaxhighlight lang="delphi">program StrangePlusNumbers;
 
const
m = 18;
 
var
pr: array [0..m] of Boolean;
n, k, a, b: Integer;
q: Boolean;
begin
// prime sieve
for n := 0 to m do
begin
q := n > 1;
for k := 2 to n - 1 do
if n mod k = 0 then q := False;
pr[n] := q
end;
 
k := 0;
for n := 101 to 499 do
begin
a := n div 10; // first two digits
b := n mod 100; // last two digits
if pr[a div 10 + a mod 10] and
pr[b div 10 + b mod 10] then
begin
Write(n);
Inc(k);
if k mod 10 = 0 then Writeln else Write(' ')
end
end
end.</syntaxhighlight>
 
{{out}}
 
<pre>111 112 114 116 120 121 123 125 129 141
143 147 149 161 165 167 202 203 205 207
211 212 214 216 230 232 234 238 250 252
256 258 292 294 298 302 303 305 307 320
321 323 325 329 341 343 347 349 383 385
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498</pre>
 
=={{header|Draco}}==
<langsyntaxhighlight lang="draco">proc small_prime(word n) bool:
word primes = 0x8A2B;
n>=2 and primes >> (n-2) & 1 = 1
Line 820 ⟶ 891:
fi
od
corp</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 832 ⟶ 903:
=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<langsyntaxhighlight lang="fsharp">
// Strange numbers. Nigel Galloway: February 25th., 2021
let pD=[0..99]|>List.map(fun n->(n/10,n%10))|>List.filter(fun(n,g)->isPrime(n+g))
pD|>List.filter(fun(n,_)->n>0)|>List.map(fun(n,g)->(n,pD|>List.filter(fun(n,_)->n=g)))
|>List.collect(fun(n,g)->g|>List.map(fun(g,k)->n*100+g*10+k))|>List.filter((>)500)|>List.iter(printf "%d ");printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 845 ⟶ 916:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: grouping grouping.extras io kernel math math.primes
math.ranges math.text.utils prettyprint sequences ;
 
Line 855 ⟶ 926:
100 500 (a,b) [ strange+? ] filter dup
10 group [ [ pprint bl ] each nl ] each nl
length pprint " strange plus numbers found." print</langsyntaxhighlight>
{{out}}
<pre>
Line 873 ⟶ 944:
=={{header|Forth}}==
{{trans|C}}
<langsyntaxhighlight lang="forth">create isprime false , false , true , true , false ,
true , false , true , false , false , false , true ,
false , true , false , false , false , true , false ,
Line 905 ⟶ 976:
 
main
bye</langsyntaxhighlight>
 
{{out}}
Line 921 ⟶ 992:
=={{header|FreeBASIC}}==
{{trans|AWK}}
<langsyntaxhighlight lang="freebasic">
Function isPrime(valor As Integer) As Boolean
If valor <= 1 Then Return False
Line 946 ⟶ 1,017:
Print !"\n\n"; k; " n£meros m s extra¤os encontrados."
Sleep
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 964 ⟶ 1,035:
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Strange_plus_numbers}}
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for storage and transfer purposes more than visualization and edition.
 
'''Solution'''
Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.
 
[[File:Fōrmulæ - Strange plus numbers 01.png]]
In '''[https://formulae.org/?example=Strange_plus_numbers this]''' page you can see the program(s) related to this task and their results.
 
[[File:Fōrmulæ - Strange plus numbers 02.png]]
 
[[File:Fōrmulæ - Strange plus numbers 03.png]]
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,003 ⟶ 1,078:
}
fmt.Printf("\n%d strange plus numbers in all.\n", count)
}</langsyntaxhighlight>
 
{{out}}
Line 1,021 ⟶ 1,096:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (intercalate)
import Data.List.Split (chunksOf)
 
Line 1,045 ⟶ 1,120:
unlines
(unwords <$> chunksOf 10 (show <$> xs))
]</langsyntaxhighlight>
{{Out}}
<pre>"Strange Plus" numbers found in range [100..500]
Line 1,060 ⟶ 1,135:
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498</pre>
 
=={{header|J}}==
 
Definitions:
<syntaxhighlight lang="j">digits=: 10&#.inv"0
strangeplus=: 100&< * 500&> * (2&{. * ::0:&(1&p:)&(+/) _2&{.)@digits</syntaxhighlight>
 
Example:
<syntaxhighlight lang="j"> I.strangeplus i.500
111 112 114 116 120 121 123 125 129 141 143 147 149 161 165 167 202 203 205 207 211 212 214 216 230 232 234 238 250 252 256 258 292 294 298 302 303 305 307 320 321 323 325 329 341 343 347 349 383 385 389 411 412 414 416 430 432 434 438 470 474 476 492 494 498</syntaxhighlight>
 
 
=={{header|Java}}==
 
<langsyntaxhighlight lang="java">public class Strange {
private static final boolean[] p = {
false, false, true, true, false,
Line 1,090 ⟶ 1,176:
}
}
}</langsyntaxhighlight>
 
<syntaxhighlight lang="text">java Strange 101 499</langsyntaxhighlight>
 
{{out}}
Line 1,109 ⟶ 1,195:
 
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<langsyntaxhighlight lang="jq">def nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
Line 1,124 ⟶ 1,210:
| join(" ");
task</langsyntaxhighlight>
{{out}}
<pre>
Line 1,138 ⟶ 1,224:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">let
smallprimes = [2, 3, 5, 7, 11, 13, 17] # 0 <= all of these primes <= 18
paired_digit_sums(n) = (d = digits(n); [sum(p) for p in zip(d[1:end-1], d[2:end])])
Line 1,148 ⟶ 1,234:
end
end
</langsyntaxhighlight>{{out}}
<pre>
111 112 114 116 120 121 123 125 129 141 143 147 149
Line 1,159 ⟶ 1,245:
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">val p = arrayOf(
false, false, true, true, false,
true, false, true, false, false,
Line 1,198 ⟶ 1,284:
fun main() {
test(101, 499)
}</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,209 ⟶ 1,295:
 
=={{header|MAD}}==
<langsyntaxhighlight lang="mad"> NORMAL MODE IS INTEGER
 
INTERNAL FUNCTION(X)
Line 1,235 ⟶ 1,321:
TEST WHENEVER STGPLS.(I), PRINT RESULTS I
 
END OF PROGRAM</langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'>I = 111
Line 1,303 ⟶ 1,389:
I = 498</pre>
=={{header|Maple}}==
<langsyntaxhighlight lang="maple">select(n->(u->isprime(add(u[1..2])) and isprime(add(u[2..3])))(convert(n,base,10)),[$101..499]);</langsyntaxhighlight>
 
{{out}}
Line 1,315 ⟶ 1,401:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Select[Range[101, 499], PrimeQ[Total[IntegerDigits[#][[;; 2]]]] && PrimeQ[Total[IntegerDigits[#][[2 ;;]]]] &]
Length[%]</langsyntaxhighlight>
{{out}}
<pre>{111, 112, 114, 116, 120, 121, 123, 125, 129, 141, 143, 147, 149, 161, 165, 167, 202, 203, 205, 207, 211, 212, 214, 216, 230, 232, 234, 238, 250, 252, 256, 258, 292, 294, 298, 302, 303, 305, 307, 320, 321, 323, 325, 329, 341, 343, 347, 349, 383, 385, 389, 411, 412, 414, 416, 430, 432, 434, 438, 470, 474, 476, 492, 494, 498}
Line 1,322 ⟶ 1,408:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE StrangePlusNumbers;
FROM InOut IMPORT WriteCard, WriteLn;
 
Line 1,355 ⟶ 1,441:
END;
WriteLn;
END StrangePlusNumbers.</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 1,366 ⟶ 1,452:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">const Primes = {2, 3, 5, 7, 11, 13, 17}
 
proc digits(n: 100..999): array[3, int] =
Line 1,376 ⟶ 1,462:
if d[0] + d[1] in Primes and d[1] + d[2] in Primes:
inc count
stdout.write n, if count mod 13 == 0: '\n' else: ' '</langsyntaxhighlight>
 
{{out}}
Line 1,387 ⟶ 1,473:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,395 ⟶ 1,481:
my $n = my @SP = grep { my @d = split ''; is_prime $d[0]+$d[1] and is_prime $d[1]+$d[2] } $low+1 .. $high-1;
say "Between $low and $high there are $n strange-plus numbers:\n" .
(sprintf "@{['%4d' x $n]}", @SP[0..$n-1]) =~ s/(.{80})/$1\n/gr;</langsyntaxhighlight>
{{out}}
<pre>Between 100 and 500 there are 65 strange-plus numbers:
Line 1,405 ⟶ 1,491:
=={{header|Phix}}==
Using the same approach as [[Strange_numbers#Phix]], so this should similarly scale/count easily to the 28-digit range.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">poss</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;">sq_sub</span><span style="color: #0000FF;">,{{</span><span style="color: #7060A8;">get_primes</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">)},</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)}),</span>
<span style="color: #000000;">nxts</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;">filter</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">poss</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"in"</span><span style="color: #0000FF;">},{{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">}},{</span><span style="color: #008000;">"[]"</span><span style="color: #0000FF;">}})</span>
Line 1,424 ⟶ 1,510:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">strange_plus</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">4</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- (3 digit numbers beginning 1..4)</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;">"%d strange_plus numbers found: %s\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;">join</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><span style="color: #008000;">","</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
65 strange_plus numbers found: 111,112,114,116,120,...,474,476,492,494,498
</pre>
 
=={{header|Picat}}==
<syntaxhighlight lang="picat">main =>
L = [N : N in 100..500, S = N.to_string.map(to_int),
prime(S[1]+S[2]),
prime(S[2]+S[3])],
Len = L.len,
foreach({N,I} in zip(L,1..Len))
printf("%3d%s",N,cond(I mod 10 == 0, "\n", " "))
end,
nl,
println(len=Len)</syntaxhighlight>
 
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
143 147 149 161 165 167 202 203 205 207
211 212 214 216 230 232 234 238 250 252
256 258 292 294 298 302 303 305 307 320
321 323 325 329 341 343 347 349 383 385
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498
len = 65</pre>
 
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">StrangePlusNumbers: procedure options(main);
smallPrime: procedure(n) returns(bit);
declare n fixed;
Line 1,456 ⟶ 1,565:
end;
end;
end StrangePlusNumbers;</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 1,467 ⟶ 1,576:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="pli">100H:
BDOS: PROCEDURE(F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
Line 1,518 ⟶ 1,627:
END;
CALL EXIT;
EOF</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,531 ⟶ 1,640:
Using [https://docs.sympy.org/latest/modules/ntheory.html sympy.isprime]
 
<langsyntaxhighlight lang="python">Python 3.8.5 (default, Sep 3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> from sympy import isprime
Line 1,539 ⟶ 1,648:
isprime(sum(int(c) for c in str(x)[1:]))]
[111, 112, 114, 116, 120, 121, 123, 125, 129, 141, 143, 147, 149, 161, 165, 167, 202, 203, 205, 207, 211, 212, 214, 216, 230, 232, 234, 238, 250, 252, 256, 258, 292, 294, 298, 302, 303, 305, 307, 320, 321, 323, 325, 329, 341, 343, 347, 349, 383, 385, 389, 411, 412, 414, 416, 430, 432, 434, 438, 470, 474, 476, 492, 494, 498]
>>> </langsyntaxhighlight>
 
 
Or, as we may not need to wake up '''sympy''' just to check membership of {2, 3, 5, 7, 11, 13, 17}:
 
<langsyntaxhighlight lang="python">'''Strange Plus Numbers'''
 
 
Line 1,602 ⟶ 1,711:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>"Strange Plus" numbers in range [100..500]
Line 1,615 ⟶ 1,724:
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery"> [ ' [ 2 3 5 7 11 13 17 ]
find 7 < ] is prime ( n --> b )
 
[ 10 /mod
swap 10 /mod
tuck + prime not iff
[ 2drop false ] done
+ prime ] is strange+ ( n --> b )
 
[] 399 times
[ i^ 101 +
dup strange+ iff
join else drop ]
dup size echo
say " strange plus numbers:"
cr cr
witheach
[ echo
i^ 10 mod 9 = iff cr else sp ]</syntaxhighlight>
 
{{out}}
 
<pre>65 strange plus numbers:
 
111 112 114 116 120 121 123 125 129 141
143 147 149 161 165 167 202 203 205 207
211 212 214 216 230 232 234 238 250 252
256 258 292 294 298 302 303 305 307 320
321 323 325 329 341 343 347 349 383 385
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498
</pre>
 
=={{header|R}}==
 
<syntaxhighlight lang="rsplus"># Primes up to 18
pr <- sapply(1:18, \(n) n > 1 && all(n %% seq(2, length.out = n - 2) > 0))
 
is.strange <- function(n) {
a <- as.integer(strsplit(as.character(n), "")[[1]])
pr[a[[1]] + a[[2]] + 1] && pr[a[[2]] + a[[3]] + 1]
}
 
a <- 101:499
a[sapply(a, is.strange)]</syntaxhighlight>
 
{{out}}
 
<pre> [1] 111 112 114 116 120 121 123 125 129 141 143 147 149 161 165 167 202 203 205 207 211 212 214
[24] 216 230 232 234 238 250 252 256 258 292 294 298 302 303 305 307 320 321 323 325 329 341 343
[47] 347 349 383 385 389 411 412 414 416 430 432 434 438 470 474 476 492 494 498</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>unit sub MAIN ($start = 100, $end = 500);
put +$_, " matching numbers from $start to $end:\n", $_ given
($start .. $end).hyper(:256batch,:8degree).grep: { all .comb.rotor(2 => -1).map: { .sum.is-prime } };</langsyntaxhighlight>
{{out}}
<pre>65 matching numbers from 100 to 500:
Line 1,625 ⟶ 1,788:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm lists strange+ integers (within a range); sum of adjacent dec. digs is prime.*/
parse arg LO HI . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 101 /*Not specified? Then use the default.*/
Line 1,647 ⟶ 1,810:
say # ' strange plus numbers found between ' LO " and " HI ' (inclusive)'
say
say strip($)</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,659 ⟶ 1,822:
=={{header|Ring}}==
 
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,685 ⟶ 1,848:
ok
next
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,696 ⟶ 1,859:
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
≪ { }
<span style="color:red">101 499</span> '''FOR''' n
n <span style="color:red">10</span> IDIV2 SWAP <span style="color:red">10</span> IDIV2
'''IF''' ROT OVER + ISPRIME? UNROT + ISPRIME? AND '''THEN''' n + '''END'''
'''NEXT'''
≫ '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: {111 112 114 116 120 121 123 125 129 141 143 147 149 161 165 167 202 203 205 207 211 212 214 216 230 232 234 238 250 252 256 258 292 294 298 302 303 305 307 320 321 323 325 329 341 343 347 349 383 385 389 411 412 414 416 430 432 434 438 470 474 476 492 494 498}
</pre>
 
=={{header|Ruby}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="ruby">$p = [
false, false, true, true, false,
true, false, true, false, false,
Line 1,737 ⟶ 1,913:
end
 
test(101, 499)</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,748 ⟶ 1,924:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func boolean: prime (in integer: number) is
Line 1,779 ⟶ 1,955:
end if;
end for;
end func;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,788 ⟶ 1,964:
412 414 416 430 432 434 438 470 474 476 492 494 498
</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program strange_plus_numbers;
$ a sum of two digits is never >18
primes := {2, 3, 5, 7, 11, 13, 17};
 
strangeplus := {
n : n in [101..499]
| lowpairsum(n) in primes and highpairsum(n) in primes
};
 
loop for n in strangeplus do
putchar(lpad(str n, 5));
if (i +:= 1) mod 10 = 0 then print; end if;
end loop;
print;
 
proc lowpairsum(n);
return n mod 100 div 10 + n mod 10;
end proc;
 
proc highpairsum(n);
return lowpairsum(n div 10);
end proc;
end program;</syntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
143 147 149 161 165 167 202 203 205 207
211 212 214 216 230 232 234 238 250 252
256 258 292 294 298 302 303 305 307 320
321 323 325 329 341 343 347 349 383 385
389 411 412 414 416 430 432 434 438 470
474 476 492 494 498</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">100..500 -> map { .digits }.grep {|d|
is_prime(d[-1]+d[-2]) && is_prime(d[-2]+d[-3])
}.map{ .digits2num }.slices(10).each { .join(' ').say }</langsyntaxhighlight>
{{out}}
<pre>
Line 1,804 ⟶ 2,013:
</pre>
 
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">fn is_prime(n int) bool {
return n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 || n == 17
}
Line 1,833 ⟶ 2,042:
}
println("\n$count strange plus numbers in all.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,851 ⟶ 2,060:
 
=={{header|VTL-2}}==
<langsyntaxhighlight VTL2lang="vtl2">10 C=0
20 N=101
30 K=N
Line 1,870 ⟶ 2,079:
180 #=C/10*0+0<%*!
190 ?=""
200 #=!</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,882 ⟶ 2,091:
=={{header|Wren}}==
Simple brute force is adequate for this.
<langsyntaxhighlight ecmascriptlang="wren">var primes = [2, 3, 5, 7, 11, 13, 17]
var count = 0
var d = []
Line 1,900 ⟶ 2,109:
}
if (count % 10 != 0) System.print()
System.print("\n%(count) strange plus numbers in all.")</langsyntaxhighlight>
 
{{out}}
Line 1,921 ⟶ 2,130:
A 16-bit solution for NASM under DOS. Assemble with <code>nasm -fbin strange.asm -o strange.com</code>. The prime sieve up to 18 is hard-coded.
 
<syntaxhighlight lang="text"> org 100h
 
mov cx, 10 ; cl is used for division, ch to count numbers printed on a line
Line 1,968 ⟶ 2,177:
 
p db 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0
k equ $-p</langsyntaxhighlight>
 
{{out}}
Line 1,981 ⟶ 2,190:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func StrangePlus(N);
int N, A, B, S;
[N:= N/10;
Line 2,000 ⟶ 2,209:
IntOut(0, N);
if rem(Cnt/20) = 0 then CrLf(0) else ChOut(0, ^ )];
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,479

edits

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