यह मेरा तकिया है

66

... क्या आप इसे अमर बनाने में मेरी मदद करेंगे?

यहाँ छवि विवरण दर्ज करें

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

इसे बिना किसी इनपुट तर्क के काम करना होगा।

आउटपुट बिल्कुल इस तरह दिखना चाहिए (नई लाइनों और रिक्त स्थान ठीक हैं)।

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

यह कोड गोल्फ है, इसलिए बाइट्स जीतने वाला सबसे छोटा कोड है!

लीडरबोर्ड

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

code-golf  ascii-art  kolmogorov-complexity 
— स्टीवी ग्रिफिन
स्रोत
7
मैं कुछ हद तक निराश हूं कि तकिया के विभिन्न लाइन मोटाई का प्रतिनिधित्व करने के लिए पैटर्न थोड़ा अधिक जटिल नहीं है।
— स्पेर
4
@ शेपर मैंने कोशिश की, लेकिन मैंने केवल ASCII वर्णों का उपयोग करके इसे अच्छा बनाने का प्रबंधन नहीं किया। यह काफी करीब था :)
— स्टूवी ग्रिफिन
3
मैंने अभी-अभी स्पेस जोड़े हैं
— स्पार्ट
1
'जाहिरा तौर पर': पी
— पिसिस
7
अब आप एक खाली तकिया खरीद सकते हैं और उस पर विजेता स्निपेट प्रिंट कर सकते हैं।
— coredump

जवाबों:

24

05AB1E , 18 15 बाइट्स

कोड:

„/\5×{4Å6×»6F=R

व्याख्या:

„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string

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

— अदनान
स्रोत
2
वाह ... दो अलग लेता है, एक ही बाइट गिनती ...
— ओलिवर नी
30

/// , 116 बाइट्स

/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD

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

संपादित करें : \\\\\\\\\\\\\\\/और \\\\\\\\\\\\\\\\वास्तव में क्रमशः एक / और \, हैं।

संपादित करें : -3 क्योंकि मैंने हटाने के बारे में सोचा था i। मुझे लगता है कि इसे आगे नहीं बढ़ाया जा सकता है।

— आउटगोल्फर को एरिक करें
स्रोत
15

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

b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6

इस साफ विधि के लिए मिच श्वार्ट्ज का धन्यवाद जो बाइट बचाता है। विचार यह है कि चार लाइनों को प्रिंट करें ('\\'*5+'/'*5)*6, स्लैश और बैकलैश की भूमिकाओं को स्वैप करें, और फिर उस पूरी प्रक्रिया को 6 बार करें। दो पात्रों में जमा हो जाती aहै और b, और के रूप में बदली a,b=b,a। निम्नलिखित कोड स्ट्रिंग उत्पन्न करके डबल-लूप डबल है, फिर इसे निष्पादित करें exec:

print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;

50 बाइट्स:

s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

लाइन स्ट्रिंग बनाता है, इसे चार बार प्रिंट करता है और फिर इसे उलट देता है, फिर 6 बार करता है। निम्नलिखित कोड उत्पन्न करके ऐसा करता है, फिर इसे क्रियान्वित करता है:

print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]

यहाँ मेरे गोल्फ के पुनरावृत्तियों में से कुछ हैं:

for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6

for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6

for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6

for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6

for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6

for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6

for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6

for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6

print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3

for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6

a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6

s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6

s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6

a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
— XNOR
स्रोत
12

05AB1E, 15 बाइट्स

„/\5×{R6×6FR4F=

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

व्याख्या:

„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping

CP-1252 एन्कोडिंग का उपयोग करता है ।

— ओलिवर नी
स्रोत
8

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

एक पुनरावर्ती कार्य। Chocochaos उत्तर से प्रेरित कई अनुकूलन ।

f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

डेमो

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

— Arnauld
स्रोत
मुझे लगता है कि आप पहली बार बाहर निकल सकते हैं &1और दो बाइट्स बचा सकते हैं
— हेनरिक क्रिस्टेंसेन
@HenrikChristensen जो केवल काम करेगा n < 480। इसके लिए n >= 480, हमें कोष्ठक की आवश्यकता होगी (n/240^n/5)&1:।
— Arnauld
8

बबलगम , 30 बाइट्स

00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......

अप्रचलित बबलगम का जवाब।

— LegionMammal978
स्रोत
ओह मेरी अच्छाई यह भाषा कमाल की है!
— पेड्रो ए
7

हास्केल, 77 70 57 बाइट्स

a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]

साइन के साथ खेलने के बजाय बोरिंग concatऔर replicateएस। पुराना था:

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— Angs
स्रोत
6

ब्रेनफक, 140 बाइट्स

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

:-D

— 0WJYxW9FMN
स्रोत
3
अरे देखो! Brainfuck समाधान जावा समाधान की तुलना में आठ बाइट्स छोटा है। ब्रेन कोड पर स्विच करने के लिए जावा कोडर्स का समय ...
— 0WJYxW9FMN
जावा पीछे
— हटता है
6

पायथन 2, 86 80 76 74 73 बाइट्स

for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

शायद यह कुछ और गोल्फ कर सकता है लेकिन यह एक शुरुआत है।

संपादित करें

कुछ अनावश्यक कोष्ठक हटाकर 6 को बचाया

एक और स्ट्रिंग का उपयोग करके एक और 4 और फिर इसे उल्टा करना

धन्यवाद @ अदनान कल रात एक देर रात थी और अभी भी पूरी तरह से नहीं जाग रही है: पी

-1 *24चर का उपयोग करके इसे दो बार उपयोग करने के बजाय

— ElPedro
स्रोत
4
मेरा मानना ​​है कि *6*4जैसा है वैसा ही है *24? : पी
— अदनान
6

ब्रेनफक, 149 बाइट्स

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

सबसे अच्छा दुभाषिया EVAR!

यह 6 कोशिकाओं (कोई रैपिंग, कोई मोडुलो) का उपयोग करता है। वे यहाँ हैं:

0A 00 2F 00 5C 00

00कोशिकाओं पाश काउंटर के लिए उपयोग किया जाता है। यहां, काउंटरों को प्रारंभिक मूल्यों से भरा गया है:

0A 06 2F 04 5C 03

सबसे बाएं काउंटर अंतरतम लूप के लिए है (हां, मैं गहराई 3 के नेस्टेड लूप का उपयोग करता हूं)। कृपया ध्यान दें कि 4 वें सेल ( 04काउंटर) का उपयोग दो बार, एक बार /////\\\\\...और \\\\\/////...हर बार एक बार किया जाता है।

0A, 2Fऔर क्रमशः 5Cवर्ण हैं \n, /और \।

— आउटगोल्फर को एरिक करें
स्रोत
6

पायथन 2.7 66 -> 56 -> 55 बाइट्स

a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

गोल्फ कोडिंग के लिए नया

a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

धन्यवाद स्टीवी ग्रिफिन

एक मूर्खतापूर्ण व्हाट्सएप भूल गए;)

— इवर मैटस्टम्स
स्रोत
2
PPCG में आपका स्वागत है! अच्छा पहला उत्तर :) क्या आप कुछ मध्यवर्ती चरों को छोड़ सकते हैं? कम से कम dऔर e, शायद अधिक। मैंने इसका परीक्षण नहीं किया है, लेकिन यह करीब होना चाहिए print(4*c+4*(6*b+"\n"))*3:। यह 5 बाइट्स कम है।
— स्टीवी ग्रिफिन
3
55 बाइट्स:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— स्टू ग्रिफिन
6

ब्रेनफक, 179 बाइट्स

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

मुझे पता है कि यह धागे में सबसे अच्छा स्कोर नहीं है, लेकिन मैं दिमाग लगाना चाहता हूं और यह कोशिश करना चाहता हूं।

संपादित करें: मुझे कॉपी करते समय एक त्रुटि हुई होगी। यह संस्करण काम करना चाहिए

— एक्सल मैटस्टम्स
स्रोत
साइट पर आपका स्वागत है!
— DJMcMayhem
मेरे लिए काम नहीं करता है। ब्राउज़र इस दुभाषिया के साथ लटका हुआ है , और एक व्यक्ति गैर-अपेक्षित 5 लाइन आउटपुट दिखाता है: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ चार बार, फिर अनंत \ ।
— अलाउक
जी हाँ, यह काम करता है :)
— aluriak
5

MATL , 18 16 बाइट्स

'\/'6:&+thK5&Y")

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

व्याख्या

'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
— लुइस मेंडो
स्रोत
5

पायथ, 22 बाइट्स

V6V4V12p*5?%+bN2\\\/)k

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

व्याख्या:

V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)

क्षमा करें यदि स्पष्टीकरण समझने में थोड़ा कठिन है, लेकिन यह थोड़े जटिल था।

— आर।
स्रोत
5

वी , 22 21 बाइट्स

संपादित करें एक बाइट जीता है, धन्यवाद @DjMcMayhem:

5á\5á/05ä$4Ä5x$p4Ä3ä}

परिवर्तन हैं:

  • Y4P-> 4ÄVim निर्मित कमांड के बजाय V डुप्लिकेट लाइन का उपयोग करें (यह पैराग्राफ के अंत में एक रिक्त रेखा जोड़ देगा)
  • 3äG-> 3ä}पूरे बफर के बजाय पैराग्राफ को डुप्लिकेट करें (पिछले परिवर्तन से उत्पन्न रिक्त लाइन से बचने के लिए)

मूल पोस्ट

5á\5á/05ä$Y4P5x$p4Ä3äG

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

इस तरह से विघटित:

5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
— statox
स्रोत
V का उपयोग करके किसी और को देखना अच्छा है! हाल तक तक, यह केवल मैं ही हूं। यदि आप कभी भी इसके साथ मदद की ज़रूरत है, मुझ में पिंग करने के लिए स्वतंत्र महसूस उन्नीसवीं बाइट
— DJMcMayhem
@DrMcMoylex हाँ अपनी भाषा :-) मैं इस पर एक समस्या थी उपयोग करने के लिए मजेदार लगता है: शुरू में मैं उपयोग करना चाहता था 5á\5á/05ä$5Ä5x$p4Ä3äGयानी की जगह Y4Pसे 4Ä, लेकिन एक कारण यह है कि मैं इसे एक अतिरिक्त प्रतियां रिक्त पंक्ति समझ में नहीं आता ... आप कर सकते हैं, तो के लिए मुझे इस पर प्रकाश डालिए यह अच्छा होगा। इसके अलावा, अगर मुझे कुछ खाली समय मिले तो मैं ख़ुशी से भाषा में योगदान
— दूंगा
आह, हाँ जिसने मुझे कई बार परेशान किया है। यह एक ज्ञात मुद्दा है। समस्या यह है कि Äएक पर्यायवाची है dd, नहीं Y। यह आमतौर पर एक मुद्दा नहीं है, लेकिन यह कुछ समस्याओं का कारण बनता है यदि बफर में केवल एक लाइन है या यदि आप अंतिम पंक्ति पर हैं।
— DJMcMayhem
वास्तव में, मैं सिर्फ एहसास हुआ, कि दृष्टिकोण अभी भी अगर आप की जगह काम करेगा 3äGसाथ 3ä}के बाद से यह है कि पिछले न्यू लाइन झटका नहीं होंगे। v.tryitonline.net/...
— DJMcMayhem
ठीक है, मुझे लगता है कि मुझे लगता है कि यह अब काम क्यों नहीं किया। और 1 बाइट जीतने का अच्छा तरीका, धन्यवाद!
— स्टेटोक्स
4

जेली , 17 16 बाइट्स

⁾/\ẋ6Wẋ4;U$ẋ3x5Y

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

-1 बाइट के लिए 6710 (मील) का धन्यवाद।

— आउटगोल्फर को एरिक करें
स्रोत
1
मुझे लगता है कि आप एक बाइट बचा सकते हैं⁾/\ẋ6Wẋ4;U$ẋ3x5Y
— मील
@ मीलों धन्यवाद, ऐसा लगता है कि मैं प्रभावी रूप से अभी तक त्वरित उपयोग नहीं कर सकता :) और मुझे पता था कि मुझे दो Yएस की आवश्यकता नहीं थी !
— आउटगोल्फर
4

दरअसल , 21 बाइट्स

"/\"5*SR6*;4α@R4α+3αi

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

-1 अदनान से बाइट

व्याख्या:

"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
— मेगो
स्रोत
क्या आप "/\"5*Sस्लेश की स्ट्रिंग बनाने के लिए कुछ कर सकते हैं ?
— अदनान
@ अदनान महान विचार!
— मेगो
4

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

निम्न स्ट्रिंग बनाता है (70 वर्ण, आवश्यकता से अधिक सेट) तो नमूना पात्रों 0..59और 5..64इसके बीच से वैकल्पिक ।

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

कोड और आउटपुट

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}

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

दिलचस्प गलती (एक 5 के बजाय एक 7)

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}

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

एपीएल, 30 बाइट्स

A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A

मैं एपीएल के लिए काफी नया हूं, (मैं एपीएलएक्स का उपयोग कर रहा हूं, लेकिन यह एपीएल के अधिकांश कार्यान्वयन पर काम करना चाहिए), इसलिए यह काफी सरल समाधान है।

व्याख्या:

A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation 
                          of A and the reverse of A (⊖A)
— रेन
स्रोत
4

सी, 66 61 बाइट्स

5 बाइट्स ने ऑरलपी को धन्यवाद दिया।

चरित्र मुद्रण द्वारा सीधा चरित्र। प्रति पंक्ति 61 वर्ण, अंतिम नई पंक्ति (ASCII 10) है और अन्य /47 और \92 के बीच वैकल्पिक हैं ।

i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);‌​}

//call like this
main(){f();}
— स्तर नदी सेंट
स्रोत
61 बाइट्स i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}:।
— 16
@orlp धन्यवाद, मुझे पता था कि इसके साथ एक बेहतर तरीका होना चाहिए, i--लेकिन मुझे इसके लिए देखने का समय नहीं मिला।
— स्तर नदी सेंट
3

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

a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)

पायथन 3 के लिए, यह (65 बाइट्स) करें:

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— आउटगोल्फर को एरिक करें
स्रोत
1
यह मेरी जैली जवाब के रूप में एक ही विधि का उपयोग करता है ।
— निकोलफर
मेरा शुरू करने के लिए अधिक कुशल विधि
— ElPedro
@ElPedro मूल रूप से, मैंने अभी कुछ स्ट्रिंग / सरणी हेरफेर किया है। चाल यह है कि मैंने एक बड़ी स्ट्रिंग तैयार की है: /////\\\\\/////...चार बार, नई
— कहानियों
3

सेल्फ-मॉडिफ़ाइंग ब्रेनफक , 91 बाइट्स

>>+++[<++++[<++++++[<.....<.....>>-]<<<.>>>>-]++++[<++++++[<<.....>.....>-]<<<.>>>>-]>-]
\/

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

मेरे ब्रेनफैक जवाब के रूप में भी , लेकिन रनटाइम पर उत्पन्न करने के बजाय स्रोत कोड के 3 अंतिम वर्णों का उपयोग करता है।

— आउटगोल्फर को एरिक करें
स्रोत
3

जे, ३१ २ 28 १ ९ बाइट्स

4#_60]`|.\5#72$'/\'

प्रयोग

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— मील की दूरी पर
स्रोत
3

ऑक्टेव, 50 48 बाइट्स

अनाम फ़ंक्शन:

@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)

आप यहाँ ऑनलाइन कोशिश कर सकते हैं । बस ऊपर दिए गए कमांड को रन करें और फिर फ़ंक्शन को रन करें ans()।

मूलतः यह 47 का मान बनाता है जो 4 उच्च और 5 चौड़ा है। यह फिर मूल्य का एक दूसरा सरणी बनाता है 92 जो समान आकार है।

दो सरणियों को एक बिसात में समाहित किया जाता है [A B;B A]। ''साथ ही चरित्र तार करने के लिए रूपांतरण के लिए मजबूर करने concatenated है।

अंत में पूरे सरणी को 3 बार नीचे और 6 बार अंतिम आकार बनाने के लिए दोहराया जाता है।

  • 2 बाइट्स सहेजे गए, धन्यवाद @StewieGriffin
— टॉम बढ़ई
स्रोत
किसी अनाम फ़ंक्शन की आवश्यकता नहीं है; 3 बाइट बचाओ।
— तस्सो पाप्पिल्लियानो
@TasosPapastylianou वहाँ है, अन्यथा यह ans=तकिया से पहले मुद्रित होगा । फ़ंक्शन में इसे रखने से यह चारों ओर हो जाता है क्योंकि यह प्रदर्शित करने के बजाय एक चर के उत्तर को वापस करने की उम्मीद है।
— टॉम कारपेंटर
वह सिर्फ शब्दार्थ है। मेरा मतलब है, यदि आप पांडित्यपूर्ण होने जा रहे हैं, तो मैं इसके बजाय दिखाई देने वाली 3-लाइन चेतावनी संदेशों के बारे में अधिक चिंता करूँगा: p इसके अलावा सामान्य नियम बताता है कि इसे प्रत्यक्ष टर्मिनल कमांड से आउटपुट या कॉल करने योग्य होना चाहिए। समारोह संभाल। मतलब आपको अपने अनाम फ़ंक्शन को एक हैंडल पर असाइन करना चाहिए (या प्रिंग करने के लिए खाते में अन्य 5 बाइट्स जोड़ना ans())। जो व्यर्थ है, क्योंकि ans() अभी भीans जब प्रिंट चलता है!
— तस्सो पाप्पिल्लियानो
@TasosPapastylianou ans()एक कॉल करने योग्य फ़ंक्शन हैंडल है, इसलिए आपको इसे किसी चीज़ के साथ असाइन करने की आवश्यकता नहीं है, जैसे a=@..., क्योंकि यह ansएक हैंडल के रूप में निहित है। ans=जब तक आप इसे तब तक नहीं छापते हैं जब तक कि आप विशेष रूप से इसे लौटाए गए मूल्य के साथ कुछ नहीं करने और नहीं जोड़ने से पूछते हैं ;। यदि आपने किया है disp(ans())तो यह केवल सटीक आउटपुट (नहीं ans=) प्रिंट करेगा । लेकिन हां, चेतावनी कष्टप्रद है, हालांकि ऐसा पहले नहीं हुआ था, इसलिए यह भाषा विशिष्ट नहीं है, बल्कि विशिष्ट व्याख्या करने वाला है।
— टॉम कारपेंटर
ठीक है, हम असहमत होंगे। जिस तरह से मैं इसे देखता हूं, यदि आप disp(ans())अपना आउटपुट प्राप्त करने से पहले भरोसा कर रहे हैं , तो आपको अपने उत्तर में 12 बाइट्स जोड़ने की आवश्यकता है। मेरा अपना मत यह है कि यह ठीक उसी तरह है जैसे कि सप्तक अपना परिणाम प्रस्तुत करता है और यह ठीक है।
— टासोस पापेनिलियनौ
3

PHP, 73 69 बाइट्स

for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];

डेमो

http://ideone.com/z7N1Md

— chocochaos
स्रोत
1
69 बाइट्स: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];( \nएक वास्तविक न्यूलाइन के साथ बदलें )। echoएक फ़ंक्शन नहीं है, इसलिए, इसे कोष्ठक की आवश्यकता नहीं है। इसके अलावा, echoकई मान प्राप्त कर सकते हैं, एक अल्पविराम द्वारा अलग किए गए। यह वास्तव में उन कोष्ठकों की आवश्यकता को हटा देता है। और फिर, आपके अंदर $s[...], बाहरी-सबसे अधिक गणना को कोष्ठक की आवश्यकता नहीं है, क्योंकि यह निहित है []। उपयोग करने $s[($i/5+($i/240|0))%2]का समान प्रभाव होता है और यह छोटा होता है।
— इस्माइल मिगुएल
धन्यवाद, अद्यतन! मैं भी कई मापदंडों ^ _ ^ स्वीकार करने के बारे में नहीं जानता था
— 21
echoऔर printकई मापदंडों को स्वीकार करते हैं। लेकिन printलूप की वृद्धि, स्थिति या असाइनमेंट पर उपयोग किए जाने पर कई मापदंडों के साथ कोष्ठक की आवश्यकता होती है।
— इस्माइल मिगुएल
बंद कर सकते हैं कि <1, भाव को बदलकर echo$i%60?'':' ',, नई पंक्ति के रूप में अभिव्यक्ति 3 में टर्नरी।
— 15
3

जावा 7, 120 बाइट्स

String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}

सब कुछ एक पाश में धकेल दिया। बीट्स ब्रेनफक, मिशन पूरा हुआ।

इसे ऑनलाइन देखें: https://ideone.com/pZjma3

— cliffroot
स्रोत
3

विम, 44 27 बाइट्स

EDIT लॉट ऑफ बाइट्स ने @DrMcMoylex को धन्यवाद जीता:

5i\<esc>5a/<esc>0y$5PY4P5x$pY3PyGPP

मूल उत्तर:

मुझे यकीन नहीं है कि वास्तव में इस साइट के नियम फिट बैठता है, लेकिन मुझे लगा कि यह कोशिश करना मजेदार था:

i\<esc>59.:s;\v(.{5})\1;\1/////;g<CR>Y4P5x$pY3PyGPP

जिसे इस तरह से विघटित किया जा सकता है:

i\<esc>                       Insert a \
59.                           Repeat 59 time the insertion
:s;\v(.{5})\1;\1/////;g<CR>   Match 5 characters followed by the same 5 characters
                              And replace them by these 5 characters followed by 5 /
Y4P                           Copy the line and repeat it 4 times
5x$p                          On the current line delete 5 characters and put them 
                              at the end of the line
Y3P                           Copy the line and repeat it 3 times
yG                            Copy all the lines
PP                            Repeat them 2 times
— statox
स्रोत
ओह हे स्टेटॉक्स, साइट पर आपका स्वागत है! यह पूरी तरह से नियमों में फिट बैठता है। मैं ज्यादातर विम में गोल्फ करता हूं। बस इतना पता है, आप 5i/<esc>5a\<esc>0y$5P9 बाइट्स को बचाने के लिए शुरुआत में कर सकते हैं ।
— DJMcMayhem
हे DrMcMoylex (नया नाम? :-)) आपको यहां देखकर खुशी हुई और मेरा जवाब फिट बैठता है। आपके संकेत के लिए भी धन्यवाद, मैं अपना उत्तर संपादित करूंगा
— स्टेटोक्स
2
हाहा, हाँ, मैंने इस चुनौती के कारण अस्थायी रूप से अपना नाम बदल दिया है । मैं 30 दिनों में इसे वापस बदल देंगे
— DJMcMayhem
3

ब्रेनफक, 168 बाइट्स

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