Strange plus numbers: Difference between revisions

 

Where &nbsp; &nbsp; 100 &nbsp; < &nbsp; '''n''' &nbsp; < &nbsp; 500

 

;Related task

{{trans|Python}}

 

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

print(el, end' ‘ ’)

I L.index % 10 == 9

 

{{out}}

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498

</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

{{out}}

 

=={{header|AppleScript}}==

 

-- isStrangePlus :: Int -> Bool

end tell

end if

{{Out}}

<pre>'Strange Plus' numbers found in range [100..500]

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

=={{header|AWK}}==

# syntax: GAWK -f STRANGE_PLUS_NUMBERS.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

</pre>

 

=={{header|C}}==

 

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

 

 

static int p[19] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0,

}

return 0;

 

{{out}}

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

=={{header|C++}}==

{{trans|Java}}

#include <vector>

 

test(101, 499);

return 0;

{{out}}

<pre>111 112 114 116 120 121 123 125 129 141

 

=={{header|Delphi}}==

{{Trans|Go}}

program Strange_plus_numbers;

 

writeln(#10, count, ' strange plus numbers in all.');

readln;

 

=={{header|F_Sharp|F#}}==

This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>

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

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

math.ranges math.text.utils prettyprint sequences ;

 

100 500 (a,b) [ strange+? ] filter dup

10 group [ [ pprint bl ] each nl ] each nl

{{out}}

<pre>

=={{header|Forth}}==

{{trans|C}}

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

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

 

main

 

{{out}}

=={{header|FreeBASIC}}==

{{trans|AWK}}

Function isPrime(valor As Integer) As Boolean

If valor <= 1 Then Return False

Print !"\n\n"; k; " n£meros m s extra¤os encontrados."

Sleep

{{out}}

<pre>

</pre>

 

 

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

}

fmt.Printf("\n%d strange plus numbers in all.\n", count)

 

{{out}}

 

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

 

unlines

(unwords <$> chunksOf 10 (show <$> xs))

{{Out}}

<pre>"Strange Plus" numbers found in range [100..500]

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

 

=={{header|Java}}==

 

private static final boolean[] p = {

false, false, true, true, false,

}

}

 

 

{{out}}

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

 

=={{header|Julia}}==

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

end

end

<pre>

111 112 114 116 120 121 123 125 129 141 143 147 149

=={{header|Kotlin}}==

{{trans|Java}}

false, false, true, true, false,

true, false, true, false, false,

fun main() {

test(101, 499)

{{out}}

<pre>111 112 114 116 120 121 123 125 129 141

474 476 492 494 498 </pre>

 

=={{header|Maple}}==

 

{{out}}

383, 385, 389, 411, 412, 414, 416, 430, 432, 434, 438, 470,

474, 476, 492, 494, 498]</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature 'say';

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

{{out}}

<pre>Between 100 and 500 there are 65 strange-plus numbers:

=={{header|Phix}}==

Using the same approach as [[Strange_numbers#Phix]], so this should similarly scale/count easily to the 28-digit range.

{{out}}

<pre>

65 strange_plus numbers found: 111,112,114,116,120,...,474,476,492,494,498

</pre>

 

=={{header|Python}}==

Using [https://docs.sympy.org/latest/modules/ntheory.html sympy.isprime]

 

Type "help", "copyright", "credits" or "license()" for more information.

>>> from sympy import isprime

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

 

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>"Strange Plus" numbers in range [100..500]

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

 

=={{header|Raku}}==

put +$_, " matching numbers from $start to $end:\n", $_ given

{{out}}

<pre>65 matching numbers from 100 to 500:

 

=={{header|REXX}}==

parse arg LO HI . /*obtain optional arguments from the CL*/

if LO=='' | LO=="," then LO= 101 /*Not specified? Then use the default.*/

say # ' strange plus numbers found between ' LO " and " HI ' (inclusive)'

say

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ring}}==

 

load "stdlib.ring"

 

ok

next

{{out}}

<pre>

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498

</pre>

 

=={{header|Ruby}}==

{{trans|Kotlin}}

false, false, true, true, false,

true, false, true, false, false,

end

 

{{out}}

<pre>111 112 114 116 120 121 123 125 129 141

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>

 

=={{header|Wren}}==

Simple brute force is adequate for this.

var count = 0

var d = []

}

if (count % 10 != 0) System.print()

 

{{out}}

A 16-bit solution for NASM under DOS. Assemble with <code>nasm -fbin strange.asm -o strange.com</code>. The prime sieve up to 18 is hard-coded.

 

 

mov cx, 10 ; cl is used for division, ch to count numbers printed on a line

 

p db 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0

 

{{out}}

389 411 412 414 416 430 432 434 438 470

474 476 492 494 498</pre>