एक ज़िगज़ैग पैटर्न बनाएं

25

आपका काम एक पूर्णांक इनपुट में लेना है और स्लैश और बैकस्लैश का उपयोग करके एक ज़िगज़ैग पैटर्न प्रिंट करना है।

  • पूर्णांक इनपुट प्रत्येक ज़िग और ज़ैग की लंबाई, साथ ही ज़िग्स और ज़ैग्स की संख्या निर्धारित करता है
  • पैटर्न हमेशा दाएं से बाएं शुरू होता है

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

4->
   /
  /
 /
/
\
 \
  \
   \
   /
  /
 /
/
\
 \
  \
   \
2->
 /
/
\
 \
0->
1->
/
8->
       /
      /
     /
    /
   /
  /
 /
/
\
 \
  \
   \
    \
     \
      \
       \
       /
      /
     /
    /
   /
  /
 /
/
\
 \
  \
   \
    \
     \
      \
       \
       /
      /
     /
    /
   /
  /
 /
/
\
 \
  \
   \
    \
     \
      \
       \
       /
      /
     /
    /
   /
  /
 /
/
\
 \
  \
   \
    \
     \
      \
       \
code-golf  ascii-art 
— Romulus3799
स्रोत
3
क्या हम प्रत्येक पंक्ति के लिए एक सरणी / स्ट्रिंग की सूची को आउटपुट कर सकते हैं? प्रशिक्षण या प्रमुख newlines या रिक्त स्थान की अनुमति है?
— शैगी
2
जब तक पैटर्न अप्रभावित रहता है, तब तक व्हाट्सएप प्रमुख है?
— एमिग्ना

जवाबों:

10

सी (जीसीसी) , 108 102 101 98 80 76 72 बाइट्स

  • केविन क्रूज़सेन के लिए धन्यवाद, छह बाइट्स बचाए ; कोष्ठक और गोल्फ N-n-1को हटानेN+~n
  • Zलूप हालत में वृद्धि को बढ़ाकर एक बाइट को बचाया
  • का उपयोग करके तीन बाइट्स सहेजा printf("%c\n",...)के बजाय putchar(...)और,puts("")
  • सेवित अठारह (!) बाइट्स थैंक्स टू हैटसपॉइंटरकुन ; का उपयोग करते हुए printf("%*s",n,"");प्रिंट nरिक्त स्थान के बजाय एक पाश का उपयोग कर j;for(j=n;j--;)putchar(32);और संयोजन दोनों printf(...);कॉल
  • के printf("%*c",-~n,...);बजाय का उपयोग करके चार बाइट्स बचाता हैprintf("%*s%c",n,"",...);
  • Nwellnhof के लिए धन्यवाद चार बाइट्स सहेजे गए ; दो के बजाय एक लूप के अंदर सब कुछ हिलना
j;f(k){for(j=0;j<k*k;j++)printf("%*c\n",j/k%2?j%k+1:k-j%k,j/k%2?92:47);}

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

— जोनाथन फ्रेच
स्रोत
Z,n,j;f(N){for(Z=0;Z<N;Z++)for(n=N;n--;putchar(Z%2?92:47),puts(""))for(j=Z%2?N+~n:n;j--;)putchar(32);} 102 बाइट्स । छोरों के अंदर सब कुछ डालकर घुंघराले कोष्ठक को हटा दिया; और में बदल N-n-1गया N+~n।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन धन्यवाद। दोनों को अदला Z%2?...:...-बदली Z<N;Z++करके और उसके साथ प्रतिस्थापित करके एक और बाइट को बचाया Z++<N;।
— जोनाथन फ्रेच
1
आप प्रिंटफ मैजिक का उपयोग करके कई बाइट्स बचा सकते हैं जैसे मैंने अपने उत्तर में किया था । इस तरह आप रिक्त स्थान को प्रिंट करने के लिए उपयोग किए जाने वाले लूप से छुटकारा पा लेंगे। अधिक जानकारी के लिए, इस स्टैक ओवरफ्लो के उत्तर को
— प्रिंटफ के
@HatsuPointerKun धन्यवाद; यह वास्तव में सी। में रिक्त स्थान को दोहराने का एक छोटा तरीका है
— जोनाथन फ्रैच
4 बाइट्स कम i;f(N){for(i=0;i<N*N;i++)printf("%*c\n",i/N%2?i%N+1:N-i%N,i/N%2?92:47);}:। इसे ऑनलाइन आज़माएं!
— nwellnhof
10

चारकोल , 16 10 9 बाइट्स

ＦＮ«↖Ｉθ→‖Ｔ

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

— नील
स्रोत
यह काम करता है ( InputNumberगोल्फ मोड में भी टूट गया था?)
— केवल
@ ASCII- केवल नहीं, इस प्रकार दिए गए रसीले संस्करण और अनुमानित क्रिया संस्करण के अलग-अलग लिंक।
— नील
ओह> _> यह देखने के लिए नहीं देखा कि मैं कौन सा लिंक खोल रहा था
— ASCII-only
@ ASCII- केवल खैर अब केवल एक लिंक है ;-)
— नील
4

MATL , 17 बाइट्स

:"GXy@o?P47}92]*c

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

व्याख्या

:         % Implicit input, n. Push range [1 2 ... n]
"         % For each k in that range
  G       %   Push n again
  Xy      %   Identity matrix of that size
  @       %   Push k
  o?      %   If it's odd
    P     %     Flip the matrix upside down
    47    %     Push 47 (ASCII for '/')
  }       %   Else
    92    %     Push 92 (ASCII for '\')
  ]       %   End
  *       %   Multiply each entry of the matrix by that number
  c       %   Convert to char. Char 0 is shown as space
          % Implicit end. Implicit display
— लुइस मेंडो
स्रोत
4

सी # (.NET कोर) , 117 103 101 बाइट्स

a=>{for(int z=a+1,e=0;e<a*a;)System.Console.WriteLine(e++/a%2<1?"/".PadLeft(--z):@"\".PadLeft(z++));}

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

— मेरा सर्वनाम monicareinstate है
स्रोत
आप इस तरह 14 बाइट्स बचा सकते हैं: a=>{var o="";for(int z=a+1,e=0;e<a*a;)o+=(e++/a%2<1?"/".PadLeft(--z):@"\".PadLeft(z++))+"\n";return o;} 103 बाइट्स आपको उन सभी कोष्ठक की आवश्यकता नहीं है; आप गठबंधन कर सकते हैं int; और केवल +"\n"एक बार जोड़ें ।
— केविन क्रूज़सेन
अरे वाह, धन्यवाद!
— मेरा सर्वनाम
हम्म, आप एक स्ट्रिंग वापस करने के बजाय सीधे प्रिंट करके 2 और बाइट्स बचा सकते हैं: a=>{for(int z=a+1,e=0;e<a*a;)System.Console.WriteLine(e++/a%2<1?"/".PadLeft(--z):@"\".PadLeft(z++));} 101 बाइट्स
— केविन क्रूज़सेन
3

SOGL V0.12 , 13 12 9 बाइट्स

╝F{±↔}P}ø

यह कोशिश करो!

╝F{±↔}P}0 टेस्ट-केस की आवश्यकता नहीं होने पर 8 बाइट्स हो सकते हैं

स्पष्टीकरण:

       }   implicitly started loop repeated input times
╝            create a down-right diagonal of the input
 F           get the current looping index, 1-indexed
  {  }       that many times
   ±↔          reverse the diagonal horizontally
      P      print that
        ø  push an empty string - something to implicitly print if the loop wasn't executed
— dzaima
स्रोत
3

गणितज्ञ, 84४ 90 बाइट्स

(n=#;Grid@Array[If[Abs[n-(s=Mod[#-1,2n])-.5]==#2-.5,If[s<n,"‌​/","\\"],""]&,{n^2,n‌​}])&
  • Jenny_mathy को -6 बाइट्स के लिए धन्यवाद।

मुझे पता नहीं क्यों \स्पष्ट रूप से गहरा है /।

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

— कीउ गण
स्रोत
2
84 बाइट्स(n=#;Grid@Array[If[Abs[n-(s=Mod[#-1,2n])-.5]==#2-.5,If[s<n,"/","\\"],""]&,{n^2,n}])&
— J42161217
3

Jq 1.5 , 94 89 बाइट्स

["/","\\"][range($n)%2]as$s|range($n)|[(range(if$s=="/"then$n-.-1 else. end)|" "),$s]|add

व्याख्या

  ["/","\\"][range($n)%2] as $s                         # for $s= / \ / \ $n times 
| range($n)                                             # for .=0 to $n-1
| [(range(if $s=="/" then $n-.-1 else . end)|" "), $s]  # form list of spaces ending with $s
| add                                                   # concatenate

नमूना चलाना

$ jq -Mnr --argjson n 5 '["/","\\"][range($n)%2]as$s|range($n)|[(range(if$s=="/"then$n-.-1 else. end)|" "),$s]|add'
    /
   /
  /
 /
/
\
 \
  \
   \
    \
    /
   /
  /
 /
/
\
 \
  \
   \
    \
    /
   /
  /
 /
/

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

— jq170727
स्रोत
3

जावा 8, 140 134 116 बाइट्स

n->{String r="";for(int a=0,b,c;a++<n;)for(b=n;b-->0;r+=a%2>0?"/\n":"\\\n")for(c=b-n+b|-a%2;++c<b;r+=" ");return r;}

-24 बाइट्स @Nevay को धन्यवाद ।

स्पष्टीकरण:

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

n->{                // Method with integer parameter and String return-type
  String r="";      //  Result-String
  for(int a=0,b,c;  //  Index integers
      a++<n;)       //  Loop (1) from 0 to the input (exclusive)
    for(b=n;        //   Reset `b` to the input
        b-->0;      //   Inner loop (2) from the input to 0 (exclusive)
                    //     After every iteration: 
        r+=a%2>0?"/\n":"\\\n") 
                    //      Append either of the slashes + a new-line
      for(c=b-n+b|-a%2;++c<b;r+=" ");
                    //    Append the correct amount of spaces
                    //   End of inner loop (2) (implicit / single-line body)
                    //  End of loop (1) (implicit / single-line body)
  return r;         //  Return the result-String
}                   // End of method
— केविन क्रूज़सेन
स्रोत
1
अंतरतम लूप की स्थिति को c-->f*(b-n-~b)(-6 बाइट्स) के रूप में लिखा जा सकता है ।
— नेवई
1
116 बाइट्स:n->{String r="";for(int a=0,b,c;a++<n;)for(b=n;b-->0;r+=a%2>0?"/\n":"\\\n")for(c=b-n+b|-a%2;++c<b;r+=" ");return r;}
— नेवे
3

जावास्क्रिप्ट ईएस 8, 83 79 78 76 75 74 71 बाइट्स

* शैगी को ES8 धन्यवाद के साथ 1 बाइट कम किया

A=(m,i=0)=>i<m*m?`/\\`[x=i/m&1].padStart(x?i%m+1:m-i%m)+`
`+A(m,++i):""

यहाँ परीक्षण करें

— DanielIndie
स्रोत
जो भी मेरे समाधान को खारिज कर दिया, क्या आप बता सकते हैं कि क्यों? क्या मैं कुछ भूल रहा हूँ?
— डैनियलइंडी
2
मैं वह नहीं हूं जिसने नीचा दिखाया, लेकिन मैं यह मानता हूं कि ऐसा इसलिए है क्योंकि कार्यों को मान्य होने के लिए दोहराने योग्य होना चाहिए। iएक डिफ़ॉल्ट पैरामीटर बनाकर आपका आसानी से तय किया जा सकता है । बाइट की गिनती भी बंद लगती है।
— एमिग्ना
1
TIO लिंक जोड़ना हमेशा की तरह सराहा जाता है, ताकि लोग आपके समाधान का आसानी से परीक्षण कर सकें।
— ईमना
1
@Emigna ने इसे तय किया (चार वार और लिंक वार) :)
— DanielIndie
1
कुछ ईएस 8 के साथ 74 बाइट्स । इसके अलावा, JS के लिए आप TIO के बजाय केवल Stack Snippet का उपयोग कर सकते हैं।
— झबरा
2

शक्ति कोशिका , 81 बाइट्स

param($a)if($a){1..$a|%{((1..$a|%{" "*--$_+'\'}),($a..1|%{" "*--$_+'/'}))[$_%2]}}

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

ऊ, यह बदसूरत है। इतना दोहराया कोड, 0विशेष मामले के लिए खाते के लिए आवश्यक 7 बाइट्स । गोल्फ सुझाव का स्वागत करते हैं।

— AdmBorkBork
स्रोत
2

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

js<*_+RV"\/"_B*L;

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

js<*_+RV"\/"_B*L;QQQ   implicit Qs at the end
              *L;Q     list with ["", " ", "  ", ..., " "*(input-1)]
            _B         bifurcate with reverse: [["" to "   "], ["   " to ""]]
     +RV"\/"           append to each one either "\" or "/": 
                       [["\", to "   \"], ["   /" to "/"]]
    _                  reverse
   *              Q    repeat input times
  <                Q   but only take the first input many
 s                     flatten the list of lists
j                      print on each line
— Jakube
स्रोत
2

पायथन 3: 90 बाइट्स 82 बाइट्स

lambda n:"\n".join(" "*(abs(i%(n*2)-n+i//n%2)-1)+"/\\"[i//n%2]for i in range(n*n))

@Jonathan Frech को यह बताने के लिए धन्यवाद कि प्रिंट की जरूरत नहीं थी और यह गलत था

— Bassintag
स्रोत
] for-> ]for।
— जोनाथन फ्रेच
आपको print(...)किसी फ़ंक्शन की आवश्यकता नहीं है , स्ट्रिंग वापस करने वाला फ़ंक्शन मान्य होगा। इसके अलावा, मुझे लगता है कि आपका शुरुआती जिग गलत तरीका (/ के बजाय \) उन्मुख है।
— जोनाथन फ्रेच
@JonathanFrech धन्यवाद! मैंने इसे बदल दिया
— बासींटाग सेप
1
(abs(...)-1)-> ~-abs(...)।
— जोनाथन फ्रेच
2

05AB1E , 17 16 बाइट्स

F<„/\Nèú.sNƒR}»,

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

व्याख्या

F                  # for N in [0 ... input-1] do
  „/\              # push the string "/\"
     Nè            # cyclically index into this string with N
 <     ú           # prepend input-1 spaces to this string
        .s         # get suffixes
          NƒR}     # reverse the list of suffixes input+1 times
              »,   # join on newline and print

कैनवास का उपयोग करके वर्तमान सर्वश्रेष्ठ प्रयास:

F„/\Nè©53NèΛ2®ð«4Λ
— Emigna
स्रोत
2

सी ++, 92 91 बाइट्स

-1 बाइट्स केविन क्रूज़सेन की बदौलत

void m(int n){for(int i=0,j;i<n;++i)for(j=0;j<n;++j)printf("%*c\n",i%2?j+1:n-j,i%2?92:47);}

जादू की शक्ति के लिए धन्यवाद printf

— HatsuPointerKun
स्रोत
आप एक बाइट को बचाने int i=0,jके लिए फॉर-लूप में रख सकते हैं for(int i=0,j;i<n;++i)।
— केविन क्रूज़सेन
— सीलिंगकैट
2

जावा (ओपनजेडके 8) , 131 106 98 96 94 91 बाइट्स

i->{for(int j=0;j<i*i;System.out.printf("%"+(j/i%2<1?i-j%i:j%i+1)+"c\n",47+45*(j++/i%2)));}

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

— रॉबर्टो ग्राहम
स्रोत
1
आप काफी कुछ कोष्ठक हटा सकते हैं: i->{for(int j=0;j<i*i;System.out.printf("%"+(j/i%2<1?i-j%i+1:j%i+2)+"s",j++/i%2<1?"/\n":"\\\n"));}(98 बाइट्स)।
— नेवई
2

डायलॉग एपीएल , 39 36 35 34 बाइट्स

{↑((,⍵ ⍵⍴(⌽,⊢)⍳⍵)/¨' '),¨⍵/⍵⍴'/\'}

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

1 बाइट Zacharý की बदौलत बच गई

— dzaima
स्रोत
इसे डांग, मुझे एक बाइट द्वारा हराया। आप कर सकते हैं ⎕IOहो सकता है 0, और फिर हटाने ¯1+।
— ज़ाचरी
@ Zacharý मैं बस यही करने वाला था: p
— dzaima
ओह, एक और बात: के (⌽,⊢)⍳⍵बजाय(⌽⍳⍵),⍳⍵
— Zacharý
@ Zacharý हाँ, मैं अभी तक tacks, tacitness और उस चीज़ के साथ आने वाली चीज़ों को नहीं समझ पा रहा हूँ: /
— dizima
चिंता न करें, मुझे पूरी तरह से समझ में नहीं आता है कि कैसे ट्रेनें / कांटे / जो भी-वे कहते हैं, वे भी काम करते हैं।
— जच्ची
1

एक्सेल VBA, 84 83 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है

For i=1To[A1]:For j=1To[A1]:?IIf(i mod 2,Space([A1]-j)&"/",Space(j-1)&"\"):Next j,i
— टेलर स्कॉट
स्रोत
0

हास्केल , 86 85 बाइट्स

f n=take(n*n)$cycle$[(' '<$[x..n-1])++"/"|x<-[1..n]]++[(' '<$[2..x])++"\\"|x<-[1..n]]

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

लाईकोनी के लिए धन्यवाद एक बाइट बचाया

ज़िग ++ ++ ज़ग को दोहराएं, और पहली n*nलाइनें लें।

— jferard
स्रोत
cycle$ ...इसके बजाय cycle( ... )एक बाइट बचाता है।
— लकोनी
@ लायकोनी धन्यवाद!
— जफरार्ड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.