Convert Descriptive Notation to Algebraic Notation

Question

Introduction

Many old chess books use descriptive notation to notate squares on a chessboard, naming the file (column) of the square based on the starting piece positions of White or Black, depending on whose move it is. The ranks (rows) are numbered 1 through 8, with 1 being closest to the player. For example, from White's perspective, QR2 represents the file where the queenside rook started, on the 2nd rank from the bottom.

However, this system has been entirely replaced by algebraic notation in the past few decades, which simply notates files with letters a-h and rows with numbers 1-8, always "from White's point of view". Therefore it would be convenient to have a program that can translate squares from old books.

Note: This problem is the simplified inverse of Convert Algebraic notation to Descriptive notation

Diagrams

Descriptive notation

Credit: David Eppstein

Algebraic notation

Credit: ILA-boy, Klin, Beao

Task

Given a chess square as a string and either white or black's perspective in descriptive notation, output the chess square in algebraic notation. Reasonable inputs may be used, such as a boolean for white/black perspective. For simplicity, we do not handle moves (including captures) or special symbols (promotion, castling, blunders, end of game, etc.)

The inputs and outputs are case sensitive and follow the above diagrams, with descriptive notation always using capital letters and algebraic notation always using lowercase letters. You must take the input square as one string like "QR1", not two like "QR" and "1".

Test cases

white,QR1 => a1
white,KR8 => h8
white,Q4  => d4
white,KN7 => g7
black,QR1 => a8
black,KR8 => h1
black,Q4  => d5
black,KN7 => g2

Answer 1

JavaScript (ES6), 62 bytes

Expects (white)(string), where white is a Boolean flag.

w=>s=>"egfbchda"[(q=parseInt(s,b=29))/b%43%10|0]+(w?q%b:9-q%b)

Try it online!

How?

We parse the descriptive notation as a base-29 string and save the result in \$q\$.

The row number is \$q\bmod29\$ for White and \$9-(q\bmod29)\$ for Black.

For the column, we apply this minimal perfect hash function:

$$\big(\lfloor q/29\rfloor\bmod43\big)\bmod10$$

Column	String	\$\lfloor q/29 \rfloor\$	\$\bmod 43\$	\$\bmod 10\$
a	"QRx"	781	7	7
b	"QNx"	777	3	3
c	"QBx"	765	34	4
d	"Qx"	26	26	6
e	"Kx"	20	20	0
f	"KBx"	591	32	2
g	"KNx"	603	1	1
h	"KRx"	607	5	5

Example search code

This simple piece of code looks for the shortest valid hash functions of the form parseInt(s, b) % m0 % m1 with \$28\le b\le 36\$ and \$2\le m_1<m_0<100\$.

It is quite inefficient because it tries all tuples \$(b,m_0,m_1)\$ even if \$(b,m_0)\$ alone leads to an unrecoverable lookup collision. But this works fine for a such a limited search space.

const O = {
  "QR" : "a",
  "QN" : "b",
  "QB" : "c",
  "Q"  : "d",
  "K"  : "e",
  "KB" : "f",
  "KN" : "g",
  "KR" : "h"
};

let best = 1 / 0;

for(let b = 28; b <= 36; b++) {
  for(let m0 = 2; m0 <= 100; m0++) {
    for(let m1 = 2; m1 < m0; m1++) {
      let lookup = Array(m1).fill('?');

      if(Object.keys(O).every(key => {
        let i = parseInt(key, b) % m0 % m1;
        if(lookup[i] == '?') {
          lookup[i] = O[key];
        }
        return lookup[i] == O[key];
      })) {
        let str = lookup.join('').replace(/\?*$/, ''),
            code = `"${str}"[parseInt(s,${b})%${m0}%${m1}]`,
            score = code.length;
        if(score <= best) {
          best = score;
          console.log(`Score: ${score} : ${code}`);
        }
      }
    }
  }
}

Try it online!

Answer 2

JavaScript, 68 bytes

s=>w=>'dcbaefgh'[x=s.at(-1),('P'>s)*4-~'BNR'.search(s[1])]+(w?x:9-x)

f=

s=>w=>'dcbaefgh'[x=s.at(-1),('P'>s)*4-~'BNR'.search(s[1])]+(w?x:9-x)

function test(white) {
  const table = document.createElement('table');
  for (const i of (white ? '12345678' : '87654321')) {
    const row = table.appendChild(document.createElement('tr'));
    for (const j of 'QR,QN,QB,Q,K,KB,KN,KR'.split(',')) {
      row.appendChild(document.createElement('td')).textContent = f(j + i)(white);
    }
  }
  document.body.appendChild(table);
}

test(true);
test(false);

table { display: inline-table; margin-right: 30px; border-collapse: collapse; border: 1px solid black; }
td { width: 25px; height: 25px; line-height: 25px; text-align: center; background: white; color: black; }
tr:nth-child(odd) td:nth-child(even), tr:nth-child(even) td:nth-child(odd) { filter: invert(); }

Answer 3

Python, 65 bytes

lambda t,s:f'{97+((x:=int(s[1:],30))>>8^3+(s<"Q")):c}{(-t^x)%10}'

Attempt This Online!

Old Python, 67 bytes (@xnor)

lambda t,s:f'{97+(11*ord(s[1])>>7^7*(s>"L")):c}{8**t*int(s[-1])%9}'

Attempt This Online!

Old Python, 68 bytes (@ovs)

lambda t,s:f'{97+(11*ord(s[1])>>7^7*(s>"L")):c}{int(t*"-"+s[-1])%9}'

Attempt This Online!

Old Python, 72 bytes

lambda t,s:"%c%i"%(97+("RNB".find(s[1])%4^7*(s<"Q")),int(t*"-"+s[-1])%9)

Attempt This Online!

A golfed version of @Adam's answer which I was advised is different enough to warrant a separate post.

Answer 4

Jelly, 24 22 bytes

ṪVN³¡%9Ṿṭ“¡ṭ."“¬’ḥịØaƲ

Try it online! (the footer is a test suite that tests all 64 possibilities from a given player's point of view)

Function submission. Takes the coordinates in descriptive notation as a function argument, and the viewpoint (white=0, black=1) as a command-line argument.

Explanation

ṪVN³¡%9Ṿṭ“¡ṭ."“¬’ḥịØaƲ
Ṫ                       On the last character of the input,
 V                      convert it to a number,
  N                     negate
    ¡                   a number of times
   ³                    equal to the command-line argument,
     %9                 wrapping-modulo by 9,
       Ṿ                convert back to a string,
        ṭ               and prepend
                 ḥ      {the result of} the randomly generated function
         “¡ṭ."“           #29699285
              “¬’         with codomain [1..8]
Ṫ                    Ʋ    applied to the input minus its last character, after
                  ịØa     indexing into the lowercase alphabet

The probability that a randomly generated function with an 8-element codomain will map the eight column names onto eight different outputs is approximately 1 in 416. As such, it's possible to convert the column names from descriptive to algebraic notation simply by searching through Jelly's catalogue of random functions to find one that's a perfect hash function for the given inputs (i.e. it maps each of them to a different number from 1 to 8), and specify the codomain using an 8-character string that contains the desired output column names in the order with which the function generates them. Function #2423 happens to have the desired behaviour (I simply checked random functions until I found one that worked).

However, doing this requires the column names to be given explicitly. It's golfier to express them by indexing into the alphabet, but this requires finding a function that maps each of the eight column names onto a different number from 1 to 8 in the correct order. The odds of any given randomly generated function happening to do this are 1 in 16777216. After searching through tens of millions of randomly generated functions, I discovered that function #29699285 happens to have the desired behaviour.

When an appropriate function for converting column names is available, the only remaining requirement is to remove the row number before running the function, subtract from 9 if necessary, and add it back at the end. (The conditional subtraction from 9 is done by conditionally negating it, and then taking its value modulo 9.)

Answer 5

Batch Script, 179 Bytes

SET t=%2
SET /A a=96,p=%t:~-1%
FOR %%? in (QR QN QB Q K KB KN KR)DO SET /A a+=1,n=9-(((9-p)*(1-%1))+p*%1)&IF %%? == %t:~0,-1% CMD /C EXIT %%a%%&CALL ECHO %%=exitcodeAscii%%%%n%%

This is assuming @ECHO OFF is enabled. The second arg is the string (ie QR1), and 1st is the side. 0 for white, 1 for black. For example on CMD, if file is named chess.bat

CALL chess.bat 0 QR1

returns a1. I use the built-in variable =exitcodeAscii to get the letters from a-h, the rest is just a simple FOR loop.

Answer 6

Python, 85 bytes

lambda t,s:"%c%i"%(101-(q:="Q"in s)+(2*q-1)*~"BNR".find(s[1]),9*t-(2*t-1)*int(s[-1]))

Attempt This Online!

Takes in the integer 0 if it's white's move, 1 if it's black's move, along with the notation string. Returns a string.

Explanation

Not much of an explanation, but here's the code separated into a series of steps:

def f(t,s):
  q=0+("Q"in s)
  r="BNR".find(s[1])
  u=(2*q-1)*~r
  col=100-(q-u)
  x=(2*t-1)
  row=9*t-x*int(s[-1])
  return "%c%i"%(col,row)

Answer 7

Retina 0.8.2, 49 bytes

T`d`Rd`b.+
T`QKl,`d-e_
+T`b-gBNR`a-cf-h_BN`.[A-Z]

Try it online! Link includes test cases. Explanation:

T`d`Rd`b.+

For black, subtract the digit from 9, i.e. transliterate 0-9 to 9-0.

T`QKl,`d-e_

Q becomes d, K becomes e, and delete the white,/black, indicator.

+T`b-gBNR`a-cf-h_BN`.[A-Z]

For each column away from the centre, update the letter, e.g. QR ↦ dR ↦ cN ↦ bB ↦ a.

Answer 8

Batch, 126 bytes

@set s=%2
@set/ar=(%1*7^^%s:~-1%-1)+1
@for %%i in (QR.a QN.b QB.c Q.d K.e KB.f KN.g KR.h)do @if %%~ni==%s:~,-1% echo%%~xi%r%

Takes a boolean (0/1) and a string as command-line parameters (-2 bytes by abusing the input format to take 0 or 7 as the first parameter). Explanation:

@set s=%2

Get the second parameter into a variable so that we can slice it.

@set/ar=(%1*7^^%s:~-1%-1)+1

Calculate the descriptive row from the algebraic row by XORing the 0-indexed row with 0 or 7 as appropriate.

@for %%i in (QR.a QN.b QB.c Q.d K.e KB.f KN.g KR.h)do @if %%~ni==%s:~,-1% echo%%~xi%r%

Based on my answer to the linked challenge, loop over the pairs of descriptive and algebraic columns and output the algebraic column corresponding to the descriptive column. Note that echo ignores most punctuation immediately after the o which I use to consume the . that's part of the ~x extension, saving 2 bytes.

Answer 9

05AB1E, 29 bytes

Çнθ<…BNR¹Åsk+.•7œΔ&‘•èI9*¹θα«

Port of @tsh' JavaScript answer

Inputs in the order notation,perspective, where the perspective is 1/0 for black/white respectively.

Try it online or verify all test cases.

Explanation:

Ç           # Convert the (implicit) first input-string to a list of codepoint-integers
 н          # Leave just the first codepoint-integer
  θ         # Leave just its last digit
   <        # Decrease it by 1:
            #  0 if 'Q' and 4 if 'K'
…BNR        # Push string "BNR"
    ¹       # Push the first input-string again
     Ås     # Pop and leave just its middle character
            # (if the input contains just two characters, those will be the 'middle')
       k    # Get the index of this middle in the string (or -1 if not found):
            #  0 if 'B'; 1 if 'N'; 2 if 'R'; -1 if 'Q#'/'K#'
+           # Add the two integers together
 .•7œΔ&‘•   # Push compressed string "cbaefghd"
         è  # Index the earlier integer into this string
            # (0-based modular, so the -1 indexes into the trailing "d")
I           # Push the second input-digit
 9*         # Multiply it by 9
   ¹        # Push the first input-string yet again
    θ       # Pop and leave its last character (the digit)
     α      # Get the absolute difference of it with the (9*perspective)
      «     # Append this digit to the earlier character
            # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to compress strings not part of the dictionary?) to understand why .•7œΔ&‘• is "cbaefghd".

Answer 10

Python 3.10, 82 bytes

lambda b,s:C[C.find(s[:-1])-1]+str(abs(9*b-int(s[-1])))
C="dQeKaQRbQNcQBfKBgKNhKR"

Attempt This Online!

Testing out dictionary interleaving idea which is a little shorter than converting to ascii codes with chr. "Q" and "K" have to come first, otherwise they will match for at "QR".

-4 bytes using find instead of index and a better rank calculation for white/black.

Answer 11

Charcoal, 35 bytes

§β⌕⪪”＆↓↶Ｇ«ü\`~6ε⪪θ⊞↷” …η⊖ＬηＩ⎇Ｎ⁻⁹ΣηΣη

Try it online! Link is to verbose version of code. Takes the White/Black flag as a boolean. Explanation:

§β⌕⪪”＆↓↶Ｇ«ü\`~6ε⪪θ⊞↷” …η⊖Ｌη

Look up the column in a compressed table and output the lowercase letter with that index.

Ｉ⎇Ｎ⁻⁹ΣηΣη

Subtract the row from 9 if the player is Black.