हेक्सप्लोसिव ASCII- कला चुनौती

20

रणनीति गेम "हेक्सप्लोड" में , खिलाड़ी एक हेक्सागोनल बोर्ड पर टोकन ले जाते हैं। एक बार टोकनों की संख्या आसन्न टाइलों की संख्या के बराबर हो जाती है, जो कि टाइल हेक्सप्लोड्स होती है , और इस पर होने वाले सभी हमलों को आसपास के पड़ोसियों तक ले जाती है। आप यहाँ ऑनलाइन खेल सकते हैं ।

मुझे यह खेल पसंद है, लेकिन कभी-कभी यह जानना मुश्किल होता है कि एक विशिष्ट टाइल पर कितने टोकन चलते हैं; मैं हमेशा पड़ोसियों की संख्या की गिनती कर रहा हूं । यह वास्तव में सुविधाजनक होगा अगर मेरे पास ASCII- कला है जिससे मुझे यह याद रखने में मदद मिल सके कि प्रत्येक टाइल पर कितने टोकन हैं।

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

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

यहां पहले 5 इनपुट के लिए कुछ नमूना आउटपुट दिए गए हैं:

2)

 3 3
3 6 3
 3 3


3)

  3 4 3
 4 6 6 4
3 6 6 6 3
 4 6 6 4
  3 4 3


4)

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

5)

    3 4 4 4 3
   4 6 6 6 6 4
  4 6 6 6 6 6 4
 4 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 4
  4 6 6 6 6 6 4
   4 6 6 6 6 4
    3 4 4 4 3

6)

     3 4 4 4 4 3
    4 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
 4 6 6 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
    4 6 6 6 6 6 4
     3 4 4 4 4 3

और पैटर्न इसी तरह से जारी है। हमेशा की तरह, मानक खामियां लागू होती हैं, और सबसे कम बाइट-गिनती के साथ उत्तर को विजेता का ताज पहनाया जाएगा!

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

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

# 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

कोड स्निपेट दिखाएं

code-golf  ascii-art  hexagonal-grid 
— DJMcMayhem
स्रोत
1
संबंधित (लेकिन पड़ोसियों की संख्या के बजाय प्रक्रिया के बारे में पूछ रहे हैं)।
— ट्राइकोप्लाक्स
1
मैं इस चुनौती के लिए हेक्सागोनी सीखने के लिए ललचा रहा हूं। ;)
— केविन क्रूज़सेन

जवाबों:

11

MATL , 39 37 बाइट्स

4*3-:!G:+o~YRtP*!tPw4LY)vtI5&lZ+47+*c

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

मुझे फिर से कनवल्शन इस्तेमाल करने को मिलता है!

इनपुट पर विचार करें n = 3। कोड पहले कॉलम वेक्टर को प्रसारण के साथ पंक्ति वेक्टर में जोड़कर आकार 4*n-3× का एक मैट्रिक्स बनाता है । इसका अर्थ है कि सभी युग्म जोड़ियों के 2 डी सरणी सरणी की गणना करना:n[1; 2; ...; 9][1, 2, 3]

 2  3  4
 3  4  5
 4  5  6
 5  6  7
 6  7  8
 7  8  9
 8  9 10
 9 10 11
10 11 12

चेकरबोर्ड पैटर्न 1द्वारा सम संख्याओं और विषम संख्याओं को प्रतिस्थापित करना0

1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

इसका उपयोग हेक्सागोनल ग्रिड के निर्माण (भाग) के लिए किया जाएगा। वन ग्रिड में बिंदुओं का प्रतिनिधित्व करेंगे, और शून्य स्थान का प्रतिनिधित्व करेंगे।

ऊपरी-दाएँ कोने को मैट्रिक्स के मुख्य "विकर्ण" के ऊपर सभी प्रविष्टियों को शून्य करके हटा दिया जाता है: 

1 0 0
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

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

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

यह एक षट्भुज की तरह लगने लगता है। समरूपता का उपयोग करके, ऊपरी आधे का उत्पादन करने के लिए ग्रिड को बढ़ाया जाता है:

0 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

अब हमें प्रत्येक प्रविष्टि को पड़ोसियों की संख्या के बराबर बदलने की आवश्यकता है। इसके लिए हम 3 × 5 पड़ोस के साथ कनवल्शन का उपयोग करते हैं (अर्थात कर्नेल 3 × 5 मैट्रिक्स वाला है)। परिणाम,

2 3 4 5 5 5 4 3 2
4 5 7 7 8 7 7 5 4
4 6 7 8 7 8 7 6 4
4 5 7 7 8 7 7 5 4
2 3 4 5 5 5 4 3 2

दो मुद्दे हैं (जो बाद में हल हो जाएंगे):

  1. सभी पदों के लिए मूल्यों की गणना की गई है, जबकि हमें केवल शून्य-एक ग्रिड में लोगों के पदों पर उनकी आवश्यकता है।
  2. उन पदों में से प्रत्येक के लिए, पड़ोसी गणना में बिंदु स्वयं शामिल है, इसलिए यह बंद है 1।

अब कोड 47प्रत्येक गणना किए गए मान में जुड़ जाता है। यह 1समस्या को हल करने के लिए घटाकर (2) और जोड़ने 48(ASCII के लिए '0') से मेल खाती है, जो प्रत्येक संख्या को उसके संबंधित वर्ण के कोड बिंदु तक पहुंचाती है।

परिणामी मैट्रिक्स को तब शून्य-एक ग्रिड की एक प्रति से गुणा किया जाता है। यह ऊपर (1) जारी करता है, जो अंक को फिर से शून्य के बराबर हेक्सागोनल ग्रिड का हिस्सा नहीं बनाते हैं:

 0  0 51  0 52  0 51  0  0
 0 52  0 54  0 54  0 52  0
51  0 54  0 54  0 54  0 51
 0 52  0 54  0 54  0 52  0
 0  0 51  0 52  0 51  0  0

अंत में, संख्याओं की यह सारणी एक वर्ण सरणी में डाली जाती है। शून्य वर्णों को अंतरिक्ष के रूप में प्रदर्शित किया जाता है, जो अंतिम परिणाम देता है:

  3 4 3  
 4 6 6 4 
3 6 6 6 3
 4 6 6 4 
  3 4 3
— लुइस मेंडो
स्रोत
15

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

n=>[...Array(m=n+--n)].map((_,i,a)=>a.map((_,j)=>(k=j-(i>n?i-n:n-i))<0?``:k&&++j<m?i/2%n?6:4:3+!i%n).join` `).join`\n`

जहां \nएक शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। स्पष्टीकरण: मान लीजिए n=4। हम निम्नलिखित अंतरिक्ष-अलग अंक वर्ग से शुरू करते हैं:

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 0

पहले |n-i| 0s हटाए जाते हैं, लेकिन रिक्त स्थान बने रहते हैं:

   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जाँचने के द्वारा कि क्या हम पहली या अंतिम पंक्ति और / या स्तंभ पर हैं , प्रत्येक के स्थान पर उचित मान की गणना करते हैं । संपादित करें: @Arnauld के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत
आपके कुछ फार्मूले का उपयोग करते हुए, मैं 107 बाइट्स वर्जन के लिए आया / कंसोल.लॉग () के साथ:n=>{for(i=n+--n;i--;)console.log(' '.repeat(l=i>n?i-n:n-i)+(j=3+!l%n)+` ${l-n?6:4}`.repeat(2*n-l-1)+' '+j)}
— Arnauld
@Arnauld मुझे पसंद है 3+!i%n!
— नील
7

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

def h(n):m=n-1;t=[' '*(m-r)+' '.join(('46'[r>0]*(r+m-1)).join('34'[r%m>0]*2))for r in range(n)];print'\n'.join(t+t[-2::-1])

टेस्ट आइडोन पर हैं

शीर्ष के माध्यम से मध्य पंक्तियों तक दौड़ता है, for r in range(n)तार का निर्माण करता है:
- दो कोनों या दो किनारों को बनाना '34'[r%m>0]*2;
- उन्हें बार-बार के साथ शामिल होने से भरने '6'या '4', '46'[r>0]*(r+m-1);
- कोनों और किनारों के साथ जुड़ना ' ';
- रिक्त स्थान के साथ prepending ' '*(m-r);

फिर यह प्रिंट करता है और यह नई लाइनों द्वारा शामिल मध्य पंक्ति में प्रतिबिंब है, print'\n'.join(t+t[-2::-1])

— जोनाथन एलन
स्रोत
4

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

n=input();m=n-1
while n+m:n-=1;j=abs(n);c='34'[0<j<m];print' '*j+c+' '+'46  '[j<m::2]*(2*m+~j)+c

यह बहुत गन्दा और कुछ हद तक गोल्फ का लग रहा है ...

— Sp3000
स्रोत
3

जावा, 375 363 361 339 329 317 293 बाइट्स

interface J{static void main(String[]r){int i=0,k,h=Integer.decode(r[0]),a=1,l,n=0;for(;i++<h*2-1;n+=a){if(n==h-1)a=-1;String s="";for(k=0;k<n+h;k++,s+=" ")s+=n==0?k==0||k==n+h-1?3:4:k!=0&&k!=n+h-1?6:n==h-1?3:4;l=(h*4-3-s.trim().length())/2;System.out.printf((l==0?"%":"%"+l)+"s%s\n","",s);}}}

Ungolfed

interface J {
    static void main(String[] r) {
        int i = 0, k, h = Integer.decode(r[0]), a = 1, l, n = 0;
        for (; i++ < h * 2 - 1; n += a) {
            if (n == h - 1) {
                a = -1;
            }
            String s = "";
            for (k = 0; k < n + h; k++, s += " ") {
                s += n == 0 ? k == 0 || k == n + h - 1 ? 3 : 4 : k != 0 && k != n + h - 1 ? 6 : n == h - 1 ? 3 : 4;
            }
            l = (h * 4 - 3 - s.trim().length()) / 2;
            System.out.printf((l == 0 ? "%" : "%" + l) + "s%s\n", "", s);
        }
    }
}

उपयोग :

$ java J 5
    3 4 4 4 3     
   4 6 6 6 6 4    
  4 6 6 6 6 6 4   
 4 6 6 6 6 6 6 4  
3 6 6 6 6 6 6 6 3 
 4 6 6 6 6 6 6 4  
  4 6 6 6 6 6 4   
   4 6 6 6 6 4    
    3 4 4 4 3

मुझे यकीन है कि भयानक नेस्टेड-और-ब्लॉक को छोटा होने के लिए फिर से लिखा जा सकता है, लेकिन मैं इसे समझ नहीं सकता। किसी भी सुझाव का स्वागत है :-)

अपडेट करें

  • केविन क्रूज़सेन के सुझाव का पालन किया और पार्सइंट के बजाय डिकोड का उपयोग किया।
  • टर्नरी ऑपरेटर का उपयोग करके कुछ आईएफएस को फिर से लिखें।
  • अधिक टर्नरी ऑपरेटर।
  • मूर टरने वाले संचालकों! मुझे लगता है कि मैंने एक राक्षस बनाया है!
  • मुद्रण के संबंध में अगर-और ब्लॉक को फिर से लिखें।
— Master_ex
स्रोत
1
मैंने उस विधि को बारीकी से नहीं देखा है जो आप स्वयं उपयोग करते हैं, लेकिन आपके वर्तमान कोड के लिए कुछ छोटे गोल्फ युक्तियाँ: Integer.parseIntको गोल्फ में डाला जा सकता है Integer.decode। l=(h*4-3-s.trim().length())/2;if(l==0)तक पहुंचा जा सकता है if((l=(h*4-3-s.trim().length())/2)==0)। इसके अलावा, यह पूरी तरह से बिना कक्षा के एक विधि पोस्ट करने के लिए पूरी तरह से स्वीकार्य है (जब तक कि प्रश्न अन्यथा नहीं मिलता है), इसलिए void f(int i){...use i...}इसके बजाय interface J{static void main(String[]r){...i=Integer.decode(r[0])...use i...}, आपको कुछ बाइट्स को भी सहेजना चाहिए। जब मेरे पास अधिक समय होगा तो मैं आगे देखूंगा।
— केविन क्रूज़सेन
@ केविनक्रूजसेन: आपके सुझाव के लिए धन्यवाद। l=(h*4-3-s.trim().length())/2;if(l==0)वास्तव में उसी लंबाई के साथ है if((l=(h*4-3-s.trim().length())/2)==0)।
— मास्टर_एक्स
2

05AB1E , 44 बाइट्स

FN_i4ë6}ð«¹ÍN+×ðìN_N¹<Q~i3ë4}.ø¹<N-ð×ì})¦«»

व्याख्या

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

F                                        }

फिर हम पंक्तियों का केंद्र भाग करते हैं।
यह पहली पंक्ति के लिए 4 और बाकी के लिए 6 है (जैसा कि हम केवल ऊपरी भाग कर रहे हैं)।
हम इस संख्या को एक स्थान के साथ बदलते हैं क्योंकि पैटर्न को संख्याओं के बीच रिक्ति की आवश्यकता होगी।

N_i4ë6}ð«

इसके बाद हम इस स्ट्रिंग X-2 + N को दोहराते हैं , जहां N वर्तमान पंक्ति 0-अनुक्रमित है और बाईं ओर एक अंतरिक्ष वर्ण को प्रस्तुत करता है।

¹ÍN+×ðì

इसके बाद यह कोनों के लिए समय है। वे पहली और आखिरी पंक्ति के लिए 3 और मध्य पंक्तियों के लिए 4 होंगे ।

N_N¹<Q~i3ë4}.ø

अब हमें यह सुनिश्चित करने की आवश्यकता है कि प्रत्येक पंक्ति के सामने रिक्त स्थान जोड़कर पंक्तियों को सही ढंग से पंक्तिबद्ध किया जाए। जोड़े गए स्थानों की संख्या X-1-N होगी ।

¹<N-ð×ì

अब जब हमारे पास ग्रिड का ऊपरी हिस्सा हो गया है, हम पंक्तियों को एक सूची में जोड़ते हैं, एक उलट प्रतिलिपि बनाते हैं और उस प्रतिलिपि से पहला आइटम हटाते हैं (जैसा कि हमें केवल एक बार केंद्रीय पंक्ति की आवश्यकता होती है), फिर इन 2 सूचियों को एक साथ मर्ज करें और मुद्रित करें।

)¦«»

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

अतिरिक्त समाधान, 44 बाइट्स:

ÍÅ10.øvN_i4ë6}ð«¹ÍN+×ðìyi4ë3}.ø¹<N-ð×ì})¦«»
— Emigna
स्रोत
2

रूबी, 87 बाइट्स

अनाम फ़ंक्शन तर्क के रूप में n लेता है और स्ट्रिंग की एक सरणी देता है।

->n{(1-n..n-=1).map{|i|j=i.abs
" "*j+(e=j%n>0?"4 ":"3 ")+["6 ","4 "][j/n]*(2*n-1-j)+e}}

परीक्षण कार्यक्रम में अपराजित

स्टड के माध्यम से इनपुट। स्टडआउट करने के लिए पूरी आकृति लिखता है। सुंदर आत्म व्याख्यात्मक।

f=->n{
  (1-n..n-=1).map{|i|            #reduce n by 1 and iterate i from -n to n
    j=i.abs;                     #absolute magnitude of i
    " "*j+                       #j spaces +
    (e=j%n>0?"4 ":"3 ")+         #start the string with 3 or 4 +
    ["6 ","4 "][j/n]*(2*n-1-j)+  #2*n-1-j 6's or 4`s as appropriate +
    e                            #end the string with another 3 or 4
  }
}

puts f[gets.to_i]
— स्तर नदी सेंट
स्रोत
1

वी , 60 बाइट्स

Àé x@aA4 xr3^.òhYpXa 6^òkyHç^/:m0
Pç 3.*6/^r4$.
òÍ6 4./6

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

यह वास्तव में बहुत लंबा रास्ता है। यहाँ एक हेक्सडंप है, क्योंकि इसमें अनपेक्षित वर्ण हैं:

0000000: c0e9 2078 4061 4134 201b 7872 335e 2ef2  .. x@aA4 .xr3^..
0000010: 6859 7058 6120 361b 5ef2 6b79 48e7 5e2f  hYpXa 6.^.kyH.^/
0000020: 3a6d 300a 50e7 2033 2e2a 362f 5e72 3424  :m0.P. 3.*6/^r4$
0000030: 2e0a f2cd 3620 9334 852e 2f36            ....6 .4../6
— DJMcMayhem
स्रोत
1

रैकेट, 487 बाइट्स

(λ(n c e o)(let((sp(append(range(- n 1)-1 -1)(reverse(range(- n 1)0 -1))))
(mm(append(range(- n 2)(-(+ n(- n 1))2))(range(-(+ n(- n 1))2)(-(- n 1)2)-1)))
(r""))(for((i sp)(j mm))(define str"")(for((ss i))(set! str(string-append str" ")))
(set! str(string-append str(if(or(= i 0)(= i(- n 1))(= i(* 2(- n 1))))c e)" "))
(for((jj j))(set! str(string-append str(if(= j(- n 2))e o)" ")))(set! r(if(or(= i 0)
(= i(- n 1))(= i(* 2(- n 1))))c e))(set! str(string-append str r))(displayln str))))

परिक्षण: 

(f 4 "3" "4" "6") 

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

(f 5 "o" "*" "-") 

    o * * * o
   * - - - - *
  * - - - - - *
 * - - - - - - *
o - - - - - - - o
 * - - - - - - *
  * - - - - - *
   * - - - - *
    o * * * o

विस्तृत संस्करण: 

(define(f1 n c e o)
  (let ((sp(append(range(sub1 n) -1 -1)
                  (reverse(range(sub1 n) 0 -1))))
        (mm(append(range(- n 2)(-(+ n(sub1 n)) 2))
                  (range(-(+ n(sub1 n)) 2)(-(sub1 n)2) -1) ))
        (r ""))
    (for((i sp)(j mm))
      (define str "")
      (for((ss i))(set! str(string-append str " ")))
      (set! str(string-append str
                              (if(or(= i 0)(= i(sub1 n))
                                    (= i(* 2(sub1 n)))) c e)
                              " "))
      (for((jj j))
        (set! str(string-append str
                                (if(= j(- n 2)) e o)
                                " ")))
      (set! r(if(or(= i 0)
                   (= i(sub1 n))
                   (= i(* 2(sub1 n)))) c e))
      (set! str(string-append str r))
      (displayln str))))
— rnso
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.