Strange numbers: Difference between revisions

{{draft task|Prime Numbers}}

 

Show all strange numbers for &nbsp; 100 &nbsp; < &nbsp; '''n''' &nbsp; < &nbsp; 500

 

;Stretch goal

{{trans|Python}}

 

V xs = String(n).map(c -> Int(c))

R all(zip(xs, xs[1..]).map((a, b) -> abs(a - b) C (2, 3, 5, 7)))

print(el, end' ‘ ’)

I L.index % 10 == 9

 

{{out}}

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497

</pre>

 

=={{header|ALGOL W}}==

% by a prime %

% returns true if n is strange, false otherwise %

logical procedure isStrange( integer value n ) ;

begin

rest := abs( n );

end isStrange ;

begin

integer strangeCount;

strangeCount := 0;

if isStrange( n ) then begin

strangeCount := strangeCount + 1;

end for_n

end

{{out}}

<pre>

 

=={{header|APL}}==

{{out}}

<pre>111 112 114 116 120 121 123 125 141 143 161 202 203 205 207 211 212 214 216 230 232 234 250 252 302 303 305 307 320 321

 

=={{header|AppleScript}}==

 

-- isStrange :: Int -> Bool

end tell

end if

{{Out}}

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

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f STRANGE_NUMBERS.AWK

BEGIN {

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

 

=={{header|BASIC}}==

{{out}}

<pre> 130 131 135 136 138

474 475 479 492 494

496 497</pre>

=={{header|BCPL}}==

 

let dgtprime(x) = x=2 | x=3 | x=5 | x=7

$)

wrch('*N')

{{out}}

<pre> 130 131 135 136 138 141 142 146 147 149

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497</pre>

 

=={{header|C}}==

{{trans|Go}}

#include <stdio.h>

 

 

return 0;

{{out}}

<pre>Strange numbers in the open interval (100, 500) are:

 

87 strange numbers in all.</pre>

 

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

{{trans|Java}}

#include <iostream>

#include <vector>

 

return 0;

{{out}}

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

 

130 131 135 136 138 141 142 146 147 149

161 163 164 168 169 181 183 185 186 202

203 205 207 241 242 246 247 249 250 252

 

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

// Strange numbers. Nigel Galloway: February 25th., 2021

let N=Array.init 10(fun n->[2;3;5;7]|>List.collect(fun g->[n+g;n-g])|>List.filter((<) -1)|>List.filter((>)10))

[1..4]|>List.collect(fun g->N.[g]|>List.map(fun n->g*10+n%10))|>List.collect(fun n->N.[n%10]|>List.map(fun g->n*10+g%10))|>List.iter(printf "%d "); printfn ""

{{out}}

<pre>

===Identifying and filtering===

{{works with|Factor|0.99 2020-08-14}}

math.text.utils math.vectors prettyprint sequences ;

 

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

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

{{out}}

<pre>

Since we know the next possible digits based on the current last digit, we can construct strange numbers with a backtracking algorithm.

{{works with|Factor|0.99 2020-08-14}}

formatting io kernel sequences sequences.generalizations

tools.memory.private tools.time ;

dup length commas write

" 10-digit strange numbers beginning with 1:" print

{{out}}

<pre>

{ 1 8 6 9 7 9 7 9 7 9 }

</pre>

 

=={{header|Forth}}==

: prime? ( n -- ? )

1 swap lshift 0xac and 0<> ;

 

main

 

{{out}}

===Basic task===

{{trans|Wren}}

 

import "fmt"

}

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

 

{{out}}

===Stretch goal===

{{trans|Julia}}

 

import "fmt"

}

fmt.Println("Found", len(strangeOnes), places, "\b-digit strange numbers beginning with", start)

 

{{out}}

 

=={{header|Haskell}}==

import Data.List.Split (chunksOf)

 

unlines

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

{{Out}}

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

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497</pre>

 

=={{header|Java}}==

{{trans|Python}}

import java.util.List;

import java.util.function.BiPredicate;

}

}

{{out}}

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

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497 </pre>

 

=={{header|Julia}}==

===Filter method===

 

function filter_open_interval(start, stop, f, doprint=true, rowlength=92)

 

filter_open_interval(100, 500, isstrange)

<pre>

Finding numbers matching isstrange for open interval (100, 500):

===Generator method===

HT: Factor for the table.

possibles = [

[2, 3, 5, 7],

countstrange(10)

@time countstrange(10)

<pre>

Found 853423 10-digit strange numbers with the most significant digit 1.

0.014545 seconds (139 allocations: 13.298 MiB, 29.39% gc time)

</pre>

 

=={{header|MAD}}==

INTERNAL FUNCTION(D)

 

VECTOR VALUES F = $I4*$

{{out}}

<pre style='height:50ex;'>STRANGE NUMBERS

496

497</pre>

 

=={{header|Pascal}}==

Not dynamically memorizing of all numbers saves much time 200ms -> 4ms.<BR>

Count is about 4.6 to the power of Digitscount -> first digit 1 followed by 9 digit -> 4.6^9 = 922190

 

const

Writeln;

Writeln('Count : ',cnt);

{{out}}

<pre>

 

=={{header|Perl}}==

use warnings;

use feature 'say';

my $cnt = my @strange = grep { is_strange($_) } $low+1 .. $high-1;

say "Between $low and $high there are $cnt strange numbers:\n" .

{{out}}

<pre>Between 100 and 500 there are 87 strange numbers:

 

=={{header|Phix}}==

{{out}}

<pre>

=== stretch goal ===

Dunno when to quit, me. As there does not appear to be much interest in which 1-digits are strange, I've shown three ways to set ones (output of 0, 10, or 4).

{{out}}

<pre>

(0.0s)

</pre>

 

=={{header|Python}}==

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497</pre>

 

=={{header|Raku}}==

 

my ($low,$high) = 100, 500;

 

say "Between $low and $high there are {+@strange} strange numbers:\n";

{{out}}

<pre>Between 100 and 500 there are 87 strange numbers:

Some optimization was added to bypass calculating the absolute value of adjacent decimal digit differences, &nbsp;

<br>as well as parsing of a number to determine the differences.

numeric digits 20 /*allow processing of larger numbers. */

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

commas(HI) ' (inclusive)'

say

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

ok

next

{{out}}

<pre>

425 427 429 461 463 464 468 469 470 472

474 475 479 492 494 496 497

</pre>

 

=={{header|Ruby}}==

{{trans|Java}}

result = []

while n > 0

xs.each_slice(10) do |s|

print s, "\n"

{{out}}

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

[425, 427, 429, 461, 463, 464, 468, 469, 470, 472]

[474, 475, 479, 492, 494, 496, 497]</pre>

 

=={{header|Wren}}==

===Basic task===

var count = 0

var d = []

}

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

 

{{out}}

... though I've generated the 'possibles' table rather than hard-code it.

Runtime about 0.085 seconds which is quick for Wren.

var possibles = List.filled(10, null)

for (i in 0..9) {

}

 

 

{{out}}

<pre>

Found 853423 10-digit strange numbers beginning with 1

</pre>