24
\$\begingroup\$

I was browsing Stack Overflow when I saw this post in Puzzling in the hot network questions and decided to make a challenge out of it (all credit goes to the creator of the challenge).

Overview

A Chess Number is a number that, when converted to base 18, results in a valid chess coordinate pair, where the first character is a-h and the second character is 1-8 (inclusive). Your job is to generate the full list of them, ordered. Output may be an array/list, printed individually, as a matrix/grid, or in a string. The numbers must be in decimal, not base 18.

Examples

Here is a Python program to generate the full list:

def baseN(num, b, numerals = "0123456789abcdefghijklmnopqrstuvwxyz"):
    return ((num == 0) and numerals[0]) or (baseN(num // b, b, numerals).lstrip(numerals[0]) + numerals[num % b])

for i in range(0, 10000):
    s = baseN(i, 18)
    if len(s) == 2 and s[0].isalpha() and s[1].isdigit() and 0 < int(s[1]) < 9:
        print(i, s)

Try it online!

The complete list is:

181, 182, 183, 184, 185, 186, 187, 188, 199, 200, 201, 202, 203, 204, 205, 206, 217, 218, 219, 220, 221, 222, 223, 224, 235, 236, 237, 238, 239, 240, 241, 242, 253, 254, 255, 256, 257, 258, 259, 260, 271, 272, 273, 274, 275, 276, 277, 278, 289, 290, 291, 292, 293, 294, 295, 296, 307, 308, 309, 310, 311, 312, 313, 314

Scoring

This is , shortest code in bytes wins

\$\endgroup\$
6
  • 1
    \$\begingroup\$ Could you include the first few numbers in the post? \$\endgroup\$
    – Ginger
    Dec 15, 2021 at 15:29
  • 1
    \$\begingroup\$ 1st done, 2nd doing \$\endgroup\$
    – Seggan
    Dec 15, 2021 at 15:31
  • 1
    \$\begingroup\$ What format can the output be in? \$\endgroup\$
    – Ginger
    Dec 15, 2021 at 15:34
  • 1
    \$\begingroup\$ It is acceptable \$\endgroup\$
    – Seggan
    Dec 15, 2021 at 16:26
  • 1
    \$\begingroup\$ Given that the list is finite and not too long, I've added it into the challenge so that it's self-contained \$\endgroup\$ Dec 15, 2021 at 18:00

29 Answers 29

12
\$\begingroup\$

Jelly, 8 7 bytes

9Ṗ+pṖḅḤ

Try it online!

-1 byte thanks to Lynn by combining our answers, so make sure to upvote their answer as well!

How it works

9Ṗ+pṖḅḤ - Main link. Takes no arguments
9       - Set the return value to 9, and execute with 9 on the left
 Ṗ      - Pop, yielding [1,2,3,4,5,6,7,8]
  +     - Add 9 to each: [10,11,12,13,14,15,16,17]
    Ṗ   - Pop, yielding [1,2,3,4,5,6,7,8]
   p    - Cartesian product: [[10,1],[10,2],...,[17,8]]
      Ḥ - Unhalve; Yield 18
     ḅ  - Unbase; Convert [a, b] to 18a+b
\$\endgroup\$
2
  • \$\begingroup\$ Clever idea doing everything with 9! Our answers combine into a 7: 9Ṗ+pṖḅḤ \$\endgroup\$
    – Lynn
    Dec 16, 2021 at 21:21
  • \$\begingroup\$ @Lynn That's a clever trick with the base conversion! \$\endgroup\$ Dec 17, 2021 at 16:44
11
\$\begingroup\$

Python 3, 55 bytes

Edit: Was 56 bytes, now 55. Thanks to Dronir for proposing printing the numbers as a list.

Edit: Was 57 bytes, now 56. Thanks to Neil for proposing the -~j modification.

print([18*i-~j for i in range(10,18)for j in range(8)])

Try it online!

Python 2, 53 bytes

Thanks to Kevin Cruijssen for propsing switching to Python 2 to save a couple of bytes.

print[18*i-~j for i in range(10,18)for j in range(8)]

Try it online!

\$\endgroup\$
17
  • \$\begingroup\$ If you switch to Python 2 you can save a byte by removing the parenthesis around the print: 56 bytes. \$\endgroup\$ Dec 15, 2021 at 16:56
  • 3
    \$\begingroup\$ for j in range(8):print(18*i-~j) saves a byte. \$\endgroup\$
    – Neil
    Dec 15, 2021 at 17:35
  • \$\begingroup\$ Printing a list comes to the same number of bytes: print([18*i-~j for i in range(10,18) for j in range(1,9)]) (56 bytes) \$\endgroup\$
    – Dronir
    Dec 16, 2021 at 7:58
  • \$\begingroup\$ @Dronir That doesn't seem for print the correct sequence. \$\endgroup\$ Dec 16, 2021 at 14:05
  • \$\begingroup\$ @Neil Thanks, I'll do that! \$\endgroup\$ Dec 16, 2021 at 14:06
9
\$\begingroup\$

R, 35 17 bytes

1:8+18*80:143%/%8

Try it online!

\$\endgroup\$
8
\$\begingroup\$

Python 2, 37 36 bytes

x=64
while x:x-=1;print 314-x-x/8*10

Try it online!

1 byte saved thanks to loopy walt

\$\endgroup\$
1
7
\$\begingroup\$

R, 44 25 22 bytes

x=180:313;x[x%%18<8]+1

Try it online!

\$\endgroup\$
4
  • \$\begingroup\$ I think the () around 10:17 are unnecessary. \$\endgroup\$
    – Giuseppe
    Dec 15, 2021 at 15:58
  • \$\begingroup\$ 21 bytes \$\endgroup\$
    – Giuseppe
    Dec 15, 2021 at 16:00
  • \$\begingroup\$ 17 bytes? \$\endgroup\$
    – Giuseppe
    Dec 15, 2021 at 16:13
  • \$\begingroup\$ @Giuseppe - Go on, post it! I'm stuck at 22 so far with my own ideas... \$\endgroup\$ Dec 15, 2021 at 16:18
7
\$\begingroup\$

05AB1E, 11 10 bytes

8Lã18δβƵz+

-1 byte thanks to @ovs.

Try it online.

A port of @JosephWalker's Python 3 answer is 11 bytes: 7ÝT+18*8LâO - Try it online.
A port of @Arnauld's JavaScript first answer is 12 bytes: ƵΔƵÖŸʒ<18%8‹ - Try it online.
A port of @GB's Ruby answer is 12 bytes as well: 63ÝD8÷T*ƵΘ++ - Try it online.
A port of @ovs' APL answer is 13 bytes: ƵgLD18%9›ÏƵη+ - Try it online.
A port of @Giuseppe's R answer is 14 bytes: 80ƵgŸ8÷18*8LÞ+ - Try it online.

Explanation:

8L         # Push a list in the range [1,8]
  ã        # Create all possible pairs with the cartesian product
     δ     # Map over each pair:
   18 β    #  Convert it from a base-18 list to an integer
       Ƶz+ # And add 162 to each
           # (after which the result is output implicitly)

See this 05AB1E answer of mine (section How to compress large integers?) to understand why Ƶz is 162.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ 8Lã18δβƵz+ works for 10 bytes \$\endgroup\$
    – ovs
    Dec 15, 2021 at 19:10
6
\$\begingroup\$

Ruby, 27 bytes

64.times{|x|p x+x/8*10+181}

Try it online!

\$\endgroup\$
6
\$\begingroup\$

APL (Dyalog Unicode), 14 bytes

171+⍸9<18|⍳143

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ equivalent BQN: 171+/9<18|↕144 \$\endgroup\$
    – Razetime
    Dec 16, 2021 at 3:25
6
\$\begingroup\$

BQN, 16 bytes

(181+⊢+18×⊣)⌜˜↕8

Run it online! Outputs an 8x8 array of numbers.

Explanation

A port of my Pip solution.

(181+⊢+18×⊣)⌜˜↕8
               ↕8  Range(8)
(           )⌜˜    Generate a table, using that range twice, with this function:
        18×⊣         18 times left argument
     ⊢+              plus right argument
 181+                 plus 181
\$\endgroup\$
6
\$\begingroup\$

Jelly, 8 bytes

18⁵rṖp8ḅ

Try it online!

18         18
  ⁵r       Range from ⁵=10: [10..18]
    Ṗ      Remove last element: [10..17] ([a..h])
     p8    Cartesian product with [1..8]
       ḅ   Convert from base 18
\$\endgroup\$
5
\$\begingroup\$

JavaScript (V8), 35 bytes

Test modulo \$18\$.

for(n=180;n<314;)n++%18<8&&print(n)

Try it online!


JavaScript (V8), 36 bytes

Expanding \$[0\dots63]\$ in reverse order to \$[181\dots314]\$.

for(n=64;n--;)print(314-(n>>3)*10-n)

Try it online!

\$\endgroup\$
4
\$\begingroup\$

APOL, 38 bytes

Port of Joeph Walker's genius answer, all credit goes to him.

ḟ(10 18 v(0 ∋) ḟ(1 9 p(*(18 +(∋ ⁰)))))

Sadly, APOL doesn't support nested for counters, so I have to use a clunkier solution. Maybe I'll implement them and come back to this later.

\$\endgroup\$
4
\$\begingroup\$

Husk, 12 bytes

ṠṪ+mo*18+9ḣ8

Try it online!

          ḣ8 # get the range from 1..8
Ṡ            # Ṡfgx = f(g(x),x)
             # so we use the range 1..8 twice
             # once directly as an argument to f
             # and once after applying g to it
 Ṫ+          # f = Ṫ+ = outer product by addition
   mo*18+9   # g = 
   mo        #   map over each element
        +9   #   add 9
     *18     #   and then multiply by 18
\$\endgroup\$
2
  • \$\begingroup\$ Wow is that the S combinator? \$\endgroup\$
    – Neil
    Dec 15, 2021 at 21:02
  • \$\begingroup\$ @Neil - "hookf (Ṡ) is a flipped S-combinator": Husk wiki \$\endgroup\$ Dec 15, 2021 at 21:36
4
\$\begingroup\$

Python 3 with NumPy, 62 52 46 bytes

lambda:18*r_[10:18]+c_[1:9]
from numpy import*

Try it online!

Utilizing the option to return output in a 2d array. I'm a little fuzzy on how I/O is allowed in python so let me know if this is unacceptable / I need more boilerplate.

Thanks to loopy wait for r_ and c_

\$\endgroup\$
1
3
\$\begingroup\$

APL+WIN, 24 bytes

18⊥(∊9+¨8/¨⍳8),[.1]64⍴⍳8

Try it online! Thanks to Dyalog Classic

\$\endgroup\$
3
\$\begingroup\$

MathGolf, 12 bytes

8r♂+G*mÉ8╒+─

Try it online.

Explanation:

8r           # Push a list in the range [0,8)
  ♂+         # Add 10 to each to make the range [10,18)
    G*       # Multiply each by 18
      m      # Map over this list,
       É     # Using 3 characters as inner code-block:
        8╒   #  Push range [1,8]
          +  #  Add the map-integer to each
           ─ # After the map: flatten the list of lists
             # (after which the entire stack is output implicitly as result)
\$\endgroup\$
3
\$\begingroup\$

Charcoal, 14 bytes

I⁺¹⁸¹E⁶⁴↨¹⁸↨ι⁸

Try it online! Link is to verbose version of code. I had three 15 byte solutions (including one which generated the range a1..h8 and converted them from base 18) but I was able to golf one of them down to 14. Explanation:

      ⁶⁴        Literal integer `64`
     E          Map over implicit range
            ι   Current integer
           ↨ ⁸  Divmod by 8 using base conversion
        ↨¹⁸     Interpret as base 18
 ⁺¹⁸¹           Vectorised add 181
I               Cast to string
                Implicitly print
\$\endgroup\$
3
\$\begingroup\$

Pip, 13 bytes

181+18*_+BMC8

Use with some kind of list-formatting flag: -P and -S work well. Try it online!

Explanation

181+18*_+BMC8
          MC   Map the following function to coordinate pairs
            8  from an 8x8 grid:
181+            181 plus
    18*_        18 times the row number
        +B      plus the column number

Here's a 16-byte solution that uses base conversion:

J_MzH8CP\,8FB:18
   z              Lowercase alphabet
    H8            First 8 characters
      CP          Cartesian product with
        \,8       1-based range up to 8
  M               To each of the resulting pairs, map:
J_                 Join into a single string
           FB:    Convert from base
              18  18

You can run it at Replit, or a 17-byte version on TIO.

\$\endgroup\$
1
  • \$\begingroup\$ When I got this in my inbox I was like, "How on Earth did you do this with Python's package manager?" ;) \$\endgroup\$
    – Seggan
    Dec 15, 2021 at 17:53
3
\$\begingroup\$

Wolfram Language (Mathematica), 23 bytes

18#+162+#2&~Array~{8,8}

Try it online!

Returns a 2d array.

\$\endgroup\$
3
\$\begingroup\$

Clojure, 59 45 bytes

(map read-string(for[x"abcdefgh"y"12345678"](str"18r"x y)))

(for[x(range 10 18)y(range 1 9)](+(* 18 x)y))

\$\endgroup\$
3
\$\begingroup\$

C, 64, 62 bytes

Thank you @JustinFinnerty for the improvement

j;main(i){for(i=9;++i%18;)while(++j%9)printf("%d ",i*18+j%9);}

Try it here!

Less golfed version:

i,j;
main(){
    for(i=9;++i%18;)
        while(++j%9)
            printf("%d ",i*18+j%9);
}
\$\endgroup\$
2
  • \$\begingroup\$ Good answer, but we can save one byte using "i=9;while(++i%18)" instead of "for(i=10;i-18;i++)" \$\endgroup\$ Dec 18, 2021 at 11:13
  • \$\begingroup\$ @JustinFinnerty you're right! Thank you! \$\endgroup\$ Dec 18, 2021 at 13:19
2
\$\begingroup\$

Retina 0.8.2, 37 bytes


63$*¶

$.`
.+
$*_181$*
_{8}
18$*
%`.

Try it online! Explanation:


63$*¶

$.`

Insert the numbers from 0 to 63.

.+
$*_181$*

Convert to unary and add 181.

_{8}
18$*

Add an extra 10 for each multiple of 8 in the original number.

%`.

Convert to decimal.

\$\endgroup\$
2
\$\begingroup\$

Desmos, 37 31 bytes

[a+bfora=[1...8],b=[10...17]18]

Try It On Desmos!

Try It On Desmos! - Prettified

Finally got a chance to utilize the new list comprehension feature in Desmos!

Explanation:

[   for                       ]         initiate list comprehension for loop
       a=[1...8],                       loop from a=1 to a=8, incrementing by 1
                 b=[10...17]18          loop from b=10*18 to b=17*18, incrementing by 18
                                        (essentially creates a nested for loop)
 a+b                                    calculate a+b
\$\endgroup\$
2
\$\begingroup\$

Vyxal, 11 10 bytes

8:Ẋ18vβ⁺=+

Try it Online!

I actually didn't port anything for once lol 05ab1e porting go brrr.

Explained

8:Ẋ18vβ⁺=+
8:Ẋ        # The cartesian product of the range(1, 9) and range(1, 9)
   18vβ    # convert each pair from arbitrary base 18
       ⁺=+ # add 162 to each (128 + the index of `=` in the vyxal codepage)

11 bytes

8ƛ₀*9ɾM18vβ

Try it Online!

8ƛ₀*9ɾM18vβ
8ƛ          # For each item n in the range [1, 8]:
  ₀*        #   Mulitply n by 10
    9ɾM     #   [[n * 10, x] for x in range(1, 10)]
       18vβ #   and convert each from arbitrary base 18 to base 10
\$\endgroup\$
2
\$\begingroup\$

Scratch, 112 bytes

Try it online!

Not much room for improvement

when gf clicked
set[N v]to(170
delete all of[C v
repeat(8
change[N v]by(10
repeat(8
change[N v]by(1
add(N)to[C v

Commentated:

when gf clicked      Initiates code
set[N v]to(170       Sets N to 98 (in base-18)
delete all of[C v    Clears the list
repeat(8             Loops code for each column of the chessboard
change[N v]by(10     Increases the tens digit by 1 and decreases the ones digit by 8
repeat(8             Loops code for each row of the chessboard
change[N v]by(1      Increases the ones digit by 1
add(N)to[C v         Adds N to the list
\$\endgroup\$
2
\$\begingroup\$

X86-64 Machine Code, Microsoft Calling Convention, 27 bytes

33 C0                xor         eax,eax  
B0 B5                mov         al,0B5h  
B2 08                mov         dl,8  
outerLoop:
B6 08                mov         dh,8  
innerLoop:
89 01                mov         dword ptr [rcx],eax  
48 83 C1 04          add         rcx,4  
FF C0                inc         eax  
FE CE                dec         dh  
75 F4                jne         innerLoop  
04 0A                add         al,0Ah  
FE CA                dec         dl  
75 EC                jne         outerLoop  
C3                   ret  

Which has the following function signature:

extern "C" void chessNumbers(uint32_t* out);
\$\endgroup\$
1
\$\begingroup\$

Perl 5, 33 bytes

map{//;say$_+$'*18for 1..8}10..17

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Brachylog, 14 bytes

8⟦₁+₉ᶻ\↔ẋ~ḃ₁₈ᵐ

Try it online!

8⟦₁               Range [1..8]
   +₉ᶻ            Add 9 to each element [[1,10],[2,11],..,[8,17]]
      \↔          Transpose and swap [[10..17],[1..8]]
        ẋ         Cartesian product [[10,1],[10,2]..]
         ~ḃ₁₈ᵐ    Convert each element from base 18

\$\endgroup\$
0
\$\begingroup\$

SimpleTemplate 0.84, 163 bytes

This code simply outputs a space separated list of numbers.

{@setN 181}{@for to314}{@if_ matches"@18[2-8]|199|2([09][0-6]|3[5-9]|4[012]|5[3-9]|60|7[1-8]|89|9[0-6])|(21|30)[789]|(22|31)[0-4]@"}{@setN N,_}{@/}{@/}{@echoj" "N}

It looks yucky, but works!

How it works?

The code loops from 0 to 314, and then verifies if the number matches the following regular expression:

@18[2-8]|199|2([09][0-6]|3[5-9]|4[012]|5[3-9]|60|7[1-8]|89|9[0-6])|(21|30)[789]|(22|31)[0-4]@

If it matches, it is added to the array of numbers we need.

The generated array looks like this:

[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[181,182],183],184],185],186],187],188],199],200],201],202],203],204],205],206],217],218],219],220],221],222],223],224],235],236],237],238],239],240],241],242],253],254],255],256],257],258],259],260],271],272],273],274],275],276],277],278],289],290],291],292],293],294],295],296],307],308],309],310],311],312],313],314]

And this is the final output:

181 182 183 184 185 186 187 188 199 200 201 202 203 204 205 206 217 218 219 220 221 222 223 224 235 236 237 238 239 240 241 242 253 254 255 256 257 258 259 260 271 272 273 274 275 276 277 278 289 290 291 292 293 294 295 296 307 308 309 310 311 312 313 314

The {@echo} will automatically flatten the array internally, before printing it.


Ungolfed:

The code is pretty nasty to look at, so, here's an ungolfed version that does the same:

{@set numbers 181}

{@for i from 0 to 314}
    {@if i matches "@18[2-8]|199|2([09][0-6]|3[5-9]|4[012]|5[3-9]|60|7[1-8]|89|9[0-6])|(21|30)[789]|(22|31)[0-4]@"}
        {@set numbers numbers, i}
    {@/}
{@/}

{@echo separator " " numbers}

About the language

There are a few things that are important to know to fully understand how it works.

  • Almost all whitespace is optional.
  • It is required to start with 181 in the variable.
    If the variable isn't set to 181, the output will be incorrect, because the first value in the array will be null.
  • The {@for to314} is the same as {@for i from 0 to 314}.
    The variable is optional, and automatically assigns to _.
    The from 0 isn't required, as the loop will automatically start from 0 to the final number.
  • Both {@echo separator " " numbers} and {@echoj" "N} do the same:
    Output the variable values separated by " ". The j stands for "join", in echoj.

Running the code:

You can run the code on: http://sandbox.onlinephpfunctions.com/code/117ed06567a1d0e710e75b963566b86b510ca7ab

Please pick a version between 5.6 and 7.4.13. Can't fix the 8.0.0 compatibility issue without invalidating this answer.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.