एक ASCII शतरंज बोर्ड ड्रा करें!


42

यहां आपके लिए एक सरल चुनौती है: आपको एक शतरंज बोर्ड के एएससीआईआई प्रतिनिधित्व का उत्पादन करना चाहिए। व्हाइट को अपरकेस अक्षरों द्वारा दर्शाया जाता है, और ब्लैक को लोअरकेस द्वारा दर्शाया जाता है। खाली टाइलों का प्रतिनिधित्व ए .। यहाँ पूर्ण बोर्ड है:

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

चूंकि यह एक प्रश्न है, आप कोई इनपुट नहीं ले सकते हैं और आपको इस बोर्ड को किसी भी डिफ़ॉल्ट विधि द्वारा आउटपुट करना होगा, उदाहरण के लिए, फ़ाइल को सहेजना, STDOUT में प्रिंट करना या फ़ंक्शन से वापस आना। आप वैकल्पिक रूप से एक अनुगामी न्यूलाइन का उत्पादन कर सकते हैं । मानक कमियां लागू होती हैं, और बाइट्स में सबसे छोटा कार्यक्रम!

हालाँकि, यह याद रखें कि यह समान भाषा में प्रस्तुतियाँ के बीच एक प्रतियोगिता है। हालांकि यह संभावना नहीं है कि जावा जैसी भाषाएं पर्ल जैसी भाषा, या पाइथ या सीजम जैसी गोल्फिंग भाषा को हरा सकती हैं, जिसमें जावा का सबसे छोटा उत्तर अभी भी वास्तव में प्रभावशाली है! प्रत्येक भाषा में सबसे कम उत्तर को ट्रैक करने में आपकी मदद करने के लिए, आप इस लीडरबोर्ड का उपयोग कर सकते हैं, जो भाषा और समग्र रूप से सबसे कम प्रस्तुतिकरण दिखाएगा।

लीडरबोर्ड

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

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


1
निश्चित रूप से एक ASCII artशतरंज बोर्ड का हर दूसरे वर्ग पर पूर्ण विराम होगा?
शॉन बेएबर्स

जवाबों:


16

जेली , 25 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 बाइट को बंद करने के लिए @Lynn को धन्यवाद!

यह काम किस प्रकार करता है

“.“.“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.

15

विम, 26 बाइट्स

irnbqkbnr<Esc>Y6p5Vr.VrpYGPgUj

एक ताजा विम पर निर्भर करता है, या फिर 5Vगलत क्षेत्र का चयन कर सकता है।

  • irnbqkbnr<Esc>: शीर्ष पंक्ति लिखें। काफी आसान।
  • Y6p: एक को छोड़कर बाकी पंक्तियों को बनाएं । बेशक सभी लेकिन ऊपर और नीचे की पंक्तियों में गलत अक्षर हैं।
  • 5Vr.: जब आपने सत्र में अभी तक दृश्य मोड का उपयोग नहीं किया है, तो आप 5 लाइनों का चयन करने के लिए इस तरह की चीजें कर सकते हैं। यदि आपने तुरंत वही चीज़ फिर से टाइप की है, तो वह 25 लाइनों का चयन करने की कोशिश करेगी। विम जैसा अजीब है।
  • Vrp: हम पहले से ही लाइन 2 पर हैं, इसलिए चलो एक प्यादा लाइन बनाते हैं।
  • YGP: उस प्यादा लाइन को नीचे की जगह पर कॉपी करें। यही कारण है कि मैंने पहले के 6pबजाय इस्तेमाल किया 7p
  • gUj: सफेद टुकड़ों को कैपिटलाइज़ करें।

1
सर्वश्रेष्ठ गोल्फ भाषा है!
को बंद कर दिया

10

ब्रेनफक , 224 बाइट्स

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

इसे प्राप्त करने में लगभग एक घंटा लगा।


8

पायथन 2, 63 बाइट्स

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

दुर्भाग्य से, काफी सरल दृष्टिकोण "चालाक" सामान की तुलना में बहुत कम था जिसे मैंने पहले प्रयास किया था ...

बोनस उत्तर, 63 बाइट्स:

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

8

05AB1E , 24 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

"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

1
मुझे लगता है कि यह एफआईआरएसटी समय है जिसे मैंने कभी बिना देखे जवाब दिया है और उपयोग किए गए वर्णों के 100% पर आपका मिलान किया है। इस बात से सहमत होना उतना ही अच्छा है जितना कि हाहा।
मैजिक ऑक्टोपस Urn

7

दरअसल , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

'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

6

चेडर, 56 बाइट्स

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

नई =>सुविधा का उपयोग करता है ।

व्याख्या

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

5
तो आपने 'शतरंज' में 'शतरंज' के बारे में एक सवाल का जवाब दिया?
DJMcMayhem

4
@DJMcMayhem .................. क्या आपने अभी किया .....
डाउनगेट

1
मिमी यह कुछ सुंदर पनीर है। डिफॉल्ट परम्स का अच्छा दुरुपयोग
कॉनर ओ'ब्रायन

6

पाइके, 28 27 26 बाइट्स

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

यहाँ यह कोशिश करो!

मैंने आज अपनी भाषा के बारे में कुछ नया सीखा: 1cएक स्ट्रिंग को पात्रों की सूची में विभाजित करने के 2 चार तरीके के रूप में इस्तेमाल किया जा सकता है।

"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

5

MATL , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

'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

5

रूबी, ४५ ४४

1 बाइट tuxcrafting के लिए धन्यवाद बचाया।

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

यह ४५ है

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

कुछ भी चालाक की कोशिश कर रहा है बस यह अब बनाने के लिए लगता है।


के बाद स्ट्रिंग से पहले अंतरिक्ष निकालेंputs
TuxCrafting

5

जावास्क्रिप्ट (ईएस 6), 69 65 बाइट्स

सहेजे गए 4 बाइट्स edc65 की बदौलत

let f =

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

console.log(f());


1
बहुत चालाक! शायद बहुत चालाक, 4 बाइट्स 'rnbqkbnrnp....PRNBQKBNR'.replace(/p|\./ig,c=>c.repeat(8)+'\n')( \nशाब्दिक न्यूलाइन में बदलाव ) के साथ बचा सकता है
edc65

5

सी #, 94 92 बाइट्स

संपादित करें: रिटर्न व्हाट्सएप को हटाने के लिए स्ट्रिंग आदेश को बदलकर 1 बाइट बचाने के लिए दूध के लिए धन्यवाद ।

संपादित करें: बेनामी फ़ंक्शन के लिए डमी पैरामीटर ( x के बजाय () के साथ 1 और बाइट को सहेजकर किसी भी ऑब्जेक्ट के साथ कॉल करके)।

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

उपरोक्त फ़ंक्शन का उपयोग करके पूरा कार्यक्रम:

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 # एक बहुत ही क्रियात्मक भाषा है ...


सी # पूर्ण कार्यक्रम, 131 बाइट्स

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());
    }
}

2
"C # एक बहुत ही क्रियात्मक भाषा है ..."। आपने VB.NET की कोशिश नहीं की है तो ...;)
TyCobb

2
आप एक बाइट को परिभाषित करके aऔर bअपरकेस के रूप में सहेज सकते हैं, तब आप अंतरिक्ष से छुटकारा पा सकते हैं return:return(a+b).ToLower()+...
दूध

@TyCobb मैंने कुछ समय पहले VB.NET की कोशिश की थी। मुझे कोड गोल्फिंग के बारे में तब पता नहीं था: P
adrianmp

के varबजाय आप का उपयोग कर सकते हैं string?
NIBlyPig

@ एसएलसी मैंने थोड़ी देर के लिए सी # में प्रोग्राम नहीं किया है, इसलिए मुझे गलत होने पर सही करें, लेकिन मुझे नहीं लगता कि आप varएक ही लाइन पर कई घोषणाओं के साथ उपयोग कर सकते हैं । तो string a="rnbqkbnr\n",b="pppppppp\n",c="........\n";बन जाएगा var a="rnbqkbnr\n";var b="pppppppp\n";var c="........\n";, जो बाइट-काउंट बढ़ाता है। संपादित करें: यह " एक अनुमानित रूप से टाइप किया गया स्थानीय चर घोषणा में कई घोषणाकर्ताओं को शामिल नहीं कर सकता है " त्रुटि देगा
केविन क्रूज़सेन

4

पायथन 2, 68 बाइट्स

वैसे भी पोस्ट करना हालांकि उपरोक्त पायथन 2 संस्करण कम है। यह बाइट्स की मात्रा के लिए एक लाइनर नहीं होगा, बस इसके साथ खेला जाएगा।

x,y,z="rnbqkbnr\n","p"*8+"\n","."*8+"\n";print x,y,4*z,(y+x).upper()

चूँकि zइसका उपयोग केवल एक बार किया जाता है ताकि आप इससे छुटकारा पा सकें और प्रिंट स्टेटमेंट में डॉट्स का निर्माण कर सकें।
कार्ल नैप

3

हास्केल, 53 बाइट्स

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

aपहली पंक्ति के रूप में और इसके बने तार की लंबाई निर्धारित करने के लिए प्रयोग किया जाता है p, .और P(-> <$a)। ।


3

जावास्क्रिप्ट (ईएस 6), 73

.toUpperCase बस बहुत लंबा है

_=>`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>


मुझे लगता है कि (r=c=>c[0].repeat(8)+\ N ,b=r)=>आपको एक बाइट बचाता है।
नील

@ नहीं मुझे बचत नहीं दिख रही है। मैंने कोड की पठनीयता (थोड़ा) बढ़ाने की कोशिश की, लेकिन बाइट की गिनती वही रही
edc65

आह, मैं देख रहा हूं कि मैंने वहां क्या गलत किया, किसी तरह मैंने एक नई राह खो दी। उसके लिए माफ़ करना।
नील

3

PowerShell v2 +, 44 बाइट्स

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

पाइपलाइन पर छोड़े गए स्ट्रिंग्स Write-Outputको कार्यक्रम के निष्पादन के साथ स्पष्ट रूप से मुद्रित किया जाता है। हम जोड़ते हैं कि एरे-ऑपरेटर के साथ अवधि की चार पंक्तियों का उत्पादन करने के लिए एक सरणी के लिए डिफ़ॉल्ट न्यूलाइन व्यवहार के साथ।

PS C:\Tools\Scripts\golfing> .\draw-ascii-chess-board.ps1
rnbqknbr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKNBR

बिंदुओं की रेखाओं में नई रेखाएँ कहाँ हैं? ", ('।' * 8) * 4" यह है ',' मुझे लगता है ...
RosLuP

@RosLuP अल्पविराम ऑपरेटर ,, एक सरणी बनाता है (इस मामले में, तार की एक सरणी)। Write-Outputकार्यक्रम पूरा होने पर डिफ़ॉल्ट अलग-अलग सरणी तत्वों सहित, पाइपलाइन पर छोड़े गए तत्वों के बीच एक नई रेखा सम्मिलित करता है। इसलिए, हम कोड में स्पष्ट newlines लिखने की आवश्यकता नहीं करने के लिए डिफ़ॉल्ट आउटपुट व्यवहार का दुरुपयोग कर रहे हैं।
AdmBorkBork 15

3

वी , 27 , 26 बाइट्स

i¸P
RNBQKBNRäkgujddppÒ.4Ä

इसे ऑनलाइन आज़माएं!

इसमें कुछ अनपेक्षित वर्ण हैं, इसलिए यहां पढ़ने योग्य संस्करण है:

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

जहां <esc>का प्रतिनिधित्व करता है 0x1B। स्पष्टीकरण:

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

3

Emotinomicon, 89 बाइट्स

अफसोस की बात है Emotinomicon में डुप्लिकेट स्टैक फ़ंक्शन जैसा कुछ भी नहीं है। उपयोगी होगा। लेकिन जावा की तुलना में कम से कम। :)

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

स्पष्टीकरण:

😭(...)😲⏪⏬⏩
😭(...)😲            String literal
         ⏪  ⏩      Loop
           ⏬        Pop one char and output

हम्म ... यह एक उपयोगी कार्य होगा, अब यह नहीं होगा ...
कॉनर ओ'ब्रायन

यहां तक ​​कि कार्यक्रम दुखद है। 😭 = दुख की बात है
A _

3

ब्रेन-फ्लैक , 366 350 + 3 = 353 बाइट्स

इसे ऑनलाइन आज़माएं!

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

यह एक प्लस 3 हो जाता है क्योंकि इसे -Aठीक से चलाने के लिए ध्वज की आवश्यकता होती है।

व्याख्या

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.

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

आप पहली दो पंक्तियों को आगे बढ़ा सकते हैं, ((((((((((((((((((((()()()()()){}){}){}()){})[()()()()])[([][][]){}])[][][])[]()())[[][][]])[][])()()()())<([]()())>[()()]))))))))जिनके साथ मुझे लगता है कि आप 16 बाइट्स बचाएंगे। यह वैकल्पिक स्टैक का उपयोग नहीं करता है, इसलिए यह शायद कम भी हो सकता है।
DJMcMayhem

3

पायथन 3.5, 56 बाइट्स

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

यह ज़वाटा द्वारा एक विचार का उपयोग करता है प्रत्येक पंक्ति को सांकेतिक शब्दों में बदलना (r*8)[:8], एक स्ट्रिंग के साथ 8 बार दोहराया गया और लंबाई तक छंटनी की गई 8। प्यादे और खाली पंक्तियों बस कर रहे हैं 'p'*8, '.'*8और 'P'*8, कोई काट-छाँट के साथ। पहली पंक्ति का उपयोग तब किया जाता है 'rnbqkbn', ('rnbqkbn'*8)[:8]जब दाईं ओर एक और रूक शामिल होता है जब गुणा और छंटनी की जाती है। अंतिम पंक्ति समान है लेकिन पूंजीकृत है।

हम पायथन 3.5 के सामान्यीकृत अनपैकिंग ['rnbqkbn','p','.','.','.','.','P','RNBQKBN']का उपयोग करते हुए पंक्ति-भागों की सूची को कॉम्पैक्ट रूप से व्यक्त करते हैं । हम पहली और अंतिम प्रविष्टियाँ लिखते हैं, और शेष एकल-वर्ण वाले स्ट्रिंग से अनपैक्ड हैं।

अजगर 2 में, हम split60 बाइट्स के बदले सुलझा सकते हैं :

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

3

पायथन 3, 82 80 75 बाइट्स

अजगर में कम से कम जवाब नहीं है, लेकिन यह मेरा पहला है और मुझे लगता है कि यह पहली बार बहुत अच्छा है

print('\n'.join((i*8)[:8]for i in'rnbqkbn p . . . . P RNBQKBN'.split()))

1
साइट पर आपका स्वागत है! यदि आप कुछ अतिरिक्त रिक्त स्थान निकालते हैं, तो आप दो बाइट ले सकते हैं। उदाहरण के लिए[:8]for i in['rnbqkbn'....
DJMcMayhem

1
सभी लाइनों को एकजुट करने और बदमाशों के पुन: उपयोग के साथ अच्छा विचार है। आप सूची को इस प्रकार लिख सकते हैं 'rnbqkbn p . . . . P RNBQKBN'.split()
xnor

@DJMcMayhem नहीं जानता था कि वे आवश्यक नहीं थे। धन्यवाद!
ज़वाटा

@ एक अच्छा विचार है! बीमार को उस चाल को मेरे "शस्त्रागार" हाहा से
जोड़ना होगा

2

बैच, 105 बाइट्स

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

बैच गंभीरता से क्रिया है ...


2

आर, 75 बाइट्स

संपादित करें: एक मूर्खतापूर्ण त्रुटि फिक्स्ड और बस बोर्ड के बड़े हिस्से को अब लिखें।

cat("rnbqkbnr\npppppppp\n",rep("........\n",4),"PPPPPPPP\nRNBQKBNR",sep="")

1
यह खड़ा होने के साथ काले टुकड़े गलत निकलते हैं: पंजे दूसरे टुकड़ों के सामने होने चाहिए।
JDL

@JDL आप निश्चित रूप से सही हैं, धन्यवाद। अंतिम दूसरा परिवर्तन करते समय मूर्खतापूर्ण गलती।
बिलीवोब


2

पॉवर्सशेल, 82 73 बाइट्स

$x=("rnbqkbnr",$("p"*8),$("."*8),$("."*8));$x+$x[3..0].ToUpper()-join"`n"


@Veskah - यह कैसे काम करता है? मैंने पहले वाली *perबात नहीं देखी है , और एक Google मुझे कोई संकेत नहीं दे रहा है। एक स्पष्टीकरण है?
क्रिस जूल

पूर्ण राइटअप के लिए यहां देखें लेकिन% प्रॉपर्टी / विधियों (नाम में वाइल्डकार्ड के साथ) को कॉल कर सकते हैं, जो यह दिया गया है
Veskah

2

जे, 55 52 बाइट्स

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

परीक्षण और मध्यवर्ती कदम

   '.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

2

पायथन 3, 64 बाइट्स

पाइथन 2 को डीएलओस के जवाब के आधार पर जैसा कि मैं सुधार नहीं कर सका।

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

"\ N" .join का उपयोग करने की तुलना में 1 बाइट कम

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

2

क्ष, ५१ बाइट्स

"\n"sv flip{x,"p...P","c"$("i"$x)-32}each"rnbqkbnr"

आप ऊपरी, और प्रत्येक-दाईं ओर कुछ बाइट्स से दाढ़ी बना सकते हैं। इसके अलावा नए प्रिंट के साथ एक स्ट्रिंग वापस करने के बजाय निम्नलिखित प्रिंट करने के लिए -1 flip"p...P"{y,x,upper y}/:"rnbqkbnr";:। 40 बाइट्स। हालांकि अच्छा समाधान!
स्ट्रीट जूल

2

GNU sed, 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

काले टुकड़ों को पहले मुद्रित किया जाता है, जो दो संबंधित बोर्ड रैंक को होल्ड स्पेस में रिवर्स ऑर्डर में सहेजता है। व्हाइट स्पेस को अपरकेस अक्षरों में होल्ड स्पेस में परिवर्तित करके प्रिंट किया जाता है।

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)

2

जावा 7, 103 99 89 बाइट्स

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

उनके C # उत्तर में @SLC के दृष्टिकोण के लिए हार्डकोडेड आउटपुट की तुलना में 10 बाइट्स बचाए गए ।

इसे यहाँ आज़माएँ।

आउटपुट:

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

इस बारे में क्या है String f(){return"rnbqkbnr\npppppppp\n........\n........\n........\n........\nPPPPPPPP\nRNBQKBNR";}। यह 100 बाइट्स है
नंबरनोट

@Numberknot कितना उबाऊ .. लेकिन आप सही हैं, यह कम है। Btw, यह 99 बाइट्स है, 100 नहीं।
केविन क्रूज़सेन

2

सी #, 85 84 83 74 बाइट्स

संपादित करें: संयोग से रिक्त स्थानों की बहुत सी पंक्तियाँ थीं!

संपादित करें: एक अतिरिक्त चरित्र को मुक्त किया और आदेश दिया (गलती से यह सब उलट गया था) @KevinCruijssen को बहुत धन्यवाद

संपादित करें: 83 कॉस पर वापस लौटा मेरे पास गलत लाइन पर झींगे थे

संपादित करें: @adrianmp का धन्यवाद जिन्होंने मुझे वापसी को छोड़ कर इसे और छोटा करने में मदद की

उपरोक्त प्रारूप @adrianmp के समान प्रारूप का उपयोग करना:

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

उपरोक्त फ़ंक्शन का उपयोग करके पूरा कार्यक्रम:

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));
        }
    }
}

नमस्ते, PPCG में आपका स्वागत है! हम्म, आपके टुकड़ों का क्रम ओपी के साथ गलत लगता है। Btw, आप बीच में स्थान को हटाकर 1 बाइट बचा सकते हैं return ", इसलिए यह बन जाता है x=>{return"rnbqkbnr\npppppppp\nxxxxPPPPPPPP\nRNBQKBNR".Replace("x","........\n");};:। अच्छा जवाब, तो मुझसे +1। और अपने यहाँ रहने का आनंद लें। :)
केविन क्रूज़सेन

और आपके उत्तर के लिए धन्यवाद। मैंने अपने जावा 7 उत्तर (निश्चित रूप से आप को श्रेय देता है) के लिए समान दृष्टिकोण को
चित्रित

मैंने इसे और बेहतर बनाया है
निब्लीपिग

गाह मैं सिर्फ यह महसूस करता हूं कि यह सही नहीं है
NIBlyPig

1
अच्छा तरीका! आप वास्तव में इसे 74 बाइट्स तक कम कर सकते हैं:x=>"rnbqkbnr\npppppppp\nxxxxRNBQKBNR\nPPPPPPPP".Replace("x","........\n");
adrianmp
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.