Rosetta Code

Numbers with same digit set in base 10 and base 16: Difference between revisions

Page Discussion

Numbers with same digit set in base 10 and base 16 (view source)

Revision as of 17:21, 7 January 2024

12,463 bytes added ,  4 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
(17 intermediate revisions by 9 users not shown)
Line 14:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">V col = 0
L(i) 100000
I Set(Array(String(i))) == Set(Array(hex(i)))
col++
print(‘#7’.format(i), end' "\n"[0 .< Int(col % 10 == 0)])
print()</langsyntaxhighlight>
 
{{out}}
Line 33:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
 
procedure Same_Digits is
Line 69:
New_Line;
Put ("Total numbers: "); Put (Count, Width => 3); New_Line;
end Same_Digits;</langsyntaxhighlight>
{{out}}
<pre>
Line 84:
=={{header|ALGOL W}}==
Generates the candidate numbers (ones that only have the digits 0-9 in their hexadecimal representation) to cut down the numbers to check.
<langsyntaxhighlight lang="algolw">begin % find numbers that use the same digits in decimal and hexadecimal %
integer hdCount, h20, h300, h4000, h50000;
logical array hex, dec ( 0 :: 9 );
Line 145:
, "representations use the same digits"
);
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 161:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(⊢(/⍨)(≡/((⊂∘⍋⌷⊢)∘∪¨10 16(⊥⍣¯1)¨⊂))¨)0,⍳99999</langsyntaxhighlight>
{{out}}
<pre>0 1 2 3 4 5 6 7 8 9 53 371 913 1040 2080 2339 4100 5141 5412 5441 6182
Line 171:
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.
use sorter : script "Insertion sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript>
 
Line 204:
if (sameDigitSetDecHex(n)) then set end of output to n
end repeat
return output</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 53, 371, 913, 1040, 2080, 2339, 4100, 5141, 5412, 5441, 6182, 8200, 9241, 13593, 13665, 13969, 16406, 20530, 26946, 30979, 32803, 33638, 33840, 33841, 33842, 33843, 33844, 33845, 33846, 33847, 33848, 33849, 34883, 37943, 38931, 38966, 38995, 66310, 71444, 71497, 71511, 75120, 75121, 75122, 75123, 75124, 75125, 75126, 75127, 75128, 75129, 75621, 86150, 88165, 91465, 91769, 96617, 98711, 99481}</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">valid?: function [n][
equal? sort unique digits n
sort unique digits.base:16 n
]
 
print select 0..100000 => valid?</langsyntaxhighlight>
 
{{out}}
Line 223:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f DECIMAL_-_HEXADECIMAL_NUMBERS.AWK
BEGIN {
Line 252:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 266:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#define LIMIT 100000
 
Line 283:
printf("\n");
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 294:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <iomanip>
#include <bitset>
Line 316:
std::cout << std::endl;
return 0;
}</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 327:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
const LIMIT := 100000;
Line 355:
i := i + 1;
end loop;
print_nl();</langsyntaxhighlight>
{{out}}
<pre>0 1 2 3 4 5 6 7 8 9
Line 366:
 
=={{header|Draco}}==
<langsyntaxhighlight lang="draco">proc nonrec digitset(ulong n; byte b) word:
word set;
set := 0;
Line 391:
od;
writeln()
corp</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 400:
71511 75120 75121 75122 75123 75124 75125 75126 75127 75128
75129 75621 86150 88165 91465 91769 96617 98711 99481</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function HasSameDigits1016(N: integer): boolean;
{Return true if base-10 string and base-16 string have same characters}
var S10,S16: string;
var I: integer;
begin
Result:=False;
{Get base-10 and -16 string}
S10:=IntToStr(N);
S16:=Format('%x',[N]);
{Compare S10 to S16}
for I:=1 to Length(S10) do
if Pos(S10[I],S16)=0 then exit;
{Compare S16 to S10}
for I:=1 to Length(S16) do
if Pos(S16[I],S10)=0 then exit;
Result:=True;
end;
 
 
procedure ShowSameDigits1016(Memo: TMemo);
var I,Cnt: integer;
var S: string;
begin
Cnt:=0;
for I:=0 to 100000-1 do
if HasSameDigits1016(I) then
begin
Inc(Cnt);
S:=S+Format('%8D',[I]);
If (Cnt mod 5)=0 then S:=S+CRLF;
end;
Memo.Lines.Add(S);
Memo.Lines.Add('Count='+IntToStr(Cnt));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
0 1 2 3 4
5 6 7 8 9
53 371 913 1040 2080
2339 4100 5141 5412 5441
6182 8200 9241 13593 13665
13969 16406 20530 26946 30979
32803 33638 33840 33841 33842
33843 33844 33845 33846 33847
33848 33849 34883 37943 38931
38966 38995 66310 71444 71497
71511 75120 75121 75122 75123
75124 75125 75126 75127 75128
75129 75621 86150 88165 91465
91769 96617 98711 99481
Count=69
Elapsed Time: 41.373 ms.
 
</pre>
 
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// Decimal-Hexdecimal: Nigel Galloway. June 7th., 2021
let rec fN g=function n when n<10->Some(Set.add n g)|n when n%16<10->fN(g.Add(n%16))(n/16) |_->None
let rec fG n g=match n/10,n%10 with (0,n)->Some(Set.add n g)|(n,i)->fG n (Set.add i g)
let g=Set.empty in seq{0..100000}|>Seq.filter(fun n->fN g n=fG n g)|>Seq.iter(printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 415 ⟶ 480:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting grouping io kernel math.parser present
sequences sets ;
 
100,000 <iota> [ dup present swap >hex set= ] filter
10 group [ [ "%5d " printf ] each nl ] each</langsyntaxhighlight>
{{out}}
<pre>
Line 432 ⟶ 497:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">function is_sds( byval n as integer ) as boolean
dim as boolean in_dec(0 to 9), in_hex(0 to 9)
dim as integer nd = n, dh
Line 459 ⟶ 524:
if c mod 10 = 0 then print
end if
next i</langsyntaxhighlight>
{{out}}<pre> 0 1 2 3 4 5 6 7 8 9
53 371 913 1040 2080 2339 4100 5141 5412 5441
Line 471 ⟶ 536:
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 515 ⟶ 580:
}
fmt.Printf("\n\n%d such numbers found.\n", count)
}</langsyntaxhighlight>
 
{{out}}
Line 527 ⟶ 592:
71,511 75,120 75,121 75,122 75,123 75,124 75,125 75,126 75,127 75,128
75,129 75,621 86,150 88,165 91,465 91,769 96,617 98,711 99,481
 
69 such numbers found.
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import qualified Data.Set as S
import Numeric (showHex)
 
---- NUMBERS WITH THE SAME DIGIT SET IN DECIMAL AND HEX --
 
sameDigitSet :: (Integral a, Show a) => a -> [(a, String)]
sameDigitSet n =
[ (n, h)
| let h = showHex n "",
S.fromList h == S.fromList (show n)
]
 
--------------------------- TEST -------------------------
main = do
print ("decimal", "hex")
mapM_ print $ [0 .. 100000] >>= sameDigitSet</syntaxhighlight>
{{Out}}
<pre>("decimal","hex")
(0,"0")
(1,"1")
(2,"2")
(3,"3")
(4,"4")
(5,"5")
(6,"6")
(7,"7")
(8,"8")
(9,"9")
(53,"35")
(371,"173")
(913,"391")
(1040,"410")
(2080,"820")
(2339,"923")
(4100,"1004")
(5141,"1415")
(5412,"1524")
(5441,"1541")
(6182,"1826")
(8200,"2008")
(9241,"2419")
(13593,"3519")
(13665,"3561")
(13969,"3691")
(16406,"4016")
(20530,"5032")
(26946,"6942")
(30979,"7903")
(32803,"8023")
(33638,"8366")
(33840,"8430")
(33841,"8431")
(33842,"8432")
(33843,"8433")
(33844,"8434")
(33845,"8435")
(33846,"8436")
(33847,"8437")
(33848,"8438")
(33849,"8439")
(34883,"8843")
(37943,"9437")
(38931,"9813")
(38966,"9836")
(38995,"9853")
(66310,"10306")
(71444,"11714")
(71497,"11749")
(71511,"11757")
(75120,"12570")
(75121,"12571")
(75122,"12572")
(75123,"12573")
(75124,"12574")
(75125,"12575")
(75126,"12576")
(75127,"12577")
(75128,"12578")
(75129,"12579")
(75621,"12765")
(86150,"15086")
(88165,"15865")
(91465,"16549")
(91769,"16679")
(96617,"17969")
(98711,"18197")
(99481,"18499")</pre>
 
=={{header|J}}==
 
Decimal numbers on left:<syntaxhighlight lang="j"> require'convert'
(":,.' ',.;@hfd"1),.I.(": -:&~.&(/:~) hfd)"0 i.1e5
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
53 35
371 173
913 391
1040 410
2080 820
2339 923
4100 1004
5141 1415
5412 1524
5441 1541
6182 1826
8200 2008
9241 2419
13593 3519
13665 3561
13969 3691
16406 4016
20530 5032
26946 6942
30979 7903
32803 8023
33638 8366
33840 8430
33841 8431
33842 8432
33843 8433
33844 8434
33845 8435
33846 8436
33847 8437
33848 8438
33849 8439
34883 8843
37943 9437
38931 9813
38966 9836
38995 9853
66310 10306
71444 11714
71497 11749
71511 11757
75120 12570
75121 12571
75122 12572
75123 12573
75124 12574
75125 12575
75126 12576
75127 12577
75128 12578
75129 12579
75621 12765
86150 15086
88165 15865
91465 16549
91769 16679
96617 17969
98711 18197
99481 18499</syntaxhighlight>
 
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">(() => {
"use strict";
 
const main = () => [
"(dec, hex)",
...enumFromTo(1)(100000).flatMap(n => {
const
d = n.toString(10),
h = n.toString(16);
 
return eqSet(new Set(d))(
new Set(h)
) ? [
`(${d}, ${h})`
] : [];
})
].join("\n");
 
 
// --------------------- GENERIC ---------------------
 
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = m =>
n => Array.from({
length: 1 + n - m
}, (_, i) => m + i);
 
 
// eqSet :: Set a -> Set a -> Bool
const eqSet = a =>
// True if the two sets have
// the same size and members.
b => a.size === b.size && (
Array.from(a).every(x => b.has(x))
);
 
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>(dec, hex)
(1, 1)
(2, 2)
(3, 3)
(4, 4)
(5, 5)
(6, 6)
(7, 7)
(8, 8)
(9, 9)
(53, 35)
(371, 173)
(913, 391)
(1040, 410)
(2080, 820)
(2339, 923)
(4100, 1004)
(5141, 1415)
(5412, 1524)
(5441, 1541)
(6182, 1826)
(8200, 2008)
(9241, 2419)
(13593, 3519)
(13665, 3561)
(13969, 3691)
(16406, 4016)
(20530, 5032)
(26946, 6942)
(30979, 7903)
(32803, 8023)
(33638, 8366)
(33840, 8430)
(33841, 8431)
(33842, 8432)
(33843, 8433)
(33844, 8434)
(33845, 8435)
(33846, 8436)
(33847, 8437)
(33848, 8438)
(33849, 8439)
(34883, 8843)
(37943, 9437)
(38931, 9813)
(38966, 9836)
(38995, 9853)
(66310, 10306)
(71444, 11714)
(71497, 11749)
(71511, 11757)
(75120, 12570)
(75121, 12571)
(75122, 12572)
(75123, 12573)
(75124, 12574)
(75125, 12575)
(75126, 12576)
(75127, 12577)
(75128, 12578)
(75129, 12579)
(75621, 12765)
(86150, 15086)
(88165, 15865)
(91465, 16549)
(91769, 16679)
(96617, 17969)
(98711, 18197)
(99481, 18499)</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq'''.
 
'''Also works with fq, a Go implementation of a large subset of jq'''
<syntaxhighlight lang=jq>
# The def of _nwise/1 is included here in case gojq or fq is used.
def _nwise($n):
def nw: if length <= $n then . else .[0:$n] , (.[$n:] | nw) end;
nw;
 
def chars: explode[] | [.] | implode;
 
# decimal number to hex string using lower-case letters
def hex:
def stream:
recurse(if . > 0 then ./16|floor else empty end) | . % 16 ;
if . == 0 then "0"
else [stream] | reverse | .[1:]
| map(if . < 10 then 48 + . else . + 87 end) | implode
end;
 
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
# Emit a stream of same-digit numbers, up to .
def sameDigitSettasktask:
def u: [tostring|chars] | unique;
range(0; .) | select((hex|u) == u);
# The task
1e5
| "Numbers under \(.) which use the same digits in decimal as in hex:",
( [sameDigitSettasktask]
| map(lpad(6))
| ((_nwise(10) | join(" ")),
"\n\(length) such numbers found." ) )
</syntaxhighlight>
{{output}}
<pre>
Numbers under 100000 which use the same digits in decimal as in hex:
0 1 2 3 4 5 6 7 8 9
53 371 913 1040 2080 2339 4100 5141 5412 5441
6182 8200 9241 13593 13665 13969 16406 20530 26946 30979
32803 33638 33840 33841 33842 33843 33844 33845 33846 33847
33848 33849 34883 37943 38931 38966 38995 66310 71444 71497
71511 75120 75121 75122 75123 75124 75125 75126 75127 75128
75129 75621 86150 88165 91465 91769 96617 98711 99481
 
69 such numbers found.
Line 532 ⟶ 922:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">dhstring(N) = [i for i in 0:N if sort(unique(digits(i))) == sort(unique(digits(i, base=16)))]
 
foreach(p -> print(rpad(p[2], 6), p[1] % 10 == 0 ? "\n" : ""), enumerate(dhstring(100000)))
</langsyntaxhighlight>{{out}}
<pre>
0 1 2 3 4 5 6 7 8 9
Line 544 ⟶ 934:
71511 75120 75121 75122 75123 75124 75125 75126 75127 75128
75129 75621 86150 88165 91465 91769 96617 98711 99481
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[Base1016SameDigitsQ]
Base1016SameDigitsQ[n_Integer] := Module[{id10, id16},
id10 = Union[IntegerDigits[n, 10]];
id16 = Union[IntegerDigits[n, 16]];
id10 === id16
]
Multicolumn[Select[Range[0, 10^5 - 1], Base1016SameDigitsQ], Appearance -> "Horizontal"]</syntaxhighlight>
{{out}}
<pre>0 1 2 3 4 5 6 7
8 9 53 371 913 1040 2080 2339
4100 5141 5412 5441 6182 8200 9241 13593
13665 13969 16406 20530 26946 30979 32803 33638
33840 33841 33842 33843 33844 33845 33846 33847
33848 33849 34883 37943 38931 38966 38995 66310
71444 71497 71511 75120 75121 75122 75123 75124
75125 75126 75127 75128 75129 75621 86150 88165
91465 91769 96617 98711 99481
</pre>
 
Line 549 ⟶ 959:
There are many ways to find the numbers. We chose to build directly the set of digits in base 10 and base 16 rather than using the string representations (more code but more efficient).
 
<langsyntaxhighlight Nimlang="nim">import strutils, sugar
 
const Lim = 99_999
Line 573 ⟶ 983:
for i, n in list:
stdout.write ($n).align(5), if (i + 1) mod 10 == 0: '\n' else: ' '
echo()</langsyntaxhighlight>
 
{{out}}
Line 587 ⟶ 997:
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">module CSet = Set.Make(struct
type t = char
let compare = compare
Line 611 ⟶ 1,021:
List.iteri (fun i x ->
Format.printf "%6d:%#8x%s" x x (if i mod 6 = 5 then "\n" else " ")) same_digits;
print_newline ()</langsyntaxhighlight>
 
{{out}}
Line 629 ⟶ 1,039:
=={{header|Pascal}}==
simply adding 1 to a number and convert as if hex digits.
<langsyntaxhighlight lang="pascal">program Dec_Hex_same_UsedDigits;
{$IFDEF FPC}
{$MODE DELPHI} {$OPTIMIZATION ON,ALL} {$COPERATORS ON}
Line 722 ⟶ 1,132:
writeln('count : ',count);
END.
</syntaxhighlight>
</lang>
{{out}}
<pre>TIO.RUN
Line 749 ⟶ 1,159:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use strict;
no warnings;
use feature 'say';
 
sub eqv { (join '', sort split '', $_[0]) eq (join '', sort split '', $_[1]) }
say join ' ', grep { eqv $_, sprintf '%x', $_ } 1..100_000;</langsyntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 53 371 913 4100 5141 5412 6182 8200 9241 75120 75121 75122 75123 75124 75125 75126 75127 75128 75129 75621 86150 91465 98711 99481</pre>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">handusc</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%x"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))=</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100000</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span><span style="color: #000000;">handusc</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"found"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 770 ⟶ 1,180:
=={{header|Python}}==
===Procedural===
<langsyntaxhighlight lang="python">col = 0
for i in range(100000):
if set(str(i)) == set(hex(i)[2:]):
col += 1
print("{:7}".format(i), end='\n'[:col % 10 == 0])
print()</langsyntaxhighlight>
{{out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 786 ⟶ 1,196:
 
===Functional===
<langsyntaxhighlight lang="python">'''Decimal - Hexadecimal numbers'''
 
 
Line 841 ⟶ 1,251:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre> 0 1 2 3 4 5 6 7 8 9
Line 850 ⟶ 1,260:
71511 75120 75121 75122 75123 75124 75125 75126 75127 75128
75129 75621 86150 88165 91465 91769 96617 98711 99481</pre>
 
or in terms of a list comprehension:
 
<syntaxhighlight lang="python">for nh in ([
(n, h) for n in range(0, 1 + 100000)
if (
(h := hex(n)[2:])
and set(str(n)) == set(h)
)
]):
print(nh)</syntaxhighlight>
<pre>(0, '0')
(1, '1')
(2, '2')
(3, '3')
(4, '4')
(5, '5')
(6, '6')
(7, '7')
(8, '8')
(9, '9')
(53, '35')
(371, '173')
(913, '391')
(1040, '410')
(2080, '820')
(2339, '923')
(4100, '1004')
(5141, '1415')
(5412, '1524')
(5441, '1541')
(6182, '1826')
(8200, '2008')
(9241, '2419')
(13593, '3519')
(13665, '3561')
(13969, '3691')
(16406, '4016')
(20530, '5032')
(26946, '6942')
(30979, '7903')
(32803, '8023')
(33638, '8366')
(33840, '8430')
(33841, '8431')
(33842, '8432')
(33843, '8433')
(33844, '8434')
(33845, '8435')
(33846, '8436')
(33847, '8437')
(33848, '8438')
(33849, '8439')
(34883, '8843')
(37943, '9437')
(38931, '9813')
(38966, '9836')
(38995, '9853')
(66310, '10306')
(71444, '11714')
(71497, '11749')
(71511, '11757')
(75120, '12570')
(75121, '12571')
(75122, '12572')
(75123, '12573')
(75124, '12574')
(75125, '12575')
(75126, '12576')
(75127, '12577')
(75128, '12578')
(75129, '12579')
(75621, '12765')
(86150, '15086')
(88165, '15865')
(91465, '16549')
(91769, '16679')
(96617, '17969')
(98711, '18197')
(99481, '18499')</pre>
 
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ 0 swap witheach [ bit | ] ] is ->set ( [ --> s )
 
[ 10 base put
Line 867 ⟶ 1,357:
[ i^ number$
nested join ] ]
60 wrap$</langsyntaxhighlight>
 
{{out}}
Line 885 ⟶ 1,375:
Several different interpretations of the (originally very vague) task instructions. It has now been clarified to mean the second.
 
<syntaxhighlight lang="raku" perl6line>say "Numbers up to 100,000 which when expressed in hexadecimal and in decimal
are composed of the same digit glyphs. (All the same glyphs, all the same
quantity.)\n";
Line 912 ⟶ 1,402:
reduce( &op, (.fmt('%x'), $_).map: { .comb."$container"() } )
} )
}</langsyntaxhighlight>
{{out}}
<pre>Numbers which when expressed in hexadecimal and in decimal are composed of
Line 978 ⟶ 1,468:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm finds integers when shown in decimal and hexadecimal use the same numerals.*/
parse arg n cols . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n = 100000 /*Not specified? Then use the default.*/
Line 1,005 ⟶ 1,495:
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,023 ⟶ 1,513:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see "working..." + nl
 
Line 1,059 ⟶ 1,549:
see nl + "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,079 ⟶ 1,569:
Found 69 numbers
done...
</pre>
 
=={{header|RPL}}==
{{works with|HP|49}}
« → b
« #0
'''WHILE''' OVER '''REPEAT'''
SWAP b IDIV2
ROT SWAP ALOG R→B OR
'''END''' NIP
» » '<span style="color:blue">DIGSET</span>' STO
« { }
0 99999 '''FOR''' n
'''IF''' n 10 <span style="color:blue">DIGSET</span> n 16 <span style="color:blue">DIGSET</span> == '''THEN''' n + '''END'''
'''NEXT'''
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: { 0 1 2 3 4 5 6 7 8 9 53 371 913 1040 2080 2339 4100 5141 5412 5441 6182 8200 9241 13593 13665 13969 16406 20530 26946 30979 32803 33638 33840 33841 33842 33843 33844 33845 33846 33847 33848 33849 34883 37943 38931 38966 38995 66310 71444 71497 71511 75120 75121 75122 75123 75124 75125 75126 75127 75128 75129 75621 86150 88165 91465 91769 96617 98711 99481 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">p (1..100_000).select{|n| n.digits.to_set == n.digits(16).to_set}</syntaxhighlight>
{{out}}
<pre>
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 53, 371, 913, 1040, 2080, 2339, 4100, 5141, 5412, 5441, 6182, 8200, 9241, 13593, 13665, 13969, 16406, 20530, 26946, 30979, 32803, 33638, 33840, 33841, 33842, 33843, 33844, 33845, 33846, 33847, 33848, 33849, 34883, 37943, 38931, 38966, 38995, 66310, 71444, 71497, 71511, 75120, 75121, 75122, 75123, 75124, 75125, 75126, 75127, 75128, 75129, 75621, 86150, 88165, 91465, 91769, 96617, 98711, 99481]
</pre>
 
=={{header|Sidef}}==
Simple solution:
<langsyntaxhighlight lang="ruby">^1e5 -> grep { Set(.digits...) == Set(.digits(16)...) }.say</langsyntaxhighlight>
 
Recursively generate the numbers (2x faster):
<langsyntaxhighlight lang="ruby">func generate_from_prefix(limit, p, base, digits) {
 
var seq = [p]
Line 1,109 ⟶ 1,626:
}
 
say numbers_with_same_digitset(1e5, 16)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,118 ⟶ 1,635:
{{libheader|Wren-fmt}}
{{libheader|Wren-set}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Conv, Fmt
import "./set" for Set
 
var limit = 1e5
Line 1,134 ⟶ 1,651:
}
}
System.print("\n\n%(count) such numbers found.")</langsyntaxhighlight>
 
{{out}}
Line 1,151 ⟶ 1,668:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func DigitSet(N, D);
\Return a bit array containing the set of digits in N divisible by D
int N, D;
Line 1,173 ⟶ 1,690:
CrLf(0); IntOut(0, Count); Text(0, " such numbers found.
")
]</langsyntaxhighlight>
 
{{out}}
Line 1,186 ⟶ 1,703:
69 such numbers found.
</pre>
 
=={{header|Zig}}==
{{trans|C}}
<syntaxhighlight lang="zig">const print = @import("std").debug.print;
fn digitset(numinp: u32, base: u32) u32 {
var set: u32 = 0;
var num: u32 = numinp;
while (num != 0) : (num /= base) {
set |= @as(u32, 1) << @truncate(u5, num % base);
}
return set;
}
pub fn main() void {
var i: u32 = 0;
const LIMIT: u32 = 100000;
while (i < LIMIT) : (i += 1) {
if (digitset(i, 10) == digitset(i, 16)) {
print("{}\n", .{i});
}
}
}</syntaxhighlight>
PureFox
9,479

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/312957...354859"