Strange plus numbers
From Rosetta Code
Strange plus numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
n is a strange plus number if the sum of the first two digits is prime and the sum of the second two digits is also prime.
Where 100 < n < 500
- Related task
Contents
11l[edit]
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)))
V xs = (100..500).filter(n -> is_strange_plus(n))
print("\n\"Strange Plus\" numbers in range [100..500]\n")
print(‘(Total: ’String(xs.len)")\n")
L(el) xs
print(el, end' ‘ ’)
I L.index % 10 == 9
print()
- Output:
"Strange Plus" numbers in range [100..500] (Total: 65) 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
APL[edit]
(∧⌿ 2 3 5 7 11 13 17 ∊⍨ 2 +⌿ 10 (⊥⍣¯1) X)/X←100+⍳399
- Output:
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
AppleScript[edit]
------------------- STRANGE PLUS NUMBERS -----------------
-- isStrangePlus :: Int -> Bool
on isStrangePlus(n)
set ds to digits(n)
script sumIsSmallPrime
on |λ|(a, b)
{2, 3, 5, 7, 11, 13, 17} contains (a + b)
end |λ|
end script
zipWith(sumIsSmallPrime, ds, rest of ds) does not contain false
end isStrangePlus
--------------------------- TEST -------------------------
on run
set xs to filter(isStrangePlus, enumFromTo(100, 500))
intercalate("\n\n", ¬
{"'Strange Plus' numbers found in range [100..500]", ¬
"Full list:", ¬
("(total " & (length of xs) as string) & ")", ¬
unlines(map(unwords, chunksOf(10, map(str, xs))))})
end run
------------------------- GENERIC ------------------------
-- chunksOf :: Int -> [a] -> [[a]]
on chunksOf(k, xs)
script
on go(ys)
set ab to splitAt(k, ys)
set a to item 1 of ab
if {} ≠ a then
{a} & go(item 2 of ab)
else
a
end if
end go
end script
result's go(xs)
end chunksOf
-- digits :: Int -> [Int]
on digits(n)
script go
on |λ|(x)
x as integer
end |λ|
end script
map(go, characters of (n as string))
end digits
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m ≤ n then
set lst to {}
repeat with i from m to n
set end of lst to i
end repeat
lst
else
{}
end if
end enumFromTo
-- intercalate :: String -> [String] -> String
on intercalate(delim, xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, delim}
set s to xs as text
set my text item delimiters to dlm
s
end intercalate
-- filter :: (a -> Bool) -> [a] -> [a]
on filter(p, xs)
tell mReturn(p)
set lst to {}
set lng to length of xs
repeat with i from 1 to lng
set v to item i of xs
if |λ|(v, i, xs) then set end of lst to v
end repeat
if {text, string} contains class of xs then
lst as text
else
lst
end if
end tell
end filter
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- min :: Ord a => a -> a -> a
on min(x, y)
if y < x then
y
else
x
end if
end min
-- splitAt :: Int -> [a] -> ([a], [a])
on splitAt(n, xs)
if n > 0 and n < length of xs then
if class of xs is text then
{items 1 thru n of xs as text, ¬
items (n + 1) thru -1 of xs as text}
else
{items 1 thru n of xs, items (n + 1) thru -1 of xs}
end if
else
if n < 1 then
{{}, xs}
else
{xs, {}}
end if
end if
end splitAt
-- str :: a -> String
on str(x)
x as string
end str
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
-- unwords :: [String] -> String
on unwords(xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, space}
set s to xs as text
set my text item delimiters to dlm
return s
end unwords
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
on zipWith(f, xs, ys)
set lng to min(length of xs, length of ys)
set lst to {}
if 1 > lng then
return {}
else
tell mReturn(f)
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, item i of ys)
end repeat
return lst
end tell
end if
end zipWith
- Output:
'Strange Plus' numbers found in range [100..500] Full list: (total 65) 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
AWK[edit]
# syntax: GAWK -f STRANGE_PLUS_NUMBERS.AWK
BEGIN {
start = 100
stop = 500
for (i=start; i<=stop; i++) {
c1 = substr(i,1,1)
c2 = substr(i,2,1)
c3 = substr(i,3,1)
if (is_prime(c1 + c2) && is_prime(c2 + c3)) {
printf("%d%1s",i,++count%10?"":"\n")
}
}
printf("\nStrange plus numbers %d-%d: %d\n",start,stop,count)
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)
}
- Output:
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 Strange plus numbers 100-500: 65
C[edit]
Generalized solution: a number is strange iff the sum of two consecutive digits is always prime. Numbers < 10 are considered non-strange.
#include <stdio.h>
static int p[19] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
0, 1, 0, 1, 0, 0, 0, 1, 0};
int isstrange(long n) {
if (n < 10) return 0;
for (; n >= 10; n /= 10) {
if (!p[n%10 + (n/10)%10]) return 0;
}
return 1;
}
int main(void) {
long n;
int k = 0;
for (n = 101; n < 500; n++) {
if (isstrange(n)) {
printf("%d%c", n, ++k%10 ? ' ' : '\n');
}
}
return 0;
}
- Output:
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
Delphi[edit]
program Strange_plus_numbers;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
function IsPrime(n: Integer): Boolean;
begin
Result := n in [2, 3, 5, 7, 11, 13, 17];
end;
begin
var count := 0;
var d: TArray<Integer>;
writeln('Strange plus numbers in the open interval (100, 500) are:');
for var i := 101 to 499 do
begin
d := [];
var j := i;
while j > 0 do
begin
SetLength(d, Length(d) + 1);
d[High(d)] := j mod 10;
j := j div 10;
end;
if IsPrime(d[0] + d[1]) and IsPrime(d[1] + d[2]) then
begin
write(i, ' ');
inc(count);
if count mod 10 = 0 then
writeln;
end;
end;
if (count mod 10) <> 0 then
writeln;
writeln(#10, count, ' strange plus numbers in all.');
readln;
end.
F#[edit]
This task uses Extensible Prime Generator (F#).
// 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 ""
- Output:
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
Factor[edit]
USING: grouping grouping.extras io kernel math math.primes
math.ranges math.text.utils prettyprint sequences ;
: strange+? ( n -- ? )
dup 10 < [ drop f ]
[ 1 digit-groups [ + ] 2 clump-map [ prime? ] all? ] if ;
"Strange plus numbers in (100, 500):" print nl
100 500 (a,b) [ strange+? ] filter dup
10 group [ [ pprint bl ] each nl ] each nl
length pprint " strange plus numbers found." print
- Output:
Strange plus numbers in (100, 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 65 strange plus numbers found.
Forth[edit]
create isprime false , false , true , true , false ,
true , false , true , false , false , false , true ,
false , true , false , false , false , true , false ,
\ tests whether n is prime for 0 <= n < 19
: prime? ( n -- ? )
cells isprime + @ ;
: strange? ( n -- ? )
dup 10 < if drop false exit then
begin
dup 10 >=
while
dup 10 /mod 10 mod +
prime? invert if drop false exit then
10 /
repeat
drop true ;
: main
0
500 101 do
i strange? if
i .
1+
dup 10 mod 0= if cr then else
then
loop
cr
drop ;
main
bye
- Output:
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
Go[edit]
package main
import "fmt"
func isPrime(n int) bool {
return n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 || n == 17
}
func main() {
count := 0
var d []int
fmt.Println("Strange plus numbers in the open interval (100, 500) are:\n")
for i := 101; i < 500; i++ {
d = d[:0]
j := i
for j > 0 {
d = append(d, j%10)
j /= 10
}
if isPrime(d[0]+d[1]) && isPrime(d[1]+d[2]) {
fmt.Printf("%d ", i)
count++
if count%10 == 0 {
fmt.Println()
}
}
}
if count%10 != 0 {
fmt.Println()
}
fmt.Printf("\n%d strange plus numbers in all.\n", count)
}
- Output:
Strange plus numbers in the open interval (100, 500) are: 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 65 strange plus numbers in all.
Haskell[edit]
import Data.List (intercalate)
import Data.List.Split (chunksOf)
------------------- STRANGE PLUS NUMBERS -----------------
isStrangePlus :: Int -> Bool
isStrangePlus n =
all
(\(a, b) -> (a + b) `elem` [2, 3, 5, 7, 11, 13, 17])
$ (zip <*> tail) (digits n)
digits :: Int -> [Int]
digits = fmap (read . return) . show
--------------------------- TEST -------------------------
main =
let xs = filter isStrangePlus [100 .. 500]
in (putStrLn . intercalate "\n\n")
[ "\"Strange Plus\" numbers found in range [100..500]",
"(total " <> (show . length) xs <> ")",
"Full list:",
unlines
(unwords <$> chunksOf 10 (show <$> xs))
]
- Output:
"Strange Plus" numbers found in range [100..500] (total 65) Full list: 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
Java[edit]
public class Strange {
private static final boolean[] p = {
false, false, true, true, false,
true, false, true, false, false,
false, true, false, true, false,
false, false, true, false
};
public static boolean isstrange(long n) {
if (n < 10) return false;
for (; n >= 10; n /= 10) {
if (!p[(int)(n%10 + (n/10)%10)]) return false;
}
return true;
}
public static void main(String[] args) {
long nMin = Long.parseLong(args[0]);
long nMax = Long.parseLong(args[1]);
int k = 0;
for (long n = nMin; n <= nMax; n++) {
if (isstrange(n)) {
System.out.print(n + (++k%10 != 0 ? " " : "\n"));
}
}
}
}
java Strange 101 499
- Output:
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
Julia[edit]
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])])
isstrangeplus(n) = all(x -> x ∈ smallprimes, paired_digit_sums(n))
printed = 0
for n in 100:500
isstrangeplus(n) && print(n, (printed += 1) % 13 == 0 ? "\n" : " ")
end
end
- Output:
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
Kotlin[edit]
val p = arrayOf(
false, false, true, true, false,
true, false, true, false, false,
false, true, false, true, false,
false, false, true, false
)
fun isStrange(n: Long): Boolean {
if (n < 10) {
return false
}
var nn = n
while (nn >= 10) {
if (!p[(nn % 10 + (nn / 10) % 10).toInt()]) {
return false
}
nn /= 10
}
return true
}
fun test(nMin: Long, nMax: Long) {
var k = 0
for (n in nMin..nMax) {
if (isStrange(n)) {
print(n)
if (++k % 10 != 0) {
print(' ')
} else {
println()
}
}
}
}
fun main() {
test(101, 499)
}
- Output:
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
Maple[edit]
select(n->(u->isprime(add(u[1..2])) and isprime(add(u[2..3])))(convert(n,base,10)),[$101..499]);
- Output:
[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]
Perl[edit]
use strict;
use warnings;
use feature 'say';
use ntheory 'is_prime';
my($low, $high) = (100, 500);
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;
- Output:
Between 100 and 500 there are 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
Phix[edit]
Using the same approach as Strange_numbers#Phix, so this should similarly scale/count easily to the 28-digit range.
constant poss = apply(true,sq_sub,{{get_primes(-7)},tagset(9,0)}),
nxts = apply(true,filter,{poss,{"in"},{{0,9}},{"[]"}})
function strange_plus(integer left, sequence digits, res={}, part={})
for i=1 to length(digits) do
integer di = digits[i]
if left=1 then
string fmt = join(repeat("%d",length(part)+1),"")
res = append(res,sprintf(fmt,part&di))
else
res = strange_plus(left-1,nxts[di+1],res,part&di)
end if
end for
return res
end function
sequence res = strange_plus(3,tagset(4)) -- (3 digit numbers beginning 1..4)
printf(1,"%d strange_plus numbers found: %s\n",{length(res),join(shorten(res,"",5),",")})
- Output:
65 strange_plus numbers found: 111,112,114,116,120,...,474,476,492,494,498
Python[edit]
Using sympy.isprime
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
>>> [x for x in range(101,500)
if isprime(sum(int(c) for c in str(x)[:2])) and
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]
>>>
Or, as we may not need to wake up sympy just to check membership of {2, 3, 5, 7, 11, 13, 17}:
'''Strange Plus Numbers'''
# isStrangePlus :: Int -> Bool
def isStrangePlus(n):
'''True all consecutive decimal digit
pairs in n have prime sums.
'''
def test(a, b):
return a + b in [2, 3, 5, 7, 11, 13, 17]
xs = digits(n)
return all(map(test, xs, xs[1:]))
# ------------------- TEST AND DISPLAY -------------------
# main :: IO ()
def main():
'''List and count of Strange Plus Numbers'''
xs = [
n for n in range(100, 1 + 500)
if isStrangePlus(n)
]
print('\n"Strange Plus" numbers in range [100..500]\n')
print('(Total: ' + str(len(xs)) + ')\n')
print(
'\n'.join(
' '.join(
str(x) for x in row
) for row in chunksOf(10)(xs)
)
)
# ----------------------- GENERIC ------------------------
# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
'''A series of lists of length n, subdividing the
contents of xs. Where the length of xs is not evenly
divible, the final list will be shorter than n.
'''
def go(xs):
return (
xs[i:n + i] for i in range(0, len(xs), n)
) if 0 < n else None
return go
# digits :: Int -> [Int]
def digits(n):
'''Component digits of a decimal number.'''
return [int(c) for c in str(n)]
# MAIN ---
if __name__ == '__main__':
main()
- Output:
"Strange Plus" numbers in range [100..500] (Total: 65) 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
Raku[edit]
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 } };
- Output:
65 matching numbers from 100 to 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
REXX[edit]
/*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.*/
if HI=='' | HI=="," then HI= 499 /* " " " " " " */
!.= 0; !.2= 1; !.3= 1; !.5= 1; !.7= 1 /*build array of sums that are prime. */
!.11= 1; !.13= 1; !.17= 1 /* " " " " " " " */
$= /*the list of strange+ numbers (so far)*/
#= 0 /* " number " " " " " */
do j=LO to HI; L= length(j) /*look for strange+ numbers in range. */
if L==1 then iterate /*Number too short? Then skip it. */
do k=1 for L-1 /*examine the difference in the digits.*/
parse var j =(k) y +1 z +1 /*get two adjacent decimal digits: Y Z */
sum= y + z /*sum of two adjacent decimal digits. */
if \!.sum then iterate j /*Sum not prime? Then skip this number*/
end /*k*/
#= # + 1 /*bump the number of "strange+" numbers*/
$= $ j /*append the number to the $ list. */
end /*j*/
/*stick a fork in it, we're all done. */
say # ' strange plus numbers found between ' LO " and " HI ' (inclusive)'
say
say strip($)
- output when using the default inputs:
65 strange plus numbers found between 101 and 499 (inclusive) 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
Ring[edit]
load "stdlib.ring"
row = 0
see "Strange plus numbers are:" + nl
for n = 100 to 500
flag = 1
str = string(n)
for m = 1 to len(str)-1
num1 = number(str[m])
num2 = number(str[m+1])
pr = num1+num2
if not isprime(pr)
flag = 0
exit
ok
next
if flag = 1
see str + " "
row = row + 1
if row % 10 = 0
see nl
ok
ok
next
- Output:
Strange plus numbers are: 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
Ruby[edit]
$p = [
false, false, true, true, false,
true, false, true, false, false,
false, true, false, true, false,
false, false, true, false
]
def isStrange(n)
if n < 10 then
return false
end
while n >= 10 do
if not $p[n % 10 + (n / 10).floor % 10] then
return false
end
n = (n / 10).floor
end
return true
end
def test(nMin, nMax)
k = 0
for n in nMin .. nMax
if isStrange(n) then
print n
k = k + 1
if k % 10 != 0 then
print ' '
else
print "\n"
end
end
end
end
test(101, 499)
- Output:
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
Wren[edit]
Simple brute force is adequate for this.
var primes = [2, 3, 5, 7, 11, 13, 17]
var count = 0
var d = []
System.print("Strange plus numbers in the open interval (100, 500) are:\n")
for (i in 101..499) {
d.clear()
var j = i
while (j > 0) {
d.add(j % 10)
j = (j/10).floor
}
if (primes.contains(d[0] + d[1]) && primes.contains(d[1] + d[2])) {
System.write("%(i) ")
count = count + 1
if (count % 10 == 0) System.print()
}
}
if (count % 10 != 0) System.print()
System.print("\n%(count) strange plus numbers in all.")
- Output:
Strange plus numbers in the open interval (100, 500) are: 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 65 strange plus numbers in all.
x86 Assembly[edit]
A 16-bit solution for NASM under DOS. Assemble with nasm -fbin strange.asm -o strange.com. The prime sieve up to 18 is hard-coded.
org 100h
mov cx, 10 ; cl is used for division, ch to count numbers printed on a line
mov si, 101 ; loop index from 101 to 499
mov di, p ; pointer to prime sieve
; p+k is a pointer to the reversed string repr. of the current index
L1 mov ax, si
xor bx, bx ; bx counts characters in the string
L2 div cl ; div by 10 to get last digit
add ah, 48 ; convert digit to ascii
mov [bx+di+k], ah ; store char
test bl, bl ; if it's the first, don't check for prime sum
jz L3
add ah, [bx+di+k-1] ; sum of digits
sub ah, 96 ; adjust for ascii
xchg ah, bl
cmp byte [bx+di], 1 ; is it prime?
jne L6 ; otherwise continue with next number
mov bl, ah ; restore bl
L3 xor ah, ah ; must be zero for the next division
inc bx ; one more char
test al, al ; are there more digits?
jnz L2
L4 mov ah, 2 ; the number is strange, print it char by char
mov dl, [bx+di+k-1]
int 21h
dec bx
jnz L4
mov ah, 2 ; print a space or a newline
mov dl, 32
inc ch
cmp ch, 10 ; if less than 10 on the current line it's a space
jne L5
mov dl, 10 ; otherwise it's a newline
xor ch, ch ; reset the counter when we reach 10
L5 int 21h
L6 inc si ; next number
cmp si, 500 ; and loop until we reach 500
jb L1
int 20h ; return to DOS
p db 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0
k equ $-p
- Output:
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
