Saída de todos os quadrados brancos ou pretos de um tabuleiro de xadrez


29

Introdução

É assim que um tabuleiro de xadrez se parece.

insira a descrição da imagem aqui

Você pode ver que a1é um quadrado escuro . No entanto, b1é um quadrado claro .

A tarefa

O desafio é, dado dark, lightou both, gerar toda a escuridão , luz ou todos os quadrados com um separador (como um espaço em branco ou uma nova linha). A ordem de todos os quadrados não importa .

Casos de teste

Input: dark
Output: a1 a3 a5 a7 b2 b4 b6 b8 
        c1 c3 c5 c7 d2 d4 d6 d8 
        e1 e3 e5 e7 f2 f4 f6 f8 
        g1 g3 g5 g7 h2 h4 h6 h8

Input: light
Output: a2 a4 a6 a8 b1 b3 b5 b7 
        c2 c4 c6 c8 d1 d3 d5 d7 
        e2 e4 e6 e8 f1 f3 f5 f7 
        g2 g4 g6 g8 h1 h3 h5 h7

Input: both
Output: a1 a2 a3 a4 a5 a6 a7 a8
        b1 b2 b3 b4 b5 b6 b7 b8
        c1 c2 c3 c4 c5 c6 c7 c8
        d1 d2 d3 d4 d5 d6 d7 d8
        e1 e2 e3 e4 e5 e6 e7 e8
        f1 f2 f3 f4 f5 f6 f7 f8
        g1 g2 g3 g4 g5 g6 g7 g8
        h1 h2 h3 h4 h5 h6 h7 h8

Nota: Eu pretendi a saída, mas isso não é necessário .

Isso é , então a submissão com a menor quantidade de bytes ganha!


Então, algo como a2a4a6...ficaria bem?
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Tem de conter um separador, como um espaço em branco ou uma nova linha, para que seja inválido.
Adnan

Podemos produzir uma matriz 2D bruta? Ou seja[[a2,a4,a6,a8],[...]...]
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Sim, isso é permitido #
Adnan

Do light, darke bothtem que ser entrada como Strings ou podem ser representados através de qualquer tipo de dados?
WKS 16/02

Respostas:


15

Pitão, 22 21 bytes

-1 byte por @ Sp3000

fn%Chz3%sCMT2sM*<G8S8

Sob a função %Chz3, os darkhashes são 1, light0 e both2. Se tomarmos a paridade da soma dos ords de um quadrado de xadrez (ou seja, a1-> [97, 33]-> (97 + 33)%2= 0, os quadrados escuros vão para 0 e a luz para 1 Isso nos permite filtrar pela desigualdade.

fn%Chz3%sCMT2sM*<G8S8      implicit: z=input
               *           Cartesian product of
                <G8          first 8 letters in G (alphabet)
                   S8        with [1,...,8] implicitly stringified
             sM*<G8S8      ['a1','a2,...,'a8','b1'...'h8']
f          T               Filter that by gives truthy result to lambda T:
        sCMT                   The sum of the ords of the chars in T,
       %    2                  modulo 2
 n                            does not equal
   Chz                          ord of the first char in z,
  %   3                         modulo 3
                            Implicitly print the list.

Experimente aqui .


21:fn%Chz3%sCMT2sM*<G8S8
Sp3000 17/02

@ Sp3000 Obrigado! Sabendo que estava usando 6 bytes para ajustá-lo, eu deveria ter tentado hashes diferentes.
lirtosiast

13

Utilitários Bash + GNU, 74

printf %s\\n {a..h}{1..9}|sed -n "`sed '/[db]/a1~2p
/t/a2~2p
c/9/d'<<<$1`"

{a..h}{1..9}é uma expansão de bash brace que produz todas as coordenadas para uma placa 8x8, além de uma coluna extra 9. Isso é importante porque torna o comprimento da linha ímpar, o que permite o efeito tabuleiro de damas.

O printfsimplesmente formatos de cada coordenada, um por linha.

A expressão sed construída exclui todas as x9coordenadas e imprime linhas pares ou ímpares ou as duas linhas de entrada, de acordo com a entrada do script.


11

JavaScript (SpiderMonkey 30+), 90 85 83 82 bytes

x=>[for(d of"12345678")for(c of"abcdefgh")if(x>'l'^parseInt(c+=d,19)%2|x<'d')c]+''

Retorna uma sequência de quadrados separados por vírgula. Versão compatível para 99 bytes:

x=>([..."12345678"].map(d=>[..."abcdefgh"].map(c=>c+d).filter(s=>x>'l'^parseInt(s,19)%2|x<'d')))+''

Funciona enumerando todos os 64 nomes de quadrados e analisando-os na base 19 para ver se são módulo claro ou escuro 2.


Boa. Este é o ES7
edc65

@ edc65 Ah, eu não conseguia lembrar. Acho que minha segunda versão é "only" ES6.
Neil

Agora o ES6 vence o ES7
edc65 16/02

@ edc65 Você estava dizendo?
Neil

4
@ edc65 Não acho que possamos concordar com um empate?
Neil

10

JavaScript (ES6), 82 87 98

Função anônima retornando uma sequência de quadrados separada por espaço.

i=>eval("for(o='',v=190;v<322;)v++%19<8&&i<'d'|v&1^i>'l'?o+=v.toString(19)+' ':o")

TESTE

f=i=>eval("for(o='',v=190;v<322;)v++%19<8&&i<'d'|v&1^i>'l'?o+=v.toString(19)+' ':o")

// less golfed

q=i=>{
  // loop over the range of number a0 (base 19) to h8 (base 19)
  for(o='',v=190;v<322;) 
  {
    if (v++ %19 < 8) // increment and execute the line below only if second digit in 1..8
      if (i<'d'|v&1^i>'l') // even == light, odd == dark, take both if input is 'both'
        o+=v.toString(19)+' '
  }
  return o
}

document.write('<hr>Both<br>'+f('both'))
document.write('<hr>Light<br>'+f('light'))
document.write('<hr>Dark<br>'+f('dark'))


1
Uau ... isso é loucura! Gostaria de saber se é possível ficar mais curto com ES6 ...
ETHproductions

@ETHproductions sim, é! Eu tenho um 86 pronto, mas eu ainda estou tentando fazer algo melhor (meu - em movimento - alvo é Neil com 85 ... não maldito 83)
edc65

7

Lote, 192 bytes

@set s=a1 a3 a5 a7
@set t=b2 b4 b6 b8
@if not %1==light call:b
@set s=a2 a4 a6 a8
@set t=b1 b3 b5 b7
@if %1==dark exit/b
:b
@echo %s% %s:a=c% %s:a=e% %s:a=g% %t% %t:b=d% %t:b=f% %t:b=h%

4

Pitão, 48 39 bytes

K*<G8S8Jfq%xGhT2%seT2K?qhz\bK?qhz\lJ-KJ

Experimente aqui!

Ainda mais do que a outra solução Pyth, mas acho que não consigo superar isso com meu algoritmo.

Explicação

Primeiro, geramos uma lista de todos os quadrados no quadro e atribuímos a ele Y. Em seguida, filtramos esta lista para que apenas os quadrados de luz permaneçam e atribuímos essa lista J. Depois disso, avaliamos a entrada e imprimimos:

  • Y se a entrada foi both
  • J se a entrada foi light
  • Y-J se a entrada foi dark

Determinar se um quadrado é claro funciona da seguinte maneira:

  • Mapeie o caractere para um número de 1-8 (a-> 1, b-> 2), resulta em 18para a8etc.
  • verifique se os dois números são ímpares ou pares ( x%2 == y%2)
  • Se são, o quadrado é claro, caso contrário, está escuro

K*<G8S8Jfq%xGhT2%seT2K?qhz\bK?qhz\lJ-KJ  # z=input

 *                                         # Cartesian product of
  <G8                                      # first 8 letters of the alphabet (a-h)
     S8                                    # 1-indexed range (1-8)
K                                          # K holds now all squares
       f             K                     # Filter K 
        q                                  # is equal
         %xGhT2                            # map [a-h] to a number [1-8] and take it modulo 2
               %seT2                       # Take modulo 2 from the row number
                      ?qhz\bK              # If input starts with 'b' print K
                             ?qhz\lJ       # If it starts with 'l' print J
                                    -KJ    # Otherwise print the difference of those 2

Oh meu Deus, que é mais curto que o meu por um longo tiro.
Addison Crump

4

Python 2, 73 71 70 bytes

lambda s:[chr(x/8+97)+`x%8+1`for x in range(64)if x+x/8&1^ord(s[0])%3]

Ainda estou um pouco confuso se as funções estão bem para a pergunta, já que o desafio menciona um "separador", mas como existem muitas outras submissões de funções, eu fiz o mesmo.

Semelhante à resposta de Erwan, mas com muito mais Python 2-ness.

(-2 bytes graças a @xnor)


lol eu nem sequer testar entre s=="dark"e s[0]=="d"mas para minha defesa no meu muito primeira tentativa eu usei s,*_=se 4cmp
Erwan

1
Eu sinto que deveria haver algo mais curto como ord(s[_])&_ou ord(s[_])/_.
Xnor

@ xnor De fato, existe com %:) Obrigado!
Sp3000 17/02

4

PHP, 132 126 120 108 106 bytes

for($s=strtr($argv[1],bdl,210);$c<8;$c++)for($r=0;$r<8;)if((++$r+$c)%2==$s||$s>1)echo"abcdefgh"[$c]."$r ";

Ele percorre as colunas (0-7) e as linhas (1-8) e verifica se a soma de ambas é ímpar / par.

Testado com PHP 5.6.4, execute: php -d error_reporting=30709 -r '<CODE>' {dark|light|both}


1
Bem-vindo ao PPCG! Esta é uma boa resposta, mas você receberá mais votos se adicionar uma explicação.
lirtosiast

Eu acho que você pode substituir $s==2por $s-1. Se s = 2 $, e -1, é um, o qual é truthy e vai continiue
Martijn

E eu acho que $c=0pode ser $c, ele vai dar um monte de avisos, mas pelo menos para escuro que funciona bem
Martijn

Obrigado, Martijn! Esqueci de remover os aparelhos também, -6 bytes por enquanto. E não sei por que, mas $s-1não funciona, mas deveria. Obrigado por esta ótima idéia! Vou depurar isso mais tarde.
killerbees19

Eu sou novo neste site, mas mensagens de erro por causa de $cvariável indefinida ? Isso soa um pouco estranho e inválido. Ou não?
killerbees19

3

Vitsy , 90 82 bytes

'`'8\[1+8\:]Yy1-\?8\['1'v8\[vD1+vr?]vX]i'h'-)[88*\[Z?aO]]i'r'-)[?1m]1m
84*\[Z??aO]

Explicação da primeira linha:

'`'8\[1+8\:]Yy1-\?8\['1'v8\[vD1+vr?]vX]i'h'-)[88*\[Z?aO]]i'r'-)[?1m]i'g'-)[1m]
'`'                     Push ` to the stack. (this is 1 less than a in ASCII)
   8\[     ]            Do the stuff in brackets 8 times.
      1+                Add one on every recursion (this gets a, b, c, d...)
        8\:             Clone the stack 8 times. (This gets 8 of each a, b, c...)
Y                       Remove the current stack.
 y1-\?                  Go one stack to the left (I really need to builtin this)
8\[                 ]   Do the stuff in brackets 8 times.
   '1'                  Push character literal 1 to the stack.
      v                 Save it as a temporary variable.
       8\[       ]      Do the stuff in brackets 8 times.
          v             Push the temporary variable to the stack.
           D            Duplicate the top item of the stack.
            1+          Add one to it (this gives us 1, 2, 3, 4...)
              v         Capture the top item of the stack as a temporary variable.
               r        Reverse the stack.
                ?       Go a stack to the right.
                  vX    Clear the temporary variable slot.
i'h')[          ]       If the last character of the input is 'h', do the stuff in brackets
      88*\[    ]        Do the stuff in brackets 64 times.
           Z            Output everything in the stack as a character.
            ?           Rotate right a stack.
             aO         Output a newline.
i'r')[?1m]              If the penultimate character of the input is 'r', rotate over a 
                        stack, then execute the first index of lines of code.
1m                      Execute the first index of lines of code.

Explicação da segunda linha:

84*\[Z??aO]
84*\[     ]   Do the stuff in brackets 32 times.
     Z        Output everything in the stack as a char.
      ??      Rotate two stacks over.
        aO    Output a newline.

Haverá novas linhas de bônus para 'escuro' e 'ambos'. Requer que apenas 'escuro', 'ambos' ou 'claro' sejam inseridos.

Experimente online!


3

PowerShell v3 +, 142 129 bytes

param($a)$d=$a[0]-in('d','b');$l=$a[0]-in('l','b')
97..104|%{$i=[char]$_;1..8|%{if((($q=($_+$i)%2)-eq$l)-or($q+1-eq$d)){"$i$_"}}}

Recebe entrada $ae define duas variáveis, se queremos gerar $darca ou $lquadrados à direita com base na primeira letra da entrada.

Então, nós loop sobre a-he 1-8e usa o mesmo truque que em Determinar a cor de um quadrado de xadrez para analisar se é um quadrado claro ou escuro (ajuste variável ajudante $qno primeiro teste) e adicionar esse quadrado ao gasoduto se for o caso. Após a execução, os elementos no pipeline são gerados um por linha.

Requer v3 ou mais recente para o -inoperador.

Editar - salvou 13 bytes, eliminando switche alterando a ordem dos testes de igualdade


3

Jolf, 48 bytes

Ζ-ώ~1tΜ fΜZAQ8ΨΖ+ζ|<%ζγwώt8ώ6d|<i'd!x%H2>i'ldbHγ

É tudo grego para mim ¯ \ _ (ツ) _ / ¯ Esta é uma transpilação da excelente resposta de edc65.

Ζ-ώ~1t
Ζ        set ζ to 
  ώ~1     100 * 2
 -   t    minus 10 (=190)

ΜZAQ8ΨΖ+ζ|<%ζγwώt8+2t
 ZAQ8                 A zero array of length Q8 (8*8 = 64)
Μ    Ψ                map that
      Ζ+ζ             ζ += 
           %ζγwώt       ζ % (γ = 19)
          <      8      < 8
         |        ώ6  || 12

Μ f■above thing■d|<i'd!x%H2>i'ldbHγ
 _f■above thing■d                    filter the above thing
                 |<i'd!x%H2>i'l      removing all the bad stuff (i<'d'|v%2^i>'l')
Μ                              dbHγ  map each character to base 19

3

Perl, 69 + 3 = 72 bytes

$b=/b/;$i=/l/;$_="@{[grep{$i=!$i||$b}map{$l=$_;map{$l.$_}1..8}a..h]}"

Para ser executado perl -p, para o qual eu adicionei 3 bytes.

Versão com menos golfe (um pouco diferente, pois o operador de carrinho de bebê dificulta a formatação):

$b=/b/;                       # flag for input containing b
$i=/l/;                       # start $i as true if input contains 'l'

@a = grep {
    $i = !$i||$b                # alternate unless $b is true
} map {
    $l = $_;                    # save letter
    map {
        $l.$_                   # join letter and number
    } 1..8                      # generate number sequence
} a..h;                         # generate letter sequence

# golfed version uses babycart operator around array expr to save one byte
$_ = "@a"                       # write array, separated

A versão golfed usa "@{[]}"; a versão comentada usa @a=...; "@"para que o código comentado ainda possa ser executado.


map$l.$_,1..8-1
choroba

e o mesmo truque para grep: grep$i=!$i||$b,mapagain -1
choroba 18/02/16

3

C ++, 132 bytes

Recebe entrada por linha de comando. Usa ponteiro / módulo vodu para a condição de impressão.

#include<stdio.h>
int main(int i,char**v){for(int n=0;n<64;n++)if((n+(i=n/8))%2-*v[1]%3){putchar(i+97);putchar(n%8+49);putchar(32);}}

Não acho que o nloop seja necessário. Acho aninhado para loops para ie jiria aparar alguns bytes fora. A (i+j)%2abordagem é realmente inteligente. Eu não tinha pensado nisso.
WKS

Eu só percebe que (i//8+i%8)%2é o mesmo que (i//8+i)%2para que você possa ganhar alguns bytes se você remover a definição dej=n%8
Erwan

3

Java, 143

class H{public static void main(String[]a){for(char
c=96;++c<'i';)for(int
i=0;++i<9;)if((i+c)%2!=a[0].charAt(0)%3)System.out.println(c+""+i);}}

Ei, não é a resposta mais longa :)

A entrada é aceita como um argumento da linha de comandos.


3

PHP, 99 82 79 76 74 73 bytes

Usa codificação ISO 8859-1.

for($z=$argv[1];++$x<72;)$x%9&&$z<c|$z>k^$x&1&&print~ß.chr($x/9+97).$x%9;

Execute assim ( -dadicionado apenas para estética):

php -d error_reporting=30709 -r 'for($z=$argv[1];++$x<72;)$x%9&&$z<c|$z>k^$x&1&&print~ß.chr($x/9+97).$x%9; echo"\n";' dark

Funciona assim: a variável $xé incrementada de 1 a 71, os números correspondem às células, como mostrado abaixo.

r\c 1  2  3  4  5  6  7  8  [invalid column]
A   1  2  3  4  5  6  7  8  9
B  10 11 12 13 14 15 16 17 18
C  19 20 21 22 23 24 25 26 27
D  28 29 30 31 32 33 34 35 36
E  37 38 39 40 41 42 43 44 45
F  46 47 48 49 50 51 52 53 54
G  55 56 57 58 59 60 61 62 63
H  64 65 66 67 68 69 70 71 72

Portanto, $x modulo 9gera o número da coluna e $x / 9o número da linha, que eu converto em uma letra usando chr. O código $z<c|$z>k^$x&1gera truepara input both( $z<c) e, no caso de lightou darkapenas para as células pares ou ímpares, respectivamente ( $z>k ^ $x&1). O resultado dessa expressão determina se as coordenadas da célula serão ou não impressas. Finalmente, se $x modulo 9resultar 0, pulo essa célula inexistente.

  • Economizou 18 17 bytes (corrigido um bug) tendo apenas 1 loop, convertendo o número em um caractere, e não o contrário
  • Economizou 3 bytes combinando a condição de escuro e claro com um xor
  • Economizou 3 bytes comparando com a entrada completa em vez do primeiro caractere
  • Salvou 2 bytes porque não precisa mais subtrair .125a expressão $x/9+69.9para obter o número de linha correto antes de converter para um caractere
  • Salva um byte usando para gerar um espaço

2

JavaScript ES6, 187 160 159 bytes

Provavelmente estou sentindo falta de algo dolorosamente óbvio. Ah bem. Não ter que achatar a matriz ajuda.

l=s=>(E=[2,4,6,8],O=[1,3,5,7],h=(z=s[0]=="d")?O:E,d=z?E:O,[...h.map(t=>[..."aceg"].map(e=>e+t)),...(d.map(t=>[..."bdfh"].map(e=>e+t))),...(s[0]=="b"?l`d`:[])])

Retorna uma matriz 2D.


Experimente aqui:


2

Ruby, 85

Eu acho que existem maneiras mais curtas sobre isso, mas esse é um uso fofo .upto.

gets;'a1'.upto('h8'){|e|puts e if e[/[1-8]/]&&(~/b/||((e.ord%2!=e[1].ord%2)^! ~/l/))}

2

R, 129 94 bytes

Eu sabia que poderia gerar melhor o quadro :). Essencialmente, isso cria uma placa invertida, filtrando as referências da grade onde a sombra não corresponde à entrada. A saída é separada por espaço.

a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))

Ungolfed

a=which(                           # Get the indexes of
  array(c('light','dark'),c(9,9))  # an array of light dark
    [-9,-9]                        # except for the ninth row and column
      !=scan(,'')                  # where the value doesn't equal the input
    ,T                             # return array index not vector
  );
cat(paste0(letters[a[,1]],a[,2]))  # using letters for col

Teste

> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: dark
2: 
Read 1 item
a1 c1 e1 g1 b2 d2 f2 h2 a3 c3 e3 g3 b4 d4 f4 h4 a5 c5 e5 g5 b6 d6 f6 h6 a7 c7 e7 g7 b8 d8 f8 h8
> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: light
2: 
Read 1 item
b1 d1 f1 h1 a2 c2 e2 g2 b3 d3 f3 h3 a4 c4 e4 g4 b5 d5 f5 h5 a6 c6 e6 g6 b7 d7 f7 h7 a8 c8 e8 g8
> a=which(array(c('light','dark'),c(9,9))[-9,-9]!=scan(,''),T);cat(paste0(letters[a[,1]],a[,2]))
1: both
2: 
Read 1 item
a1 b1 c1 d1 e1 f1 g1 h1 a2 b2 c2 d2 e2 f2 g2 h2 a3 b3 c3 d3 e3 f3 g3 h3 a4 b4 c4 d4 e4 f4 g4 h4 a5 b5 c5 d5 e5 f5 g5 h5 a6 b6 c6 d6 e6 f6 g6 h6 a7 b7 c7 d7 e7 f7 g7 h7 a8 b8 c8 d8 e8 f8 g8 h8
>

2

Oracle SQL 11.2, 192 180 bytes

SELECT CHR(64+x),DECODE(y,0,8,y)FROM(SELECT CEIL(LEVEL/8)x,MOD(LEVEL,8)y FROM DUAL CONNECT BY LEVEL<=64)WHERE(:1='dark'AND MOD(x+y,2)=0)OR(:1='light'AND MOD(x+y,2)=1)OR(:1='both');

Sem golfe

WITH v AS
(
  SELECT CEIL(LEVEL/8)x, DECODE(MOD(LEVEL,8),0,8,MOD(LEVEL,8))y  
  FROM DUAL CONNECT BY LEVEL<=64
)
SELECT CHR(64+x),y
FROM   v
WHERE  (:1='dark' AND MOD(x+y,2)=0)OR(:1='light' AND MOD(x+y,2)=1)OR(:1='both');

A visualização v gera as coordenadas de cada quadrado. Se a soma das coordenadas for uniforme, o quadrado será preto, caso contrário, será branco.


2

Ferrugem, 263 259 244 Bytes

use std::char;use std::env;fn main(){let n=env::args().nth(1).unwrap();for i in 0..8{for j in 0..8{if n=="both"||(n=="dark"&&(i+j)%2==0)||(n== "light"&&(i+j)%2!=0){println!("{}{}",char::from_u32(i+97).unwrap(),char::from_u32(j+49).unwrap())}}}}

Forma expandida:

fn main() {
    let input = env::args().nth(1).unwrap();
    for i in 0..8{
            for j in 0..8{
                if input == "both"
                || (input == "dark" && (i+j)%2==0)
                || (input == "light" && (i+j)%2!=0){
                    println!("{}{}",char::from_u32(i+97).unwrap(),char::from_u32(j+49).unwrap());
            }
        }
    }
}

1
Em vez de codificar sua entrada, não é possível lê-la no terminal ou na linha de comando ou como um parâmetro de função?
194 Neil


2

CJam, 29

qci3%:X;8Ym*{~+2%X-},"a1 "f.+

Apenas uma solução rápida e suja: p
Experimente online

Explicação:

q           read the input
ci          convert to (first) character then to integer
3%          modulo 3; results for d(ark), l(ight) and b(oth) are 1, 0, 2
:X;         store in X and pop
8Ym*        generate all pairs (Y=2) of numbers from 0 to 7
{…},        filter using the condition block
  ~         dump the current pair on the stack
  +2%       calculate the sum modulo 2
  X-        subtract X; if the result is not 0, the pair is kept
"a1 "f.+    vectorized-add "a1 " to each remaining pair
             this means the character 'a' is added to the first number,
             the character '1' is added to the second number,
             and then the space character is appended
            the contents of the stack are automatically printed at the end

2

Haskell, 133 116 105 100 98 91 bytes

f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
l=[0..7]

Esta é a minha primeira tentativa de jogar golfe em Haskell.

Com a ajuda de Michael Klein, conseguimos obter menos de 100 caracteres!


1
Que tal c>0para c==1e c<1para c==0? Salva dois bytes.
Michael Klein

Fantástico, conseguimos menos de 100! Obrigado Michael.
Joeytwiddle #

1
De nada. Fui um pouco sugado e reduzi-o para 86 bytes, refatorando um pouco:f r=[[[a,b]|a<-['a'..'h'],b<-['1'..'8']]!!i|i<-[0..63],even i||r<"l",odd i||r!!0/='d']
Michael Klein

1
Isso é muito bom, uma abordagem repensada. Embora lamento dizer que o ímpar e o par inão nos dão listras diagonais. Alguns resolvem isso com i+i`div`8(como x+y). Outros começam com ['1'..'9']e, em [0..71]seguida, retêm apenas os i`mod`9<8resultados posteriormente, por 96 bytes. No entanto, esse híbrido de nossas duas abordagens se sai bem em 91 bytes:l=[0..7];f r=[["abcdefgh"!!x,"12345678"!!y]|x<-l,y<-l,odd(x+y)||r<"l",even(x+y)||r!!0/='d']
joeytwiddle 19/02/16

Ah, bem, isso é ainda um bom bocado melhor
Michael Klein

1

Mathematica 133 bytes

Método 1 : 108 bytes. Isso constrói o quadro como uma tabela, com rótulos em cada célula e retorna diagonais ou faixas claras ou escuras, conforme necessário.

Table[Table[{i,j},{i,{h,g,f,e,d,c,b,a}},{j,Range@8}]~Diagonal~k,{k,If[#=="light",-6,-7],7,If[#=="both",1,2]}]&

%["light"]   (*where % repeats the preceding line *)

{{{b, 1}, {a, 2}}, {{d, 1}, {c, 2}, {b, 3}, {a, 4}}, {{f, 1}, {e , 2}, {d, 3}, {c, 4}, {b, 5}, {a, 6}}, {{h, 1}, {g, 2}, {f, 3}, {e , 4}, {d, 5}, {c, 6}, {b, 7}, {a, 8}}, {{h, 3}, {g, 4}, {f, 5}, {e , 6}, {d, 7}, {c, 8}}, {{h, 5}, {g, 6}, {f, 7}, {e, 8}}, {{h, 7}, {g, 8}}}


Método 2 : 133 bytes. Cria uma matriz e seleciona de acordo com a natureza ímpar da soma do número da linha + número da coluna de cada célula.

Position[Array[Boole@OddQ[#+#2] &,{8,8}],Switch[#,"dark",0,"light",1,"both",0|1]]/.
{j_,k_}:>{j/.Thread[Range@8->{a,b,c,d,e,f,g,h}],k}&


1

JS, 197 bytes

b=[];d=[];l=[];for(i=1;i<9;i++){for(j=1;j<9;j++){a=String.fromCharCode(96+i*1)+j;b.push(a);if((i+j)%2<1){d.push(a)}else{l.push(a)}}}m=[0,"both",b,"dark",d,"light",l];alert(m[m.indexOf(prompt())+1])

1

Python (3.5), 106 100 96 92 bytes

use o truque do MegaTom (i+j)%2para ganhar 6 bytes

f=lambda s:[chr(97+i//8)+str(1+i%8)for i in range(64)if s[0]=='b'or(i//8+i)%2==(s[0]=='l')]

Experimente em repl.it

Resultados

>>> f('light')
['a2', 'a4', 'a6', 'a8', 'b1', 'b3', 'b5', 'b7', 'c2', 'c4', 'c6', 'c8', 'd1', 'd3', 'd5', 'd7', 'e2', 'e4', 'e6', 'e8', 'f1', 'f3', 'f5', 'f7', 'g2', 'g4', 'g6', 'g8', 'h1', 'h3', 'h5', 'h7']
>>> f('dark')
['a1', 'a3', 'a5', 'a7', 'b2', 'b4', 'b6', 'b8', 'c1', 'c3', 'c5', 'c7', 'd2', 'd4', 'd6', 'd8', 'e1', 'e3', 'e5', 'e7', 'f2', 'f4', 'f6', 'f8', 'g1', 'g3', 'g5', 'g7', 'h2', 'h4', 'h6', 'h8']
>>> f('both')
['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'g7', 'g8', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7', 'h8']

Versão anterior

f=lambda s:[i for i in[i+j for i in'abcdefgh'for j in'123456780'][s[0]=='l'::2-(s[0]=='b')]if'0'not in i]

1

C ++, 119 bytes

Baseado no truque da MegaTom.

#include <stdio.h>
int main(int n,char**v){for(n=0;n<64;++n){if((n+n/8)%2-**(v+1)%3){printf("%c%c ",n/8+97,n%8+49);}}}

0

C (gcc) , 112 bytes

f(char*s){for(int m=*s^'d'?*s^'l'?3:2:1,l=64,x;l--;m&1&!x|(m&2&&x)&&printf("%c%d ",l%8+97,l/8+1))x=l%8%2^l/8%2;}

Experimente online!

Se a == 1, um quadrado será sempre preto se a "ímparidade" da linha e coluna for a mesma, ou seja, ambas são ímpares ou ambas são pares. O oposto é verdadeiro para quadrados brancos, onde linha e coluna sempre diferem em termos de singularidade.

Depois disso, é apenas uma questão de combinar loops de linha e coluna, além de consultar uma tabela de precedência do operador até que um nível suficiente de incompreensibilidade seja alcançado.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.