Strange numbers: Difference between revisions

Line 16:

<~~lang~~ 11l>F is_strange(n)

<syntaxhighlight lang="11l">F is_strange(n)

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

Line 26:

print(el, end' ‘ ’)

I L.index % 10 == 9

print()</~~lang~~>

print()</syntaxhighlight>

Line 47:

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>BYTE Func IsStrangeNumber(INT i)

<syntaxhighlight lang="action!">BYTE Func IsStrangeNumber(INT i)

BYTE ARRAY primes=[0 0 1 1 0 1 0 1 0 0]

BYTE d,diff,prev

Line 81:

OD

PrintF("%E%EThere are %I strange numbers",count)

RETURN</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strange_numbers.png Screenshot from Atari 8-bit computer]

Line 94:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_IO; use Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;

procedure Strange_Numbers is

Line 134:

end loop;

Put_Line ("Strange numbers in range 1_000_000_000 .. 1_999_999_999: " & Count'Image);

end Strange_Numbers;</~~lang~~>

end Strange_Numbers;</syntaxhighlight>

<pre>

Line 152:

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

<~~lang~~ algolw>begin % find "strange numbers" - numbers where digits differ from the next %

<syntaxhighlight lang="algolw">begin % find "strange numbers" - numbers where digits differ from the next %

% by a prime %

% returns true if n is strange, false otherwise %

Line 190:

end for_n

end

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 201:

=={{header|APL}}==

<~~lang~~ ~~APL~~>(⊢(/⍨)(∧/2 3 5 7∊⍨2+/⍎¨∘⍕)¨) 100+⍳400</~~lang~~>

<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

Line 207:

=={{header|AppleScript}}==

<~~lang~~ ~~AppleScript~~>--------------------- STRANGE NUMBERS --------------------

<syntaxhighlight lang="applescript">--------------------- STRANGE NUMBERS --------------------

-- isStrange :: Int -> Bool

Line 418:

end tell

end if

end zipWith</~~lang~~>

end zipWith</syntaxhighlight>

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

Line 437:

=={{header|AWK}}==

# syntax: GAWK -f STRANGE_NUMBERS.AWK

BEGIN {

Line 469:

}

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

</syntaxhighlight>

</lang>

<pre>

Line 485:

=={{header|BASIC}}==

<~~lang~~ basic>10 DEFINT I,J,K: DEFSTR S

<syntaxhighlight lang="basic">10 DEFINT I,J,K: DEFSTR S

20 FOR I=100 TO 500

30 S=STR$(I)

Line 493:

70 NEXT J

80 PRINT I,

90 NEXT I</~~lang~~>

90 NEXT I</syntaxhighlight>

<pre> 130 131 135 136 138

Line 514:

496 497</pre>

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

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

Line 530:

$)

wrch('*N')

$)</~~lang~~>

$)</syntaxhighlight>

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

Line 543:

=={{header|BQN}}==

<~~lang~~ bqn>↑‿10⥊((∧´(|¯1↓«-⊢)∊⟨2,3,5,7⟩˙)○•Fmt)¨⊸/100+↕400</~~lang~~>

The unused positions in the table are filled with <code>0</code>s, because that's the behaviour

Line 562:

=={{header|C}}==

<~~lang~~ c>#include <stdbool.h>

<syntaxhighlight lang="c">#include <stdbool.h>

#include <stdio.h>

Line 600:

return 0;

}</~~lang~~>

}</syntaxhighlight>

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

Line 616:

===Extended task===

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

const int next_digit[] = {

Line 655:

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre>% ./a.out | fmt

Line 669:

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

<~~lang~~ cpp>#include <algorithm>

<syntaxhighlight lang="cpp">#include <algorithm>

#include <iostream>

#include <vector>

Line 720:

return 0;

}</~~lang~~>

}</syntaxhighlight>

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

Line 736:

=={{header|CLU}}==

<~~lang~~ clu>digits = iter (n: int) yields (int)

<syntaxhighlight lang="clu">digits = iter (n: int) yields (int)

while n>0 do

yield(n // 10)

Line 771:

end

end start_up</~~lang~~>

end start_up</syntaxhighlight>

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

Line 784:

=={{header|COBOL}}==

<~~lang~~ cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. STRANGE-NUMBERS.

Line 819:

MOVE NUM TO N-OUT.

DISPLAY N-OUT.

DONE. EXIT.</~~lang~~>

DONE. EXIT.</syntaxhighlight>

<pre style='height:50ex;'>130

Line 910:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub abs(n: int8): (r: uint8) is

Line 945:

n := n + 1;

end loop;

print_nl();</~~lang~~>

print_nl();</syntaxhighlight>

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

Line 958:

=={{header|Draco}}==

<~~lang~~ draco>proc nonrec strange(word n) bool:

<syntaxhighlight lang="draco">proc nonrec strange(word n) bool:

bool is_strange;

short da, db, diff;

Line 986:

fi

od

corp</~~lang~~>

corp</syntaxhighlight>

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

Line 999:

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

<~~lang~~ fsharp>

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

</syntaxhighlight>

</lang>

<pre>

Line 1,012:

===Identifying and filtering===

<~~lang~~ factor>USING: grouping io kernel math.ranges math.statistics

<syntaxhighlight lang="factor">USING: grouping io kernel math.ranges math.statistics

math.text.utils math.vectors prettyprint sequences ;

Line 1,022:

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

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

length pprint " strange numbers found." print</~~lang~~>

length pprint " strange numbers found." print</syntaxhighlight>

<pre>

Line 1,043:

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

<~~lang~~ factor>USING: backtrack compiler.tree.propagation.call-effect

<syntaxhighlight lang="factor">USING: backtrack compiler.tree.propagation.call-effect

formatting io kernel sequences sequences.generalizations

tools.memory.private tools.time ;

Line 1,065:

dup length commas write

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

[ first2 ] [ last2 ] bi "%u\n%u\n...\n%u\n%u\n" printf</~~lang~~>

[ first2 ] [ last2 ] bi "%u\n%u\n...\n%u\n%u\n" printf</syntaxhighlight>

<pre>

Line 1,079:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>function is_strange( n as ulongint ) as boolean

<syntaxhighlight lang="freebasic">function is_strange( n as ulongint ) as boolean

dim as uinteger d, ld, a

if n<10 then return true 'arbitrary, but makes the recursion easier

Line 1,098:

if is_strange(n) then c+=1

next n

print using "There are ####### 10-digit strange numbers beginning with 1.";c</~~lang~~>

print using "There are ####### 10-digit strange numbers beginning with 1.";c</syntaxhighlight>

{{out}}<pre>

Strange numbers between 100 and 500

Line 1,106:

=={{header|Forth}}==

<~~lang~~ forth>\ tests whether n is prime for 0 <= n < 10

<syntaxhighlight lang="forth">\ tests whether n is prime for 0 <= n < 10

: prime? ( n -- ? )

1 swap lshift 0xac and 0<> ;

Line 1,136:

main

bye</~~lang~~>

bye</syntaxhighlight>

Line 1,154:

===Basic task===

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 1,188:

}

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

}</~~lang~~>

}</syntaxhighlight>

Line 1,209:

===Stretch goal===

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 1,239:

}

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

}</~~lang~~>

}</syntaxhighlight>

Line 1,247:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.List (intercalate)

<syntaxhighlight lang="haskell">import Data.List (intercalate)

import Data.List.Split (chunksOf)

Line 1,270:

unlines

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

]</~~lang~~>

]</syntaxhighlight>

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

Line 1,290:

=={{header|J}}==

<~~lang~~ J>isStrange=: ([: */ 2 3 5 7 e.&:|~ 2 -/\ 10 #.inv ])"0

<syntaxhighlight lang="j">isStrange=: ([: */ 2 3 5 7 e.&:|~ 2 -/\ 10 #.inv ])"0

strangePair=: (1 p: ::0:"0 i.10),. 0 1}.isStrange (+ 10&*)"0/~ i.10</~~lang~~>

strangePair=: (1 p: ::0:"0 i.10),. 0 1}.isStrange (+ 10&*)"0/~ i.10</syntaxhighlight>

To test if a number is strange, we check if the absolute value of the differences of adjacent pairs of digits are 2, 3, 5 or 7.

Line 1,300:

Task examples:

<~~lang~~ J> (#~ 100&<:) I. isStrange i.500

<syntaxhighlight lang="j"> (#~ 100&<:) I. isStrange i.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 253 257 258 270 272 274 275 279 292 294 296 297 302 303 305 307 313 314 316 318 350 352 353 357 358 361 363 364 368 369 381 383 385 386 ...

#{{ ;<@{{x,"1 0 I. ({:x){y }}&strangePair"1 y}}^:9 ,:1

853423</~~lang~~>

853423</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ ~~Java~~>import java.util.LinkedList;

<syntaxhighlight lang="java">import java.util.LinkedList;

import java.util.List;

import java.util.function.BiPredicate;

Line 1,359:

}

}</~~lang~~>

}</syntaxhighlight>

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

Line 1,379:

===Filter method===

def is_strange:

def digits: tostring | explode | map([.] | implode | tonumber);

Line 1,401:

task(100; 500; is_strange)

</syntaxhighlight>

</lang>

<pre>

Line 1,420:

===Generator method===

`lpad` and and `nwise` are as above and so their definitions are not repeated.

# input: width

# $start: maximum first digit allowed e.g. 9 for unrestricted

Line 1,442:

[3 | generate(4) | map(tostring) | join("") | tonumber]

| nwise(10) | map(lpad(3)) | join(" ")

</syntaxhighlight>

</lang>

As above, except for the header.

===Stretch goal===

Using generate/1 as already defined:

def count(s): reduce s as $x (null; .+1);

count(10 | generate(1))

</~~lang~~>

</syntaxhighlight>

Line 1,459:

=={{header|Julia}}==

===Filter method===

<~~lang~~ julia>isstrange(n::Integer) = (d = digits(n); all(i -> abs(d[i] - d[i + 1]) ∈ [2, 3, 5, 7], 1:length(d)-1))

<syntaxhighlight lang="julia">isstrange(n::Integer) = (d = digits(n); all(i -> abs(d[i] - d[i + 1]) ∈ [2, 3, 5, 7], 1:length(d)-1))

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

Line 1,475:

filter_open_interval(100, 500, isstrange)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

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

Line 1,488:

===Generator method===

HT: Factor for the table.

<~~lang~~ julia>function countstrange(places, fixedstart=1)

<syntaxhighlight lang="julia">function countstrange(places, fixedstart=1)

possibles = [

[2, 3, 5, 7],

Line 1,514:

countstrange(10)

@time countstrange(10)

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

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

Line 1,524:

=={{header|Kotlin}}==

<~~lang~~ scala>import kotlin.math.abs

<syntaxhighlight lang="scala">import kotlin.math.abs

fun digits(n: Int): List<Int> {

Line 1,568:

}

println()

}</~~lang~~>

}</syntaxhighlight>

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

Line 1,584:

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

INTERNAL FUNCTION(D)

Line 1,617:

VECTOR VALUES F = $I4*$

END OF PROGRAM </~~lang~~>

END OF PROGRAM </syntaxhighlight>

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

Line 1,709:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Select[Range[101, 499],

AllTrue[Partition[IntegerDigits[#], 2, 1], Differences /* First /* PrimeQ] &

]</~~lang~~>

]</syntaxhighlight>

=={{header|Modula-2}}==

<~~lang~~ modula2>MODULE StrangeNumbers;

<syntaxhighlight lang="modula2">MODULE StrangeNumbers;

FROM InOut IMPORT WriteCard, WriteLn;

Line 1,750:

END;

WriteLn

END StrangeNumbers.</~~lang~~>

END StrangeNumbers.</syntaxhighlight>

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

Line 1,765:

Our program finds the strange numbers with a given number of digits. Filtering is done afterwards. It consumes a lot of memory but is able to find the result in less than a second on our small laptop.

<~~lang~~ ~~Nim~~>import algorithm, sequtils

<syntaxhighlight lang="nim">import algorithm, sequtils

const PrimeDigits = [2, 3, 5, 7]

Line 1,802:

result = findStrangeNumbers(10).filterIt(it div 1_000_000_000 == 1)

echo "\nFound ", result.len, " strange numbers with 10 digits and starting with 1."</~~lang~~>

echo "\nFound ", result.len, " strange numbers with 10 digits and starting with 1."</syntaxhighlight>

Line 1,819:

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

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

<~~lang~~ pascal>program strangenumbers;

<syntaxhighlight lang="pascal">program strangenumbers;

const

Line 1,905:

Writeln;

Writeln('Count : ',cnt);

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 1,923:

=={{header|Perl}}==

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 1,937:

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

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

(sprintf "@{['%5d' x $cnt]}", @strange[0..$cnt-1]) =~ s/(.{80})/$1\n/gr;</~~lang~~>

(sprintf "@{['%5d' x $cnt]}", @strange[0..$cnt-1]) =~ s/(.{80})/$1\n/gr;</syntaxhighlight>

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

Line 1,948:

=={{header|Phix}}==

constant diff = {-7,-5,-3,-2,2,3,5,7},

poss = apply(true,sq_add,{tagset(9,0),{diff}}),

Line 1,970:

sequence res = strange(3,tagset(4)) -- (3 digit numbers beginning 1..4)

printf(1,"%d strange numbers found: %s\n",{length(res),join(shorten(res,"",5),",")})

<pre>

Line 1,977:

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

constant diff = {-7,-5,-3,-2,2,3,5,7},

poss = apply(true,sq_add,{tagset(9,0),{diff}}),

Line 2,011:

printf(1,"(%s)\n",elapsed(time()-t0))

<pre>

Line 2,048:

=={{header|PL/I}}==

<~~lang~~ pli>strangeNumbers: procedure options(main);

<syntaxhighlight lang="pli">strangeNumbers: procedure options(main);

strange: procedure(nn) returns(bit);

declare (n, nn) fixed;

Line 2,076:

end;

end strangeNumbers;</~~lang~~>

end strangeNumbers;</syntaxhighlight>

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

Line 2,089:

=={{header|PL/M}}==

<~~lang~~ pli>100H:

<syntaxhighlight lang="pli">100H:

BDOS: PROCEDURE (F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; GO TO 0; END EXIT;

Line 2,134:

END;

CALL EXIT;

EOF</~~lang~~>

EOF</syntaxhighlight>

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

Line 2,147:

=={{header|Python}}==

<~~lang~~ python>'''Strange Numbers'''

<syntaxhighlight lang="python">'''Strange Numbers'''

Line 2,205:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

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

Line 2,222:

=={{header|Raku}}==

<lang ~~perl6~~>sub infix:<′>(\x,\y) { abs(x - y) ∈ (2, 3, 5, 7) }

<syntaxhighlight lang="raku" line>sub infix:<′>(\x,\y) { abs(x - y) ∈ (2, 3, 5, 7) }

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

Line 2,228:

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

print @strange.batch(20)».fmt("%4d").join: "\n";</~~lang~~>

print @strange.batch(20)».fmt("%4d").join: "\n";</syntaxhighlight>

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

Line 2,241:

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

as well as parsing of a number to determine the differences.

<~~lang~~ rexx>/*REXX pgm lists strange integers (within a range) whose decimal digs differ by a prime.*/

<syntaxhighlight lang="rexx">/*REXX pgm lists strange integers (within a range) whose decimal digs differ by a prime.*/

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

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

Line 2,274:

exit 0

/*──────────────────────────────────────────────────────────────────────────────────────*/

commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _</~~lang~~>

commas: parse arg _; do jc=length(_)-3 to 1 by -3; _=insert(',', _, jc); end; return _</syntaxhighlight>

<pre>

Line 2,290:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

Line 2,316:

ok

</syntaxhighlight>

</lang>

<pre>

Line 2,333:

=={{header|Ruby}}==

<~~lang~~ ruby>def digits(n)

<syntaxhighlight lang="ruby">def digits(n)

result = []

while n > 0

Line 2,370:

xs.each_slice(10) do |s|

print s, "\n"

end</~~lang~~>

end</syntaxhighlight>

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

Line 2,386:

=={{header|Sidef}}==

<~~lang~~ ruby>func generate_from_prefix(limit, p, base) {

<syntaxhighlight lang="ruby">func generate_from_prefix(limit, p, base) {

var seq = [p]

Line 2,413:

strange_numbers(500).grep { _ > 100 }.slices(10).each{

.join(' ').say

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 2,430:

===Basic task===

<~~lang~~ vlang>fn is_prime(nn int) bool {

<syntaxhighlight lang="vlang">fn is_prime(nn int) bool {

mut n := nn

if n < 0 {

Line 2,461:

}

println("\n$count strange numbers in all.")

}</~~lang~~>

}</syntaxhighlight>

Line 2,482:

=={{header|Wren}}==

===Basic task===

<~~lang~~ ecmascript>var primes = [2, 3, 5, 7]

<syntaxhighlight lang="ecmascript">var primes = [2, 3, 5, 7]

var count = 0

var d = []

Line 2,500:

}

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

System.print("\n%(count) strange numbers in all.")</~~lang~~>

System.print("\n%(count) strange numbers in all.")</syntaxhighlight>

Line 2,523:

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

Runtime about 0.085 seconds which is quick for Wren.

<~~lang~~ ecmascript>var diffs = [-7, -5, -3, -2, 2, 3, 5, 7]

<syntaxhighlight lang="ecmascript">var diffs = [-7, -5, -3, -2, 2, 3, 5, 7]

var possibles = List.filled(10, null)

for (i in 0..9) {

Line 2,544:

}

System.print("Found %(strangeOnes.count) %(places)-digit strange numbers beginning with %(start).")</~~lang~~>

System.print("Found %(strangeOnes.count) %(places)-digit strange numbers beginning with %(start).")</syntaxhighlight>

Line 2,553:

=={{header|XPL0}}==

Takes 49 seconds on Raspberry Pi 4.

<~~lang~~ ~~XPL0~~>func Strange(N);

<syntaxhighlight lang="xpl0">func Strange(N);

int N, A, B, D;

[N:= N/10;

Line 2,580:

Cnt:= Cnt+1;

IntOut(0, Cnt);

]</~~lang~~>

]</syntaxhighlight>