एंबेडेड डायमंड्स!


26

नहीं, यह । और यह भी नहीं । यह सवाल ऐसा कुछ नहीं है

निम्नलिखित आउटपुट को प्रिंट / वापस करने के लिए सबसे छोटा कोड लिखें:

   /\      /\      /\
  /  \    /  \    /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  / /\ \  / /\ \  /
   \/ /  \ \/ /  \ \/
   /\ \  / /\ \  / /\
  /  \ \/ /  \ \/ /  \
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
  \  /    \  /    \  /
   \/      \/      \/
  • इनपुट / आउटपुट के मानक तरीके।
  • मानक खामियां लागू होती हैं।
  • किसी भी राशि में ट्रेलिंग / अग्रणी व्हाट्सएप ठीक है।

3
यह नहीं, वह नहीं, इस बारे में क्या ?
मैथ्यू रो

जवाबों:


14

चारकोल , 28 24 23 बाइट्स

↗²↖↙⁴⟲P²⁴⁶↘↙↙²⟲P²⁴⁶C⁸¦⁰

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

↗²↖↙⁴   Draw the top left 4x4 corner
         /
        //
⟲P²⁴⁶   Rotate it three times to complete a diamond
         /\
        //\\
        \\//
         \/
↘↙↙²    Draw the top left line of the inner diamond
         /\
        //\\
        \\//
         \//
⟲P²⁴⁶   Rotate three times to complete five diamonds
C⁸¦⁰    Copy everything 8 characters to the right to complete eight diamonds

संपादित करें: मेरा पिछला उत्तर ‖M‖M↓शीर्ष कोने को दर्शाते हुए एक पूरे हीरे का निर्माण करता था, लेकिन चारकोल में एक बग के कारण यह कर्सर को स्थिति से बाहर कर देता है। सौभाग्य से मैंने उसी प्रभाव को प्राप्त करने का एक और तरीका खोजा जो कर्सर को स्थानांतरित नहीं करता है, जिसका मतलब है कि मैंने आंतरिक हीरे को आकर्षित करने वाली बाइट को बचाया। (मैंने ओवरलैपिंग ऑपरेशंस पर भी ध्यान दिया, लेकिन मैं रोटेट / कॉपी अप्रोच पर सुधार नहीं कर पाया।)

संपादित करें: ↖²↗↘⁴‖M¬M¹¦³↘²‖M¬C⁸¦⁰21 बाइट्स में काम करता है, लेकिन यह नए प्रतिबिंबित व्यवहार पर निर्भर करता है, इसलिए मुझे नहीं पता कि यह पुराने कोड के साथ संभव था या नहीं।


हाँ, क्षमा करें, यह एक बग था - मैंने इसे ठीक कर दिया है और एएसएपी को आगे बढ़ाने की कोशिश करेगा, लेकिन यह अभी भी बहुत कम है: ओ +1
एएससीआईआई-केवल

@ ASCII- केवल यदि मैं TIO का उपयोग कर रहा हूं, तो यह मुझे कैसे प्रभावित करता है?
नील

खैर, यह अभी भी कैश्ड है, इसलिए जब तक यह कैश्ड है, यह ठीक होना चाहिए, अगर आपका मतलब है
ASCII-only

@ ASCII- केवल जो मैं जानना चाहता हूं वह यह है कि जब TIO का व्यवहार बदलता है तो मैं एक अद्यतन (हालांकि गैर-प्रतिस्पर्धात्मक) लिंक प्रदान करने में सक्षम होना चाहूंगा।
नील

ओह, उस मामले में यह पहले से ही ठीक है
केवल

7

चारकोल , 62 50 48 45 42 40 बाइट्स

@ दो बाइट बचाने के लिए @ ऑक्स का धन्यवाद!

↙²→↘²↙↖⁴→↗⁴‖MF²C⁸¦⁰M⁸↓→↗²↓↘²M⁴→↑↗²↓↘²‖M↓

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

स्पष्टीकरण:

↙²→↘²          // Draw the left half of the inner part of the first diamond.
↖⁴→↗⁴          // Draw the left half of the outer part.
‖M             // Mirror the half of the diamond to create the first full diamond.
F²C⁸¦⁰         // Copy the picture eight characters to the left twice.
               // The first copy gives us two diamonds, and the second copy of the
               // two diamonds overlaps so that the result is three diamonds.
M⁸↓→↗²↓↘²     // Move down to draw the upper inner half of the first middle diamond.
M⁴→↑↗²↓↘²     // Move right to do the same for the second middle diamond.
‖M↓           // Mirror the whole thing vertically.

1
आप एक बाइट को बचाने के C⁸¦⁰C⁸¦⁰साथ बदल सकते हैं F²C⁸¦⁰¦
ओकेक्स

@ ऑक्स थैंक्स! दरअसल, यह दो बाइट्स बचाता है, क्योंकि यह अनुगामी के बिना काम करता है ¦
स्टेडीबॉक्स

रिकॉर्ड के लिए, कुछ अपडेट ने इसे तोड़ दिया है, क्योंकि कोड अब TIO पर ठीक से काम नहीं करता है। उत्तर अभी भी मान्य है, क्योंकि जब यह उत्तर पोस्ट किया गया था, तो यह TIO संस्करण के साथ काम करता था।
स्टेडीबॉक्स

6

05AB1E , 45 44 43 बाइट्स

कोड:

…/ \©•—‹íćCé']d₂2ó@¯çX‘¯¨•3вè8äJvy®‡«}»Â»

पूर्व स्पष्टीकरण:

•—‹íćCé'\]d₂2ó@¯çX‘¯¨•3вभाग निम्नलिखित सरणी के सिर्फ संकुचित संस्करण है:

[1, 1, 1, 0, 2, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 2, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 2, 1, 2, 0, 1, 0, 1, 2, 1, 2, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 2, 1, 2, 0, 1, 0, 1, 1, 2, 1, 2, 1, 1, 2, 1, 1, 0, 1, 0, 2, 1, 2, 1, 1, 1, 1, 2, 0, 1, 0, 1, 1, 2, 1, 2]

जिसे हम स्ट्रिंग में इंडेक्स करते हैं …/ \। इस नक्शे 0 -> /, 1 -> space, 2 -> \। उसके बाद, हम इस स्ट्रिंग को निम्न प्रोग्राम के साथ संसाधित करते हैं:

8äJvy®‡«}»Â»

8ä               # Split the array into 8 pieces
  J              # Join each sub-array in the array
   vy     }      # For each string in the array
     Â           #   Bifurcate (duplicate and reverse)
      ®          #   Push the string "/ \" (which was copied using ©)
       Â         #   Bifurcate to get "\ /"
        ‡        #   Transliterate / -> \ and \ -> /
         «       #   Append to the original string
           »     # Join the entire stack on newlines
            Â    # Bifurcate
             »   # Join the stack by newlines

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


05AB1E ASCII- कला में बहुत अच्छा है, ऐसा लगता है ...
फलों

4
चौरासी को पार किया अभी भी चौंसठ है।
ओकेक्स

@ ओक्स जब तक आप नॉन-ब्रेकिंग स्पेस लागू नहीं करते ।
स्टेडीबॉक्स


3

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

_=>(a=`3868683
2/274/274/272
1/18172/18172/18171
/1/27191/27191/2717
7172/18172/18172/1/
17191/27191/27191/1
272/18172/18172/2
391/27191/27193`.replace(/\d/g,n=>n>6?['\\','/\\','\\/'][n-7]:' 
'.repeat(n)))+`
`+[...a].reverse().join``

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

const f = _=>(a=`3868683
2/274/274/272
1/18172/18172/18171
/1/27191/27191/2717
7172/18172/18172/1/
17191/27191/27191/1
272/18172/18172/2
391/27191/27193`.replace(/\d/g,n=>n>6?['\\','/\\','\\/'][n-7]:' '.repeat(n)))+`
`+[...a].reverse().join``

console.log(`
${f()}
`)


मेरे पास नीचे 126 बाइट समाधान है। :)
स्टीव बेनेट

3

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

400.times{|i|print (23<x=i%25)?$/:" /  \\   "[(x^y=i/25)&4^x+y&1^(x-2&4&y-2>y/6%2*x/2%11*4?2:0)]}

व्याख्या

प्रत्येक 4x4 वर्ग में केवल रिक्त स्थान और /या होते हैं \। हम समग्र हीरा पैटर्न देने के लिए इनकी साजिश रचते हैं। सीमाओं पर आंशिक पैटर्न से बचने के लिए, कुछ 2x2 वर्गों को नीचे की तरह खाली छोड़ दिया जाना चाहिए।

.. /\ .... /\ .... /\ ..
../  \..../  \..../  \..
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
..\  / /\ \  / /\ \  /..
.. \/ /  \ \/ /  \ \/ ..
.. /\ \  / /\ \  / /\ ..
../  \ \/ /  \ \/ /  \..
 / /\ \  / /\ \  / /\ \
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ /
..\  /....\  /....\  /..
.. \/ .... \/ .... \/ ..

असंगठित संस्करण - स्पष्टीकरण में सहायता के लिए ऊपर मुद्रित करने के लिए संशोधित

400.times{|i|print (23<x=i%25)?$/:     #Calculate x. If last column, print a newline else
  " /..\\ .."[(x^y=i/25)&4^x+y&1^      #If (x^y)&4==4, use x+y&1 to select between space and /. If (x^y)&4==0 select between \ and space.
  (x-2&4&y-2>y/6%2*x/2%11*4?2:0)]      #If x-2&4&y-2==4, and we are on the 2 character wide border (y/6%2*x/2%11==0), XOR with 2 to print .
}


1

सी #, 608 बाइट्स

void q(){Action<string>a=Console.Write;Func<int,int,string>b=(c,d)=>new string(' ',c)+(d<1?"/\\":d<2?"/  \\":d<3?"/ /\\ \\":d<4?"/ /  \\ \\":d<5?"\\ \\  / /":d<6?"\\ \\/ /":d<7?"\\  /":"\\/");Action e=()=>a(b(0,4)+b(0,4)+b(0,4)+"\n"+b(1,5)+b(2,5)+b(2,5)+"\n");Action f=()=>a(b(1,2)+b(2,2)+b(2,2)+"\n");Action g=()=>a(b(0,3)+b(0,3)+b(0,3)+"\n");a(b(3,0)+b(6,0)+b(6,0)+"\n"+b(2,1)+b(4,1)+b(4,1)+"\n");f();g();e();a("  \\  / /\\ \\  / /\\ \\  /\n"+"   \\/ /  \\ \\/ /  \\ \\/\n"+"   /\\ \\  / /\\ \\  / /\\\n"+"  /  \\ \\/ /  \\ \\/ /  \\\n");f();g();e();a(b(2,6)+b(4,6)+b(4,6)+"\n"+b(3,7)+b(6,7)+b(6,7)+"\n");}

ऐसा नहीं है कि मैं इसे अब और बनाना चाहता हूं लेकिन ऐसा लगता है कि आप गायब हैं using System;। मुझे पूरा यकीन है कि आप इसे और अधिक कर सकते हैं लेकिन मैंने 100% सुनिश्चित होने में बहुत अधिक समय नहीं लगाया है।
TheLethalCoder

इसके उत्पादन की तुलना में लंबे समय तक सिर्फ System.Console.WriteLine(@"...");200 बाइट की तरह मेरे जवाब को हरा देंगे।
लाईफ़डेवेन

1

सी #, 382 291 बाइट्स

_=>string.Format(@"{5}{5}{5}
{2}{2}{2}
{0}{0}{0}
{1}{1}{1}
\ \ {0}{0} / /
 \ \{1}{1}/ /
  \ {0}{0} /
   \{1}{1}/
   /\ \ {0} / /\
  /  \ \{1}/ /  \
 {0}{0}{0}
{1}{1}{1}
\ \ {0}{0} / /
 \ \{1}{1}/ /
{4}{4}{4}
{3}{3}{3}",@" / /\ \ ",@"/ /  \ \",@"  /  \  ",@"   \/   ",@"  \  /  ",@"   /\   ");

1

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

for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1&&r%14>1,q=[1,,C&&r&2,,,,C&&~r&2,,1],a+=q[c+5+r&7]?'/':q[r-c+20&7]?'\\':' '

चूंकि यह अब बहुत ही अपठनीय है, एक बुनियादी व्याख्या:

  • हम नीचे दायीं ओर बायीं ओर ऊपर की ओर टाइल लगाते हैं
  • हम इसे मूल रूप से 6 विकर्ण रेखाओं के रूप में आकर्षित करते हैं जो हर 8 वर्णों को दोहराते हैं: 2 ठोस रेखाएं, और 4 जो "धराशायी" (दो वर्ण, फिर दो स्थान ...) हैं।
  • C=...सामान बाउंडिंग बॉक्स के भीतर करने के लिए लाइनों में से कुछ की ड्राइंग सीमा है
  • बहुत सारे पात्रों को बचाने के लिए, हम जानबूझकर संख्याओं को ऊपर और नीचे की रेखाओं के लिए समान बनाने के लिए जोड़ते हैं
  • फिर, अभिव्यक्तियों को एक विरल सरणी में डाल दिया [1,,C&&...], जिसे हम देखते हैं। यदि कोई सत्य मूल्य है, तो हम उचित चरित्र बनाते हैं।

-

for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))                 // basic grid tiling
C=c%22>1&&r%14>1,   // are we not near the edges
q=[1,               // a solid line that always draws
,                   // a line that never draws
C&&r&2,             // a line that draws if not near the edge, and if on the correct "dash" (r&2)
,,,
C&&~r&2,            // if not near the edge, and on the opposite "dash" (~r&2)
,1                  // the opposite diagonal line that always draws
],
a+=q[c+5+r&7]?'/' // compute which upward line we're on, check whether to draw it
:q[r-c+20&7]?'\\' // do the same for the downward line
:' '                // otherwise draw a space

शायद इस स्पष्टीकरण से मदद नहीं मिली। :)

ऑनलाइन कोशिश करें: https://codepen.io/stevebennett/pen/WjgMpY

उम्मीद है कि मुझे आउटपुट सही मिला:

   /\      /\      /\   
  /  \    /  \    /  \  
 / /\ \  / /\ \  / /\ \ 
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ / 
  \  / /\ \  / /\ \  /  
   \/ /  \ \/ /  \ \/   
   /\ \  / /\ \  / /\   
  /  \ \/ /  \ \/ /  \  
 / /\ \  / /\ \  / /\ \ 
/ /  \ \/ /  \ \/ /  \ \
\ \  / /\ \  / /\ \  / /
 \ \/ /  \ \/ /  \ \/ / 
  \  /    \  /    \  /  
   \/      \/      \/   

इतिहास

130

for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1&&r%14>1,q=[1,,C&&r&2,,,,C&&~r&2,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

133

for(c=r=a='';r<16;c++>22&&(r++,c=0,a+=`
`))C=c%22>1,q=[1,,C&&r&2&&r<14,,,,C&&~r&2&&r>1,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

137

for(c=r=a='';r<16;c++==23&&(r++,c=0,a+=`
`))C=c<22&&c>1,q=[1,,C&&r&2&&r<14,,,,C&&~r&2&&r>1,,1],a+=q[(c+5+r)%8]?'/':q[(r-c+20)%8]?'\\':' '

155

for(c=r=a='';r<16;c++==23&&(r++,c=0,a+=`
`))Z=(C=c<22&&c>1)&&~r&2&&r>1,Y=C&&r&2&&r<14,B=(c-r+12)%8,A=(c+5+r)%8,q=[1,,Y,,,,Z,,1],a+=q[A]?'/':q[8-B]?'\\':' '

इतिहास: १ 17२

for(c=r=a='';r<16;c++==23&&(r++,c=0,a+='\n'))a+=(Z=(C=c<22&&c>1)&&~r&2&&r>3,Y=C&&r&2&&r<12,B=(c-r+16)%8,A=(c+r)%8,A==3||A==5&&Y||A==1&&Z?'/':B==4||B==2&&Y||B==6&&Z?'\\':' ')

1

कैनवस , 18 बाइट्स

4/2/33╋╬2/77╋╬:91╋

यहाँ यह कोशिश करो!

स्पष्टीकरण:

4/           push a diagonal of length 4
  2/         push a diagonal of length 2
    33╋      insert that at [3;3] in the 1st diagonal
                    /
                   / 
                  / /
                 / / 
╬            quad-palindromize with 0 overlap
 2/77╋       insert a 2-long diagonal in the bottom-right corner
                    /\   
                   /  \  
                  / /\ \ 
                 / /  \ \
                 \ \  / /
                  \ \/ / 
                   \  / /
                    \/ / 
      ╬      quad-palindromize with 0 overlap, creating most of the output
                    /\      /\   
                   /  \    /  \  
                  / /\ \  / /\ \ 
                 / /  \ \/ /  \ \
                 \ \  / /\ \  / /
                  \ \/ /  \ \/ / 
                   \  / /\ \  /  
                    \/ /  \ \/   
                    /\ \  / /\   
                   /  \ \/ /  \  
                  / /\ \  / /\ \ 
                 / /  \ \/ /  \ \
                 \ \  / /\ \  / /
                  \ \/ /  \ \/ / 
                   \  /    \  /  
                    \/      \/   
       :91╋  overlap self on [9;1]

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.