Dessine un échiquier ASCII!

42

Voici un défi simple pour vous: Vous devez produire cette représentation ASCII d’un échiquier. Le blanc est représenté par des majuscules et le noir par des minuscules. Les tuiles vides sont représentées par un .. Voici la pension complète:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR

Comme il s’agit d’une question de complexité kolmogorov , vous ne pouvez effectuer aucune saisie et vous devez sortir ce tableau par n’importe quelle méthode par défaut, par exemple, enregistrer un fichier, imprimer sur STDOUT ou revenir d’une fonction. Vous pouvez éventuellement produire une nouvelle ligne de fuite. Les failles standard s'appliquent et le programme le plus court en octets!

Toutefois, rappelez-vous qu’il s’agit tout autant d’une mise en concurrence de soumissions rédigées dans la même langue. Bien qu'il soit peu probable qu'un langage comme Java puisse battre un langage comme Perl ou un langage de golf comme Pyth ou Cjam, il est toujours impressionnant d'avoir la réponse Java la plus courte possible! Pour vous aider à suivre la réponse la plus courte dans chaque langue, vous pouvez utiliser ce classement, qui présentera la soumission la plus courte par langue et dans son ensemble.

Classements

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
source
1
Sûrement un ASCII artéchiquier aurait le plein arrêt chaque carré?
— Shaun Bebbers le

Réponses:

16

Gelée , 25 à 24 octets

“.“.“p“rnbqkbn”ṁ€8µṚ;ŒuY

Essayez-le en ligne!

Merci à @Lynn pour le golf d'un octet!

Comment ça marche

“.“.“p“rnbqkbn”ṁ€8µṚ;ŒuY  Main link. No arguments.

“.“.“p“rnbqkbn”           Yield [".", ".", "p", "rnbqkbnr"].
               ṁ€8        Mold-each 8; reshape each string like the array
                          [1, 2, 3, 4, 5, 6, 7, 8], i.e., cyclically repeat its
                          contents to create strings of length 8.
                          This yields the upper half of the board in reversed
                          order, i.e., the string array
                          A := "........", "........", "pppppppp", "rnbqkbnr"].
                  µ       Begin a new, monadic chain. Argument: A
                   Ṛ      Reverse A.
                     Œu   Convert all characters in A to uppercase.
                    ;     Concatenate the results to both sides.
                       Y  Join the strings, separating by linefeeds.
— Dennis
source
15

Vim, 26 octets

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

S'appuie sur un nouveau Vim, sinon 5Vvous pouvez sélectionner la mauvaise zone.

  • irnbqkbnr<Esc>: Écrivez la rangée du haut. Assez facile.
  • Y6p: Faire le reste des lignes, sauf une . Bien sûr, toutes les lignes sauf les premières et les dernières contiennent les mauvais caractères.
  • 5Vr.: Lorsque vous n'avez pas encore utilisé le mode visuel dans la session, vous pouvez procéder comme ceci pour sélectionner 5 lignes. Si vous tapez à nouveau la même chose tout de suite, il essaiera de sélectionner 25 lignes. Vim est bizarre comme ça.
  • Vrp: Nous sommes déjà sur la ligne 2, alors faisons une ligne de pion.
  • YGP: Copiez cette ligne de pion à sa place en bas. C'est pourquoi j'ai utilisé 6pau lieu d' 7pavant.
  • gUj: Capitaliser les pièces blanches.
— udioica
source
1
La meilleure langue de golf qui soit!
— cessé de tourner dans
10

Brainfuck , 224 octets

+++++[>+++[>++++++<-]+<-]>>.[>>+>+<<<-]>>>[<<<+>>>-]<<<----.<+++[>---<-]>.>>-.------.<<.>>+++.++++.--<++++++++++>>++++++++++.<........>.[>+++++<-]>----<++++[>........<<<.>>-]<........<.>++.----.<<.>>+++.------.<<.>>+++.++++.

Il a fallu presque une heure pour l'obtenir.

— Hunter VL
source
8

Python 2, 63 octets

print"\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"])

Malheureusement, l'approche assez simple était beaucoup plus courte que le "malin" que j'avais essayé au début ...

Réponse bonus, également 63 octets:

print"\n".join(["rnbqkbnr"]+[c*8for c in"p....P"]+["RNBQKBNR"])
— DLosc
source
8

05AB1E , 24 octets

Utilise le codage CP-1252 .

"rnbqkbnr"'p8×'.8×D)Âu«»

Essayez-le en ligne!

Explication

"rnbqkbnr"                # push the string "rnbqkbnr"
                          # STACK: "rnbqkbnr"
          'p8×            # push the char "p" repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp"
              '.8×        # push the char "." repeated 8 times
                          # STACK: "rnbqkbnr", "pppppppp", "........"
                  D       # duplicate
                          # STACK: "rnbqkbnr", "pppppppp", "........", "........"
                   )      # wrap in list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"]
                    Â     # push a reversed copy of the list
                          # STACK: ["rnbqkbnr", "pppppppp", "........", "........"], 
                                   ["........", "........", "pppppppp", "rnbqkbnr"]
                     u«   # convert to upper-case and concatenate
                          # STACK: ['rnbqkbnr', 'pppppppp', '........', '........', 
                                    '........', '........', 'PPPPPPPP', 'RNBQKBNR']
                       »  # join list by newline
— Emigna
source
1
Je pense que c'est la première fois que je joue au golf avec une réponse sans vous regarder et vous faire correspondre sur 100% des personnages utilisés. Je suis d'accord, c'est aussi bon que ça devient haha.
— Urne Magic Octopus
7

En fait , 26 octets

'p8*"rnbqkbnr"│û@û4'.8*n((

Essayez-le en ligne!

Explication:

'p8*"rnbqkbnr"│û@û4'.8*n((
'p8*                        "p"*8 ["pppppppp"]
    "rnbqkbnr"              that string ["rnbqkbnr", "pppppppp"]
              │             duplicate stack ["rnbqkbnr", "pppppppp", "rnbqkbnr", "pppppppp"]
                û@û         uppercase the dupes ["RNBQKBNR", "PPPPPPPP", "rnbqkbnr", "pppppppp"]
               4   '.8*n    "."*8, 4 times ["RNBQKBNR", "PPPPPPPP", "........", "........", "........", "........", "rnbqkbnr", "pppppppp"]
                        ((  move the uppercase strings to the bottom of the stack, implicitly print
— Mego
source
6

Cheddar, 56 octets

a=['rnbqkbnr','p'*8]+['.'*8]*2->(a+a.rev=>@.upper).vfuse

Utilise la nouvelle =>fonctionnalité.

Explication

a=                      // set a to the first half
  ['rnbqkbnr','p'*8] +  // First two rows
  ['.'*8]*2             // Next two dots
->(
   a +
   a.rev=>@.upper       // Reverse and map all items to uppercase
).vfuse                 // Join on newlines
— Downgoat
source
5
Vous avez donc répondu à une question sur "les échecs" dans "ches"?
— DJMcMayhem
4
@DJMcMayhem .................. avez-vous simplement .....
— Rédigé
1
mm c'est du beau fromage. abus abusif des paramètres par défaut
— Conor O'Brien
6

Pyke, 28 27 26 octets

"rnbqkbnr"i"P..p"1c8m*Xil3

Essayez-le ici!

J'ai appris quelque chose de nouveau sur ma langue aujourd'hui: cela 1cpeut être utilisé comme moyen de scinder une chaîne de caractères en une liste de caractères.

"rnbqkbnr"i                - i = "rnbqkbnr"
                             stack = ["rnbqkbnr"])
           "P..p"1c        -  chunk("P..p", 1)
                             stack = ["rnbqkbnr", ["P", ".", ".", "p"]]
                   8m*     - map(8*>, ^)
                             stack = ["rnbqkbnr", ["PPPPPPPP", "........", "........", "pppppppp"]]
                      X    - splat(^)
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP"]
                       il3 - i.changecase()
                             stack = ["rnbqkbnr", "pppppppp", "........", "........", "PPPPPPPP", "RNBQKBNR"]
                           - implicit join with newlines

rnbqkbnr
pppppppp
........
........
PPPPPPPP
RNBQKBNR
— Bleu
source
5

MATL , 26 octets

'rnbqkbnr' 'p..'!l8X"vtPXk

Essayez-le en ligne!

Explication

'rnbqkbnr'   % Push this string (1×8 char array)
'p..'!       % Push this string transposed (3×1 char array)
l8X"         % Repeat 1×8 times: gives 3×8 char array
v            % Concatenate the two arrays vertically into a 4×8 char array
tP           % Duplicate and flip vertically
Xk           % Convert to uppercase. Implicitly display the two 4×8 arrays
— Luis Mendo
source
5

Ruby, 45 44

1 octet économisé grâce à tuxcrafting.

puts"rnbqkbnr",?p*8,[?.*8]*4,?P*8,"RNBQKBNR"

C'est 45

puts s="rnbqkbnr",?p*8,[?.*8]*4,?P*8,s.upcase

Essayer quelque chose d'intelligent semble juste le rendre plus long.

— Level River St
source
Supprimez l'espace avant la chaîne après leputs
— TuxCrafting
5

JavaScript (ES6), 69 à 65 octets

4 octets sauvés grâce à edc65

let f =

_=>`rnbqkbnr
p....PRNBQKBNR`.replace(/p|\./ig,c=>c.repeat(8)+`
`)

console.log(f());
Développer l'extrait

— Arnauld
source
1
Très intelligent! Peut-être trop malin, pourrait économiser 4 octets avec 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')(changement \nde nouvelle ligne)
— edc65
5

C #, 94 92 octets

Edit: Merci à milk d’ avoir économisé 1 octet en modifiant l’ordre des chaînes pour supprimer les espaces de retour.

Édition: 1 octet supplémentaire enregistré en ajoutant un paramètre factice ( x au lieu de () ) pour la fonction anonyme et en l’appelant avec n’importe quel objet.

x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};

Programme complet utilisant la fonction ci-dessus:

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object,string>f= x=>{string a="RNBQKBNR\n",b="PPPPPPPP\n",c="........\n";return(a+b).ToLower()+c+c+c+c+b+a;};
            Console.WriteLine(f(1));
        }
    }
}

C # est un langage très prolixe ...

Programme complet en C #, 131 octets

class P{static void Main(){string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());}}

Ungolfed:

class P
{
    static void Main()
    {
        string a="rnbqkbnr\n",
            b="pppppppp\n",
            c="........\n";
        System.Console.Write(a+b+c+c+c+c+(b+a).ToUpper());
    }
}
— adrianmp
source
2
"C # est une langue très prolixe ...". Vous n'avez pas encore essayé VB.NET ...;)
— TyCobb 10/10
2
Vous pouvez sauvegarder un octet en définissant aet ben majuscule, vous pourrez alors vous débarrasser de l'espace après return:return(a+b).ToLower()+...
— milk
@TyCobb J'ai essayé VB.NET il y a un certain temps. Je ne connaissais pas le code golf à l'époque: P
— adrianmp
pouvez-vous utiliser varau lieu de string?
— NibblyPig
@SLC Je n'ai pas programmé en C # depuis un moment, corrigez-moi si je me trompe, mais je ne pense pas que vous puissiez utiliser varplusieurs déclarations sur une seule ligne. Alors , string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";deviendrait var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, ce qui augmente le nombre d'octets. EDIT: Cela donnerait une erreur " Une déclaration de variable locale implicitement typée ne peut pas inclure plusieurs déclarateurs " .
— Kevin Cruijssen
4

Python 2, 68 octets

La publication de toute façon bien que la version ci-dessus de Python 2 soit plus courte. Il ne serait pas nécessaire que le nombre d'octets soit égal à un, mais simplement de jouer avec.

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()
— DomPar
source
Puisque zn’est utilisé qu’une fois, vous pouvez vous en débarrasser et produire les points de la déclaration print.
— Karl Napf
3

Haskell, 53 octets

a="rnbkqbnr" 
unlines$a:map(<$a)"p....P"++["RNBKQBNR"]

aest utilisé comme première ligne et pour déterminer la longueur des chaînes constituées de p, .et P(-> <$a). .

— nimi
source
3

JavaScript (ES6), 73

.toUpperCase est tout simplement trop long

_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

O.textContent=(
  
_=>`rnbqkbnr
${r=c=>c[0].repeat(8)+`
`,r`p`+(b=r`.`)+b+b+b+r`P`}RNBQKBNR`

)()
<pre id=O></pre>
Développer l'extrait

— edc65
source
Je pense (r=c=>c[0].repeat(8)+\ n ,b=r. )=>vous sauve un octet.
— Neil
@ Neil je ne vois pas la sauvegarde. J'ai essayé de réécrire le code en augmentant la lisibilité (un peu), mais le nombre d'octets reste le même
— edc65
Ah, je vois ce que j'ai mal fait là-bas, j'ai perdu une nouvelle ligne en cours de route. Désolé pour ça.
— Neil
3

PowerShell v2 +, 44 octets

'rnbqknbr'
'p'*8
,('.'*8)*4
'P'*8
'RNBQKNBR'

Les chaînes laissées sur le pipeline sont implicitement imprimées Write-Outputlors de l'exécution du programme. Nous couplons cela avec le comportement de nouvelle ligne par défaut pour un tableau afin de produire les quatre lignes de périodes avec l'opérateur virgule.

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR
— AdmBorkBork
source
Où sont les nouvelles lignes dans les lignes de points? ", ('.' * 8) * 4" c'est le ',' je suppose ...
— RosLuP
@RosLuP L'opérateur de virgule ,crée un tableau (dans ce cas, un tableau de chaînes). La valeur par défaut Write-Outputà l'achèvement du programme insère une nouvelle ligne entre les éléments laissés sur le pipeline, y compris des éléments de tableau individuels. Donc, nous abusons du comportement de sortie par défaut pour ne pas avoir besoin d'écrire des retours à la ligne explicites dans le code.
— AdmBorkBork
3

V , 27 , 26 octets

i¸P
RNBQKBNRäkgujddppÒ.4Ä

Essayez-le en ligne!

Cela contient des caractères non imprimables, donc voici la version lisible:

i¸P
RNBQKBNR<esc>äkgujddppÒ.4Ä

où <esc>représente 0x1B. Explication:

i                               " Enter insert mode
 ¸P                             " Enter 8 'P' characters
                                " and a newline
RNBQKBNR<esc>                   " Enter the first row and escape to normal mode.
             äk                 " Duplicate this line and the line above
               guj              " Convert this line, and the line below to lowercase
                  dd            " Delete this line
                    pp          " And paste it twice below us
                      Ò.        " Replace this whole line with '.' chars
                        4Ä      " And create four copies of this line
— DJMcMayhem
source
3

Emotinomicon, 89 octets

Malheureusement, Emotinomicon n'a rien à voir avec une fonction de pile dupliquée. Serait utile. Mais au moins plus court que Java. :)

😭RNBKQBNR
PPPPPPPP
........
........
........
........
pppppppp
rnbkqbnr😲⏪⏬⏩

Explication:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output
— Roman Gräf
source
Hmm ... ce serait une fonction utile, n'est-ce pas ...
— Conor O'Brien
Même le programme est triste. 😭 = Malheureusement
— Un _
3

Brain-Flak , 366 350 + 3 = 353 octets

Essayez-le en ligne!

(((((((((((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>))<>)<>)<>)))<<>({}<>)<>({}<>)<>({}<>)([]()())>[()]))))))))(()()()()){({}[()]<((((((((((((()()()()()){})()){}()){}))))))))>)}{}(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((((()()()))){})(({}{})(([{}({})](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}

Cela donne un plus 3 parce que cela nécessite le -Adrapeau pour fonctionner correctement.

Explication

First we push the last 5 letters to the active stack.
We also push copies of last 3 numbers to the inactive stack.
This is done with fairly simple methods I won't go into for the sake of brevity.

 (((()()())){}(((({}))){}{}(([((({})){}){}](([({}())](((((({}()){}){}){}()){})<>)<><>)<>)<>)<>)))

We Move Everything from the offstack to the onstack.
The first 3 letters are the same as the last 3 letters in the first line

{<>({}<>)}{}

We push 10 for a new line

((()()()()()){})

Using the value of Q we create a P and push it 8 times

((((((((<...>[()]))))))))

We loop 4 times each time pushing 8 dots and a newline

(()()()())
{({}[()]<
    ((((((((((((()()()()()){})()){}()){}))))))))
>)}{}

We push the last two lines in a very similar way to the first two.

(((()()()()()){})<((((((((([][]()()()()))))))))<>)<>>)(((()()()){})(({}()()())(([{}(()()())](([{}()](<>({}()())<>)<>)<>)<>)<>))){<>({}<>)}{}
— Assistant de blé
source
Vous pouvez appuyer sur les deux premières lignes avec ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))lesquelles, je pense, vous économiserait 16 octets. Cela n'utilise pas du tout la pile alternative, elle pourrait donc être encore plus courte.
— DJMcMayhem
3

Python 3.5, 56 octets

for r in['rnbqkbn',*'p....P','RNBQKBN']:print((r*8)[:8])

Ceci utilise une idée de zawata pour encoder chaque ligne (r*8)[:8], avec une chaîne répétée 8 fois et ajustée à la longueur 8. Les pions et les lignes vides sont juste 'p'*8, '.'*8et 'P'*8, sans coupe. La première ligne utilise 'rnbqkbn', avec l’ ('rnbqkbn'*8)[:8]ajout d’une autre tour à droite lors de la multiplication et de la réduction. La dernière ligne est la même mais en majuscule.

Nous exprimons la liste des éléments de ligne de manière compacte à l' ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']aide du décompactage généralisé de Python 3.5 . Nous écrivons les première et dernière entrées, et celles qui ne contiennent qu'un seul caractère sont extraites d'une chaîne.

En Python 2, nous pourrions nous contenter splitde 60 octets:

for i in'rnbqkbn p . . . . P RNBQKBN'.split():print(i*8)[:8]
— Xnor
source
3

Python 3, 82 80 75 octets

Ce n’est pas la réponse la plus courte en python, mais c’est ma première et je pense que c’est très bien pour la première fois

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))
— zawata
source
1
Bienvenue sur le site! Vous pouvez supprimer deux octets si vous supprimez des espaces supplémentaires. Par exemple[:8]for i in['rnbqkbn'....
— DJMcMayhem
1
Bonne idée avec unifier toutes les lignes et de réutiliser les tours. Vous pouvez écrire la liste plus courte que 'rnbqkbn p . . . . P RNBQKBN'.split().
— xnor
@DJMcMayhem ne savait pas que ce n'était pas nécessaire. Merci!
— zawata
@xnor c'est une bonne idée! malade dois ajouter ce tour à mon "arsenal" haha
— zawata
2

Lot, 105 octets

@set e=@echo ........
@echo rnbqkbnr
@echo pppppppp
%e%
%e%
%e%
%e%
@echo PPPPPPPP
@echo RNBQKBNR

Le lot est sérieusement commenté ...

— Neil
source
2

R, 75 octets

Edit: Correction d'une erreur stupide et écrivez simplement la partie majuscule du tableau maintenant. 

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")
— Billywob
source
1
Les pièces noires sortent mal en l'état: les pions devraient être devant les autres pièces.
— JDL
@JDL Vous avez bien sûr raison, merci. Erreur stupide lors des changements de dernière seconde.
— Billywob 10/1016
— Giuseppe
2

Powershell, 82 73 octets

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"
— Chris J
source
— Veskah
@Veskah - comment ça marche? Je n'ai jamais vu la *perchose avant, et un Google ne me donne aucun indicateur. Vous avez une explication?
— Chris J
Vérifiez ici le texte complet mais |% peut appeler des propriétés / méthodes (avec des caractères génériques dans le nom) sur ce qu'il a donné
— Veskah
2

J, 55 52 octets

'.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0

Étapes de test et intermédiaires

   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR
   8 48#6 0
6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1 6 6 6 6 6 6 6 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   8 8$1 2 3 4 5 3 2 1,8 48#6 0
1 2 3 4 5 3 2 1
6 6 6 6 6 6 6 6
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
   (+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
 1  2  3  4  5  3  2  1
 6  6  6  6  6  6  6  6
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
_6 _6 _6 _6 _6 _6 _6 _6
_1 _2 _3 _4 _5 _3 _2 _1
   '.rnbkqpPQKBNR'{~(+-@|.)8 8$1 2 3 4 5 3 2 1,8 48#6 0
rnbkqbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBKQBNR
— Conor O'Brien
source
2

Python 3, 64 octets

Basé sur DLosc répondre à Python 2 comme sur le mien je ne pouvais pas améliorer.

print(*["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"],sep="\n")

1 octet de moins par rapport à "\ n" .join

print("\n".join(["rnbqkbnr","p"*8]+["."*8]*4+["P"*8,"RNBQKBNR"]))
— DomPar
source
2

q, 51 octets

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"
— Boston Walker
source
Vous pouvez supprimer quelques octets avec upper et chaque right. Aussi les impressions suivantes à l' écran plutôt que de retourner une chaîne avec des sauts de ligne: -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";. 40 octets. Belle solution quand même!
— streetster le
2

GNU sed, 54 octets

s:^:rnbqkbnr:p;h
s:.:p:gp;G
h;s:[^\n]:.:gp;G
s:.:\U&:g

Essayez-le en ligne!

Explication:

Les pièces noires sont imprimées en premier, en sauvegardant les deux rangs de cartes associés dans l’ordre inverse dans l’espace réservé. Les pièces blanches sont imprimées en convertissant l'espace de maintien en lettres majuscules.

s:^:rnbqkbnr:p;h   # change pattern and hold spaces to 'rnbqkbnr' and print string
s:.:p:gp           # replace each pattern space letter with a 'p', then print
G;h                # append hold space, then copy pattern space to hold space
s:[^\n]:.:gp       # replace each pattern space letter with a '.', then print
G;s:.:\U&:g        # append hold space and convert pattern space to uppercase
                   # (automatic printing of pattern space at the end)
— seshoumara
source
2

Java 7, 103 99 89 octets

String f(){return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".replace("x","........\n");}

10 octets économisés par rapport à la sortie codée en dur grâce à l’ approche de @SLC dans sa réponse en C # .

Essayez ici.

Sortie:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR
— Kevin Cruijssen
source
Qu'en est-il de cela String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}. C'est 100 octets .
— Numéro numéroté
@Numberknot Comme c'est ennuyeux .. mais tu as raison, c'est plus court. Au fait, c'est 99 octets, pas 100.
— Kevin Cruijssen
2

C #, 85 84 83 74 octets

Edit: Accidentellement eu trop de lignes d'espaces vides!

Edit: libéré un caractère supplémentaire et corrige la commande (par mégarde, tout a été inversé) merci beaucoup à @KevinCruijssen

Edit: Retourné à 83 parce que j'avais les crevettes sur la mauvaise ligne

Edit: Merci à @adrianmp qui m'a aidé à le réduire davantage en omettant de revenir

En utilisant le même format que la réponse @adrianmp ci-dessus:

x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");

Programme complet utilisant la fonction ci-dessus:

using System;

namespace DrawAnASCIIChessBoard
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<object, string> f = 
                x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
                    Console.WriteLine(f(1));
        }
    }
}
— NibblyPig
source
Bonjour, bienvenue sur PPCG! Hmm, l'ordre de vos pièces semble incorrect avec celui de OP. BTW, vous pouvez enregistrer 1 octet en supprimant l'espace entre return ", il devient: x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};. Bonne réponse, donc +1 de moi. Et profitez de votre séjour ici. :)
— Kevin Cruijssen
Et merci pour votre réponse. J'ai porté la même approche à ma réponse Java 7 (en vous créditant bien sûr) , en réduisant le nombre d'octets de 10. :)
— Kevin Cruijssen
Je l'ai encore amélioré
— NibblyPig
Gah, je viens de me rendre compte que ce n'est pas correct
— NibblyPig
1
Belle approche! Vous pouvez réellement le réduire à 74 octets:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
— adrianmp
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.