Strange plus numbers: Difference between revisions

From Rosetta Code
Content added Content deleted
(Add CLU)
(Add Draco)
Line 611: Line 611:
readln;
readln;
end.</lang>
end.</lang>

=={{header|Draco}}==
<lang draco>proc small_prime(word n) bool:
word primes = 0x8A2B;
n>=2 and primes >> (n-2) & 1 = 1
corp

proc strange_plus(word n) bool:
word dl, dr;
bool pair_prime;
dl := n % 10;
while
dr := dl;
n := n / 10;
dl := n % 10;
pair_prime := small_prime(dl + dr);
pair_prime and n >= 10
do od;
pair_prime and n < 10
corp

proc main() void:
byte col;
word cand;
col := 0;
for cand from 101 upto 499 do
if strange_plus(cand) then
write(cand:4);
col := col + 1;
if col = 10 then writeln(); col := 0 fi
fi
od
corp</lang>
{{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|F_Sharp|F#}}==
=={{header|F_Sharp|F#}}==

Revision as of 12:55, 11 May 2022

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



11l

Translation of: Python

<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)))

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()</lang>
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

Action!

<lang 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

 prev=255
 first=1
 WHILE i#0
 DO
   d=i MOD 10
   IF prev#255 THEN
     sum=d+prev
     IF first=1 AND primes(sum)=0 THEN
       RETURN (0)
     FI
     first=0
   FI
   prev=d
   i==/10
 OD
 IF primes(sum)=0 THEN
   RETURN (0)
 FI

RETURN (1)

PROC Main() 

 INT i,count=[0]

 FOR i=101 TO 499
 DO
   IF IsStrangePlusNumber(i) THEN
     PrintI(i) Put(32)
     count==+1
   FI
 OD
 PrintF("%E%EThere are %I strange plus numbers",count)

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer 

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

There are 65 strange plus numbers

ALGOL 68

Does not attempt to generalise beyond 3 digit numbers.

Library: ALGOL 68-primes

<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                              #
   PR read "primes.incl.a68" PR
   []BOOLprime = PRIMESIEVE 18;  # note: PRIMESIEVE includes 0 in the sieve #
   INT s count := 0;
   FOR n FROM 101 TO 499 DO
       INT v := n;
       INT d1 = v MOD 10; v OVERAB 10;
       INT d2 = v MOD 10; v OVERAB 10;
       INT d3 = v;
       IF prime[ d1 + d2 ] AND prime[ d2 + d3 ] THEN
           print( ( " ", whole( n, -3 ) ) );
           IF ( s count +:= 1 ) MOD 10 = 0 THEN print( ( newline ) ) FI
       FI
   OD

END</lang>

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

APL

Works with: Dyalog APL

<lang APL>(∧⌿ 2 3 5 7 11 13 17 ∊⍨ 2 +⌿ 10 (⊥⍣¯1) X)/X←100+⍳399</lang>

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

<lang applescript>------------------- 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</lang>

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

<lang AWK>

  1. 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)

} </lang>

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

Generalized solution: a number is strange iff the sum of two consecutive digits is always prime. Numbers < 10 are considered non-strange.

<lang c>#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;

}</lang>

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

C++

Translation of: Java

<lang cpp>#include <iostream>

  1. include <vector>

const std::vector<bool> p{ 

   false, false, true,  true,  false,
   true,  false, true,  false, false,
   false, true,  false, true,  false,
   false, false, true,  false

};

bool isStrange(long n) { 

   if (n < 10) {
       return false;
   }
   for (; n >= 10; n /= 10) {
       if (!p[n % 10 + (n / 10) % 10]) {
           return false;
       }
   }
   return true;

}

void test(int nMin, int nMax) { 

   int k = 0;

   for (long n = nMin; n <= nMax;n++) {
       if (isStrange(n)) {
           std::cout << n;
           if (++k % 10 != 0) {
               std::cout << ' ';
           } else {
               std::cout << '\n';
           }
       }
   }

}

int main() { 

   test(101, 499);
   return 0;

}</lang>

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

CLU

<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
       if n=p then return(true) end
   end
   return(false)

end small_prime

strange_plus = proc (n: int) returns (bool) 

   while n >= 10 do
       d1: int := n // 10
       n := n / 10
       d2: int := n // 10
       if ~small_prime(d1 + d2) then return(false) end
   end
   return(true)

end strange_plus

start_up = proc () 

   po: stream := stream$primary_input()
   col: int := 0
   for i: int in int$from_to(100,500) do
       if strange_plus(i) then
           stream$putright(po, int$unparse(i), 4)
           col := col + 1
           if col // 10 = 0 then stream$putl(po, "") end
       end
   end

end start_up</lang>

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

COBOL

<lang cobol> IDENTIFICATION DIVISION. 

      PROGRAM-ID. STRANGE-PLUS-NUMBERS.

      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01 VARIABLES.
         03 CANDIDATE            PIC 999.
         03 DIGITS               REDEFINES CANDIDATE,
                                 PIC 9 OCCURS 3 TIMES.
         03 LEFT-PAIR            PIC 99.
            88 LEFT-PAIR-PRIME   VALUES 2, 3, 5, 7, 11, 13, 17.
         03 RIGHT-PAIR           PIC 99. 
            88 RIGHT-PAIR-PRIME  VALUES 2, 3, 5, 7, 11, 13, 17.
      01 OUT.
         03 ROW                  PIC X(40) VALUE SPACES.
         03 PTR                  PIC 99 VALUE 1.
      
      PROCEDURE DIVISION. 
      BEGIN. 
          PERFORM CHECK-STRANGE-NUMBER
          VARYING CANDIDATE FROM 100 BY 1
          UNTIL CANDIDATE IS GREATER THAN 500.
          DISPLAY ROW.
          STOP RUN.

      CHECK-STRANGE-NUMBER. 
          ADD DIGITS(1), DIGITS(2) GIVING LEFT-PAIR.
          ADD DIGITS(2), DIGITS(3) GIVING RIGHT-PAIR. 
          IF LEFT-PAIR-PRIME AND RIGHT-PAIR-PRIME,
              PERFORM WRITE-STRANGE-NUMBER.

      WRITE-STRANGE-NUMBER.
          STRING CANDIDATE DELIMITED BY SIZE INTO ROW
          WITH POINTER PTR.
          ADD 1 TO PTR.
          IF PTR IS GREATER THAN 40,
              DISPLAY ROW,
              MOVE SPACES TO ROW,
              MOVE 1 TO PTR.</lang>
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

Library: System.SysUtils
Translation of: Go

<lang Delphi> 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.</lang>

Draco

<lang draco>proc small_prime(word n) bool: 

   word primes = 0x8A2B;
   n>=2 and primes >> (n-2) & 1 = 1

corp

proc strange_plus(word n) bool: 

   word dl, dr;
   bool pair_prime;
   dl := n % 10;
   while
       dr := dl;
       n := n / 10;
       dl := n % 10;
       pair_prime := small_prime(dl + dr);
       pair_prime and n >= 10
   do od;
   pair_prime and n < 10

corp

proc main() void: 

   byte col;
   word cand;
   col := 0;
   for cand from 101 upto 499 do
       if strange_plus(cand) then
           write(cand:4);
           col := col + 1;
           if col = 10 then writeln(); col := 0 fi
       fi
   od

corp</lang>

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

F#

This task uses Extensible Prime Generator (F#).
<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 "" </lang>

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

Works with: Factor version 0.99 2021-02-05

<lang factor>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</lang>

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

Translation of: C

<lang forth>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</lang>

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


FreeBASIC

Translation of: AWK

<lang freebasic> Function isPrime(valor As Integer) As Boolean 

   If valor <= 1 Then Return False
   For i As Integer = 2 To Int(Sqr(valor))
       If valor Mod i = 0 Then Return False
   Next i
   Return True

End Function

Dim As Integer k = 0 Print !"Los n£meros m s extra¤os son:\n" For m As Integer = 100 To 500 

   Dim As Integer num1, num2, num3
   num1 = Val(Mid(Str(m), 1, 1))
   num2 = Val(Mid(Str(m), 2, 1))
   num3 = Val(Mid(Str(m), 3, 1))
   
   If isPrime(num1 + num2) And isPrime(num2 + num3) Then 
       Print Using "####"; m;
       k += 1
       If k Mod 10 = 0 Then Print
   End If

Next m Print !"\n\n"; k; " n£meros m s extra¤os encontrados." Sleep </lang>

Output:
Los números más extraños son:

 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 números más extraños encontrados.

Fōrmulæ

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 —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its 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.

In this page you can see the program(s) related to this task and their results.

Go

Translation of: Wren

<lang go>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)

}</lang>

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

<lang haskell>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))
       ]</lang>
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

<lang java>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"));
           }
       }
   }

}</lang>

<lang>java Strange 101 499</lang>

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

jq

Works with: jq

Works with gojq, the Go implementation of jq

See e.g. Erdős-primes#jq for a suitable implementation of `is_prime`. <lang jq>def nwise($n): 

 def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
 n;

def is_strange: 

 def sum($i): (.[$i:$i+1]|tonumber) + (.[$i+1:$i+2]|tonumber);
 tostring
 | length > 2 and (sum(0) | is_prime) and  (sum(1) | is_prime) ;

def task: 

 [range(101; 500)
  | select(is_strange)]
 | nwise(10)
 | join(" ");

task</lang>

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

<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])])
   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

</lang>

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

Translation of: Java

<lang scala>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)

}</lang>

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

<lang maple>select(n->(u->isprime(add(u[1..2])) and isprime(add(u[2..3])))(convert(n,base,10)),[$101..499]);</lang>

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]

Mathematica/Wolfram Language

<lang Mathematica>Select[Range[101, 499], PrimeQ[Total[IntegerDigits[#];; 2]] && PrimeQ[Total[IntegerDigits[#]2 ;;]] &] Length[%]</lang>

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}
65

Nim

<lang Nim>const Primes = {2, 3, 5, 7, 11, 13, 17}

proc digits(n: 100..999): array[3, int] = 

 [n div 100, n div 10 mod 10, n mod 10]

var count = 0 for n in 101..<500: 

 let d = n.digits
 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: ' '</lang>
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

Library: ntheory

<lang perl>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;</lang>
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

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]
        string pn = part&di+'0'
        if left=1 then
            res = append(res,pn)
        else
            res = strange_plus(left-1,nxts[di+1],res,pn)
        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

Using sympy.isprime

<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

>>> [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] >>> </lang>


Or, as we may not need to wake up sympy just to check membership of {2, 3, 5, 7, 11, 13, 17}:

<lang python>Strange Plus Numbers


  1. 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:]))


  1. ------------------- TEST AND DISPLAY -------------------
  2. 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)
       )
   )


  1. ----------------------- GENERIC ------------------------
  1. 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


  1. digits :: Int -> [Int]

def digits(n): 

   Component digits of a decimal number.
   return [int(c) for c in str(n)]


  1. MAIN ---

if __name__ == '__main__': 

   main()</lang>
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

<lang perl6>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 } };</lang>
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

<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.*/ 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)*/

  1. = 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($)</lang>

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

<lang ring> 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 </lang>

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

Translation of: Kotlin

<lang ruby>$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)</lang>

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

Seed7

<lang seed7>$ include "seed7_05.s7i";

const func boolean: prime (in integer: number) is 

 return number in {2, 3, 5, 7, 11, 13, 17};

const func boolean: strange (in var integer: number) is func 

 result
   var boolean: strange is TRUE;
 begin
   while number > 9 and strange do
     if not prime(number rem 10 + number div 10 rem 10) then
       strange := FALSE;
     end if;
     number := number div 10;
   end while;
 end func;

const proc: main is func 

 local
   var integer: n is 0;
   var integer: count is 0;
 begin
   for n range 101 to 499 do
     if strange(n) then
       write(n <& " ");
       incr(count);
       if count rem 13 = 0 then
         writeln;
       end if;
     end if;
   end for;
 end func;</lang>
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

Sidef

<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 }</lang>

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

Vlang

Translation of: Go

<lang vlang>fn is_prime(n int) bool { 

   return n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 || n == 17

}

fn main() { 

   mut count := 0
   mut d := []int{}
   println("Strange plus numbers in the open interval (100, 500) are:\n")
   for i := 101; i < 500; i++ {
       d = d[..0]
       mut j := i
       for j > 0 {
           d << j%10
           j /= 10
       }
       if is_prime(d[0]+d[1]) && is_prime(d[1]+d[2]) {
           print("$i ")
           count++
           if count%10 == 0 {
               println()
           }
       }
   }
   if count%10 != 0 {
       println()
   }
   println("\n$count strange plus numbers in all.")

}</lang>

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.

Wren

Simple brute force is adequate for this. <lang ecmascript>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.")</lang>

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

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.

<lang> 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</lang>

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

XPL0

<lang XPL0>func StrangePlus(N); int N, A, B, S; [N:= N/10; A:= rem(0); loop [N:= N/10; 

       B:= rem(0);
       S:= A+B;
       if S#2 & S#3 & S#5 & S#7 & S#11 & S#13 & S#17 then return false;
       if N = 0 then return true;
       A:= B];

];

int Cnt, N; [Cnt:= 0; for N:= 100 to 500-1 do 

   if StrangePlus(N) then
       [Cnt:= Cnt+1;
       IntOut(0, N);
       if rem(Cnt/20) = 0 then CrLf(0) else ChOut(0, ^ )];

]</lang>

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
Retrieved from "https://rosettacode.org/wiki/Strange_plus_numbers?oldid=308457"