I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Strange plus numbers

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

## 11l

Translation of: Python
`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
```

## ALGOL 68

Does not attempt to generalise beyond 3 digit numbers.

`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    ODEND`
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
`(∧⌿ 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

`------------------- STRANGE PLUS NUMBERS ----------------- -- isStrangePlus :: Int -> Boolon 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 falseend 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 ifend enumFromTo  -- intercalate :: String -> [String] -> Stringon 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    send 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 tellend 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 ifend 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 tellend map  -- min :: Ord a => a -> a -> aon min(x, y)    if y < x then        y    else        x    end ifend 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 ifend splitAt  -- str :: a -> Stringon str(x)    x as stringend str  -- unlines :: [String] -> Stringon 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    send unlines  -- unwords :: [String] -> Stringon 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 send 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 ifend 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

` # syntax: GAWK -f STRANGE_PLUS_NUMBERS.AWKBEGIN {    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

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

## C++

Translation of: Java
`#include <iostream>#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;}`
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

Translation of: Go
` 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#

This task uses Extensible Prime Generator (F#).

` // Strange numbers. Nigel Galloway: February 25th., 2021let 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

Works with: Factor version 0.99 2021-02-05
`USING: grouping grouping.extras io kernel math math.primesmath.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 nl100 500 (a,b) [ strange+? ] filter dup10 group [ [ pprint bl ] each nl ] each nllength 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

Translation of: C
`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 ; mainbye`
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
` 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 TrueEnd Function Dim As Integer k = 0Print !"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 mPrint !"\n\n"; k; " n£meros m s extra¤os encontrados."Sleep `
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

```

## 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.

## Go

Translation of: Wren
`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.
```

`import Data.List (intercalate)import Data.List.Split (chunksOf) ------------------- STRANGE PLUS NUMBERS ----------------- isStrangePlus :: Int -> BoolisStrangePlus 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

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

## 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`.

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

`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" : "  ")    endend `
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
`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

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

## Mathematica/Wolfram Language

`Select[Range[101, 499], PrimeQ[Total[IntegerDigits[#][[;; 2]]]] && PrimeQ[Total[IntegerDigits[#][[2 ;;]]]] &]Length[%]`
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

`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 = 0for 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: ' '`
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
`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

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

`Python 3.8.5 (default, Sep  3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)] on win32Type "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 -> Booldef 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

`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

`/*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)'saysay 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

` load "stdlib.ring" row = 0see "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     oknext `
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
`\$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 trueend 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    endend 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```

## 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;`
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

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

Simple brute force is adequate for this.

`var primes = [2, 3, 5, 7, 11, 13, 17]var count = 0var 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

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 indexL1      mov     ax, si        xor     bx, bx                  ; bx counts characters in the stringL2      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 10L5      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, 0k       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```