परिचय

यदि आप हेक्सागोनी से परिचित नहीं हैं , तो यह मार्टिन ब्यूटनर द्वारा बनाई गई एक गूढ़ भाषा है। बात यह है कि यह भाषा कार्यक्रम के लिए कई रूपों को स्वीकार करती है। निम्नलिखित कार्यक्रम सभी समतुल्य हैं:

abcdefg

तथा

 a b
c d e
 f g

तो मूल रूप से, कोड को एक नियमित षट्भुज में रोल किया गया है। लेकिन ध्यान दें कि कोड में एक नया कमांड जोड़ना, जो abcdefghनिम्नलिखित प्रोग्राम में परिणामित होगा:

  a b c
 d e f g
h . . . .
 . . . .
  . . .

जैसा कि आप देख सकते हैं, पहला कदम कोड को एक षट्भुज में लुढ़का रहा है, और उसके बाद षट्भुज .अगले- केंद्रित षट्कोणीय संख्या के लिए no-ops ( ) के साथ भर गया है ।

आपका कार्य सरल है, जब एक स्ट्रिंग (स्रोत कोड) दिया जाता है, तो पूर्ण षट्भुज स्रोत कोड का उत्पादन होता है।

नियम

आप एक कार्यक्रम या एक समारोह प्रदान कर सकते हैं।
अग्रणी व्हाट्सएप की अनुमति है, लेकिन केवल जब षट्भुज आकार से बाहर नहीं निकलता है
अनुगामी व्हाट्सएप की अनुमति है।
ध्यान दें कि कार्यक्रम में व्हाट्सएप को नजरअंदाज किया गया है । तो a b cके बराबर हैabc
केवल मुद्रण योग्य ASCII वर्ण ( 32 - 126) का उपयोग किया जाता है, इसलिए केवल नियमित Spaceवर्ण को अनदेखा किया जाता है।
मान लें कि स्ट्रिंग की लंबाई 0 से अधिक है।
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

परीक्षण के मामलों

Input: ?({{&2'2':{):!/)'*/

Output:
  ? ( {
 { & 2 '
2 ' : { )
 : ! / )
  ' * /


Input: H;e;l;d;*;r;o;Wl;;o;*433;@.>;23<\4;*/

Output:
   H ; e ;
  l ; d ; *
 ; r ; o ; W
l ; ; o ; * 4
 3 3 ; @ . >
  ; 2 3 < \
   4 ; * /


Input: .?'.) .@@/'/ .!.>   +=(<.!)}    (  $>( <%

Output:
   . ? ' .
  ) . @ @ /
 ' / . ! . >
+ = ( < . ! )
 } ( $ > ( <
  % . . . .
   . . . .

— अदनान
स्रोत

6

इसके अलावा, मुझे यकीन नहीं है कि आप उस योग्य व्यक्ति बनना चाहते हैं, लेकिन कोड चौड़ाई निर्धारित करने की प्रक्रिया में बैकटिक्स को अनदेखा किया जाता है क्योंकि वे अगले वर्ण को एनोटेट करते हैं। तो abc`defgवास्तव में pastebin.com/ZrdJmHiR

— मार्टिन एंडर

2

@ मार्टिनबटनर ओह, मुझे नहीं पता था कि :)। इस चुनौती के लिए, बैकटिक्स को अनदेखा नहीं किया जाएगा।

— अदनान

18

मैं वास्तव में इस प्रश्न के लिए हेक्सागोनी में एक उत्तर देखना चाहता हूं।

— आर्कटिकस

2

@ अदनान संभवतः एक बेहतर प्रतिक्रिया होगी "आप मान सकते हैं कि इनपुट में कोई डिबग फ़्लैग ( `वर्ण) नहीं है।"

— 1

4

@ एम्पोरा पूछें और आप प्राप्त करेंगे।

— मार्टिन एंडर

13

पायथ, 57 54 50 49 48 46

V+UJfgh*6sUTlK-zd1_UtJ+*d-JNjd:.[K\.^TJZ=+Z+JN

परीक्षण सूट

प्रत्येक पंक्ति पर एक प्रमुख स्थान प्रिंट करता है।

इस संस्करण में एक प्रमाण की आवश्यकता है कि सभी के लिए 10 ^ n> = 3n (n - 1) + 1 सभी n> = 1 है । साक्ष्य प्रदान करने के लिए एएनआरडीआई और एरिकॉन्ग को धन्यवाद ।

इन असमानताओं के बाद: 10 ^ n> (1 + 3) ^ n = 1 + 3n + 9n (n - 1) + ...> 3n (n - 1) + 1 कोई भी आसानी से देख सकता है कि यह n> के लिए सही है = २ । N = 1 मामले की जांच बल्कि तुच्छ है, 10> 1 दे रही है ।

वैकल्पिक रूप से, इन समीकरणों के दो बार व्युत्पन्न होने से पता चलता है कि 10 ^ n में सभी n> = 1 के लिए एक बड़ा दूसरा व्युत्पन्न है , जिसे बाद में पहले व्युत्पन्न और अंत में मूल समीकरणों तक ले जाया जा सकता है।

व्याख्या

              ##  Implicit: z=input(); Z=0
Jf...1        ##  Save to J the side length of the hexagon the code fills up
              ##  by finding the first number such that:
gh*6sUT       ##  the the T'th hexagonal number is greater than...
              ##  Computes 6 * T'th triangular number (by using sum 1..T-1) + 1
    lK-zd     ##  ...the length of the code without spaces (also save the string value to K)
V+UJ_UtJ      ##  For loop over N = [0, 1, ..., J-1, ..., 0]:
+*d-JN        ##  append J - N spaces to the front of the line
jd            ##  riffle the result of the next operation with spaces
:.[K\.yJ      ##  slice the string given by K padded to be the length of the Jth hexagon
              ##  number with noops
Z=+Z+JN       ##  from Z to Z + J + N, then set Z to be Z + J + N

— FryAmTheEggman
स्रोत

2

पहले आपको यह साबित करने की आवश्यकता है कि n> = 1 के लिए ln (10) * 10 ^ n> 6n-3 (डेरिवेटिव)। यह आसान है, क्योंकि इन अभिव्यक्तियों का व्युत्पन्न ln (10) ^ 2 10 ^ n और 6 है। 10 ^ n के बाद से नीरसता बढ़ रही है और 10 ^ 1> 6 * 1, 10 ^ n सभी के लिए 6n-3 से अधिक है। n> = 1। आप 10 ^ n और 3n (n-1) +1 के लिए सबूत पूरा करने के लिए उसी तर्क का उपयोग कर सकते हैं।

— आर्कटिकस

@Ampora धन्यवाद, मैंने डेरिवेटिव का उपयोग करने पर विचार किया था, लेकिन यह अशुद्ध लग रहा था। मैं एक बेहतर तरीका नहीं मिल सकता है, इतना सराहना की!

— FryAmTheEggman

मदद करने में खुशी। कैल्क कभी-कभी वास्तविक रूप से बदसूरत हो सकता है।

— आर्क्यूरस

ऊपर लिंक pyth.herokuapp.com/?code=etc ऊपर मैं कंपाइलर को नहीं चलाता ...

— RosLuP

1

@FryAmTheEggman बहुत मजबूत बाउंड 4 ^ n> 3n (n-1) + 1 को n> = 1 के लिए दिखाने का एक बहुत आसान तरीका है, किसी भी पथरी की आवश्यकता नहीं है। बस इस तथ्य का उपयोग करें कि (1 + 3) ^ n = 1 + 3n + 9n (n-1) / 2 + ... द्विपद विस्तार द्वारा। पहली और तीसरी शर्तें सीधे 1 + 3n (n-1) को प्रमुख बनाती हैं, इसलिए यदि तीसरा शब्द मौजूद है (यानी n> = 2 के लिए) तो असमानता तत्काल है। यह केवल केस n = 1 को छोड़ देता है जो RHS के बाद से तुच्छ है। 1.

— एरिक वोंग

90

हेक्सागोनी , 271 बाइट्स

मैं आपके सामने प्रस्तुत करता हूं, हेक्सागोनी आत्म-व्याख्याकार का पहला 3% ...

|./...\..._..>}{<$}=<;>'<..../;<_'\{*46\..8._~;/;{{;<..|M..'{.>{{=.<.).|.."~....._.>(=</.\=\'$/}{<}.\../>../..._>../_....@/{$|....>...</..~\.>,<$/'";{}({/>-'(<\=&\><${~-"~<$)<....'.>=&'*){=&')&}\'\'2"'23}}_}&<_3.>.'*)'-<>{=/{\*={(&)'){\$<....={\>}}}\&32'-<=._.)}=)+'_+'&<

इसे ऑनलाइन आज़माएं! आप इसे स्वयं भी चला सकते हैं, लेकिन इसमें लगभग 5-10 सेकंड का समय लगेगा।

सिद्धांत रूप में, यह पक्ष-लंबाई 9 (217 या उससे कम के स्कोर के लिए) में फिट हो सकता है, क्योंकि यह केवल 201 कमांड का उपयोग करता है, और मेरे द्वारा पहले लिखे गए ungolfed संस्करण (केवल साइड-लेंथ 30 पर) को केवल 178 आदेशों की आवश्यकता है। हालाँकि, मुझे पूरा यकीन है कि यह हमेशा के लिए सब कुछ ठीक कर देगा, इसलिए मुझे यकीन नहीं है कि मैं वास्तव में इसका प्रयास करूँगा।

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

व्याख्या

आइए कोड को अनफॉलो करके और कंट्रोल फ्लो पाथ को एनोटेट करके शुरू करें:

यह अभी भी काफी गड़बड़ है, इसलिए यहां "अनलॉल्फ्ड" कोड के लिए वही आरेख है जो मैंने पहले लिखा था (वास्तव में, यह साइड-लेंथ 20 है और मूल रूप से मैंने साइड-लेंथ 30 पर कोड लिखा था लेकिन यह इतना विरल था कि यह 'सभी में पठनीयता में सुधार नहीं होता है, इसलिए मैंने आकार को थोड़ा अधिक उचित बनाने के लिए इसे थोड़ा संकुचित कर दिया है):

^{बड़े संस्करण के लिए क्लिक करें।}

रंग बिल्कुल समान हैं कुछ बहुत ही मामूली विवरणों के अलावा, गैर-नियंत्रण-प्रवाह आदेश भी बिल्कुल समान हैं। इसलिए मैं समझा रहा हूं कि यह कैसे काम करता है जो अनऑर्गोडेड संस्करण पर आधारित है, और यदि आप वास्तव में जानना चाहते हैं कि गोल्फ कैसे काम करता है, तो आप जांच कर सकते हैं कि बड़े हेक्सागोन में कौन से भागों के अनुरूप हैं। (केवल पकड़ यह है कि गोल्फ कोड एक दर्पण से शुरू होता है ताकि वास्तविक कोड बाएं कोने में शुरू हो।)

मूल एल्गोरिथ्म लगभग मेरे CJam उत्तर के समान है । दो अंतर हैं:

केंद्रित हेक्सागोनल संख्या समीकरण को हल करने के बजाय, मैं बस लगातार केंद्रित हेक्सागोनल संख्याओं की गणना करता हूं जब तक कि इनपुट की लंबाई के बराबर या उससे बड़ा न हो। ऐसा इसलिए है क्योंकि हेक्सागोनी में एक वर्गमूल की गणना करने का सरल तरीका नहीं है।
इसके बजाय इनपुट को बिना ऑप्स के पैड करने के बजाय, मैं बाद में जांचता हूं कि क्या मैंने पहले ही इनपुट में कमांड को समाप्त कर दिया है और .यदि मेरे पास है तो इसके बजाय प्रिंट करें ।

इसका मतलब है कि मूल विचार नीचे उबलता है:

अपनी लंबाई की गणना करते समय इनपुट स्ट्रिंग पढ़ें और स्टोर करें।
सबसे छोटी साइड-लंबाई N(और इसी केंद्रित हेक्सागोनल संख्या hex(N)) का पता लगाएं जो पूरे इनपुट को पकड़ सकती है।
व्यास की गणना करें 2N-1।
प्रत्येक पंक्ति के लिए, इंडेंट और कोशिकाओं की संख्या (जो योग करें 2N-1) की गणना करें । इंडेंट प्रिंट करें, कोशिकाओं को प्रिंट करें ( .यदि इनपुट पहले से ही समाप्त हो गया है) का उपयोग करके , एक लाइनफीड प्रिंट करें।

ध्यान दें कि केवल नो-ऑप्स हैं इसलिए वास्तविक कोड बाएं कोने में शुरू होता है ( $, जो कि ऊपर कूदता है >, इसलिए हम वास्तव, में अंधेरे ग्रे पथ पर शुरू करते हैं )।

यहाँ प्रारंभिक मेमोरी ग्रिड है:

तो मेमोरी पॉइंटर उत्तर की ओर इशारा करते हुए, लेबल वाले इनपुट पर शुरू होता है । ,एसटीडीआईएन से एक बाइट पढ़ता है या -1अगर हमने ईओएफ को उस किनारे पर मारा है। इसलिए, इसके <बाद का अधिकार सशर्त है कि क्या हमने सभी इनपुट पढ़े हैं। आइए अब हम इनपुट लूप में बने रहें। अगला कोड हम निष्पादित करते हैं

{&32'-

यह बढ़त लेबल में एक 32 लिखते हैं अंतरिक्ष , और फिर बढ़त लेबल में इनपुट मूल्य से यह घटा देती है diff । ध्यान दें कि यह कभी भी नकारात्मक नहीं हो सकता क्योंकि हम गारंटी देते हैं कि इनपुट में केवल मुद्रण योग्य ASCII शामिल है। यह शून्य होगा जब इनपुट एक स्थान था। (जैसा कि टिमवी बताते हैं, यह तब भी काम करेगा जब इनपुट में लाइनफीड या टैब शामिल हो सकते हैं, लेकिन यह 32 से कम वर्ण कोड वाले अन्य सभी वर्णों को भी <हटा देगा ।) उस स्थिति में, निर्देश सूचक (IP) को विक्षेपित कर देता है और हल्के भूरे रंग का रास्ता लिया जाता है। वह रास्ता बस सांसद की स्थिति को रीसेट करता है {=और फिर अगले चरित्र को पढ़ता है - इस प्रकार, रिक्त स्थान छोड़ दिए जाते हैं। अन्यथा, यदि चरित्र एक स्थान नहीं था, तो हम निष्पादित करते हैं

=}}})&'+'+)=}

के माध्यम से षट्भुज के आसपास यह पहली चाल लंबाई बढ़त इसके विपरीत जब तक diff बढ़त के साथ =}}}। तो फिर यह प्रतियां विपरीत से मूल्य लंबाई में बढ़त लंबाई के साथ धार, और यह वेतन वृद्धि )&'+'+)। हम एक दूसरे में देखेंगे कि यह क्यों समझ में आता है। अंत में, हम एक नया किनारा लेकर चलते हैं =}:

(विशेष बढ़त मूल्य चुनौती में दिए गए अंतिम परीक्षण मामले से हैं।) इस बिंदु पर, लूप दोहराता है, लेकिन सब कुछ एक षट्भुज उत्तर-पूर्व में स्थानांतरित हो गया। इसलिए एक और चरित्र को पढ़ने के बाद, हमें यह मिलता है:

अब आप देख सकते हैं कि हम उत्तर-पूर्व विकर्ण के साथ धीरे-धीरे इनपुट (माइनस स्पेस) लिख रहे हैं, हर दूसरे किनारे पर वर्णों के साथ, और उस वर्ण तक की लंबाई को लेबल की गई लंबाई के समानांतर संग्रहीत किया जा रहा है ।

जब हम इनपुट लूप के साथ होते हैं, तो मेमोरी इस तरह दिखाई देगी (जहां मैंने पहले भाग के लिए कुछ नए किनारों को लेबल किया है):

%अंतिम वर्ण हम पढ़ है, 29हम पढ़ गैर अंतरिक्ष वर्णों की संख्या है। अब हम षट्भुज की भुजा-लम्बाई ज्ञात करना चाहते हैं। सबसे पहले, गहरे हरे / ग्रे पथ में कुछ रैखिक प्रारंभिक कोड है:

=&''3{

इधर, =&धार लेबल में प्रतियां लंबाई (29 हमारे उदाहरण में) लंबाई । फिर 3''3 लेबल वाले किनारे पर जाता है और इसके मूल्य को निर्धारित करता है (जिसे हमें गणना में एक निरंतर के रूप में आवश्यकता होती है)। अंत में N (N-1) लेबल वाले किनारे पर जाता है ।3{

अब हम नीले लूप में प्रवेश करते हैं। यह लूप वेतन वृद्धि N( एन लेबल वाले सेल में संग्रहीत ) फिर अपने केंद्रित हेक्सागोनल संख्या की गणना करता है और इसे इनपुट लंबाई से घटाता है। रैखिक कोड जो ऐसा करता है:

{)')&({=*'*)'-

यहाँ, एन{) को बढ़ता है और बढ़ता है । N-1')&( लेबल वाले किनारे पर जाता है , वहां प्रतियां और इसे घटाता है। N (N-1) में उनके उत्पाद की गणना करता है । कई गुणा जो निरंतर और वृद्धि के परिणामस्वरूप बढ़त को हेक्स (एन) में लेबल करता है । जैसी कि उम्मीद थी, यह Nth केंद्रित षट्कोणीय संख्या है। अंत में उस और इनपुट लंबाई के बीच अंतर की गणना करता है। यदि परिणाम सकारात्मक है, तो पक्ष-लंबाई अभी तक बड़ी नहीं है, और लूप दोहराता है (जहां एमपी को किनारे पर एन (एन -1) लेबल करें )।N{=*'*)3'-}}

एक बार जब पक्ष-लंबाई काफी बड़ी हो जाती है, तो अंतर शून्य या नकारात्मक होगा और हम इसे प्राप्त करते हैं:

सबसे पहले, अब वास्तव में लंबा रैखिक हरा रास्ता है जो आउटपुट लूप के लिए कुछ आवश्यक आरंभ करता है:

{=&}}}32'"2'=&'*){=&')&}}

{=&में परिणाम को कॉपी करके शुरू होता है diff में बढ़त लंबाई धार, क्योंकि हम बाद में कुछ गैर सकारात्मक वहाँ की जरूरत है। }}}32बढ़त लेबल में एक 32 लिखते हैं अंतरिक्ष । '"2ऊपर लेबल नहीं किया गया किनारे में एक निरंतर 2 लिखते diff । एक ही लेबल के साथ दूसरे किनारे में '=&प्रतियां N-1। '*)इसे 2 से गुणा करें और इसे बढ़ाएं ताकि हमें शीर्ष पर 2N-1 लेबल वाले किनारे में सही मूल्य मिल सके । यह षट्कोण का व्यास है। 2N-1{=&')& लेबल वाले दूसरे किनारे में व्यास को कॉपी करता है । अंत में शीर्ष पर 2N-1 लेबल वाले किनारे पर वापस जाता है ।}}

आइए किनारों को फिर से लगाएँ:

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

अब हम गुलाबी पथ पर हैं जो इंडेंट की गणना करता है । ('-decrements लाइनों इटरेटर और से यह घटा देती है N-1 (में मांगपत्र धार)। कोड में छोटी नीली / ग्रे शाखा केवल परिणाम के मापांक की गणना करती है ( ~यदि यह ऋणात्मक या शून्य है तो मान को घटाता है, और सकारात्मक होने पर कुछ भी नहीं होता है)। गुलाबी पथ के शेष भाग को इंडेंट को व्यास से कोशिकाओं के किनारे में "-~{घटाया जाता है और फिर इंडेंट किनारे पर वापस ले जाता है ।

गंदा पीला रास्ता अब इंडेंटेशन को प्रिंट करता है। लूप सामग्री वास्तव में सिर्फ हैं

'";{}(

कहाँ '"करने के लिए ले जाता है अंतरिक्ष में बढ़त, ;यह प्रिंट, {}ले जाता है वापस करने के लिए इंडेंट और (यह decrements।

जब हम उस (दूसरे) गहरे भूरे रंग के रास्ते को खोजते हैं, तो अगले वर्ण को प्रिंट करने के लिए खोजता है। =}स्थिति में ले जाता है (जिसका अर्थ है, पर कोशिकाओं बढ़त, दक्षिण इशारा करते हुए)। तब हमारे पास एक बहुत कड़ा लूप होता है, {}जो बस दो किनारों को दक्षिण-पश्चिम दिशा में नीचे ले जाता है, जब तक कि हम संग्रहीत स्ट्रिंग के अंत को हिट नहीं करते हैं:

ध्यान दें कि मैंने EOF को एक किनारे पर स्थानांतरित कर दिया है ? । एक बार जब हम इस चरित्र को संसाधित कर लेते हैं, तो हम उस किनारे को नकारात्मक बना देंगे, ताकि {}अगली यात्रा के बजाय लूप यहां समाप्त हो जाए :

कोड में, हम अंधेरे ग्रे पथ के अंत में हैं, जहां 'इनपुट चरित्र पर एक कदम पीछे जाता है। यदि स्थिति पिछले दो आरेखों में से एक है (यानी इनपुट में अभी भी एक चरित्र है जिसे हमने अभी तक नहीं छापा है), तो हम हरे रंग की राह ले रहे हैं (नीचे वाला, उन लोगों के लिए जो हरे रंग के साथ अच्छे नहीं हैं और नीला)। यह एक काफी सरल है: ;चरित्र को ही प्रिंट करता है। 'इसी स्थान के किनारे पर ले जाता है जो अभी भी पहले से एक 32 रखता है और ;उस स्थान को प्रिंट करता है। फिर {~हमारा ईओएफ बनाता है ? अगले पुनरावृत्ति के लिए नकारात्मक, 'एक कदम पीछे जाता है ताकि हम एक और तंग }{लूप के साथ स्ट्रिंग के उत्तर-पश्चिम छोर पर लौट सकें । जो लंबाई पर समाप्त होता हैसेल ( हेक्स (एन) के नीचे एक गैर-सकारात्मक ) अंत }में कोशिकाओं के किनारे पर वापस चला जाता है ।

यदि हमने पहले ही इनपुट समाप्त कर दिया है, तो लूप जो ईओएफ खोजता है? वास्तव में यहाँ समाप्त होगा:

उस मामले 'में लंबाई सेल पर चलती है , और हम इसके बजाय हल्के नीले (शीर्ष) पथ ले रहे हैं, जो एक नो-ऑप प्रिंट करता है। इस शाखा का कोड रैखिक है:

{*46;{{;{{=

{*46;राईट धार में एक 46 लेबल कोई को-अप और यह (यानी अवधि) प्रिंट करता है। फिर {{;करने के लिए ले जाता है अंतरिक्ष में बढ़त और कहा कि प्रिंट करता है। {{=करने के लिए ले जाता है वापस कोशिकाओं अगले चरण के लिए किनारे।

इस बिंदु पर पथ एक साथ वापस आते हैं और कोशिकाओं के किनारे को (घटाते हैं । यदि इट्रेटर अभी तक शून्य नहीं है, तो हम हल्के भूरे रंग का रास्ता अपनाएंगे, जो बस सांसद की दिशा को उलट देता है और फिर प्रिंट करने के लिए अगले वर्ण की तलाश करता है।=

अन्यथा, हम वर्तमान रेखा के अंत तक पहुंच गए हैं, और आईपी इसके बजाय बैंगनी मार्ग ले जाएगा। यह मेमोरी ग्रिड उस बिंदु पर कैसा दिखता है:

बैंगनी पथ में यह शामिल है:

=M8;~'"=

=फिर सांसद की दिशा उलट। M8इसके मान को सेट करता है 778(क्योंकि चरित्र कोड Mहै 77और अंक वर्तमान मूल्य के लिए खुद को जोड़ देंगे)। ऐसा होता है 10 (mod 256), इसलिए जब हम इसे प्रिंट करते हैं ;, तो हमें एक लाइनफीड मिलता है। फिर ~किनारे को नकारात्मक बनाता है, लाइनों के किनारे पर '"वापस जाता है और एक बार फिर एमपी को उलट देता है।=

अब अगर रेखा किनारे शून्य है, तो हम कर रहे हैं। आईपी (बहुत कम) लाल पथ लेगा, जहां @कार्यक्रम को समाप्त करता है। अन्यथा, हम उस बैंगनी पथ पर जारी रहते हैं जो दूसरी पंक्ति को प्रिंट करने के लिए गुलाबी एक में वापस छोर देता है।

टिमवी के हेक्सागोनीकॉलर के साथ बनाया गया नियंत्रण प्रवाह आरेख । मेमोरी डायग्राम उनके एसोटेरिक आईडीई में दृश्य डिबगर के साथ बनाया गया है ।

— मार्टिन एंडर
स्रोत

19

मैं खुद को हेक्सागोनी उत्तरों पर यह कहते हुए पाता हूं: बस वाह।

— कॉनर ओ'ब्रायन

5

हुह ... लेकिन .. वाट ... मन = उड़ा

— अदनान

मुझे उम्मीद थी कि कोई ऐसा करेगा और ... वाह। मैं अवाक हूँ। वह तो कमाल है।

— आर्कटिकस

19

चरण दो - अन्य 97% लिखें। :)

— ASCIIThenANSI

चरण तीन - कम से कम बाइट के साथ जवाब के रूप में।

— टॉम एम

19

CJam, 56 52 50 48 बाइट्स

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

lS-{_,4*(3/mq:D1%}{'.+}wD{D(2/-z_S*D@-@/(S*N@s}/

इसका परीक्षण यहां करें।

व्याख्या

गणित के बारे में पहले केंद्रित हेक्सागोनल संख्याओं का एक सा। यदि नियमित षट्भुज की लंबाई लंबाई है N, तो इसमें 3N(N-1)+1कोशिकाएँ होंगी , जिन्हें स्रोत कोड की लंबाई के बराबर होना चाहिए k। हम इसे हल कर सकते हैं Nक्योंकि यह एक सरल द्विघात समीकरण है:

N = 1/2 ± √(1/4 + (k-1)/3)

हम नकारात्मक जड़ को नजरअंदाज कर सकते हैं, क्योंकि यह एक नकारात्मक एन देता है। इसके लिए एक समाधान के लिए, हमें वर्गमूल की आवश्यकता है एक आधा पूर्णांक। या दूसरे शब्दों में, √(1 + 4(k-1)/3) = √((4k-1)/3)पूर्णांक होना चाहिए (सौभाग्य से, यह पूर्णांक D = 2N-1षट्भुज का व्यास होता है , जिसे हमें वैसे भी आवश्यकता होगी)। इसलिए हम बार-बार एक सिंगल जोड़ सकते हैं .जब तक कि वह शर्त पूरी न हो जाए।

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

lS-     e# Read input and remove spaces.
{       e# While the first block yields something truthy, evaluate the second...
  _,    e#   Duplicate the code and get its length k.
  4*(   e#   Compute 4k-1.
  3/    e#   Divide by 3.
  mq    e#   Take the square root.
  :D    e#   Store this in D, just in case we're done, because when we are, this happens
        e#   to be the diameter of the hexagon.
  1%    e#   Take modulo 1. This is 0 for integers, and non-zero for non-integers.
}{      e# ...
  '.+   e#   Append a no-op to the source code.
}w
D{      e# For every i from 0 to D-1...
  D(2/  e#   Compute (D-1)/2 = N, the side length.
  -z    e#   Subtract that from the current i and get its modulus. That's the size of the
        e#   indentation on this line.
  _S*   e#   Duplicate and get a string with that many spaces.
  D@-   e#   Subtract the other copy from D to get the number of characters of code
        e#   in the current line.
  @/    e#   Pull up the source code and split into chunks of this size.
  (S*   e#   Pull off the first chunk and riffle it with spaces.
  N     e#   Push a linefeed character.
  @s    e#   Pull up the remaining chunks and join them back into a single string.
}/

यह पता चला है कि हमें दोहरे अंकगणित का उपयोग करने की आवश्यकता नहीं है (वर्गमूल को छोड़कर)। 4 से गुणा करने के कारण, 3 से विभाजित होने पर कोई टकराव नहीं होता है, और वांछित kएक पूर्णांक वर्गमूल उत्पन्न करने वाला पहला होगा।

— मार्टिन एंडर
स्रोत

8

पर्ल, 203 200 198

के लिए + 1 शामिल है -p

s/\s//g;{($l=y///c)>($h=1+3*++$n*($n-1))&&redo}$s=$_.'.'x($h-$l);for($a=$n;$a<($d=2*$n-1);$a++){$s=~s/.{$a}/$&\n/,$s=reverse($s)for 0..1}$_=join$/,map{(' 'x abs($n-$i++-1)).$_}$s=~/\S+/g;s/\S/ $&/g

ऐसे दोड़ो: echo abc | perl -p file.pl

एक बहुत ही भोली दृष्टिकोण:

#!/usr/bin/perl -p

s/\s//g;                            # ignore spaces and EOL etc.
{                                   # find the smallest hex number:
    ($l=y///c)                      # calc string length
    > ($h=1+3*++$n*($n-1))          # 
    && redo                         # (should use 'and', but..)
}

$s = $_                             # save $_ as it is used in the nested for
   . '.' x ($h-$l);                 # append dots to fill hexagon

for ( $a = $n; $a < ($d=2*$n-1); $a++ )
{
        $s=~s/.{$a}/$&\n/,          # split lines
        $s=reverse($s)              # mirror
    for 0..1                        # twice
}

$_ = join$/,                        # join using newline
map {                               # iterate the lines
    (' 'x abs($n-$i++-1)) .$_       # prepend padding
} $s=~/\S+/g;                       # match lines

s/\S/ $&/g                          # prepend spaces to characters
                                    # -p takes care of printing $_

अपडेट 200 बाइट मूविंग वैरिएबल असाइनमेंट को सेव करता है, और फाइनल को छोड़ कर दूसरा 2 ;; अब 200 बाइट्स के तहत ही कोड!
अद्यतन 198 के$s=~/\S+/g बजाय का उपयोग करके 2 बाइट्स सहेजेंsplit/\n/,$s

— केनी
स्रोत

7

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

अनाम फ़ंक्शन

हेक्सागोन आकार विकिपीडिया से समीकरण को हल करते हुए पाया जाता है

3*n*(n-1)-1 = l

समाधान सूत्र मूल रूप से है

n = ceil(3+sqrt(12*l-3))/6)

कुछ बीजगणित और कुछ सन्निकटन (@ उपयोगकर्ता 18655 पर भी) के साथ यह बन जाता है

n = trunc(sqrt(l/3-1/12)+1.4999....)

s=>eval("s=s.match(/\\S/g);m=n=Math.sqrt(s.length/3-1/12)+1.49999|0;p=o=``;for(i=n+n;--i;i>n?++m:--m)for(o+=`\n`+` `.repeat(n+n-m),j=m;j--;o+=` `)o+=s[p++]||`.`")

अधिक पठनीय

s=>{
  s=s.match(/\S/g);
  m=n=Math.sqrt(s.length/3-1/12)+1.49999;
  p=o='';
  for(i=n+n; --i; i>n?++m:--m)
    for(o += '\n'+' '.repeat(n+n-m), j=m; j--; o += ' ')
      o+=s[p++]||'.';
  return o
}

टेस्ट स्निपेट (बेहतर पूर्ण पृष्ठ - चलने का समय ~ 1 मिनट)

f=s=>eval("s=s.match(/\\S/g);m=n=Math.sqrt(s.length/3-1/12)+1.49999|0;p=o=``;for(i=n+n;--i;i>n?++m:--m)for(o+=`\n`+` `.repeat(n+n-m),j=m;j--;o+=` `)o+=s[p++]||`.`")

t=0;
r='0';
(T=_=>t++<816?(O.innerHTML=f(r=t%10+r),setTimeout(T,20)):0)()

pre { font-size: 66% }

<pre id=O></pre>

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

— edc65
स्रोत

1

आप 2 बाइट्स को बचाने के n=...+1-1e-9|0बजाय उपयोग कर सकते हैं n=Math.ceil(...)। आप ES7 पर भी जा सकते हैं और **0.5इसके बजाय उपयोग कर सकते हैं Math.sqrtलेकिन यह आपके ऊपर है। मैं आमतौर पर अपने जवाब ES6 रखता हूं क्योंकि वे मेरे ब्राउज़र में काम करते हैं!

— user81655

@ user81655 अच्छा संकेत, धन्यवाद

— edc65

5

पायथ, 52 51 बाइट्स

Jfgh**3TtTl=H-zd1=+H*\.*lHTV+UJt_UJAcH]+JN+*-JNdjdG

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

प्रत्येक पंक्ति में एक अतिरिक्त प्रमुख स्थान है, जैसा कि ओपी द्वारा अनुमति है।

व्याख्या

 f              1          |   find first number n for which
             -zd           |           remove spaces from input
           =H              |         put result in H
          l                |       length of input without spaces
  g                        |     is less than or equal to
   h**3TtT                 |       nth centered hexagonal number
J                          | put result (hexagon side length) in J
                           |
      *lHT                 |      ten times length of input without spaces
   *\.                     |   that amount of dots
=+H                        | append to H
                           |
  UJ                       |    numbers 0 up to side length - 1
 +  t_UJ                   |   add numbers side length - 2 down to 0
V                          | loop over result
            +JN            |       current loop number + side length
         cH]               |     split to two parts at that position
        A                  |   put parts to G and H
                 -JN       |       side length - current loop number - 1
                *   d      |     that many spaces
                     jdG   |     join code on the line (G) by spaces
               +           |   concatenate parts and print

— PurkkaKoodari
स्रोत

5

रेटिना , 161 बाइट्स

2 बाइट बचाने के लिए FryAmTheEggman को धन्यवाद।

यह उत्तर गैर-प्रतिस्पर्धात्मक है। रेटिना ने इस चुनौती के बाद से कुछ अपडेट देखे हैं, और मुझे पूरा यकीन है कि मैं कुछ नई सुविधाओं का उपयोग कर रहा हूं (हालांकि मैंने जांच नहीं की है)।

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। पहली पंक्ति में एकल स्थान होता है। ध्यान दें कि अधिकांश ·वास्तव में केंद्र बिंदु (0xB7) हैं।

 

^
$._$*·¶
^·¶
¶
((^·|\2·)*)·\1{5}·+
$2·
^·*
$.&$* ·$&$&$.&$* 
M!&m`(?<=(?= *(·)+)^.*)(?<-1>.)+(?(1)!)|^.+$
+m`^( *·+)· *¶(?=\1)
$& 
·
 ·
O$`(·)|\S
$1
·
.
G-2`

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

कुंआ...

व्याख्या

केवल एक ही चरित्र ( ·इस मामले में) का उपयोग करके पहले लेआउट का निर्माण करना सबसे आसान लगता है और फिर इनपुट वर्णों के साथ परिणामी लेआउट को भरें। इसका मुख्य कारण यह है कि किसी एकल वर्ण का उपयोग करने से मुझे बैकरेफरेंस और चरित्र पुनरावृत्ति का उपयोग करने की सुविधा मिलती है, जहां सीधे इनपुट बिछाने से महंगे संतुलन समूहों की आवश्यकता होगी।

हालाँकि यह ज्यादा नहीं दिखता है, लेकिन यह पहला चरण इनपुट से रिक्त स्थान को हटा देता है।

^
$._$*·¶

हम एक अतिरिक्त लाइन को तैयार करके शुरू करते हैं जिसमें Mकेंद्र बिंदु होते हैं, जहां Mइनपुट की लंबाई (रिक्त स्थान हटाने के बाद) होती है।

^·¶
¶

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

((^·|\2·)*)·\1{5}·+
$2·

यह आवश्यक पक्ष लंबाई Nशून्य से गणना करता है । यहां बताया गया है कि यह कैसे काम करता है: केंद्रित हेक्सागोनल संख्याएं हैं 3*N*(N-1) + 1। चूंकि त्रिकोणीय संख्याएं हैं N*(N-1)/2, इसका मतलब है कि हेक्सागोनल संख्याएं त्रिकोणीय संख्या से छह गुना अधिक हैं। 1. यह सुविधाजनक है क्योंकि 1 + 2 + 3 + ... + Nएक रेक्स में मिलान त्रिकोणीय संख्याएं (जो वास्तव में बस हैं ) आगे के संदर्भों के साथ काफी आसान हैं। (^·|\2·)*मैचों सबसे बड़ा त्रिकोणीय संख्या यह कर सकते हैं। एक अच्छा बोनस के रूप में, $2फिर इस त्रिकोणीय संख्या के सूचकांक को धारण करेंगे। इसे 6 से गुणा करने के लिए, हम इसे समूह में कैप्चर करते हैं 1और इसे 5 बार मिलान करते हैं। हम यह सुनिश्चित करना है कि वहाँ कम से कम दो और अधिक कर रहे हैं ·के साथ ·और·+। इस तरह से पाया गया त्रिकोणीय संख्या का सूचकांक तब तक नहीं बढ़ता है जब तक कि एक केंद्रित हेक्सागोनल संख्या से अधिक एक चरित्र न हो।

अंत में, यह मैच हमें समूह में आवश्यक षट्भुज की साइड-लंबाई से दो कम देता है $2, इसलिए हम लिखते हैं कि वापस पाने के लिए एक और केंद्र डॉट के साथ N-1।

^·*
$.&$* ·$&$&$.&$*

यह N-1केंद्र बिंदुओं के हमारे तार को N-1रिक्त स्थान, 2N-1केंद्र बिंदु और अन्य N-1स्थानों में बदल देता है। ध्यान दें कि यह अधिकतम इंडेंटेशन है, उसके बाद हेक्सागोन के व्यास के बाद, फिर से इंडेंटेशन।

M!&m`(?<=(?= *(·)+)^.*)(?<-1>.)+(?(1)!)|^.+$

यह अप्रिय रूप से लंबा है, लेकिन यह मूल रूप से हमें सभी ओवरलैपिंग मैच देता है , जो या तो एक) 2N-1वर्ण लंबी और पहली पंक्ति या ख) दूसरी पंक्ति है। यह पिछले चरण से पूर्ण में परिणाम निकालता है, लेकिन अजीब रूप से इंडेंटेड हेक्सागोन। उदाहरण के लिए इनपुट 12345678हमें मिलेगा:

  ···
 ····
·····
···· 
···  
12345678

यही कारण है कि हमें पिछले चरण में भी रिक्त स्थान को जोड़ने की आवश्यकता थी।

+m`^( *·+)· *¶(?=\1)
$&

यह केंद्र के बाद की पंक्तियों के इंडेंटेशन को ठीक करता है, बार-बार किसी भी ऐसी लाइन को इंडेंट करके, जो पिछली से छोटी है (अनुगामी स्थानों की अनदेखी), इसलिए हमें यह मिलता है:

  ···
 ····
·····
 ···· 
  ···  
12345678

अब हम केवल कुछ रिक्त स्थान सम्मिलित करते हैं

·
 ·

जो हमें देता है:

   · · ·
  · · · ·
 · · · · ·
  · · · · 
   · · ·  
12345678

काहे, हो गया।

O$`(·)|\S
$1

केंद्र डॉट्स में इनपुट स्ट्रिंग को भरने का समय। यह एक सॉर्ट चरण की मदद से किया जाता है। हम अंतिम पंक्ति पर सभी केंद्र बिंदुओं और प्रत्येक वर्ण से मेल खाते हैं, और हम दिए गए प्रतिस्थापन के परिणाम के अनुसार उन्हें क्रमबद्ध करते हैं। वह प्रतिस्थापन अंतिम पंक्ति पर और ·केंद्र बिंदुओं के लिए वर्णों के लिए खाली है , इसलिए क्या होता है कि केंद्र बिंदुओं को अंत में क्रमबद्ध किया जाता है (चूंकि छंटाई स्थिर है)। यह इनपुट वर्णों को स्थान पर ले जाता है:

   1 2 3
  4 5 6 7
 8 · · · ·
  · · · · 
   · · ·  
········

अभी दो चीजें बाकी हैं:

·
.

यह केंद्र बिंदुओं को नियमित अवधि में बदल देता है।

G-2`

और यह अंतिम पंक्ति को डिस्कस करता है।

— मार्टिन एंडर
स्रोत

1

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

(s,n=1,l=0,p=0,m=s.match(/\S/g))=>m[n]?f(s,n+6*++l,l):[...Array(l+l+1)].map((_,i,a)=>a.map((_,j)=>j<l-i|j<i-l?``:m[p++]||`.`).join` `).join`\n`

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। हेक्सागोन बनाने के लिए एक तकनीक का उपयोग करता है जिसे मैंने पहले कई अन्य हेक्सागोनल-ग्रिड उत्तरों पर उपयोग किया है। ES7 के लिए वर्गमूल लेने से पुनरावर्ती दृष्टिकोण की तुलना में थोड़ा कम काम होता है:

(s,p=0,m=s.match(/\S/g),l=(~-m.length/3)**.5+.5|0)=>[...Array(l+l+1)].map((_,i,a)=>a.map((_,j)=>j<l-i|j<i-l?``:m[p++]||`.`).join` `).join`\n`

— नील
स्रोत

1

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

c=input().replace(' ','')
n=x=1
while x<len(c):x+=n*6;n+=1
c=c.ljust(x,'.')
while c:print(' '*(x-n)+' '.join(c[:n]));c=c[n:];n-=(len(c)<x/2)*2-1

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

यह विभिन्न आकार के हेक्सागोन्स के लिए अग्रणी व्हाट्सएप की एक अलग-अलग मात्रा का उपयोग करता है, लेकिन सामान्य आकार जीवित रहता है।

— मजाक कर रहा है
स्रोत

हेक्सागोनी स्रोत कोड को अनफॉलो करना

परिचय

नियम

परीक्षण के मामलों

पायथ, 57 54 50 49 48 46

व्याख्या

हेक्सागोनी , 271 बाइट्स

व्याख्या

CJam, 56 52 50 48 बाइट्स

व्याख्या

पर्ल, 203 200 198

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

पायथ, 52 51 बाइट्स

व्याख्या

रेटिना , 161 बाइट्स

व्याख्या

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

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