खाली गो बोर्ड पर एक पत्थर रखें

Question

यह भी देखें: एक जाओ बोर्ड पर एक चाल बनाने ।

कार्य

गो एक बोर्ड गेम है जहां दो खिलाड़ी (ब्लैक एंड व्हाइट) 19 × 19 बोर्ड पर ग्रिड लाइनों के चौराहों पर पत्थर रखते हैं। काली चाल पहले - उदाहरण के लिए, D4 पर:

       

इस चुनौती में, आपको D4इनपुट के रूप में एक गो बोर्ड का समन्वय करना चाहिए , और दिए गए बिंदु पर पहली चाल के साथ एक बोर्ड के ASCII प्रतिनिधित्व का उत्पादन करना चाहिए ।

ध्यान दें कि कोई स्तंभ I नहीं है। यह ऐतिहासिक रूप से, जे और एल के साथ भ्रम को कम करने के लिए है।

इस आउटपुट में 19 लाइनें हैं, जिनमें से प्रत्येक में 19 अक्षर हैं। उस पर पत्थर के साथ बिंदु चिह्नित है O। बोर्ड पर खाली बिंदुओं के रूप में दिखाया जाता है .नौ के लिए छोड़कर, स्टार अंक (कम D4, D10, D16, K4, K10, K16, Q4, Q10, और Q16), चिह्नित कर रहे हैं जो *।

उदाहरण के लिए, F5इनपुट के रूप में दिया गया, आपके उत्तर का आउटपुट होना चाहिए:

...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
.....O.............
...*.....*.....*...
...................
...................
...................

और Q16इनपुट के रूप में दिया गया, आपका आउटपुट होना चाहिए:

...................
...................
...................
...*.....*.....O...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................

नियम

• आप एक फ़ंक्शन लिख सकते हैं जो समन्वय को एक तर्क के रूप में लेता है, या एक प्रोग्राम जो कमांड लाइन से या समन्वय को पढ़ता है STDIN।

• आप निम्न-मामले या ऊपरी-मामले में इनपुट स्वीकार करना चुन सकते हैं, लेकिन आपके उत्तर को दोनों को संभालने की आवश्यकता नहीं है।

• इनपुट हमेशा एक स्ट्रिंग की तरह है a1या T19, कभी भी स्ट्रिंग + संख्या या दो तार नहीं।

• यदि आप एक पूर्ण कार्यक्रम लिखते हैं, तो आपका उत्तर STDOUTएक स्ट्रिंग के रूप में मुद्रित किया जाना चाहिए , वैकल्पिक रूप से एक अनुगामी न्यूलाइन द्वारा। यदि आपका उत्तर एक फ़ंक्शन है, तो आप  एक स्ट्रिंग प्रिंट कर सकते हैं STDOUT, या वापस कर सकते हैं , या  स्ट्रिंग (पंक्तियों) की एक सरणी / सूची  लौटा सकते हैं , या दो-आयामी सरणी या वर्णों की नेस्टेड सूची वापस कर सकते हैं।

• यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

Comments

बस यह सुनिश्चित करने के लिए, "एक तर्क के रूप में समन्वय" का अर्थ यह है कि हम दो तर्क नहीं ले सकते हैं, जैसे f("G", 14), सही?

— FryAmTheEggman

20k पर बधाई !!

— लुइस मेंडो

"यह ऐतिहासिक रूप से, जे और एल के साथ भ्रम को कम करने के लिए है।" लेकिन J और L दोनों बोर्ड में हैं ??!

— घातक

हां। इसके अलावा, निश्चित रूप से, गायब पत्र ने शायद किसी भी चीज़ से अधिक भ्रम और आश्चर्य पैदा किया है ...

— लिन

@ अलग-अलग दिशाओं में मोड़ के बाद से, J और L काफी अलग दिखते हैं। जे और एल के साथ, एक उतरता है, दूसरा ऊपर जाता है। लेकिन मैं और जम्मू एक समान हैं, और इसलिए मैं, एल और I ...

— ilkachachu

Answer 1

MATL , 33 बाइट्स

'*O.'19: 6\4=&*Hj1&)Uw64-t8>-&(P)

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

व्याख्या

'*O.'    % Push string with needed characters. Will be indexed into
19:      % Push numeric vector [1 2 ... 19]
6\4=     % 1 for values that equal 4 mod 6, 0 for the rest
&*       % Multiply by transposed version of itself with broadcast. This gives
         % the 19×19 board with 0 instead of '.' and 1 instead of '*'
H        % Push 2. This will correspond to 'O' (stone)
j        % Input string, such as 'Q16'
1&)      % Split into its first char ('Q') and then the rest ('16')
U        % Convert to number (16)
w        % Swap, to move 'Q' to top
64-      % Subtract 64. Thus 'A' gives 1, 'B' gives 2 etc
t8>-     % Duplicate. Subtract 1 if it exceeds 8. This corrects for missing 'I'
&(       % Fill a 2 at coordinates given by the number and the letter
P        % Flip upside down, because matrix coordinates start up, not down
)        % Index the string '*O.' with the 19×19 array containing 0,1,2.
         % Implicitly display

Answer 2

सी, 212 195 193 181 171 132 103 98 बाइट्स

@ बाइट के लिए 1 बाइट धन्यवाद @FryAmTheEggman, 5 बाइट्स @orlp के लिए धन्यवाद

f()खेलने की स्थिति के साथ कॉल करें (कैपिटल होना चाहिए), और यह परिणामी बोर्ड को प्रिंट करता है।

i;f(char*p){for(i=380;i--;)putchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10);}

इसे आइडोन पर आज़माएं ।

Comments

98 बाइट्सputchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10)

— orlp

धन्यवाद। मैं उस मोडुलो एक्सप्रेशन को कम करने का तरीका ढूंढ रहा था।

— १२:०२ पर ओवेरोडर

Answer 3

सी (जीसीसी), 132 128 109

i;m;f(char*s){for(i=380;i--;putchar(m?m^84-*s+(*s>73)|(i/20+1)^atoi(s+1)?m%6^4|i/20%6^3?46:42:79:10))m=i%20;}

Ideone

एक फ़ंक्शन जो बोर्ड को STDOUT पर प्रिंट करता है। पत्र को पूंजी होने के लिए समन्वय की आवश्यकता होती है। एक लूप में मुद्रण पिछले नेस्टेड लूप दृष्टिकोण से थोड़ा छोटा लगता है।

Answer 4

MATLAB, 135 बाइट्स

पहला प्रयास, चतुर कुछ भी नहीं, बस यह देखने के लिए कि अन्य लोग कितना बेहतर कर सकते हैं:

function go(a)
b=repmat('.',19);
b(4:6:end,4:6:end)='*';
a=sscanf(a,'%c%d');
a(1)=a(1)-64;
if a(1)>8
a(1)=a(1)-1;
end
b(20-a(2),a(1))='0'

उपयोग:

go('T19')

Comments

PPCG में आपका स्वागत है! बाइट्स को कम करने के लिए कुछ सुझाव: 1 चार (या साथ एक स्क्रिप्ट a=input('');) के साथ एक फ़ंक्शन नाम का उपयोग करें ; नई टिप्पणियाँ निकालें; बदलने '*'के लिए 42और '0'करने के लिए 48; endद्वारा प्रतिस्थापित 19; ifशाखा के बजाय सीधे तार्किक मूल्य घटाएं । वास्तव में, आप पिछले fiive लाइनों द्वारा जगह ले सकता हैb(20-a(2),a(1)-64-(a(1)>8))=48

— लुइस Mendo

नमस्ते और पीपीसीजी में आपका स्वागत है। अगर मैं गलत नहीं हूँ, तो आपका कोड 137 बाइट लंबा और 135 नहीं है। (मुझे लगता है कि यह बहुत मायने नहीं रखता है, लेकिन मैं सिर्फ आपको बताना चाहता हूं)

— दादा

Answer 5

रूबी, 93 91 बाइट्स

कमांड लाइन पर इनपुट लेता है, जैसे $ ruby script.rb Q16।

19.downto(1){|c|puts ([*?A..?T]-[?I]).map{|d|d+c.to_s==$*[0]??O:"DKQ"[d]&&c%6==4??*:?.}*""}

Repl.it पर इसका परीक्षण करें (प्रतिकृति के बाद एक लंबो में लिपटे। यह कमांड लाइन तर्क नहीं लेता है: https://repl.it/CkvT/1

Ungolfed

19.downto(1) do |row|
  puts ([*?A..?T] - [?I]).map {|column|
    if column + row.to_s == ARGV[0]
      "O"
    elsif "DKQ"[column] && row % 6 == 4
      "*"
    else
      "."
    end
  }.join
}

Comments

मुझे लगता है कि आप $><<इसके बजाय एक बाइट को बचा सकते हैं puts । हालांकि यकीन नहीं हो रहा है।

— निधि मोनिका का मुकदमा

@QPaysTaxes Alas, मुझे एक नई लाइन कहीं और संलग्न करनी होगी।

— जॉर्डन

ओह, हाँ। कोई बात नहीं

— निधि मोनिका मुकदमा

Answer 6

चले जाओ, 319 286 बाइट्स

import(."strconv"
."strings")
func g(c string)(s string){p:=SplitN(c,"",2)
n,_:=Atoi(p[1])
for i:=19;i>0;i--{
for j:= 'a';j<'t';j++{
if j=='i'{
}else if n==i&&ContainsRune(p[0],j){s+="o"
}else if((i==4||i==10||i==16)&&(j=='d'||j=='k'||j=='q')){s+="*"
}else{s+="."}}
s+="\n"}
return}

शायद गोल्फ थोड़ा छोड़ देता है, मैं एक भिखारी हूं

Comments

आप का नाम बदलकर 9 पात्रों को बचा सकता है partकरने के लिए p?

— corsiKa

गो में गोल्फिंग के लिए टिप्स। मैंने उन्हें स्वयं आपके उत्तर में लागू करने की स्वतंत्रता ली।

— EMBLEM

क्या आपने देखा कि टिप्पणी "भाषा की पसंद के लिए +1" में पोस्ट की तुलना में अधिक upvotes हैं? (ऐसा होता है कि टिप्पणियों में अधिक उतार-चढ़ाव होता है, लेकिन इस तरह की टिप्पणी के लिए, यह अप्रत्याशित है)

— दादा

Answer 7

रूबी, 130 128 121 + 3 ( -nध्वज) = 124 बाइट्स

स्विच किया -pगया -nक्योंकि puts bएक बाइट से कम है$_=b*$/

~/(.)(.+)/
b=(1..19).map{?.*19}
(a=3,9,15).map{|i|a.map{|j|b[i][j]=?*}}
b[19-$2.to_i][([*?A..?T]-[?I]).index$1]=?o
puts b

Comments

क्या आप यह जांच कर बाइट्स बचा सकते हैं कि क्या इंडेक्स मॉड 6 हार्डकॉडिंग 3, 9 और 15 के बजाय 3 है?

— FryAmTheEggman

@FryAmTheEggman यह हो सकता है, लेकिन मुझे अभी तक एक समाधान का पता लगाना है जो ऐसा करता है।

— वैल्यू इंक

Answer 8

पायथन, 148 145 136 130 121 119 116 बाइट्स

-3 बाइट्स @RootTwo को धन्यवाद

lambda x,r=range(19):[[".*o"[[i%6==j%6==3,2][j==ord(x[0])-(x>"I")-65and-~i==int(x[1:])]]for j in r]for i in r[::-1]]

अनाम लंबोदर फ़ंक्शन, "A1" फॉर्म (बड़े अक्षर) का इनपुट लेता है और पाइथन की सूची की सूची को आउटपुट करता है (len == 1 स्ट्रिंग्स पाइथन में)

Comments

".*oo"[2*(j==ord(x[0])-(x[0]>"I")-65and int(x[1:])==i+1)+(i%6==j%6==3)]"o"if...else"*"if...else"."

— RootTwo

इसके अलावा, मुझे लगता है कि आप 3 बाइट्स को बचाने के (x>'I')बजाय उपयोग कर सकते हैं (x[0]>'I')।

— रूटट्वो

@RootTwo धन्यवाद, पहला सुझाव अब उपयोगी नहीं है, जब से मैंने एक छोटा समाधान ढूंढ लिया है। दूसरा अब स्पष्ट प्रतीत होता है और मुझे प्रश्न करता है कि मैंने इस बारे में पहले क्यों नहीं सोचा।

— कार्लकास्टर 5

Answer 9

> <> , 98 96 बाइट्स

'_U'i-:b)-0\
+*a$%cv?(0:i<
{*+{4*\+
+4gf-o>1-:?!;:{:}=3*&::aa+%::0=2*&+&6%1-}-aa+,6%{*9=&
=9^^

ध्यान दें कि 0x14पहली पंक्ति में पहली के बाद एक है ', और अंतिम पंक्ति के पहले और पहले के 0x19बीच में है । इसे ऑनलाइन आज़माएं!9^

इनपुट को मैप किया जाता है ताकि A-Tबन 1-19(0 के साथ एक काल्पनिक "न्यूलाइन" कॉलम को दर्शाते हुए) और पूर्णांक पंक्ति की संख्या 1 से घट जाती है। प्रोग्राम 37 लूप से 0 तक लूप करता है, नीचे की पंक्ति से एक चार को चुनता है जैसा कि वह जाता है। 15 से ऑफसेट, इस तथ्य के लिए कि आप कोडबॉक्स में एक शाब्दिक नई प्रविष्टि दर्ज नहीं कर सकते हैं)। न्यूलाइन्स के माध्यम से जाँच की जाती है i % 20 == 0, और स्टार अंक द्वारा जाँच की जाती है ((i%20-1)%6)*((i/20)%6) == 9।

Answer 10

एफ #, 241 237 225 216 214 211 बाइट्स

let G(c:string)=for k=1 to 380 do printf(if k%20=0 then"\n"elif"_ABCDEFGHJKLMNOPQRST".IndexOf c.[0]=k%20&&19-k/20=int(c.Substring 1)then"o"elif(k%20=4||k%20=10||k%20=16)&&(k/20=3||k/20=9||k/20=15)then"*"else".")

मुश्किल यह एक ... मुझे आश्चर्य है कि अगर यह कम किया जा सकता है।

संपादित करें: एक बग को ठीक किया, कुछ संख्याओं को कुछ स्थानों को हटाकर दूसरों में जोड़ दिया, किसी तरह एक ही गिनती के साथ समाप्त हो गया। बाद में किया जा सकता है संख्या फेरबदल की कोशिश करो ।

Edit2: अधिक बाइट्स में से एक को स्पेल से बचाकर, सहज रूप से काउंटर करें।

Edit3: फिक्स्ड एक और बग: अब अंतिम रैंक पर टुकड़ों के लिए काम करना चाहिए और दो बाइट्स को बचाने में कामयाब रहा, जबकि मैं किसी भी तरह से हूं।

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

Comments

ओह, यह समस्या थी। मजेदार, यह एक चीज है जिसे मैंने दो बार नहीं देखा

— asibahi

Answer 11

रेटिना , 134 129 122 बाइट्स

मार्टिन एंडर के लिए 11 बाइट्स धन्यवाद, और 1 और की प्रेरणा के लिए।

S2=`
[K-S]
1$&
T`xL`d9d
.+
$*
$
aaab
a
bbbcbb
b|c
¶$0
c
ddd.
d
...*..
b
19$*.
1(1)*¶1(1)*¶((?<-2>.+¶)*(?<-1>.)*).
$3O
O^$`

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

Comments

अरे, आपके सोने के बैज पर बधाई!

— लुइस मेंडो

Answer 12

पर्ल, 132 बाइट्स

-3 बाइट्स @ डॉम हेस्टिंग्स को धन्यवाद

@v=eval"[('.')x19],"x19;@{$v[$_]}[@t]=("*")x3for@t=(3,9,15);pop=~/\d+/;$v[19-$&][($t=ord$`)-65-($t>73)]=O;map{say}map{join"",@$_}@v;

कमांड लाइन इनपुट लेता है। -M5.010टु रन की जरूरत है । उदाहरण के लिए :

$ cat go_board.pl
@v=eval"[('.')x19],"x19;@{$v[$_]}[@t]=("*")x3for@t=(3,9,15);pop=~/\d+/;$v[19-$&][($t=ord$`)-65-($t>73)]=O;map{say}map{join"",@$_}@v;
$ perl -M5.010 go_board.pl Q16

मुझे लगता है कि यह कम हो सकता है, लेकिन मैं यह पता नहीं लगा सका ... कृपया मुझे बताएं कि क्या आप करते हैं!

Comments

फिर से अधिक जादू चर का अच्छा उपयोग! मैंने इसका ठीक से परीक्षण नहीं किया है, लेकिन मुझे लगता है कि आप @v=([(".")x18])x18;सूची को शुरू करने के लिए कुछ और बचत कर सकते हैं ... इससे बेहतर तरीका और भी हो सकता है, लेकिन मैं अभी किसी टर्मिनल पर नहीं हूं! मुझे लगता है कि आप @{...}विस्तार को डेरेफ्रेंसिंग तीरों से भी बदल सकते हैं: $v[$_]->[@t]फिर भी अप्रयुक्त! इसके अलावा, मुझे आशा है कि आप मुझे कोड परिवर्तन का सुझाव देने में कोई आपत्ति नहीं करेंगे ...

— डोम हेस्टिंग्स

@DomHastings बेशक, मुझे कोई आपत्ति नहीं है, इसके विपरीत, मैं आपको सुधार का सुझाव देने के लिए प्रोत्साहित करता हूँ! @v=([(".")x19])x19काम नहीं करता है (मैंने btw से पहले यह कोशिश की), क्योंकि यह केवल एक सरणी बनाता है और यह 19 बार रेफरी की नकल करता है, न कि सरणी (इसलिए अंत में आपके पास केवल 1 पंक्ति 19 बार दोहराई गई है)। की जगह @{..}के रूप में आप का सुझाव दिया या तो काम करने के लिए प्रतीत नहीं होता। मुझे लगता है कि क्योंकि मैं एक टुकड़ा पर काम कर रहा हूँ और केवल एक तत्व नहीं हूँ। यदि आपके पास कोई अन्य सुझाव है, तो बेझिझक सुझाव दें! :)

— दादा

लानत है, निश्चित रूप से यह वही होगा ... मैं eval-3 के लिए उपयोग करने में कामयाब रहा हूं : हालांकि @v=eval"[('*')x19],"x19;। और आप arrayref के साथ 100% सही हैं ... क्या संभव है कि 1D सरणी का उपयोग किया जाए और उस में अनुक्रमणिका का काम किया जाए? बाद में इसके साथ खेल सकते हैं!

— डोम हेस्टिंग्स

@DomHastings -3 बाइट्स के लिए धन्यवाद। शायद 1D सरणी के साथ प्रयास करने के लिए कुछ, वास्तव में। मैं जल्द ही इसकी कोशिश करूँगा

— दादा

Answer 13

बैच, 322 310 308 बाइट्स

@echo off
set/pi=
set/aa=0,b=1,c=2,d=3,e=4,f=5,g=6,h=7,j=8,k=9,l=10,m=11,n=12,o=13,p=14,q=15,r=16,s=17,t=18,x=%i:~1%-1,y=%i:~,1%,z=y+1
for /l %%r in (18,-1,0)do call:l %%r
exit/b
:l
set s=...*.....*.....*...
call set t=%%s:~%1,1%%
if %x%==%1 call set s=%%s:~,%y%%%o%%s:~%z%%%
call echo %%s:.*=.%t%%%

स्पष्टीकरण: स्टड पर पत्थर के लिए संकेत देकर शुरू होता है। फिर, प्रत्येक संभव स्तंभ के लिए चर सेट करता है, ताकि यह yसमन्वय प्राप्त करने के लिए एक चर के रूप में पत्थर के पहले चरित्र का मूल्यांकन कर सके। xसमन्वय से 1 घटाएँ क्योंकि यह 1-अनुक्रमित है और हम 0-अनुक्रमित चाहते हैं और गणना भी करते हैं z=y+1क्योंकि बाद में इसकी आवश्यकता होगी। फिर, rप्रत्येक पंक्ति के लिए 18 से नीचे 0 से छोरों । स्ट्रिंग लेता है ...*.....*.....*...और rबाद के लिए वें स्थिति में वर्ण निकालता है । पर xवीं पंक्ति, yवें चरित्र एक साथ बदल दिया है o। अंत में, .*एस को .पहले निकाले गए चरित्र के साथ बदल दिया जाता है; यह पंक्तियों 4, 10 और 16 पर एक नो-ऑप है लेकिन इसे प्राप्त करने का यह सबसे छोटा तरीका है। (मुझे उपयोग करना है.*क्योंकि *बैच में जगह स्पष्ट रूप से अवैध है।)

Answer 14

PowerShell v2 +, 157 152 बाइट्स

$x,$y=[char[]]$args[0];$a=,0*19;0..18|%{$a[$_]=,'.'*19};3,9,15|%{$i=$_;3,9,15|%{$a[$_][$i]='*'}};$a[-join$y-1][$x-65-($x-gt73)]='O';$a[18..0]|%{-join$_}

_{(मुझे लगता है कि मैं अल्पविराम-ऑपरेटर के साथ किसी प्रकार की अजीब गड़बड़ में भाग गया, इसलिए सरणी निर्माण की तुलना में थोड़ा लंबा है)}

के माध्यम से एक बड़े स्ट्रिंग के रूप में इनपुट लेता है $args[0], इसे चार-सरणी के रूप में रखता है, पहले अक्षर को $xऔर शेष अक्षरों में संग्रहीत करता है $y। यह प्रभावी रूप से इनपुट को अक्षर / संख्या में विभाजित करता है।

हम फिर अपने बहुआयामी सरणी का निर्माण करते हैं $a। हम आकार की एक सरणी को पूर्व-आबाद करते हैं19 साथ 0कॉमा-ऑपरेटर का उपयोग रों। फिर हम अल्पविराम ऑपरेटर का उपयोग करके 0..18प्रत्येक तत्व को $a[$_]समान अवधि के बजाय समान बनाने के लिए लूप करते हैं । (एनबी - सिद्धांत रूप में, इसे संघनित करने में सक्षम होना चाहिए $a=,(,'.'*19)*19, लेकिन यह अनुक्रमण असाइनमेंट के साथ सही काम नहीं करता है ... मुझे घाव हो रहा है *)

इसके बाद, हम 3,9,15संबंधित तत्वों को सेट करने के लिए दो बार लूप करते हैं* । फिर हम पत्थर को सेट करने के लिए सही स्थान पर इसे अनुक्रमित करते हैं O। ऐसा करने के लिए, हम (यानी, ASCII "A" 65 65से घटाते हैं $x, और हम शून्य-अनुक्रमित होते हैं), और बूलियन-टू-इंट कास्ट का उपयोग करके एक अतिरिक्त को घटाते हैं यदि (यानी, ASCII) "" $xसे बड़ा है 73)।

अब, हमारा आउटपुट उल्टा है (यानी, ऊपरी-बाएँ होगा A1), इसलिए हमें सरणी को उल्टा करने की आवश्यकता है $a[18..0]। अंत में, हम प्रत्येक पंक्ति का उत्पादन करते हैं-join एक स्ट्रिंग बनाने के लिए एड को एक साथ ।

Answer 15

> <> , 124 बाइट्स

मेरे सी उत्तर के समान सटीक दृष्टिकोण का उपयोग करता है। इनपुट एक कैपिटल लेटर होना चाहिए जिसके बाद एक दशमलव संख्या हो।

88*i:&-&'I')+0 v
*a&-'0'v!?)0:i&<+
+**2a&~/*a'&'&
:;!?:-1<o'O'v!?=&:&
{*?!v'*'o63.>:6%4=}:a4*+'x'%aa*)
*2a:/  av?%
.37o<'.'<

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

स्पष्टीकरण:

88*i:&-&'I')+0 v         'Push 64-<first input char>+(<first input char> > 'I')
*a&-'0'v!?)0:i&<+        'Set register to 0, parse decimal integer into register.
+**2a&~/*a'&'&           'Pop the -1 (EOF) from stack, multiply register by 20.
                         'Add result of first line to register.
                         'Push 380 onto stack.
:;!?:-1<o'O'v!?=&:&      'Main loop, while top of stack is not 0.
                         'Subtract 1 from top of stack (loop counter)
                         'If current index is the playing piece index, print 'O'
{*?!v'*'o63.>:6%4=}:a4*+'x'%aa*) 
                         'If (index%6)=4 and (index+40)%120>100, print '*'
*2a:/  av?%              'If (index%20)=0, print newline
.37o<'.'<                'Otherwise, print '.'

Answer 16

जावास्क्रिप्ट, 138 बाइट्स

s=>[...t="...*.....*.....*..."].map((c,i)=>t.replace(/\*/g,c).replace(/./g,(c,j)=>x-j|19-i-s.slice(1)?c:'o'),x=parseInt(s[0],36)*.944-9|0)

स्ट्रिंग्स की एक सरणी देता है। स्पष्टीकरण:

s=>[...                         Parameter
 t="...*.....*.....*..."        Pattern of lines 4, 10 and 16
].map((c,i)=>                   Loop 19 times
 t.replace(/\*/g,c)             Change the `*` to `.` on other lines
  .replace(/./g,(c,j)=>         Loop over each character
   x-j|19-i-s.slice(1)?c:'o'),  Change to o at the appropriate position
 x=parseInt(s[0],36)*.944-9|0)  Compute the column number from the letter

Comments

तार की एक सरणी आवश्यक आउटपुट से मेल नहीं खा रही है, बस join। इसके अलावा यह ओ को गलत पंक्ति और डी 5 (पहले परीक्षण मामले) के लिए गलत कॉलम में रखता है।

— कोनिज़न

@tomdemuyt स्ट्रिंग्स की एक सरणी को वापसी मान के रूप में अनुमति दी जाती है। हालाँकि, यह संभव है कि मुझे मेरी पंक्तियाँ और स्तंभ मिल गए, इसलिए मैं दोबारा जाँच करूँगा।

— नील

हम्म, वास्तव में स्ट्रिंग्स की सरणी

— कोनिज़ॉन

Answer 17

आर, 169 161 बाइट्स

f=function(p){S=substr;N=rep(".",114);N[61+6*0:2]="*";M=matrix(N,19,19);M[(S(p,2,3):1)[1],which(LETTERS[-9]==S(p,1,1))]="O";for(i in 19:1)cat(M[i,],"\n",sep="")}

इंडेंट और न्यूलाइन्स के साथ:

f=function(p){
    S=substr
    N=rep(".",114) # 6 lines of dots
    N[61+6*0:2]="*" # Place the hoshis
    M=matrix(N,19,19) # Make the 19x19 board using vector recycling
    M[(S(p,2,3):1)[1],  #grab and force coerce the row number to integer
      which(LETTERS[-9]==S(p,1,1))]="O" #Place the first stone
    for(i in 19:1) cat(M[i,],"\n",sep="")
}

उपयोग:

> f("A19")
O..................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
> f("D4")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...O.....*.....*...
...................
...................
...................
> f("K10")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....O.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................

Answer 18

लुआ, 187 बाइट्स

function g(i)i:gsub("(%a+)(%d+)",function(a,b)q=string.byte(a)-64 r=b+0 end)for x=1,19 do s=""for y=1,19 do s=s..(x+y*19==r+q*19 and"o"or(x-4)%6+(y-4)%6==0 and"*"or"-")end print(s)end end

मैं इस विशेष परियोजना के लिए 187 के बारे में बहुत बुरा नहीं मानता। लूआ अभी भी गोल्फिंग के लिए बहुत क्लिंक के रूप में सामने आता है, लेकिन मुझे इस पर गर्व है कि मैं इसके साथ कितनी दूर जा सकता हूं।

Answer 19

PHP, 280 268 263 261 255 218 216 बाइट्स

<?php $a=ucfirst($argv[1]);$x=substr($a,0,1);$y=substr($a,1);$s=['DKQ',4,16,10];$i=85;while(64<$i--){$j=0;while($j++<20){echo($x==chr($i)&&$y==$j)?'O':((strpos($s[0],chr($i))>-1&&in_array($j,$s))?'*':'.');}echo"\n";}

मेरा पहला गोल्फ।

उपयोग:
PHP फ़ाइल के रूप में सहेजें और php filename.php coordinateउदाहरण के लिए इसे कॉल करेंphp go.php k13