Numbers in base-16 representation that cannot be written with decimal digits: Difference between revisions

From Rosetta Code
Content added Content deleted
m (Corrected a type in output.)
m (→‎{{header|ALGOL 68}}: Remove unused declaration)
Line 8: Line 8:
Generates the numbers.
Generates the numbers.
<lang algol68>BEGIN # find numbers whose hex representation does not contain the digits 0-9 #
<lang algol68>BEGIN # find numbers whose hex representation does not contain the digits 0-9 #
INT max number = 499;
# generate and print the numbers up to 499 #
# generate and print the numbers #
# 499 is 1F3 in hex, so we need to find numbers up to FF #
# the maximum number to consider is 1F3 in hex, so we need to find numbers up to FF #
INT h count := 0;
INT h count := 0;
# 1 hex digit numbers #
# 1 hex digit numbers #

Revision as of 17:49, 26 June 2021

Numbers in base-16 representation that cannot be written with decimal digits 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.
Task

Find positive integers in base-16 representation that cannot be written with decimal digits,   where   n   <   50010

ALGOL 68

Generates the numbers. <lang algol68>BEGIN # find numbers whose hex representation does not contain the digits 0-9 # 

   # generate and print the numbers up to 499 #
   # 499 is 1F3 in hex, so we need to find numbers up to FF #
   INT h count := 0;
   # 1 hex digit numbers #
   FOR d1 FROM 10 TO 15 DO
       print( ( " ", whole( d1, -3 ) ) );
       h count +:= 1
   OD;
   # two hex digit numbers #
   FOR d1 FROM 10 TO 15 DO
       FOR d2 FROM 10 TO 15 DO
           print( ( " ", whole( ( d1 * 16 ) + d2, -3 ) ) );
           IF ( h count +:= 1 ) MOD 12 = 0 THEN print( ( newline ) ) FI
       OD
   OD

END</lang>

Output:
  10  11  12  13  14  15 170 171 172 173 174 175
 186 187 188 189 190 191 202 203 204 205 206 207
 218 219 220 221 222 223 234 235 236 237 238 239
 250 251 252 253 254 255

BASIC

<lang basic>10 DEFINT A-Z 20 H=0: GOSUB 50 30 FOR H=10 TO 15: GOSUB 50: NEXT 40 END 50 FOR L=10 TO 15 60 PRINT H*16+L, 70 NEXT 80 RETURN</lang>

Output:
 10            11            12            13            14
 15            170           171           172           173
 174           175           186           187           188
 189           190           191           202           203
 204           205           206           207           218
 219           220           221           222           223
 234           235           236           237           238
 239           250           251           252           253
 254           255

BCPL

<lang bcpl>get "libhdr"

let lownybble(hi) be 

   for lo=#XA to #XF do
       writef("%N*N", hi<<4 | lo)

let start() be $( lownybble(0) 

   for hi=#XA to #XF do
       lownybble(hi)

$)</lang>

Output:
10
11
12
13
14
15
170
171
172
173
174
175
186
187
188
189
190
191
202
203
204
205
206
207
218
219
220
221
222
223
234
235
236
237
238
239
250
251
252
253
254
255

COBOL

<lang cobol> IDENTIFICATION DIVISION. 

      PROGRAM-ID. NO-0-9-IN-HEX.
      
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01 HIGH-NYBBLE      PIC 99.
      01 LOW-NYBBLE       PIC 99.
      01 OUT-NUM          PIC 999.
      01 OUT-FMT          PIC ZZ9.
      
      PROCEDURE DIVISION.
      BEGIN.
          MOVE ZERO TO HIGH-NYBBLE, PERFORM LOOP-LOW-NYBBLE.
          PERFORM LOOP-LOW-NYBBLE VARYING HIGH-NYBBLE FROM 10 BY 1
              UNTIL HIGH-NYBBLE IS EQUAL TO 16.
          STOP RUN.
      
      LOOP-LOW-NYBBLE.
          PERFORM SHOW-DECIMAL VARYING LOW-NYBBLE FROM 10 BY 1
              UNTIL LOW-NYBBLE IS EQUAL TO 16.
      
      SHOW-DECIMAL.
          MULTIPLY HIGH-NYBBLE BY 16 GIVING OUT-NUM.
          ADD LOW-NYBBLE TO OUT-NUM.
          MOVE OUT-NUM TO OUT-FMT.
          DISPLAY OUT-FMT.</lang>
Output:
 10
 11
 12
 13
 14
 15
170
171
172
173
174
175
186
187
188
189
190
191
202
203
204
205
206
207
218
219
220
221
222
223
234
235
236
237
238
239
250
251
252
253
254
255

F#

<lang fsharp> // Base16 numbers represented using only digits greater than 9. Nigel Galloway: June 25th., 2021 let rec fG n g=seq{yield! g; yield! fG n (g|>List.collect(fun g->n|>List.map(fun n->n+g*16)))} fG [10..15] [10..15]|>Seq.takeWhile((>)5000)|>Seq.iter(fun n->printf "%d(%0x) " n n); printfn "" </lang>

Output:
10(a) 11(b) 12(c) 13(d) 14(e) 15(f) 170(aa) 171(ab) 172(ac) 173(ad) 174(ae) 175(af) 186(ba) 187(bb) 188(bc) 189(bd) 190(be) 191(bf) 202(ca) 203(cb) 204(cc) 205(cd) 206(ce) 207(cf) 218(da) 219(db) 220(dc) 221(dd) 222(de) 223(df) 234(ea) 235(eb) 236(ec) 237(ed) 238(ee) 239(ef) 250(fa) 251(fb) 252(fc) 253(fd) 254(fe) 255(ff) 2730(aaa) 2731(aab) 2732(aac) 2733(aad) 2734(aae) 2735(aaf) 2746(aba) 2747(abb) 2748(abc) 2749(abd) 2750(abe) 2751(abf) 2762(aca) 2763(acb) 2764(acc) 2765(acd) 2766(ace) 2767(acf) 2778(ada) 2779(adb) 2780(adc) 2781(add) 2782(ade) 2783(adf) 2794(aea) 2795(aeb) 2796(aec) 2797(aed) 2798(aee) 2799(aef) 2810(afa) 2811(afb) 2812(afc) 2813(afd) 2814(afe) 2815(aff) 2986(baa) 2987(bab) 2988(bac) 2989(bad) 2990(bae) 2991(baf) 3002(bba) 3003(bbb) 3004(bbc) 3005(bbd) 3006(bbe) 3007(bbf) 3018(bca) 3019(bcb) 3020(bcc) 3021(bcd) 3022(bce) 3023(bcf) 3034(bda) 3035(bdb) 3036(bdc) 3037(bdd) 3038(bde) 3039(bdf) 3050(bea) 3051(beb) 3052(bec) 3053(bed) 3054(bee) 3055(bef) 3066(bfa) 3067(bfb) 3068(bfc) 3069(bfd) 3070(bfe) 3071(bff) 3242(caa) 3243(cab) 3244(cac) 3245(cad) 3246(cae) 3247(caf) 3258(cba) 3259(cbb) 3260(cbc) 3261(cbd) 3262(cbe) 3263(cbf) 3274(cca) 3275(ccb) 3276(ccc) 3277(ccd) 3278(cce) 3279(ccf) 3290(cda) 3291(cdb) 3292(cdc) 3293(cdd) 3294(cde) 3295(cdf) 3306(cea) 3307(ceb) 3308(cec) 3309(ced) 3310(cee) 3311(cef) 3322(cfa) 3323(cfb) 3324(cfc) 3325(cfd) 3326(cfe) 3327(cff) 3498(daa) 3499(dab) 3500(dac) 3501(dad) 3502(dae) 3503(daf) 3514(dba) 3515(dbb) 3516(dbc) 3517(dbd) 3518(dbe) 3519(dbf) 3530(dca) 3531(dcb) 3532(dcc) 3533(dcd) 3534(dce) 3535(dcf) 3546(dda) 3547(ddb) 3548(ddc) 3549(ddd) 3550(dde) 3551(ddf) 3562(dea) 3563(deb) 3564(dec) 3565(ded) 3566(dee) 3567(def) 3578(dfa) 3579(dfb) 3580(dfc) 3581(dfd) 3582(dfe) 3583(dff) 3754(eaa) 3755(eab) 3756(eac) 3757(ead) 3758(eae) 3759(eaf) 3770(eba) 3771(ebb) 3772(ebc) 3773(ebd) 3774(ebe) 3775(ebf) 3786(eca) 3787(ecb) 3788(ecc) 3789(ecd) 3790(ece) 3791(ecf) 3802(eda) 3803(edb) 3804(edc) 3805(edd) 3806(ede) 3807(edf) 3818(eea) 3819(eeb) 3820(eec) 3821(eed) 3822(eee) 3823(eef) 3834(efa) 3835(efb) 3836(efc) 3837(efd) 3838(efe) 3839(eff) 4010(faa) 4011(fab) 4012(fac) 4013(fad) 4014(fae) 4015(faf) 4026(fba) 4027(fbb) 4028(fbc) 4029(fbd) 4030(fbe) 4031(fbf) 4042(fca) 4043(fcb) 4044(fcc) 4045(fcd) 4046(fce) 4047(fcf) 4058(fda) 4059(fdb) 4060(fdc) 4061(fdd) 4062(fde) 4063(fdf) 4074(fea) 4075(feb) 4076(fec) 4077(fed) 4078(fee) 4079(fef) 4090(ffa) 4091(ffb) 4092(ffc) 4093(ffd) 4094(ffe) 4095(fff)

Factor

Count up by letters A-F; convert from hexadecimal to decimal.

Works with: Factor version 0.99 2021-06-02

<lang factor>USING: kernel math.combinatorics math.parser prettyprint sequences.extras ;

"ABCDEF" { 1 2 } [ [ hex> ] map-selections ] with map-concat .</lang>

Output:
{
    10
    11
    12
    13
    14
    15
    170
    171
    172
    173
    174
    175
    186
    187
    188
    189
    190
    191
    202
    203
    204
    205
    206
    207
    218
    219
    220
    221
    222
    223
    234
    235
    236
    237
    238
    239
    250
    251
    252
    253
    254
    255
}

Go

<lang go>package main

import ( 

   "fmt"
   "strconv"
   "strings"

)

func main() { 

   const decimal = "0123456789"
   c := 0
   for i := int64(1); i < 500; i++ {
       hex := strconv.FormatInt(i, 16)
       if !strings.ContainsAny(decimal, hex) {
           fmt.Printf("%3d ", i)
           c++
           if c%14 == 0 {
               fmt.Println()
           }
       }
   }
   fmt.Printf("\n%d such numbers found.\n", c)

}</lang>

Output:
 10  11  12  13  14  15 170 171 172 173 174 175 186 187 
188 189 190 191 202 203 204 205 206 207 218 219 220 221 
222 223 234 235 236 237 238 239 250 251 252 253 254 255 

42 such numbers found.

Nim

<lang Nim>import strutils, sugar

let list = collect(newSeq): 

            for d1 in {0, 10..15}:
              for d2 in {10..15}:
                if (let n = 16 * d1 + d2; n < 500): n

echo "Found ", list.len, " numbers < 500 which cannot be written in base 16 with decimal digits:" for i, n in list: 

 stdout.write ($n).align(3), if (i + 1) mod 7 == 0: '\n' else: ' '</lang>
Output:
Found 42 numbers < 500 which cannot be written in base 16 with decimal digits:
 10  11  12  13  14  15 170
171 172 173 174 175 186 187
188 189 190 191 202 203 204
205 206 207 218 219 220 221
222 223 234 235 236 237 238
239 250 251 252 253 254 255

Perl

<lang perl>use strict; use warnings;

print join( ' ', grep sprintf("%x", $_) !~ /[0-9]/, 1 .. 500 ) =~ s/.{71}\K /\n/gr, "\n";</lang>

Output:
10 11 12 13 14 15 170 171 172 173 174 175 186 187 188 189 190 191 202 203
204 205 206 207 218 219 220 221 222 223 234 235 236 237 238 239 250 251
252 253 254 255

Phix

Spot the difference... 

with javascript_semantics
function above9(integer n) return min(sprintf("%x",n))>'9' end function
printf(1,"%s\n",{join(shorten(apply(filter(tagset(500),above9),sprint),"found",10))})
Output:
10 11 12 13 14 15 170 171 172 173 ... 236 237 238 239 250 251 252 253 254 255  (42 found)

Raku

Find numbers in base-16 representation that cannot be written with decimal digits, where n < 500

This is literally the exact same task as (the horribly named) Base-16 representation task.

Leaving aside the requirement that it be base 16 (well, base negative 16 according to the task title); assume it really means hexadecimal, otherwise all bets are off.

I challenge anyone to demonstrate how, say 46510, can be written in hexadecimal using only decimal digits.

The task as written:

<lang perl6>put "{+$_} such numbers:\n", .batch(20)».fmt('%3d').join("\n") 

   given (1..500).grep( { so any |.map: { .polymod(16 xx *) »>» 9 } } );</lang>
Output:
301 such numbers:
 10  11  12  13  14  15  26  27  28  29  30  31  42  43  44  45  46  47  58  59
 60  61  62  63  74  75  76  77  78  79  90  91  92  93  94  95 106 107 108 109
110 111 122 123 124 125 126 127 138 139 140 141 142 143 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 266 267 268 269
270 271 282 283 284 285 286 287 298 299 300 301 302 303 314 315 316 317 318 319
330 331 332 333 334 335 346 347 348 349 350 351 362 363 364 365 366 367 378 379
380 381 382 383 394 395 396 397 398 399 410 411 412 413 414 415 416 417 418 419
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
500


What the task author probably meant.

Find numbers in decimal that when written in hexadecimal are expressed using only alphabetic glyphs.

Which is a tiny (2 character) change from Base-16 representation. Add some other (possibly useful) functionality.

<lang perl6>#Filter out such numbers from a range: put "Filter: {+$_} such numbers:\n", .batch(20)».fmt('%3d').join("\n") 

   given (1..500).grep( { so all |.map: { .polymod(16 xx *) »>» 9 } } );
  1. Generate such numbers directly, up to a threshold:

put "\nGenerate: first {+$_}:\n", .batch(10)».map({ "{$_}({:16($_)})" })».fmt('%9s').join("\n") given 

   ((1..^Inf).grep(* % 7).map( { .base(7).trans: [1..6] => ['A'..'F'] } )).grep(!*.contains: 0)[^42];
  1. Count such numbers directly, up to a threshold

my $upto = 500; put "\nCount: " ~ [+] flat (map {exp($_, 6)}, 1..($upto.log(16).floor)), +(exp($upto.log(16).floor, 16) .. $upto).grep( { so all |.map: { .polymod(16 xx *) »>» 9 } });</lang>

Output:
Filter: 42 such numbers:
 10  11  12  13  14  15 170 171 172 173 174 175 186 187 188 189 190 191 202 203
204 205 206 207 218 219 220 221 222 223 234 235 236 237 238 239 250 251 252 253
254 255

Generate: first 42:
    A(10)     B(11)     C(12)     D(13)     E(14)     F(15)   AA(170)   AB(171)   AC(172)   AD(173)
  AE(174)   AF(175)   BA(186)   BB(187)   BC(188)   BD(189)   BE(190)   BF(191)   CA(202)   CB(203)
  CC(204)   CD(205)   CE(206)   CF(207)   DA(218)   DB(219)   DC(220)   DD(221)   DE(222)   DF(223)
  EA(234)   EB(235)   EC(236)   ED(237)   EE(238)   EF(239)   FA(250)   FB(251)   FC(252)   FD(253)
  FE(254)   FF(255)

Count: 42

REXX

version 1

<lang rexx>/*REXX pgm finds positive integers when shown in hex that can't be written with dec digs*/ parse arg n cols . /*obtain optional argument from the CL.*/ if n== | n=="," then n = 500 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 10 /* " " " " " " */ w= 10 /*width of a number in any column. */ title= " positive integers when shown in hexadecimal that can't be written with" , 

      'decimal digits,  where  N  < '    n

say ' index │'center(title, 1 + cols*(w+1) ) /*display the title for the output. */ say '───────┼'center("" , 1 + cols*(w+1), '─') /* " a sep " " " */ found= 0; y= 0123456789; idx= 1 /*# finds; forbidden glyphs; set IDX.*/ $= /*list of numbers found (so far). */ 

   do j=1  for n-1                              /*find ints in hex with no dec. digits.*/
   if verify(y, d2x(j), 'M')\==0  then iterate  /*Any dec. digs in hex number?   Skip. */    /* ◄■■■■■■■■ the filter. */
   found= found + 1                             /*bump number of found such numbers.   */
   $= $  right(j, w)                            /*add the found number  ───►  $  list. */
   if found // cols \== 0        then iterate   /*have we populated a line of output?  */
   say center(idx, 7)'│'  substr($, 2);   $=    /*display what we have so far  (cols). */
   idx= idx + cols                              /*bump the  index  count for the output*/
   end   /*j*/

if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ say '───────┴'center("" , 1 + cols*(w+1), '─') /*display the foot sep for output. */ say say 'Found ' found title exit 0 /*stick a fork in it, we're all done. */</lang>

output   when using the default inputs:
 index │    positive integers when shown in hexadecimal that can't be written with decimal digits,  where  N  <  500
───────┼───────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │         10         11         12         13         14         15        170        171        172        173
  11   │        174        175        186        187        188        189        190        191        202        203
  21   │        204        205        206        207        218        219        220        221        222        223
  31   │        234        235        236        237        238        239        250        251        252        253
  41   │        254        255
───────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  42  positive integers when shown in hexadecimal that can't be written with decimal digits,  where  N  <  500

version 2

This REXX version is exactly the same as version 1,   but the   filter   was "inverted" so as to achieve the same result. <lang rexx>/*REXX pgm finds positive integers when shown in hex that can't be written with dec digs*/ parse arg n cols . /*obtain optional argument from the CL.*/ if n== | n=="," then n = 500 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 10 /* " " " " " " */ w= 10 /*width of a number in any column. */ title= " positive integers when shown in hexadecimal that can't be written with" , 

      'decimal digits,  where  N  < '    n

say ' index │'center(title, 1 + cols*(w+1) ) /*display the title for the output. */ say '───────┼'center("" , 1 + cols*(w+1), '─') /* " a sep " " " */ found= 0; idx= 1 /*count of #'s found (so far); set IDX.*/ $= /*list of numbers found (so far). */ 

   do j=1  for n-1                              /*find ints in hex with no dec. digits.*/
   if \datatype( d2x(j), 'M')    then iterate   /*All digs in hex # alphabetic?  Skip. */    /* ◄■■■■■■■■ the filter. */
   found= found + 1                             /*bump number of found such numbers.   */
   $= $  right(j, w)                            /*add the found number  ───►  $  list. */
   if found // cols \== 0        then iterate   /*have we populated a line of output?  */
   say center(idx, 7)'│'  substr($, 2);   $=    /*display what we have so far  (cols). */
   idx= idx + cols                              /*bump the  index  count for the output*/
   end   /*j*/

if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ say '───────┴'center("" , 1 + cols*(w+1), '─') /*display the foot sep for output. */ say say 'Found ' found title exit 0 /*stick a fork in it, we're all done. */</lang>

output   is identical to the 1st REXX version.



Ring

<lang ring> see "working..." + nl see "Numbers in base-16 representation that cannot be written with decimal digits:" + nl

row = 0 baseList = "ABCDEF" limit = 500

for n = 1 to limit 

   flag = 1  
   hex = upper(hex(n))
   for m = 1 to len(hex)
       ind = substr(baseList,hex[m])
       if ind < 1
          flag = 0
          exit
       ok
   next
    
   if flag = 1
      see "" + n + " "
      row = row + 1
      if row%5 = 0
         see nl
      ok
   ok

next

see nl + "Found " + row + " numbers" + nl see "done..." + nl </lang>

Output:
working...
Numbers in base-16 representation that cannot be written with decimal digits:
10 11 12 13 14 
15 170 171 172 173 
174 175 186 187 188 
189 190 191 202 203 
204 205 206 207 218 
219 220 221 222 223 
234 235 236 237 238 
239 250 251 252 253 
254 255 
Found 42 numbers
done...

Wren

Library: Wren-fmt

<lang ecmascript>import "/fmt" for Conv, Fmt

var decimal = "0123456789" var c = 0 for (i in 1..499) { 

   var hex = Conv.hex(i)
   if (!hex.any { |c| decimal.contains(c) }) {
       Fmt.write("$3s ", i)
       c = c + 1
       if (c % 14 == 0) System.print()
   }

} System.print("\n%(c) such numbers found.")</lang>

Output:
 10  11  12  13  14  15 170 171 172 173 174 175 186 187 
188 189 190 191 202 203 204 205 206 207 218 219 220 221 
222 223 234 235 236 237 238 239 250 251 252 253 254 255 

42 such numbers found.

XPL0

<lang XPL0>func Hexed(N); \Return 'true' if N contains a hex digit int N; [while N do 

   [if (N&$F) >= 10 then return true;
   N:= N>>4;
   ];

return false; ];

int Count, N; [SetHexDigits(3); Count:= 0; for N:= 0 to 500-1 do 

   if Hexed(N) then
       [HexOut(0, N);
       Count:= Count+1;
       if rem(Count/20) = 0 then CrLf(0) else ChOut(0, ^ );
       ];

CrLf(0); IntOut(0, Count); Text(0, " such numbers found. "); ]</lang>

Output:
00A 00B 00C 00D 00E 00F 01A 01B 01C 01D 01E 01F 02A 02B 02C 02D 02E 02F 03A 03B
03C 03D 03E 03F 04A 04B 04C 04D 04E 04F 05A 05B 05C 05D 05E 05F 06A 06B 06C 06D
06E 06F 07A 07B 07C 07D 07E 07F 08A 08B 08C 08D 08E 08F 09A 09B 09C 09D 09E 09F
0A0 0A1 0A2 0A3 0A4 0A5 0A6 0A7 0A8 0A9 0AA 0AB 0AC 0AD 0AE 0AF 0B0 0B1 0B2 0B3
0B4 0B5 0B6 0B7 0B8 0B9 0BA 0BB 0BC 0BD 0BE 0BF 0C0 0C1 0C2 0C3 0C4 0C5 0C6 0C7
0C8 0C9 0CA 0CB 0CC 0CD 0CE 0CF 0D0 0D1 0D2 0D3 0D4 0D5 0D6 0D7 0D8 0D9 0DA 0DB
0DC 0DD 0DE 0DF 0E0 0E1 0E2 0E3 0E4 0E5 0E6 0E7 0E8 0E9 0EA 0EB 0EC 0ED 0EE 0EF
0F0 0F1 0F2 0F3 0F4 0F5 0F6 0F7 0F8 0F9 0FA 0FB 0FC 0FD 0FE 0FF 10A 10B 10C 10D
10E 10F 11A 11B 11C 11D 11E 11F 12A 12B 12C 12D 12E 12F 13A 13B 13C 13D 13E 13F
14A 14B 14C 14D 14E 14F 15A 15B 15C 15D 15E 15F 16A 16B 16C 16D 16E 16F 17A 17B
17C 17D 17E 17F 18A 18B 18C 18D 18E 18F 19A 19B 19C 19D 19E 19F 1A0 1A1 1A2 1A3
1A4 1A5 1A6 1A7 1A8 1A9 1AA 1AB 1AC 1AD 1AE 1AF 1B0 1B1 1B2 1B3 1B4 1B5 1B6 1B7
1B8 1B9 1BA 1BB 1BC 1BD 1BE 1BF 1C0 1C1 1C2 1C3 1C4 1C5 1C6 1C7 1C8 1C9 1CA 1CB
1CC 1CD 1CE 1CF 1D0 1D1 1D2 1D3 1D4 1D5 1D6 1D7 1D8 1D9 1DA 1DB 1DC 1DD 1DE 1DF
1E0 1E1 1E2 1E3 1E4 1E5 1E6 1E7 1E8 1E9 1EA 1EB 1EC 1ED 1EE 1EF 1F0 1F1 1F2 1F3

300 such numbers found.
Retrieved from "https://rosettacode.org/wiki/Numbers_in_base-16_representation_that_cannot_be_written_with_decimal_digits?oldid=313272"