पिनहोल कैमरा के माध्यम से सूर्य ग्रहण

Question

यह चुनौती 21 अगस्त 2017 को हुए सूर्य ग्रहण से प्रेरित एक सरल ASCII- कला चुनौती है । एक इनपुट को देखते हुए 0 <= n <= 4, नीचे वर्णित ग्रहण के संबंधित चरण को आउटपुट करें:

n=0:
   *****
 **     **
*         *
*         *
**       **
  *******

n=1:
   *****
 **  *****
*   *******
*   *******
**   ******
  *******

n=2:
   *****
 *********
***********
***********
***********
  *******

n=3:
   *****
 *****  **
*******   *
*******   *
******   **
  *******

n=4:
   *****
 **     **
*         *
*         *
**       **
  *******

---

नियम

• आप 0 या 1 इंडेक्स, यह बता सकते हैं कि आपने क्या चुना।
• उपयोग किए गए चार्ट अंतरिक्ष हैं और *, आप *(स्थान के अलावा) के लिए किसी भी मुद्रण योग्य चार्ट का उपयोग कर सकते हैं ।
• अनुगामी स्थान वैकल्पिक हैं (आपके पास हो भी सकता है और नहीं भी)।
• यह कोड-गोल्फ है , सबसे कम बाइट-काउंट विजेता है।

Comments

@ Mr.Xcoder मैं kolmogorov-complexity के रूप में इनपुट पाने की चुनौतियों का टैग लगाने के खिलाफ हूं , हालांकि यह ओपी के विवेक पर निर्भर है।

— आउटगॉल्फ

बम्मर कि यह सममित शीर्ष-से-नीचे नहीं है।

— AdmBorkBork

इसके अलावा, ग्रहण पहले ही शुरू हो चुका है ...

— एरिक आउटगोल्फर

@AdmBorkBork हाँ, मैं कुछ बाइट्स बचा सकता था ...

— एरिक द आउटगलर

"आप किसी भी वर्ण का उपयोग कर सकते हैं *" ... अंतरिक्ष सहित? ;)

— हेगन वॉन ईटीजेन

Answer 1

पायथन 2 , 161 149 142 135 बाइट्स

lambda n,u=u' *':u'''   *****
 ****
**
**
****
  *******'''.translate({1:u[0<n<3],2:u[0<n<4],3:u[1<n<4]})

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

-7 श्री एक्सकोडर का धन्यवाद ।

Comments

अप्रतिबंधों का अच्छा दुरुपयोग।

— Zacharý

जब तक मैं Emacs में कॉपी-पेस्ट नहीं करता, तब तक इस जवाब की पूरी तरह से सराहना नहीं की। प्रतिभाशाली!

— सिल्वियो मेयोलो

@SilvioMayolo उम्म, आपने Emacs के साथ क्या किया?

— एरिक आउटगॉल्फ

मैं सिर्फ इस पृष्ठ पर उत्तर देख रहा था और समझ में नहीं आया कि यह कैसे काम करता है। Emacs सभी छिपे हुए चरित्रों को ^ A, ^ B, ^ C, इत्यादि के रूप में

— दिखाता है

@SilvioMayolo ओह, क्योंकि unprintables में एक प्रतिनिधित्व है जो कुछ हद तक यूनिकोड वर्ण जैसा दिखता है।

— आउटगॉल्फ

Answer 2

चारकोल , 82 81 55 43 बाइट्स

-38 बाइट्स नील को धन्यवाद!

Ｎν”{“⟲ＦEd⧴_³⟲”‖Ｏ¿﹪ν⁴«Ｆ﹪ν²Ｇ↗³↑²↖²↙³*↑¤*¿⁼ν¹‖

इसे ऑनलाइन आज़माएं! लिंक वर्बोज वर्जन के लिए है।

मैंने इसके लिए हेक किया। : P मैं शायद 40 बाइट्स से गोल्फ से बाहर हो जाऊंगा। 26 38 बाइट्स ... पर्याप्त बंद करें?

Comments

मैंने आपके मूल एल्गोरिथ्म के लिए कुछ सरलीकरण किए हैं: इसे ऑनलाइन आज़माएं!

— नील

मैं चारकोल का उपयोग करने में असमर्थता के बजाय अपने तर्क में बाहर निकल गया। > _> धन्यवाद!

— पूरी तरह से

ऐसा लगता है कि बाहरी "सर्कल" प्रिंट करना सबसे कम काम करता है। मैं विषम इनपुट के लिए बहुभुज के साथ भी रचनात्मक था: इसे ऑनलाइन आज़माएं!

— नील

1) दमयन्ती, मुझे लगा कि मैं चतुर हो रहा हूँ PolygonHollow। : पी 2) ओह, अच्छा। धन्यवाद!

— पूरी तरह से

Answer 3

दालचीनी गोंद , 70 बाइट्स

Hexdump:

0000000: 6c33 5053 5050 d002 012e 20a5 0002 4026  l3PSPP.... ...@&
0000010: 9001 0568 6c20 07a6 0648 4080 b521 8a19  ...hl ...H@..!..
0000020: 30a6 1644 1093 0de3 a098 6184 6206 422d  0..D......a.b.B-
0000030: 6136 c20c 6374 3380 3cb8 5aa0 1436 36ba  a6..ct3.<.Z..66.
0000040: 5f4c 280f 0f00                           _L(...

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

मुझे इस भाषा का उपयोग करने का पता लगाने के लिए बहुत समय से प्रतीक्षा है । : पी

तो, दालचीनी गोंद बबलगम है, लेकिन यह बबलगम की तुलना में "वास्तविक" भाषा है।

पहला बाइट ( l) डिक्शनरी को डिक्शनरी मोड में सेट करता है। बाकी बाइट्स निम्न स्ट्रिंग संपीड़ित है।

0&   *****
 **     **
*         *
*         *
**       **
  *******;1&   *****
 **  *****
*   *******
*   *******
**   ******
  *******;2&   *****
 *********
***********
***********
***********
  *******;3&   *****
 *****  **
*******   *
*******   *
******   **
  *******;4&   *****
 **     **
*         *
*         *
**       **
  *******

यह अनिवार्य रूप से एक नंबर को निर्दिष्ट प्रत्येक पाठ के साथ एक लुकअप तालिका बनाता है। कार्यक्रम तब इनपुट लेता है और संबंधित पाठ को आउटपुट करता है।

Comments

बाइट्स बचा सकते हैं argument%4या कर सकते हैं argument&3?

— टाइटस

Answer 4

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

f=
n=>`   *****
 **66733**${s=`
*666777333*`}${s}
**6667333**
  *******`.replace(/\d/g,c=>" *"[c*2>>n&1])

<input type=number min=0 max=4 oninput=o.textContent=f(this.value)><pre id=o>

संपादित करें: @darrylyeo के लिए 1 बाइट धन्यवाद सहेजा गया।

Comments

*666777333*\nएक चर में भंडारण द्वारा -2 बाइट्स ।

— darrylyeo

@darrylyeo मैं कुछ गलत कर रहा हूँ क्योंकि मैं केवल 1 बाइट बचा सकता हूँ ...

— नील

मेरा बुरा, यह वास्तव में सिर्फ 1 बाइट बचाता है।

— darrylyeo

Answer 5

SOGL V0.12 , 40 39 बाइट्स

"⁽Ρūa╔Ƨ ‘╥▓.4%?52"¹ο1¹‘╬¡╬5.H?:±}.2=?╬8

यह कोशिश करो!

Comments

यदि वह कोई मदद करता है, तो ट्रेलिंग स्थान वैकल्पिक हैं (आपके पास हो सकता है या नहीं भी हो सकता है)। - एसओजीएल को नहीं जानते, लेकिन बाइट्स बचा सकते हैं

— श्री एक्सकोडर

@ Mr.Xcoder यह विपरीत करेगा, जैसा कि SOGL ने ASCII कला से कहीं भी निपटने के दौरान अनुगामी रिक्त स्थान जोड़ता है: p

— dzaima

Answer 6

VI, 108 बाइट्स

D:let@a=@"%2?@":@"%4?"X":"\\d"<CR>
3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp
:%s/<C-r>a/ /g<CR>
:%s/\d/*/g<CR>

<CR>है Enterस्ट्रोक, <C-?>से मेल खाती है Control + ?, और <Esc>करने के लिए Escapeस्पष्ट रूप से। 1 बाइट के लिए इनमें से प्रत्येक की गिनती ( मेटा देखें )। समाधान में लाइन ब्रेक पठनीयता के लिए है। केवल <CR>वास्तविक Enterस्ट्रोक का प्रतिनिधित्व करता है ।

इनपुट

इनपुट फ़ाइल में केवल 1 वर्ण होना चाहिए, जिसका प्रतिनिधित्व करना चाहिए n।

प्रक्षेपण

VI को इस तरह शुरू किया जाना चाहिए:

vi -u NONE input

स्पष्टीकरण

समाधान में 3 भाग हैं। मैं पहले भाग (दूसरी पंक्ति) का वर्णन करूंगा, क्योंकि यह व्याख्या करना सबसे आसान है।

सूर्य को आकर्षित करना

सूर्य को आकर्षित करने की आज्ञा है:

3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp

सूरज के साथ तैयार किया जाना चाहिए , *, 0, 1और 3, इस तरह:

   *****
 **11033**
*111000333*
*111000333*
**1110333**
  *******

एक समरूपता ने इस हिस्से के बाइट्स के आकार को कम करने में मदद की होगी, लेकिन यह उतना महत्वपूर्ण नहीं है। मैं पूरी लाइन की व्याख्या नहीं करूंगा, लेकिन पैटर्न *****का उपयोग आसानी से अंतिम लाइन उत्पन्न करने के लिए किया जाता है, और पैटर्न **1110333**को 3 अन्य लाइनों को उत्पन्न करने के लिए एक संदर्भ के रूप में लिया गया है 0, 1और 3।

इसका उपयोग करना महत्वपूर्ण है 0, 1और 3सूरज के हिस्सों के लिए जिसे भरा जा सकता है (अगले स्पष्टीकरण देखें)। इस सूरज को आकर्षित करने में 55 बाइट्स लगते हैं , और संभवत: इसे कुछ ट्रिकों के साथ चलाया जा सकता है।

सूर्य को अनुसार भरना n

सूरज को सही ढंग से भरने के लिए, पालन करने के निर्देश हैं:

• यदि n = 0, तब 0, 1और 3(सभी अंक) को प्रतिस्थापित किया जाना चाहिए
• यदि n = 1, तो , के साथ अन्य अंकों के साथ 1प्रतिस्थापित किया जाना चाहिए*
• यदि n = 2, तब 0, 1और 3(सभी अंक) को प्रतिस्थापित किया जाना चाहिए*
• यदि n = 3, तो , के साथ अन्य अंकों के साथ 3प्रतिस्थापित किया जाना चाहिए*
• यदि n = 4, तब 0, 1और 3(सभी अंकों) को प्रतिस्थापित किया जाना चाहिए (जैसे n = 0)

उस से, हम अनुमान लगा सकते हैं कि आवश्यक प्रतिस्थापन निम्नलिखित हैं:

• ( पहले प्रतिस्थापन ) द्वारा कुछ अंकों को बदलें
• *( दूसरे प्रतिस्थापन ) द्वारा अन्य सभी अंकों को बदलें

ध्यान दें कि "कुछ अंक" का अर्थ "कोई अंक नहीं" हो सकता है ( n = 2उदाहरण के लिए)। और "सभी अन्य अंक" भी "कोई अंक नहीं" का प्रतिनिधित्व कर सकते हैं, यदि सभी अंक पहले प्रतिस्थापन ( n = 0उदाहरण के लिए) द्वारा प्रतिस्थापित किए गए हैं ।

दूसरा प्रतिस्थापन आसानी से में लिखा जा सकता है 11 बाइट्स :

:%s/\d/*/g<CR>

पहले प्रतिस्थापन पर निर्भर करता है n, इसलिए पहले हम गणना करने के लिए क्या अंक प्रतिस्थापित किया जा करने के लिए जा रहे हैं। यदि प्रतिस्थापित वर्णों को रजिस्टर में संग्रहीत किया जाता है a, तो प्रतिस्थापन कमांड को 11 बाइट्स में भी लिखा जाता है :

:%s/<C-r>a/ /g<CR>

<C-r>aaजब आदेश टाइप किया जाता है तो रजिस्टर की सामग्री द्वारा प्रतिस्थापित किया जाता है।

aपिछले निर्देशों का पालन करते हुए, मान की गणना करने के लिए , एल्गोरिथ्म (छद्म कोड में) है:

n := read()
if (n % 2 != 0)
then
    a := n
else
    if(n % 4 != 0)
    then
        a := "X"
    else
        a := "\d"

"X"स्ट्रिंग का उपयोग तब किया जाता है क्योंकि जब n = 2, कोई अंक रिक्त स्थान द्वारा प्रतिस्थापित नहीं किया जाता है। कोई भी स्ट्रिंग जो सूरज नहीं है, उसका उपयोग यहां किया जा सकता है, जब तक कि पहला प्रतिस्थापन कुछ भी नहीं करता है।

यह 31 बाइट्स में लिखा जा सकता है :

D                                   # yank and delete the first character of the file (n) to register "" (yank by default) : n = @"
 :let@a=                            # define register "a content
        @"%2                        # if (n % 2 != 0)
            ?                       # then
             @"                     #   n
               :                    # else
                @"%4                #   if (n % 4 != 0)
                    ?               #   then
                     "X"            #       "X"
                        :           #   else
                         "\\d"      #       "\\d"
                              <CR>  # calculate "a

समाधान

इन सभी भागों को सही क्रम में रखें, और आपके पास इसका हल है:

D:let@a=@"%2?@":@"%4?"X":"\\d"<CR>                                              # calculate the digits to replace with spaces
3i <Esc>5a*<Esc>Yphr*$a*<Esc>O**1110333**<Esc>YPi <Esc>3lx3lx"0px4lyl2p$xYp     # draw the sun with spaces, stars, 0, 1 and 3
:%s/<C-r>a/ /g<CR>                                                              # replace the pattern stored in register "a with spaces
:%s/\d/*/g<CR>                                                                  # replace the remaining digits with stars

Answer 7

PHP, 114 + 1 बाइट्स

के लिए +1 बाइट -R। शुक्रिया @Neil शिफ्टिंग संकेत के लिए।

for(;$c="   *****
 **66733**
*666777333*
*666777333*
**6667333**
  *******"[$i++];)echo+$c?" *"[$c*2>>$argn&1]:$c;

*0-अनुक्रमित के लिए अंडरस्कोर का उपयोग करता है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

PHP 5.5 या बाद के संस्करण की आवश्यकता है:
पुराने PHP शाब्दिक स्ट्रिंग अनुक्रमण (पार्स त्रुटि) को नहीं समझते हैं;
PHP 7.1 गैर-संख्यात्मक मान ( फिक्स के +$cसाथ बदलें $c>0) के बारे में शिकायत करता है ।

Comments

मुझे लगता है कि " _"[$c*2>>$argn&1]अगर आपको ज़रूरत है तो नकारात्मक बदलाव के मापदंडों से बचें।

— नील

Answer 8

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

• -1 बाइट @ @IOSCoder के लिए धन्यवाद: निष्पादन का उपयोग

def f(x,k=0):exec'print"".join(ord(i)*" *"[j%2]for j,i in enumerate(["		","	","	!",""][x%4]))[11*k:][:11];k+=1;'*6

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

Comments

169 बाइट्स

Answer 9

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

lambda n,s=' ',a='*':"""   *****
 **%s**
*%s*
*%s*
**%s**
  *******"""%[(s*5,s*9,s*9,s*7),(s*2+a*3,s*3+a*6,s*3+a*6,s*3+a*4),(a*5,a*9,a*9,a*7),(a*3+s*2,a*6+s*3,a*6+s*3,a*4+s*3)][n%4]

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

बहुत भोली दृष्टिकोण, गोल्फिन ' एनवीएम ' पर काम कर रहा है।

Answer 10

जावा 8, 225 213 211 बाइट्स

n->{String a=n<2|n>3?"   ":"***",b=n<1|n>2?"   ":"***",c=n%4<1?" ":"*",d=a+(n%4<1?"   ":"***")+b;return"   *****\n **"+(n<2|n>3?"  ":"**")+c+(n<1|n>2?"  ":"**")+"**\n*"+d+"*\n*"+d+"*\n**"+a+c+b+"**\n  *******";}

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

Answer 11

05AB1E , 46 बाइट्स

„* •zÇRéóĀ—ÚÂÐoʒ<]ÜA›¶Ò¿H¶ ∞m•b3äûIèSèJ6äIií}»

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