Numbers in base-16 representation that cannot be written with decimal digits: Difference between revisions
m (→version 1: changed a comment.) |
(Add Factor) |
||
Line 4: | Line 4: | ||
Find positive integers in base-16 representation that cannot be written with decimal digits, where '''n < 500<sub>10</sub>''' |
Find positive integers in base-16 representation that cannot be written with decimal digits, where '''n < 500<sub>10</sub>''' |
||
<br><br> |
<br><br> |
||
=={{header|Factor}}== |
|||
Count up by letters A-F; convert to hex. |
|||
{{works with|Factor|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> |
|||
{{out}} |
|||
<pre style="height:24em"> |
|||
{ |
|||
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 |
|||
} |
|||
</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
Revision as of 19:24, 24 June 2021
- Task
Find positive integers in base-16 representation that cannot be written with decimal digits, where n < 50010
Factor
Count up by letters A-F; convert to hex.
<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.
Phix
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 } } );
- 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];
- 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
<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.