28

एक मानक स्क्रैबल बोर्ड अक्षर टाइल लगाने के लिए रिक्त स्थान का 15 × 15 ग्रिड है। अधिकांश रिक्त स्थान रिक्त हैं, लेकिन कुछ डबल शब्द स्कोर (गुलाबी), ट्रिपल शब्द स्कोर (लाल), डबल अक्षर स्कोर (हल्का नीला), और ट्रिपल अक्षर स्कोर (नीला) हैं। आमतौर पर बहुत केंद्र में एक स्टार होता है (जो दोहरे शब्द स्कोर के रूप में गिना जाता है)।

एक प्रोग्राम या फ़ंक्शन लिखें जो ASCII फॉर्म में एक मानक, खाली स्क्रैबल बोर्ड को आउटपुट करता है:

. एक खाली जगह का प्रतिनिधित्व करता है
D एक दोहरे शब्द स्कोर का प्रतिनिधित्व करता है
T एक ट्रिपल शब्द स्कोर का प्रतिनिधित्व करता है
d एक दोहरे अक्षर स्कोर का प्रतिनिधित्व करता है
t एक ट्रिपल लेटर स्कोर का प्रतिनिधित्व करता है
X केंद्र तारे का प्रतिनिधित्व करता है

यानी आपका सटीक आउटपुट होना चाहिए

T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T

वैकल्पिक रूप से एक अनुगामी newline द्वारा पीछा किया।

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

स्टार का प्रतिनिधित्व क्यों Xऔर कैसे नहीं *? : o

— घातक

6

*बहुत ऊंचा और शक्तिशाली है।

— केल्विन के शौक

क्यों नहीं ★? : D

— mbomb007

5

@ mbomb007 ASCII- कला चुनौती में गैर-ASCII चार? पाषंड !

— लुइस मेंडो सेप

16

MATL , 59 54 52 बाइट्स

4t:g2I5vXdK8(3K23h32h(H14(t!XR+8: 7:Pht3$)'DtdTX.'w)

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

व्याख्या

कोड तीन मुख्य चरणों का पालन करता है:

8x8 मैट्रिक्स उत्पन्न करें

4 0 0 3 0 0 0 4
0 1 0 0 0 2 0 0
0 0 1 0 0 0 3 0
3 0 0 1 0 0 0 3
0 0 0 0 1 0 0 0
0 2 0 0 0 2 0 0
0 0 3 0 0 0 3 0
4 0 0 3 0 0 0 5

इसे 15x15 मैट्रिक्स तक बढ़ाएं

4 0 0 3 0 0 0 4 0 0 0 3 0 0 4
0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
4 0 0 3 0 0 0 5 0 0 0 3 0 0 4
0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
4 0 0 3 0 0 0 4 0 0 0 3 0 0 4

'DtdTX.'वांछित परिणाम उत्पन्न करने के लिए उस मैट्रिक्स के साथ स्ट्रिंग को अनुक्रमित करें ।

चरण 1

4        % Push 4
t:       % Duplicate, range: pushes [1 2 3 4]
g        % Logical: convert to [1 1 1 1]
2I5      % Push 2, then 3, then 5
v        % Concatenate all stack vertically into vector [4 1 1 1 1 2 3 5]
Xd       % Generate diagonal matrix from that vector

अब हमें नॉनज़रो ऑफ-विकर्ण प्रविष्टियों को भरने की आवश्यकता है। हम केवल उन विकर्णों को भरेंगे, और फिर दूसरों को भरने के लिए समरूपता का उपयोग करेंगे।

प्रत्येक मूल्य को भरने के लिए हम रैखिक अनुक्रमण का उपयोग करते हैं ( यह उत्तर , लंबाई -12 स्निपेट देखें)। इसका मतलब है कि मैट्रिक्स को एक्सेस करना जैसे कि इसका केवल एक ही आयाम था। 8 × 8 मैट्रिक्स के लिए, रैखिक सूचकांक का प्रत्येक मान निम्नानुसार एक प्रविष्टि को संदर्भित करता है:

1   9         57
2  10         58
3  11
4  
5  ...       ...
6  
7             63
8  16 ... ... 64

तो, निम्न मान 4 से निचले-बाएँ प्रविष्टि को असाइन करता है:

K        % Push 4
8        % Push 8
(        % Assign 4 to the entry with linear index 8

मान 3 के लिए कोड समान है। इस मामले में सूचकांक एक वेक्टर है, क्योंकि हमें कई प्रविष्टियाँ भरने की आवश्यकता है:

3        % Push 3
K        % Push 4
23h      % Push 23 and concatenate horizontally: [4 23]
32h      % Push 32 and concatenate horizontally: [4 23 32]
(        % Assign 4 to the entries specified by that vector

और 2 के लिए:

H        % Push 2
14       % Push 14
(        % Assign 2 to that entry

अब हमारे पास मैट्रिक्स है

4 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0
3 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 2 0 0 0 2 0 0
0 0 3 0 0 0 3 0
4 0 0 3 0 0 0 5

ऊपरी आधा भरने के लिए हम समरूपता का फायदा उठाते हैं:

t!       % Duplicate and transpose
XR       % Keep the upper triangular part without the diagonal
+        % Add element-wise

चरण 2

स्टैक में अब चरण 1 से उत्पन्न 8 × 8 मैट्रिक्स शामिल है। इस मैट्रिक्स का विस्तार करने के लिए हम अनुक्रमण का उपयोग करते हैं, इस बार दो आयामों में।

8:       % Push vector [1 2 ... 7 8]
7:P      % Push vector [7 6 ... 1]
h        % Concatenate horizontally: [1 2 ... 7 8 7 ... 2 1]. This will be the row index
t        % Duplicate. This will be the column index
3$       % Specify that the next function will take 3 inputs
)        % Index the 8×8 matrix with the two vectors. Gives a 15×15 matrix

चरण 3

स्टैक में अब चरण 2 से उत्पन्न 15 × 15 मैट्रिक्स है।

'DtdTX.' % Push this string
w        % Swap the two elements in the stack. This brings the matrix to the top
)        % Index the string with the matrix

— लुइस मेंडो
स्रोत

यह वास्तव में, वास्तव में, अच्छा है।

— AdmBorkBork 20

मुझे यह उत्तर सामान्य रूप से पसंद है, हालांकि यह थोड़ा सा 'itches' है क्योंकि आप लंबाई के वेक्टर बनाने के लिए 8 वर्णों का उपयोग करते हैं। क्या आपने गणितीय अनुक्रम द्वारा संख्याओं को प्राप्त करने पर विचार किया है? अभी तक कुछ भी मीठा नहीं मिला, लेकिन विशेष रूप से पिछले 7 में ऐसा अच्छा पैटर्न दिखा। उदाहरण के लिए छत ((1: 7) ^

— 4/500

@DennisJ धन्यवाद! हाँ, यह बहुत ज्यादा लगता है। मैं कोशिश करूँगा कि बाद में, अब फोन पर

— लुइस मेंडू सेप

8

रूबी, 103 97 बाइट्स

पुनरावृत्तियों पर 6 बाइट सुधार के लिए मिच श्वार्ट्ज के लिए धन्यवाद।

a=(-7..7).map &:abs
a.map{|i|puts a.map{|j|(d=i%7-j%7)%4<1?'X d t DTDdDdDtT d'[i+j+d*d/3]:?.}*''}

नीचे मेरे मूल जवाब के लिए एक समान लेकिन काफी अलग दृष्टिकोण। पहले की तरह, हम इस तथ्य का उपयोग करते हैं कि एक पत्र i%7-j%7को 0 या 4 के बराबर होने पर मुद्रित किया जाना चाहिए । लेकिन यहां हम उस अंतर को संग्रहीत करते हैं dऔर उस i+j+d*d/3पूर्णांक को देने के लिए सूत्र का उपयोग करते हैं जो उस विशेष रंगीन वर्ग के लिए अद्वितीय (समरूपता के लिए) है। फिर हम इसे जादुई स्ट्रिंग में देखते हैं।

बस मज़े के लिए: इस दृष्टिकोण का सी संस्करण, 120 बाइट्स

z,i,j,d;f(){for(z=240;z--;)i=abs(z%16-8),j=abs(z/16-7),putchar(i-8?(d=i%7-j%7)%4?46:"X d t DTDdDdDtT d"[i+j+d*d/3]:10);}

रूबी, 115 113 बाइट्स

2 बाइट्स ने मूल्य स्याही के लिए धन्यवाद बचाया।

(k=-7..7).map{|y|k.map{|x|i=x.abs;j=y.abs
$><<=(i%7-j%7)%4<1?"#{'XdTdT'[(i+j)/3]}dtDDDD"[[i%7,j%7].min]:?.}
puts}

व्याख्या

उत्पत्ति को बोर्ड का केंद्र माना जाता है।

यदि वर्ण वर्ग के x और y निर्देशांक समान या भिन्न होते हैं तो एक पत्र मुद्रित होना चाहिए। केवल अपवाद बोर्ड के बाहरी किनारे पर हैं, लेकिन ये केंद्रीय पंक्ति / स्तंभ के समान पैटर्न का अनुसरण करते हैं बोर्ड, तो हम उसी स्थिति का उपयोग कर सकते हैं यदि हम x और y निर्देशांक 7 लेते हैं।

प्रदर्शित पत्र का चुनाव न्यूनतम परिमाण के समन्वय पर आधारित है। इस तरह से युगल और त्रिकोणीय (1,5) और (2,6) उसी नियम का पालन करते हैं जैसे (1,1) और (2,2) और 7 वर्ण स्ट्रिंग से प्राप्त किया जाता है। "#{formula}dtDDDD"यह सभी विविधताओं को कवर नहीं करता है किनारे और सेंट्रीलाइन वर्गों के लिए, इसलिए सूत्र से स्ट्रिंग के पहले वर्ण की गणना की जाती है 'XdTdT'[(i+j)/3]।

(k=-7..7).map{|y|
  k.map{|x|
    i=x.abs;j=y.abs
    print (i%7-j%7)%4<1?      #IF this expression is true print a letter 
    "#{'XdTdT'[(i+j)/3]       #select 1st character of magic string where [i%7,j%7].min==0 
     }dtDDDD"[[i%7,j%7].min]: #remaining 6 characters of magic string for diagonal
    ?.                        #ELSE print .
  }
  puts                        #at the end of the row print a newline
}

— स्तर नदी सेंट
स्रोत

(k=-7..7).map{|y|k.map{...आपकी डबल -7.upto(7)तकनीक से 2 बाइट्स छोटी है ।

— वैल्यू इंक

6 बाइट्स को बचाने के लिए कुछ संशोधन:a=(-7..7).map &:abs;a.map{|i|puts a.map{|j|(d=i%7-j%7)%4<1?'X d t DTDdDdDtT d'[i+j+d*d/3]:?.}*''}

— मिच श्वार्ट्ज

7

ब्रेनफक , 598 596 590 बाइट्स

गोल्फ टिप्स का स्वागत करते हैं।

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

व्याख्या

करने के लिए टेप प्रारंभ [10 116 68 46 100 84 92] यानी [nl टी डी। d T \]

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

यहां प्रत्येक पंक्ति तब बोर्ड की एक पंक्ति को प्रिंट करती है।
मध्य रेखा भी घट जाती है92 to 88 i.e. \ to X

.<<..>.<...>>.<<...>.<..>>.<<<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>....<.>.....<.>....<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>>>.<<..>.<...>>>----.<<<...>.<..>>.<<<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>....<.>.....<.>....<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>>>.<<..>.<...>>.<<...>.<..>>.

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

— Emigna
स्रोत

1

बीएफ के लिए सुझाव: बीएफ में एएससीआई गोल्फ न करें; हालांकि अच्छी रणनीति।

— मैजिक ऑक्टोपस Urn

5

PowerShell v2 +, 147 बाइट्स

($x='T..d...T...d..T')
($y='.D...t..','..D...d.','d..D...d','....D...','.t...t..','..d...d.'|%{$_+-join$_[6..0]})
$x-replace'.T.','.X.'
$y[5..0]
$x

Write-Outputप्रोग्राम निष्पादन के अंत में डिफ़ॉल्ट कैसे सरणियों का लाभ उठाता है (यानी, यह तत्वों के बीच एक नई प्रविष्टि सम्मिलित करता है)। बोर्ड के मध्य उत्पन्न करने के लिए एक बेहतर तरीका हो सकता है - मैं अभी भी इस पर काम कर रहा हूं।

पहली पंक्ति बोर्ड की शीर्ष पंक्ति को आउटपुट करती है, इसे $xबाद में उपयोग के लिए संग्रहीत भी करती है ।

अगली पंक्ति सभी डबल-वर्ड लाइनों को प्रत्येक के बाएं "आधा" लेकर, उन्हें ( -join$_[6..0]स्टेटमेंट) मिरर करके , और एरे में तत्वों के रूप में स्टोर करके उत्पन्न करती है $y।

अगली पंक्ति मध्य पंक्ति है, मध्य में ए X, धन्यवाद के साथ -replace।

अगली पंक्ति $yरिवर्स ऑर्डर में आउटपुट करती है, जिससे हमें नीचे डबल-वर्ड लाइनें मिलती हैं।

अंतिम पंक्ति अभी $xफिर से है।

PS C:\Tools\Scripts\golfing> .\draw-empty-scrabble-board.ps1
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T

— AdmBorkBork
स्रोत

5

> <> (मछली), 153 बाइट्स

\!o;!?l
\'T..d...T...d..T'a'.D...t...t...D.'a'..D...d.d...D..'a'd..D...d...D..d'a'....D.....D....'a'.t...t...t...t.'a'..d...d.d...d..'a'T..d...'
\'X/'02p

चीजों को करने का एक भयानक, भयानक, अकुशल तरीका। वर्तमान में इसे क्षैतिज और लंबवत दोनों प्रकार से ठीक करके इसे छोटा करने का एक तरीका है।

इसे ऑनलाइन आज़माएं! (यदि आप पूरे दिन नहीं रहना चाहते हैं तो सुनिश्चित करें कि आपने एनीमेशन के बिना निष्पादन गति को अधिकतम या चलाने के लिए निर्धारित किया है।)

— कैलम केर
स्रोत

4

सी, 146 145 142 138 बाइट्स

i,r,c;main(){for(;i<240;)r=abs(i/16-7),c="T..12..0..12..0"[r+7-abs(i%16-7)],putchar(++i%16?c&4?c:"Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3]:10);}

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

लेवल रिवर सेंट की ~~बदौलत 1 बाइट~~ 5 बाइट बच गई

यह एन्कोडिंग के लिए बोर्ड के विकर्ण पैटर्न का शोषण करता है। विशेष रूप से, यदि हम बोर्ड के शीर्ष बाएँ वृत्त का चतुर्थ भाग लेते हैं और विकर्ण को संरेखित करते हैं, तो हमें यह मिलता है:

       T..d...T
      .D...t..
     ..D...d.
    d..D...d
   ....D...
  .t...t..
 ..d...d.
T..d...X

... बहुत सारे कॉलम अब लाइन में हैं। यदि हम कॉलम को एक पंक्ति में इस तरह से एन्कोड करते हैं:

       0..12..0 y/012/Td./
      .0..12..  y/012/D.t/
     ..0..12.   y/012/D.d/
    2..0..12    y/012/D.d/
   12..0..1     y/012/D../
  .12..0..      y/012/tt./
 ..12..0.       y/012/dd./
T..12..0        y/012/Xd./

... तो बोर्ड पैटर्न को एक 15 वर्ण स्ट्रिंग में ढहाया जा सकता है T..12..0..12..0:; और हमें बस प्रत्येक पंक्ति के लिए सही मैपिंग की आवश्यकता है।

इसे ध्यान में रखते हुए, यहाँ टिप्पणियों के साथ एक विस्तारित संस्करण है:

i,r,c;
main() {
   for(;i<240;)  // one char per output including new line
   r=abs(i/16-7) // row; goes from 7 to 0 and back to 7.
   , c="T..12..0..12..0"[r+7-abs(i%16-7)] // pattern char
   , putchar(++i%16 // if this is 0 we need a new line
   ? c&4 // hash to distinguish 'T' and '.' from '0', '1', '2'
     ? c // print 'T' and '.' literally
     : "Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3] // otherwise look up replacement char
   : 10 // print the new line
   );
}

— एच वाल्टर्स
स्रोत

बहुत अच्छा। 1. आप एक कार्यक्रम के बजाय एक समारोह प्रस्तुत कर सकते हैं, तो i,r,c;f()ठीक है। 2. (i%16-7)%8-> i%16-7&73. मुझे लगता है c-48-> c%4काम करता है, यह नहीं है?

— लेवल रिवर सेंट

उफ़, क्षमा करें, फ़ंक्शंस को पुन: प्रयोज्य f()करना होगा , इसलिए i=0फ़ंक्शन के अंदर एक अतिरिक्त की आवश्यकता होगी ताकि यह कुछ भी न बचाए।

— लेवल रिवर सेंट

टिप्पणियों के लिए धन्यवाद! 2 या तो काम नहीं करेगा ( %8% 16 मान 0..15 से -7..7 मैप करने के लिए कार्यान्वयन के नकारात्मक मापांक का उपयोग करता है; &7यह 0..7,0..7 पर मैप करेगा)। लेकिन, हाँ, 3 बिल्कुल काम करेगा ... जब मुझे मौका मिलेगा तो अपडेट करूंगा।

— एच वाल्टर्स

@LevelRiverSt Mea gupa; 2 अभी भी सख्ती से काम नहीं करेगा, लेकिन मुझे उस सामान की ज़रूरत नहीं थी।

— एच वाल्टर्स

3

05AB1E , 57 53 बाइट्स

कोड

•jd]31‚ŽÔc¦Ïïì¹Ep.Üì8Ìa;“•6B4ÝJ".TdDt"‡5'.3×:Â'Xý15ô»

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण (पुराना)

•4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5Bइस नंबर पर decompresses:

1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000

साथ 4ÝJ".TdtD"‡में, हम इस बड़ी संख्या में निम्नलिखित लिप्यन्तरण:

0 -> .
1 -> T
2 -> d
3 -> t
4 -> D

हम पूरे स्ट्रिंग को द्विभाजित करते हैं, स्ट्रिंग और स्ट्रिंग को स्टैक पर उल्टा छोड़ देते हैं और उनका "X"उपयोग करके जुड़ते हैं ý। हम वें 15ôकोड का उपयोग करके पूरे स्ट्रिंग को 15 के टुकड़ों में विभाजित करते हैं और नए सरणी का उपयोग करके पूरे सरणी में शामिल होते हैं »।

— अदनान
स्रोत

û€ûएक अंतर्निहित होना चाहिए;)।

— मैजिक ऑक्टोपस Urn

2

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

d=lambda s:s+s[-2::-1]
print(*d(list(map(d,'T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X '.split()))),sep='\n')

— RootTwo
स्रोत

बदलें list(map(A))करने के लिए [*map(A)], 3 बाइट (अजगर की आवश्यकता है 3.5+) की बचत होती है।

— शौकी

2

05AB1E , 49 44 बाइट्स

•1nÑ=}íge/Þ9,ÑT‰yo¬iNˆå•6B8ôû€û»5ÝJ".TtdDX"‡

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

व्याख्या की:

धक्का दें: 1003000104000200004000303004000300004000020002000030003010030005

8 के विखंडू में विभाजित करें, प्रत्येक को पलिंड्रोमाइज करें।

फिर से पालिंड्रोमाइज करें।

वर्णों के साथ संख्याएँ बदलें।

अन्य आइडिया (किसी MATL में यह कोशिश करो)

हर किसी को देखकर ऐसा लगता है कि यह समय-समय पर इनब्रेट करता है ...

प्रत्येक टुकड़े को शून्य इनबेट की संख्या गिनें:

1003000104000200004000303004000300004000020002000030003010030005
^  ^   ^ ^   ^    ^   ^ ^  ^   ^    ^    ^   ^    ^   ^ ^  ^   ^

131424334342233135 => w\F6ß¿

शून्य रनों की गिनती लेना:

23134312344343123 => ì:¼˜¾

तब आप डिक्रिप्ट और उन्हें एक साथ स्थानांतरित करेंगे।

05AB1E में उनका उपयोग (परिणाम +5 बाइट में वृद्धि):

05AB1E , 27 बाइट्स

•w\F6ß¿•6BS•ì:¼˜¾•5BS0×‚øJJ

कोशिश करो...

मेटा-गोल्फ प्रविष्टि:

05AB1E , 104 बाइट्स

•G¨J´JÏÍ?»"”Ö3úoÙƒ¢y”vf%¯‚6À°IÕNO’Å2Õ=ÙŠxn®žÑŸ¶¼t¨š,Ä]ÓŽÉéÈºÂ/ø‡ŸÖ|e³J—Ë'~!hj«igÄ‹Î‚wî’©•7BžLR"
.DTXdt"‡

कोशिश करो!

मेटा-golfed ASCII आर्ट के लिए मेरे मेटा-गोल्फ खिलाड़ी का उपयोग कर: https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw

— जादू ऑक्टोपस Urn
स्रोत

1

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

_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`

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

स्ट्रिंग "T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"'X' से ठीक पहले अपने ऊपरी बाएं कोने से वर्ग तक के बोर्ड का वर्णन करती है, लगातार खाली वर्गों को अंकों के रूप में एन्कोड किया गया है। replace()समारोह दोनों खाली वर्गों unpacks और दर्पण स्ट्रिंग बनाता rबोर्ड के नीचे के लिए। फिर दोनों हिस्सों को एक साथ रखा जाता है और हर 15 अक्षरों में गाड़ी का रिटर्न डाला जाता है।

डेमो

let f =
_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`
console.log(f())

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

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

f=
_=>(a=[...Array(15)].map(_=>Array(15).fill`.`),r=([c,i,j])=>[a[i][j]=a[k=14-i][j]=a[i][j=14-j]=a[k][j]=c,j,i],[..."TDDDDtdX"].map((c,i)=>r([c,i,i])),"d30t51d62d73T70".replace(/.../g,s=>r(r(s))),a.map(a=>a.join``).join`
`)
;o.textContent=f()

<pre id=o>

स्निपेट का विस्तार करें

जब से मैं इसे बनाने की मुसीबत में चला गया मैंने सोचा कि मैं इसे वैसे भी पोस्ट करूंगा भले ही एक स्पष्ट रूप से बेहतर समाधान उपलब्ध हो।

— नील
स्रोत

1

सी 234 बाइट्स

#define g(t) while(i++<8)putchar(*b++);b-=2;--i;while(--i>0)putchar(*b--);putchar('\n');b+=t;
char*r="T..d...T.D...t....D...d.d..D...d....D....t...t....d...d.T..d...X";i;f(){char*b=r;do{g(9);}while(*b);b-=16;do{g(-7);}while(b>=r);}

यहाँ उत्पादन है:

T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T

— cleblanc
स्रोत

1

लकड़ी का कोयला , 33 बाइट्स (नॉनकमेटिंग)

इस उत्तर का सारा श्रेय @DLosc को जाता है ।

T↑↑↘tdd↗→→↖XdtDDDD↓T..d‖Ｏ⟦↗→↓⟧ＵＢ.

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

वाचाल

Print("T")
Move(:Up)
Move(:Up)
Print(:DownRight, "tdd")
Move(:UpRight)
Move(:Right)
Move(:Right)
Print(:UpLeft, "XdtDDDD")
Print(:Down, "T..d")
ReflectOverlap([:UpRight, :Right, :Down])
SetBackground(".")

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

— ASCII-केवल
स्रोत

इस चुनौती के लिए सही उपकरण, यह विकर्ण मुद्रण क्षमताओं के साथ है। +1 (और ASCII के लिए एक पृष्ठभूमि विधि देखने के लिए भी अच्छा है)

— केविन क्रूज़सेन

0

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

g=(++)<*>reverse.init
unlines$g$g<$>words"T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X"

gएक गैर-पॉइंटफ़्री संस्करण में है g x = x ++ (reverse (init x))। इसे प्रति (आधा) लाइन पर एक बार और फिर से परिणाम पर लागू किया जाता है।

— nimi
स्रोत

0

श + कोरुटिल्स, 119 बाइट्स

यह एक बाइनरी फ़ाइल है। हेक्सडंप के रूप में दिखाया गया है:

00000000  74 61 69 6c 20 2d 63 39  34 20 24 30 7c 67 75 6e  |tail -c94 $0|gun|
00000010  7a 69 70 0a 65 78 69 74  0a 1f 8b 08 00 2e ec ca  |zip.exit........|
00000020  57 00 03 65 4f c9 0d c0  30 08 fb 7b 18 4f 91 11  |W..eO...0..{.O..|
00000030  fc e8 00 1e a1 fb ab 08  68 a4 90 07 60 d9 98 43  |........h...`..C|
00000040  a4 49 8a 59 05 ae 40 6f  c7 22 98 84 b3 29 10 fc  |.I.Y..@o."...)..|
00000050  13 59 1d 7a 11 9d b1 bd  15 a8 56 77 26 54 c4 b3  |.Y.z......Vw&T..|
00000060  f7 0d fd f6 9f f3 ef fd  e7 7d f3 7e 8d ff 3e 05  |.........}.~..>.|
00000070  57 d9 a0 f0 00 00 00                              |W......|
00000077

यहाँ आधार 64 फॉर्म है जिससे आप इसे कॉपी / पेस्ट कर सकते हैं:

begin-base64 755 test.sh
dGFpbCAtYzk0ICQwfGd1bnppcApleGl0Ch+LCAAu7MpXAANlT8kNwDAI+3sY
T5ER/OgAHqH7qwhopJAHYNmYQ6RJilkFrkBvxyKYhLMpEPwTWR16EZ2xvRWo
VncmVMSz9w399p/z7/3nffN+jf8+BVfZoPAAAAA=
====

— यहोशू
स्रोत

0

सी 230 228 बाइट्स

char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
#define X(N) {putchar(s[a]);N y<=x?1:y;}
#define P for(y=1;y<8;y++)X(a+=)for(y--;y+1;y--)X(a-=)puts("");
main(){for(;x<8;x++){a=b+=x;P}for(x=6;x+1;x--){a=b-=(x+1);P}}

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

यह पोस्ट किए गए मूल C संस्करण को बेहतर बनाने का एक प्रयास है, जिसमें C सरणी में संग्रहीत बोर्ड का चौथाई भाग था। उतना कम नहीं जितना मैं उम्मीद कर रहा था। इस संस्करण में केवल एक आठवीं बोर्ड जमा है।

Ungolfed:

char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
main(){
    for(x = 0; x < 8; x++){
        a=b+=x;
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a -= y<=x ? 1 : y;
        }
        puts("");
    }
    for(x=6; x >= 0; x--){
        a=b-=(x+1);
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a-= y<=x ? 1 : y;
        }
        puts("");
    }
}

— bnf679
स्रोत

0

GNU sed, 219 205 बाइट्स

s/$/T..d...T...d..T/p;h
s/.*/.D...t...t...D./p;G;h
s/.*/..D...d.d...D../p;G;h
s/.*/d..D...d...D..d/p;G;h
s/.*/....D.....D..../p;G;h
s/.*/.t...t...t...t./p;G;h
s/.*/..d...d.d...d../p;G;h
s/.*\n//;s/T/X/2p;g

बोर्ड की दर्पण समरूपता का लाभ उठाते हुए, दूसरा भाग पहले वाला है जो होल्ड स्पेस में रिवर्स ऑर्डर में संग्रहीत किया गया था।

— seshoumara
स्रोत

एक खाली स्क्रैबल बोर्ड ड्रा करें

MATL , 59 54 52 बाइट्स

व्याख्या

चरण 1

चरण 2

चरण 3

रूबी, 103 97 बाइट्स

रूबी, 115 113 बाइट्स

ब्रेनफक , 598 596 590 बाइट्स

PowerShell v2 +, 147 बाइट्स

> <> (मछली), 153 बाइट्स

सी, 146 145 142 138 बाइट्स

05AB1E , 57 53 बाइट्स

कोड

स्पष्टीकरण (पुराना)

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

05AB1E , 49 44 बाइट्स

व्याख्या की:

अन्य आइडिया (किसी MATL में यह कोशिश करो)

05AB1E , 27 बाइट्स

05AB1E , 104 बाइट्स

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

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

डेमो

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

सी 234 बाइट्स

लकड़ी का कोयला , 33 बाइट्स (नॉनकमेटिंग)

वाचाल

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

श + कोरुटिल्स, 119 बाइट्स

सी 230 228 बाइट्स

GNU sed, 219 205 बाइट्स