Desafío

La notación de Forsyth-Edwards (FEN) es una notación estándar para describir una posición particular del tablero de un juego de ajedrez. Su desafío es evaluar el puntaje utilizando la cadena FEN. Este es un ejemplo de una cadena FEN:

5k2/ppp5/4P3/3R3p/6P1/1K2Nr2/PP3P2/8

Con esta cadena, puede calcular la puntuación del material para cada color con la siguiente tabla de puntuación:

• p / P = Peón = 1 punto
• n / N = Caballero = 3 puntos
• b / B = Obispo = 3 puntos
• r / R = Torre = 5 puntos
• q / Q = Reina = 9 puntos
• k / K = Rey, estos no tienen ningún punto porque cada posición legal contiene un rey para cada lado

Las piezas blancas se designan con letras mayúsculas ("PNBRQK") mientras que las piezas negras usan minúsculas ("pnbrqk"). Los cuadrados vacíos se observan utilizando los dígitos del 1 al 8 (el número de cuadrados vacíos), y "/" separa los rangos.

A partir de la cadena de ejemplo FEN, podemos calcular las puntuaciones de material para cada lado:

Para negro:

5 k 2 / ppp 5 / 4P3 / 3R3 p / 6P1 / 1K2N r 2 / PP3P2 / 8

Quedan todas las piezas negras: p + p + p + p + r, esto es un total de 9

Para blanco:

5k2 / ppp5 / 4 P 3/3 R 3p / 6 P 1/1 K 2 N r2 / PP 3 P 2/8

Quedan todas las piezas blancas: P + R + P + N + P + P + P, esto es un total de 13

El puntaje final se determina con la siguiente fórmula: puntaje blanco - puntaje negro = puntaje final , entonces, por ejemplo, el puntaje final sería: 13 - 9 = 4

Ejemplo :

Entrada:

5k2/ppp5/4P3/3R3p/6P1/1K2Nr2/PP3P2/8

Salida:

4

Todos los códigos de golf reglas se aplican aquí, la solución con la menor cantidad de bytes victorias.

Cómo publicar

# Language Name, N bytes

 [code]

 [explaination, etc.]

CJam, 28 27 26 bytes

0l{i32mdD%[5ZZX9]=\3%(*+}/

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

0l         e# Push a 0 (accumulator) and a line from STDIN.
{          e# For each character of that line:
  i32md    e#   Divide its code point by 32; push quotient and residue.
           e#   This serves two purposes:
           e#     1. The quotient will let us distinguish between uppercase
           e#        letters, lowercase letters and non-letters.
           e#     2. The residue will be the same for uppercase and lowercase
           e#        variants of the same letter.
  D%       e#   Take the residue modulo 13.
           e#   This maps R,N,B,P,Q -> 5,1,2,3,4
  [5ZZX9]= e#   Select the element at that index (5 ≡ 0) from [5 3 3 1 9].
  \        e#   Swap the quotient on top of the stack.
           e#   1 is digit or slash, 1 is uppercase, 2 is lowercase.
  3%(      e#   Take the quotient modulo 3 and subtract 1 from the result.
           e#   This maps 1,2,3 -> 0,1,-1.
  *+       e#   Multiply the generated integers.
  +        e#   Add the product to the accumulator.
}/         e#

> <> , 64 57 56 53 bytes

"QRBNP"013359v
$0p4}:{:v?=1l<p4+' '{-
g4v?(0:i<+
n~<;

(-7 bytes con algo de inspiración de la respuesta de @ El'endiaStarman, -3 bytes gracias a @randomra)

Explicación

El programa usa el cuadro de código como una tabla de búsqueda. Los put / gets fuera de rango no funcionan con el intérprete en línea, por lo que esto solo funciona con el intérprete oficial de Python.

La primera línea empuja las piezas, seguido de los valores de las piezas. También empuja un 0 inicial para iniciar el total de la tercera línea.

La segunda línea coloca el valor positivo o negativo apropiado en la celda de pieza correspondiente, por ejemplo, -1se coloca en ('p', 4)y 1se coloca ('P', 4). La longitud de la pila se verifica para asegurarse de que el ciclo se ejecute 5 veces.

Una vez que finaliza el ciclo, la pila consiste en nuestro único cero desde la primera línea. Para cada carácter, realizamos una búsqueda en la celda correspondiente en la tabla y la agregamos a nuestro total. Por defecto, los valores de celda no inicializados son 0, lo cual es perfecto para nuestros propósitos.

La última línea simplemente imprime el resultado.

Ruby, 88 caracteres

->s{s.chars.map{|c|({P:1,N:3,B:3,R:5,Q:9}[:"#{c.upcase}"]||0)*(c.ord<90?1:-1)}.inject:+}

Esto es incómodo y feo, y probablemente haya una mejor manera, pero bueno.

La {foo: 'bar'}sintaxis de Ruby en realidad es solo azúcar, esto {:foo => 'bar'}es molesto para el golf porque significa que tengo que convertir la clave en un símbolo antes de usarla para acceder a un elemento hash ( :"#{x}"es un carácter más corto que x.to_sym).

Pip, 39 bytes

Tomaré mi breve turno antes de que lleguen las respuestas de CJam y Pyth ...

$+Y(95<=>A_)*013359@{"KPNBRQ"@?UCa|0}Ma

Toma la cadena FEN como un argumento de línea de comandos. Aquí hay una explicación para una versión ungolfed:

$+({(95<=>Aa)*013359@("KPNBRQ"@?UCa|0)}Ma)

   {                                  }Ma   Map this function to each character in input:
                                UCa          Uppercase version of character
                      "KPNBRQ"@?             Its index in this string, nil if not present
                                   |0        Logical or with 0 (to turn nil into 0)
              013359@(               )       Index into this number to get piece's score
          Aa                                 ASCII value of character
     95<=>                                   1 if less than 95, -1 if greater than 95
    (       )*                               Multiply by the score
$+(                                      )  Sum all scores and autoprint result

Perl, 44 bytes

#!perl -p
$\+=lc=~y/pnbrq/13359/r*(a cmp$_)for/\D/g}{

Contando el shebang como uno, la entrada se toma de stdin.

Uso de muestra

$ echo 5k2/ppp5/4P3/3R3p/6P1/1K2Nr2/PP3P2/8 | perl fen-score.pl
4

Explicación

Las piezas se transliteran con sus respectivos valores. Si la pieza está en mayúscula (es decir, menor que a), su valor se agrega a la suma, si no se resta.

JavaScript ES7, 79 bytes 124 131

s=>(i=0,[for(q of s)i+={P:1,N:3,B:3,R:5,Q:9,p:-1,n:-3,b:-3,r:-5,q:-9}[q]||0],i)

Tan corto como puedo llegar. Utiliza comprensiones de arreglos elegantes para recorrer la cadena.

Explicación

s=>(     // Define function with an argument

    i=0, // this var will store the score

    [for(q of s)   // Loops through input
      i+=          // Adds to score by...

         {P:1,...,   // Defines value of each letter
          p:-1,...}  // Negative value instead, which will subtract
         || 0        // Otherwise add 0

    ], i           // Return score

Minkolang 0.9 , 72 65 64 60 44 42 41 bytes

13359"QRBNP"m5[d3~c~$r48*+0p0p]$I[o0q+]N.

Pruébalo aquí

¡Muchas gracias a Sp3000 por señalar una forma mucho más eficiente de hacer esto!

Explicación

13359"QRBNP"mempuja los puntajes y sus caracteres correspondientes, luego los intercala , para que la pila se vea así:[1,80,3,78,3,66,5,82,9,81] . Luego 5[d3~c~$r48*+0p0p]coloca la puntuación de cada carácter, tanto en minúsculas como en mayúsculas, en su ubicación en el espacio de código. Finalmente, $I[o0q+]N.recorre la entrada hasta que esté vacía, sumando los puntajes a medida que avanza.

CJam, 33 bytes

q{"PNBRQ"_el+#13359Ab_Wf*+0+=}%:+

Aquí está la manera súper ingenua de encontrar cuerdas. Pruébalo en línea .

Ouroboros , 82

Ouroboros es un esolang que diseñé esta semana. ¡Es hora de dar una vuelta!

i.1+!57*(\m1(M\1).96>.@32*-.80=\.78=3*\.66=3*\.82=5*\81=9*++++\2*1\-*+
)L!4*(4Sn1(

Cada línea de comandos ^de un solo carácter ¹ representa una serpiente ouroboros, en la que la ejecución procede de la cabeza (inicio) a la cola (final) y regresa a la cabeza. El (y) comandos le permiten comer parte de la cola o regurgitan, cambiando así lo que los comandos se ejecutan. Si alguna vez se traga el puntero de instrucción, la serpiente muere (deja de ejecutarse). Un programa Ouroboros consiste en una o más serpientes que se ejecutan en paralelo. Cada serpiente tiene una pila propia, y también hay una pila compartida.

¹ _{Una excepción, que distingue a Ouroboros de muchos lenguajes 2D: los números de varios dígitos se pueden escribir directamente, sin tener que hacer cálculos matemáticos o presionar un 0 primero.}

Serpiente 1

La primera serpiente lee un carácter ( i) y comprueba si es -1 / EOF ( .1+!). Si es así, se come la mayor parte de su cola, hasta e incluyendo el M( 57*().

Luego, la serpiente intercambia el código del personaje con la cuenta que está arriba de la pila ( \), mueve la cuenta a la pila compartida ( m) y se traga otro personaje ( 1(). Si ya se había tragado un montón, esto significa que se traga el hecho de (que la IP está actualmente encendida y muere. De lo contrario, la ejecución continúa moviendo la cuenta de regreso a la pila de la serpiente 1, intercambiándola con el código de char y regurgitando el personaje que se tragó previamente ( M\1)).

Luego usamos operaciones matemáticas y de pila para generar el puntaje apropiado para el personaje. .96>prueba si es minúscula o no; los siguientes se 32*-convierten a mayúsculas. A continuación, el largo tramo de .80=a 81=9*++++mapas P-> 1, N-> 3, etc. Por último, \2*1\-*niega la puntuación si la carta fue minúscula, y +lo añade a la cuenta corriente. La serpiente luego gira y lee otro personaje.

Serpiente 2

La segunda serpiente comienza con una operación de regurgitación ( )), que no hace nada la primera vez (ya que todavía no se ha tragado nada, y también desde que aparece una pila vacía 0). Luego, empuja la longitud de la pila compartida a su propia pila y niega lógicamente ( L!). Esto da 1si la pila está vacía, de lo 0contrario. La serpiente se multiplica por 4 y se come esa cantidad de caracteres ( 4*().

Si la pila compartida estaba vacía, esto significa que la serpiente ahora termina antes que S. Empuja 4y regresa al ), donde regurgita a los personajes que acaba de tragar y comienza de nuevo.

Sin embargo, si hubo un valor en la pila compartida, no se tragan caracteres y la ejecución continúa. La serpiente cambia a la pila compartida y muestra el número allí ( Sn); luego se traga su último personaje y muere (1( ).

Sincronización

Las dos serpientes deben sincronizarse cuidadosamente para que nunca haya un valor en la pila compartida cuando la serpiente 2 hace su verificación, hasta que se alcanza el final de la entrada. Snake 1 pone un valor en la pila compartida brevemente en cada pasada a través de su ciclo. Por lo tanto, el Lcomando de la serpiente 2 nunca debe ejecutarse entre los comandos my Mde la serpiente 1. Afortunadamente, las serpientes se alinean muy bien. Crucialmente, la longitud del bucle de la serpiente 1 (70 instrucciones) es un múltiplo del bucle de la serpiente 2 (7 instrucciones), por lo que los dos nunca se desincronizarán:

i.1+!57*(\m1(M\1).96>.@32*-.80=\.78=3*\.66=3*\.82=5*\81=9*++++\2*1\-*+
)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5)L!5*(5
          |__|
       Danger zone

Si los números no hubieran funcionado tan perfectamente, habría rellenado una o ambas serpientes con espacios para alinearlas según sea necesario.

¡Todo esto está muy bien, pero quiero verlo en acción!

Aquí está el programa anterior a través de Fragmento de pila. Incluso en 1000 operaciones por segundo, lleva unos 10 segundos escupir la respuesta para la entrada de muestra, ¡pero llega allí!

// Define Stack class
function Stack() {
  this.stack = [];
  this.length = 0;
}
Stack.prototype.push = function(item) {
  this.stack.push(item);
  this.length++;
}
Stack.prototype.pop = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack.pop();
    this.length--;
  }
  return result;
}
Stack.prototype.top = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack[this.length - 1];
  }
  return result;
}
Stack.prototype.toString = function() {
    return "" + this.stack;
  }

// Define Snake class
function Snake(code) {
  this.code = code;
  this.length = this.code.length;
  this.ip = 0;
  this.ownStack = new Stack();
  this.currStack = this.ownStack;
  this.alive = true;
  this.wait = 0;
  this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
    if (!this.alive) {
      return null;
    }
    if (this.wait > 0) {
      this.wait--;
      return null;
    }
    var instruction = this.code.charAt(this.ip);
    var output = null;
    if (this.partialString !== null) {
      // We're in the middle of a double-quoted string
      if (instruction == '"') {
        // Close the string and push its character codes in reverse order
        for (var i = this.partialString.length - 1; i >= 0; i--) {
          this.currStack.push(this.partialString.charCodeAt(i));
        }
        this.partialString = null;
      } else {
        this.partialString += instruction;
      }
    } else if (instruction == '"') {
      this.partialString = "";
    } else if ("0" <= instruction && instruction <= "9") {
      if (this.partialNumber !== null) {
        this.partialNumber = this.partialNumber + instruction; // NB: concatenation!
      } else {
        this.partialNumber = instruction;
      }
      next = this.code.charAt((this.ip + 1) % this.length);
      if (next < "0" || "9" < next) {
        // Next instruction is non-numeric, so end number and push it
        this.currStack.push(+this.partialNumber);
        this.partialNumber = null;
      }
    } else if ("a" <= instruction && instruction <= "f") {
      // a-f push numbers 10 through 15
      var value = instruction.charCodeAt(0) - 87;
      this.currStack.push(value);
    } else if (instruction == "$") {
      // Toggle the current stack
      if (this.currStack === this.ownStack) {
        this.currStack = this.program.sharedStack;
      } else {
        this.currStack = this.ownStack;
      }
    } else if (instruction == "s") {
      this.currStack = this.ownStack;
    } else if (instruction == "S") {
      this.currStack = this.program.sharedStack;
    } else if (instruction == "l") {
      this.currStack.push(this.ownStack.length);
    } else if (instruction == "L") {
      this.currStack.push(this.program.sharedStack.length);
    } else if (instruction == ".") {
      var item = this.currStack.pop();
      this.currStack.push(item);
      this.currStack.push(item);
    } else if (instruction == "m") {
      var item = this.ownStack.pop();
      this.program.sharedStack.push(item);
    } else if (instruction == "M") {
      var item = this.program.sharedStack.pop();
      this.ownStack.push(item);
    } else if (instruction == "y") {
      var item = this.ownStack.top();
      this.program.sharedStack.push(item);
    } else if (instruction == "Y") {
      var item = this.program.sharedStack.top();
      this.ownStack.push(item);
    } else if (instruction == "\\") {
      var top = this.currStack.pop();
      var next = this.currStack.pop()
      this.currStack.push(top);
      this.currStack.push(next);
    } else if (instruction == "@") {
      var c = this.currStack.pop();
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(c);
      this.currStack.push(a);
      this.currStack.push(b);
    } else if (instruction == ";") {
      this.currStack.pop();
    } else if (instruction == "+") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a + b);
    } else if (instruction == "-") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a - b);
    } else if (instruction == "*") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a * b);
    } else if (instruction == "/") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a / b);
    } else if (instruction == "%") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a % b);
    } else if (instruction == "_") {
      this.currStack.push(-this.currStack.pop());
    } else if (instruction == "I") {
      var value = this.currStack.pop();
      if (value < 0) {
        this.currStack.push(Math.ceil(value));
      } else {
        this.currStack.push(Math.floor(value));
      }
    } else if (instruction == ">") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a > b));
    } else if (instruction == "<") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a < b));
    } else if (instruction == "=") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a == b));
    } else if (instruction == "!") {
      this.currStack.push(+!this.currStack.pop());
    } else if (instruction == "?") {
      this.currStack.push(Math.random());
    } else if (instruction == "n") {
      output = "" + this.currStack.pop();
    } else if (instruction == "o") {
      output = String.fromCharCode(this.currStack.pop());
    } else if (instruction == "r") {
      var input = this.program.io.getNumber();
      this.currStack.push(input);
    } else if (instruction == "i") {
      var input = this.program.io.getChar();
      this.currStack.push(input);
    } else if (instruction == "(") {
      this.length -= Math.floor(this.currStack.pop());
      this.length = Math.max(this.length, 0);
    } else if (instruction == ")") {
      this.length += Math.floor(this.currStack.pop());
      this.length = Math.min(this.length, this.code.length);
    } else if (instruction == "w") {
      this.wait = this.currStack.pop();
    }
    // Any instruction not covered by the above cases is ignored
    if (this.ip >= this.length) {
      // We've swallowed the IP, so this snake dies
      this.alive = false;
      this.program.snakesLiving--;
    } else {
      // Increment IP and loop if appropriate
      this.ip = (this.ip + 1) % this.length;
    }
    return output;
  }

// Define Program class
function Program(source, speed, io) {
  this.sharedStack = new Stack();
  this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
    var snake = new Snake(snakeCode);
    snake.program = this;
    snake.sharedStack = this.sharedStack;
    return snake;
  }.bind(this));
  this.snakesLiving = this.snakes.length;
  this.io = io;
  this.speed = speed || 10;
  this.halting = false;
}
Program.prototype.run = function() {
  if (this.snakesLiving) {
    this.step();
    this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
  }
}
Program.prototype.step = function() {
  for (var s = 0; s < this.snakes.length; s++) {
    var output = this.snakes[s].step();
    if (output) {
      this.io.print(output);
    }
  }
}
Program.prototype.halt = function() {
  window.clearTimeout(this.timeout);
}
var ioFunctions = {
  print: function(item) {
    var stdout = document.getElementById('stdout');
    stdout.value += "" + item;
  },
  getChar: function() {
    if (inputData) {
      var inputChar = inputData[0];
      inputData = inputData.slice(1);
      return inputChar.charCodeAt(0);
    } else {
      return -1;
    }
  },
  getNumber: function() {
    while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
      inputData = inputData.slice(1);
    }
    if (inputData) {
      var inputNumber = inputData.match(/\d+/)[0];
      inputData = inputData.slice(inputNumber.length);
      return +inputNumber;
    } else {
      return -1;
    }
  }
};
var program = null;
var inputData = null;

function resetProgram() {
  var stdout = document.getElementById('stdout');
  stdout.value = null;
  if (program !== null) {
    program.halt();
  }
  program = null;
  inputData = null;
}

function initProgram() {
  var source = document.getElementById('source'),
    stepsPerSecond = document.getElementById('steps-per-second'),
    stdin = document.getElementById('stdin');
  program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
  inputData = stdin.value;
}

function runBtnClick() {
  if (program === null || program.snakesLiving == 0) {
    resetProgram();
    initProgram();
  } else {
    program.halt();
    var stepsPerSecond = document.getElementById('steps-per-second');
    program.speed = +stepsPerSecond.innerHTML;
  }
  program.run();
}

function stepBtnClick() {
  if (program === null) {
    initProgram();
  } else {
    program.halt();
  }
  program.step();
}

.container {
  width: 100%;
}
.so-box {
  font-family: 'Helvetica Neue', Arial, sans-serif;
  font-weight: bold;
  color: #fff;
  text-align: center;
  padding: .3em .7em;
  font-size: 1em;
  line-height: 1.1;
  border: 1px solid #c47b07;
  -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
  background: #f88912;
  box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
  display: inline-block;
  border-radius: 6px;
  float: left;
  margin-right: 25px;
  cursor: pointer;
}
.option {
  padding: 10px 20px;
  margin-right: 25px;
  float: left;
}
h1 {
  text-align: center;
  font-family: Georgia, 'Times New Roman', serif;
}
a {
  text-decoration: none;
}
input,
textarea {
  box-sizing: border-box;
}
textarea {
  display: block;
  white-space: pre;
  overflow: auto;
  height: 40px;
  width: 100%;
  max-width: 100%;
  min-height: 25px;
}
span[contenteditable] {
  padding: 2px 6px;
  background: #cc7801;
  color: #fff;
}
#stdout-container,
#stdin-container {
  height: auto;
  padding: 6px 0;
}
#reset {
  float: right;
}
#source-display-wrapper {
  display: none;
  width: 100%;
  height: 100%;
  overflow: auto;
  border: 1px solid black;
  box-sizing: border-box;
}
#source-display {
  font-family: monospace;
  white-space: pre;
  padding: 2px;
}
.activeToken {
  background: #f88912;
}
.clearfix:after {
  content: ".";
  display: block;
  height: 0;
  clear: both;
  visibility: hidden;
}
.clearfix {
  display: inline-block;
}
* html .clearfix {
  height: 1%;
}
.clearfix {
  display: block;
}

<!--
Designed and written 2015 by D. Loscutoff
Much of the HTML and CSS was taken from this Befunge interpreter by Ingo Bürk: http://codegolf.stackexchange.com/a/40331/16766
-->
<div class="container">
  <textarea id="source" placeholder="Enter your program here" wrap="off">i.1+!57*(\m1(M\1).96>.@32*-.80=\.78=3*\.66=3*\.82=5*\81=9*++++\2*1\-*+
)L!4*(4Sn1(</textarea>
  <div id="source-display-wrapper">
    <div id="source-display"></div>
  </div>
</div>
<div id="stdin-container" class="container">
  <textarea id="stdin" placeholder="Input" wrap="off">5k2/ppp5/4P3/3R3p/6P1/1K2Nr2/PP3P2/8</textarea>
</div>
<div id="controls-container" class="container clearfix">
  <input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" />
  <input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" />
  <input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" />
  <input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" />
</div>
<div id="stdout-container" class="container">
  <textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea>
</div>
<div id="options-container" class="container">
  <div class="option so-box">Steps per Second: <span id="steps-per-second" contenteditable>1000</span>
  </div>
</div>

JavaScript ES6, 71

Como una función anónima

n=>[...n].map(x=>t+=~(y='q   rnb p PBN R   Q'.search(x))?y-9|1:0,t=0)|t

Perl 5, 71 63 bytes

%a=(P,1,N,3,B,3,R,5,Q,9);$\+=$a{$_}||-$a{uc$_}for<>=~/./g;print

Esto modifica $\ (el separador de línea para print, que comienza en falso) para cada alfanumérico en la cadena que es una clave del hash %adefinido al principio. Se incrementa $\por el valor del hash si la letra es una clave como es; de lo contrario, incrementa en negativo el valor del hash si la letra mayúscula es una clave; de lo contrario no agrega nada.

Muchas gracias a primo por salvarme ocho bytes (en un comentario sobre esta respuesta).

Puedo guardar otro byte con otra sugerencia de primo (¡gracias!): Cambiar $a{$_}||-$a{uc$_}a$a{$_}-$a{$"^$_} . Pero creo que esa es una respuesta bastante diferente a la mía, así que no tomaré el "crédito" (de -1 byte) por ello.

Clojure / ClojureScript, 63 caracteres

#(apply +(map{"P"1"N"3"B"3"R"5"Q"9"p"-1"n"-3"b"-3"r"-5"q"-9}%))

Escrito usando un ClojureScript REPL, también debe ser válido Clojure. Intentalo aquí . Ingrese, luego llámelo usando(*1 "FEN_string_here")

Muy claro. {"P"1..."q"-9}es una estructura de datos literal para un mapa de "P" a 1, "N" a 3, etc. maptoma la función como primer argumento y la estructura de datos para procesar como el segundo; en este caso, está utilizando la función que Una estructura de datos (el literal del mapa) puede actuar como su propia función de acceso. El parámetro de cadena ( %de la macro de función) puede tratarse como una lista de cadenas de caracteres individuales. Cualquier personaje que no esté en el mapa terminará como nilen la lista resultante, que +felizmente ignora.

Pyth, 25 bytes

-Fmsmhy/4@S5%Ck12@Gd_rBz2

Demostración

Utiliza la siguiente fórmula de mapeo para las letras pbnrq, si kes la letra:

(4 / (((chr(k) % 12) % 5) + 1) * 2 + 1

Esto se representa en Pyth como:

hy/4@S5%Ck12

Primero, el programa crea la versión con mayúsculas y minúsculas de la entrada, luego en ambas cadenas se filtran las letras minúsculas, luego aplica la fórmula anterior, luego suma y resta los valores negros de los valores blancos.

Pitón 3, 93

v=dict(zip('pbnrqPBNRQ',[1,3,3,5,9]*2))
print(sum(v.get(c,0)*(-1)**(c>'Z')for c in input()))