वैकल्पिक पैटर्न

16

अब हटाए गए स्टैकओवरफ़्लो प्रश्न में, किसी ने निम्नलिखित पोस्ट किया:

एक कार्यक्रम या समारोह में बारी पैटर्न मुद्रित करने के लिए लिखें *और #एक दिया पूर्णांक के आधार पर n। कुछ उदाहरण:

इनपुट: n=1
आउटपुट:

*

इनपुट n=5
आउटपुट:

*####
###**
***##
###**
*####

इनपुट: n=8
आउटपुट:

*#######
######**
***#####
####****
****####
#####***
**######
#######*

चूंकि यह एक बहुत अच्छा कोड-गोल्फ चुनौती की तरह लग रहा था, यहाँ यह है।

ये पैटर्न कैसे बनते हैं?

पहली पंक्ति एकल के साथ शुरू होती है *, जिसके बाद n-1अनुगामी राशि होती है #।
दूसरी पंक्ति में दो होते हैं *, जिसमें n-2अग्रणी राशि होती है #।
तीसरी पंक्ति तीन से शुरू होती है *, उसके बाद n-3अनुगामी राशि होती है #।
आदि।

एक बार जब हम बीच में पहुँच गए हैं ( n/2), हम फिर से गणना करते हैं *, जिसकी मात्रा ऊपर के उदाहरणों में देखी जा सकती है।

ध्यान दें कि विषम इनपुट नंबरों के लिए लाइनों की उलटी जोड़ी (इसलिए पहली और आखिरी; दूसरी और आखिरी से आखिरी; आदि) बिल्कुल समान हैं। में n=5उदाहरण के प्रथम और अंतिम लाइनें हैं *####; दूसरी और अंतिम पंक्तियाँ हैं ###**।
यहां तक ​​कि इनपुट संख्याओं के लिए भी उलटी जोड़ी गई रेखाएं उलट जाती हैं। में n=8उदाहरण के प्रथम और अंतिम लाइनें हैं *#######और #######*; दूसरे और अंतिम लाइनों के बगल में हैं ######**और **######; आदि।

चुनौती नियम:

  • आप किसी भी दो अलग-अलग उपयोग कर सकते हैं मुद्रण योग्य बजाय वर्ण *और #। आप उपयोग कर सकते हैं Aऔर B; 3और 7; <और >; आदि कृपया अपने उत्तरों में बताएं कि आपने क्या उपयोग किया है।
  • आप मान सकते हैं nकि एक सकारात्मक पूर्णांक ( >= 1) होगा
  • आपको प्रत्येक पंक्ति या वर्णों के 2D मैट्रिक्स के लिए स्ट्रिंग की एक सूची / सरणी को आउटपुट करने की अनुमति है, बजाय उन्हें STDOUT को प्रिंट करने के।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित मापदंडों और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
  • डिफ़ॉल्ट लूपोल्स वर्जित हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ना अत्यधिक अनुशंसित है।

परीक्षण के मामले (पहले के n=1माध्यम से n=10)

*

*#
#*

*##
#**
*##

*###
##**
**##
###*

*####
###**
***##
###**
*####

*#####
####**
***###
###***
**####
#####*

*######
#####**
***####
###****
***####
#####**
*######

*#######
######**
***#####
####****
****####
#####***
**######
#######*

*########
#######**
***######
#####****
*****####
#####****
***######
#######**
*########

*#########
########**
***#######
######****
*****#####
#####*****
****######
#######***
**########
#########*
code-golf  string  ascii-art 
— केविन क्रूज़सेन
स्रोत
" आप * और # के बजाय किसी भी दो अलग-अलग वर्णों का उपयोग कर सकते हैं। " - क्या उन्हें प्रिंट करने योग्य होना चाहिए? क्या हम NUL और SOH (ASCII कोड 0 और 1) का उपयोग कर सकते हैं?
— ngn
@ क्षमा करें, केवल मुद्रण योग्य वर्ण। चुनौती विवरण में स्पष्ट करेंगे।
— केविन क्रूज़सेन

जवाबों:

14

जेली , 9 बाइट्स

>þµoṚUÐeY

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

व्याख्या

>þ           Create a table of (x>y) over [1…n]×[1…n]:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 0 0 1]
               [0 0 0 0 0]
  µ          Take this array, and...
   oṚ        OR it with its reverse:
               [0 1 1 1 1]
               [0 0 1 1 1]
               [0 0 0 1 1]
               [0 0 1 1 1]
               [0 1 1 1 1]
    UÐe      Apply U (reverse) to even-indexed rows.
       Y     Join by newlines.
— लिन
स्रोत
17

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

lambda n:["%*s"%(i%2*2*n-n,"x"*min(i+1,n-i))for i in range(n)]

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

उपयोग xऔर स्थान।

पंक्तियों की गणना इस तरह की जाती है:

"%-5s" % "x"      == "x    "
"%5s"  % "xx"     == "   xx"
"%-5s" % "xxx"    == "xxx  "
"%5s"  % "xx"     == "   xx"
"%-5s" % "x"      == "x    "

के %*sबीच चयन करने के लिए स्पेसियर का उपयोग करना nऔर -n।

— लिन
स्रोत
6

MATL, 34 31 18 बाइट्स

:t!>tPY|!"@X@oQ&P!

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

* के लिए 0 और * के लिए 1 का उपयोग करता है। लिन के जेली उत्तर के आधार पर ।

पुराने उत्तर, 31 बाइट्स:

2/tk:wXk:Ph"X@ot~XHh@Gy-hHQ&PY"

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

# के लिए 1 और * के लिए 1 का उपयोग करता है। 

         % implicit input, say 5
2/       % divide input number by 2 [2.5]
tk       % make a copy and floor that [2.5, 2]
:        % create range 1 to the floored value [2.5, [1, 2]]
wXk      % bring out the division result and this time ceil it
         %  [[1, 2], 3]
:        % create range 1 to that [[1, 2], [1, 2, 3]]
Ph       % flip the last array and concatenate horizontally 
         %  [[1, 2, 3, 2, 1]]
"        % loop through the array
  X@o    % Is the current loop index odd? 1 for odd, 0 for even
  t~     % duplicate and logical negate that
  XH     % copy that value to clipboard H
  h      % and concatenate the values ([1 0] on odd iterations, [0 1] on even) 
  @      % push current value from array (say 2, then stack is [[0 1], 2)
  G      % push input again
  y-     % subtract current array value from input [[0 1], 2, 3]
  h      % concatenate those two [[0 1], [2, 3]]
  H      % get the stored value from clipboard H (1 for even iterations, 0 for odd) 
  Q      % increment that
  &P     % flip the array in that dimension: in even iterations, this flips
         %   across columns and hence inverts the two values. [[0 1], [3, 2]]
         %   in odd iterations, it's a no-op
  Y"     % run-length decoding - repeat the element from first array the number of times
         %  specified in the second array
         % implicit loop end, implicit output
— sundar - मोनिका को बहाल करना
स्रोत
6

एपीएल (डायलॉग क्लासिक) , 18 बाइट्स

⎕a[↑⊢∘⌽\(⊂>⊢⌊⌽)⍳⎕]

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

के ABबजाय आउटपुट*#

⎕ मूल्यांकित इनपुट n

⍳⎕ सदिश 0 1 ... n-1

⊢⌊⌽मिनट ( ⌊) खुद के बीच ( ⊢) और उनके रिवर्स ( ⌽) - ट्रेनें देखें

⊂>⊢⌊⌽जहां ⍳सदिश एक पूरे के रूप में ( ⊂) इसके प्रत्येक से कम है ⊢⌊⌽- बूलियन (0/1) वैक्टर के एक सदिश को लौटाएं

⊢∘⌽\ हर दूसरे वेक्टर को उल्टा करें

↑ एक मैट्रिक्स में मिलाएं

⎕aअपरकेस अंग्रेजी वर्णमाला, 'AB...Z'

⎕a[ ]के 0 1साथ बदलें'A' 'B'

— NGN
स्रोत
जिज्ञासा से बाहर। रिक्त स्थान के बिना 0s और 1s के मैट्रिक्स का उत्पादन करने के लिए कितने बाइट्स होंगे? मैं यह सोचते कर रहा हूँ ⎕a[...}उन्हें परिवर्तित करने Aऔर Bरिक्त स्थान के बिना उन्हें रखने से भी कम है 0और 1विचार आपको लगता है कि का उपयोग किया है रिक्त स्थान के बिना, लेकिन सिर्फ उत्सुक अगर वहाँ बाइट में ज्यादा अंतर नहीं है अगर आप उन्हें के रूप में रखने 0और 1।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन जहां तक ​​मैं गोल्फ कर सकता हूं, यह एक ही लंबाई होगी - या तो ⎕d[... ]या ⊃¨⍕¨... बाद की अभिव्यक्ति ⍕¨में "प्रारूप प्रत्येक" है - यह प्रत्येक संख्या को एक नेस्टर्ड वेक्टर में बदल देता है , इसलिए हमें प्रत्येक "पहले" की आवश्यकता है "( ⊃¨) केवल चार स्केलर प्राप्त करने के लिए (और इसलिए जब मुद्रण नहीं व्हाट्सएप)।
— NGN
5

चारकोल , 21 बाइट्स

≔⮌…⁰ＮθＥθ⭆蛧⟦μλ⟧κ⌊⟦κι

इसे ऑनलाइन आज़माएं! उपयोग 0और 1। लिंक कोड के वर्बोज़ वर्जन के लिए है और इसमें §*#आउटपुट शामिल है *और #प्रश्न में। स्पष्टीकरण:

    Ｎ                   Input number
  …⁰                    Range from 0
 ⮌                      Reversed
≔    θ                  Assign to `q`
      Ｅθ                Map over reversed range
        ⭆θ              Map over reversed range and join
           §⟦μλ⟧κ       Alternate between range and reversed range column
                 ⌊⟦κι   Minimum of range and reversed range row
          ›             Greater
                        Implicitly print each row on its own line
— नील
स्रोत
5

जेली ,  12  15 बाइट्स

+3 फिक्सिंग n=1एज-केस बग :(

R«Ṛ$‘r⁸ṬUÐe0YE?

एक पूर्ण कार्यक्रम एक पूर्णांक के रूप में ओ पी का उपयोग कर के रूप में परिभाषित उत्पादन प्रिंट को स्वीकार करने 0और 1के लिए *और #क्रमशः।

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

कैसे?

R«Ṛ$‘r⁸ṬUÐe0YE? - Main Link: integer, n
R               - range -> [1,2,3,4,...,n]
   $            - last two links as a monad:
  Ṛ             -   reverse -> [n,...,4,3,2,1]
 «              -   minimum (vectorises) -> [1,2,3,4,...,4,3,2,1]
    ‘           - increment (vectorises) -> [2,3,4,5,...,5,4,3,2]
      ⁸         - chain's left argument, n
     r          - inclusive range (vectorises) -> [[2,3,...,n],[3,4,...n],[4,5,...n],[5,...n],...,[5,...n],[4,5,...n],[3,4,...n],[2,3,...,n]]
       Ṭ        - untruth (vectorises) -> [[0,1,1,...,1],[0,0,1,1,...,1],[0,0,0,1,...,1],[0,0,0,0,1,...,1],...,[0,0,0,0,1,...,1],[0,0,0,1,...,1],[0,0,1,1,...,1],[0,1,1,...,1]]
         Ðe     - apply to entries with even indices:
        U       -   upend              -> [[0,1,1,...,1],[1,1,...,1],[0,0,0,1,...,1],[1,...,1,0,0,0,0],...]
              ? - if...
             E  - ...condition: all equal? (only true when n=1, where we have [1,1])
           0    - ...then: zero
            Y   - ...else: join with newline characters
                - implicit print
— जोनाथन एलन
स्रोत
ऐसा लगता है कि यह वास्तव में मेरा एल्गोरिथ्म है, लेकिन एक अलग कार्यान्वयन जो 1s के बजाय 0s को आउटपुट करता है और इसके विपरीत।
— आउटगॉल्फ जूल
हाँ प्रभावी रूप से एक ही बात ... और मैंने अपने द्वारा किए गए सुधार को दिखाने के लिए अपनी पोस्ट को अपडेट नहीं किया था।
— जोनाथन एलन
4

जावा 10, 145 बाइट्स

n->{var r=new char[n][n];for(int j=0,k;j<n;++j)for(k=0;k<n;)r[j][k]=k++<(j<n/2?j%2<1?j+1:n+~j:j%2>0?j:n-j)?j%2<1?'*':'#':j%2>0?'*':'#';return r;}

सभी टर्नरी इसे थोड़ा गड़बड़ करते हैं, लेकिन यह ठीक काम करता है। मैंने नेस्टेड लूप और अन्य विभिन्न चीजों को समतल करने की कोशिश की, लेकिन उन्होंने केवल बाइट की गिनती में वृद्धि की। इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

n -> { // lambda taking an integer as output and returning a char[][]
    var r = new char[n][n]; // the output array; we make use of Java 10's var here (replace with char[][] for another 4 bytes to make this work in Java 8)
    for(int j = 0, k; j < n; ++j) // iterate over the lines
        for(k = 0; k < n; )       // iterate over the j'th line
            r[j][k] = // set the current character
                      k++ < // determine if we're in the first or second portion of the line:
                            (j < n/2 ? // for the first half of the output:
                                 j%2 < 1  // on even lines ...
                                 ? j + 1  // ... print the first symbol j+1 times ...
                                 : n + ~j // ... on odd lines, print it n-j-1 times.
                             : j%2 > 0 ?  // for the second half of the output, on odd lines ...
                                 j :      // ... print the first symbol j times ...
                                 n - j)   // ... on even lines, print it n-j times.
                      ? j%2 < 1 ? '*' : '#'  // for the first part of the line, use '*' on even lines, '#' otherwise
                      : j%2 > 0 ? '*' : '#'; // for the second part of the line, use '*' on odd lines, '#' otherwise
    return r; // return the completed array
}

जावा 8 11, 179 127 बाइट्स

n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}

यहां इसे ऑनलाइन आज़माएं (TIO में अभी जावा 11 नहीं है, इसलिए यह एक कस्टम विधि का उपयोग करता है जिसके परिणामस्वरूप एक ही बाइट गिनती होती है String#repeat())।

52 बाइट के लिए केविन क्रूज़सेन को धन्यवाद !

Ungolfed:

n -> { // lambda taking an int argument and returning a String
    String r = "", // the output String
           a,      // temporary String containing the '*'s
           b;      // temporary String containing the '#'s
    for(int j = 0; j < n; // loop over the lines
        b = "#".repeat( // repeat the '#' character ...
            j < n/2 ? n + ~j // ... n-j-1 times in the first half of the output ...
            : j), // ... j times in the second half
        r += (j++ % 2 < 1 ? a + b : b + a) + "\n") // assemble the j'th line and append it to the output: on even lines, the '*'s go first; on odd lines, the '#'s go first
        a = "*".repeat( // repeat the '*' character ...
              j < n/2 ? j + 1 // ... j+1 times in the first half of the output ...
              : n - j); // n-j times in the second half
    return r; // return the completed output
}
— OOBalance
स्रोत
3
यदि आप जावा 11 में बदलते हैं, तो आप इसका उपयोग करके 127 बाइट्स में गोल्फ कर सकते हैं "*".repeat(...)और "#".repeat(...)(साथ ही सीधे प्रिंटिंग और गोल्फिंग के बजाय एक स्ट्रिंग वापस करने के n-j-1लिए n+~j):n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}
— केविन क्रूज़सेन
धन्यवाद, यह बाइट्स में एक महान बचत है। मैं नेस्टेड लूप्स का उपयोग करके जावा 10 के लिए एक 145-बाइट संस्करण बनाने में कामयाब रहा हूं - जावा 11 की रिहाई के लिए इंतजार नहीं कर सकता, यह repeat()विधि गोल्फ के लिए वास्तव में अच्छा है।
— OOBalance
4

लुआ ,  148  133 बाइट्स

function(n)t,a,b={},".","#"for i=1,n do r=i<n/2+1 and i or-~n-i s=a:rep(r)..b:rep(n-r)t[i]=i%2<1 and s:reverse()or s end return t end

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

-15 बाइट्स @KevinCruijssen और @JoKing की बदौलत।

function(n)
   t = {}; a = "."; b = "#"          -- initialize variables, output is in table
                                     -- strings are needed in variables for
                                     --   the str:rep and str:reverse syntax

   for i = 1, n do                          -- build the rows of the table
      r = i<=(n+1)/2 and i or n-i+1         -- logic used to count up then down
      str = a:rep(r)..b:rep(n-r)            -- append correct number of '.'s, fill
                                            --   in the rest with '#'s
      t[i]=i%2==0 and str:reverse() or str  -- logic used to control reversing
   end
   return t                                 -- return table
end
— एज़्योर हाइट्स
स्रोत
2
मैं लूआ को अच्छी तरह से नहीं जानता, लेकिन ऐसा लगता है कि आप पाँच बाइट्स बचा सकते हैं: (n+1)/2से -~n/2; or n-i+1को or-~n-i; i%2==0को i%2<1; और reverse() orकरने के लिए reverse()or। इसके अलावा, आपके TIO संस्करण और बाइट-काउंट दोनों में एक अनुगामी अर्ध-बृहदान्त्र होता है जो आवश्यक नहीं लगता है। हालांकि पहला जवाब अच्छा लगा। मुझ से +1। और PPCG में आपका स्वागत है! :)
— केविन क्रूज़सेन
2
आपको वास्तव में किसी भी अर्ध-कॉलन की आवश्यकता नहीं है । केविन के सुझावों सहित 133 बाइट्स ।
— जो किंग
@KevinCruijssen धन्यवाद! क्या मैं पूछ सकता हूं कि -~nआपके सुझावों में क्या है? यह निश्चित रूप से काम करता है, लेकिन मुझे समझ नहीं आता कि क्यों।
— एज़्योर हाइट्स
1
@AzureHeights ज़रूर ~एक अविवेकी बिटवाइस निगेटिव ऑपरेटर है। हालांकि कोडगॉल्फिंग के लिए जो महत्वपूर्ण है, वह यह है कि ~iइसके समान मूल्य है -i-1। इसलिए हम -~iइसके बजाय i+1और के ~-iबजाय उपयोग कर सकते हैं i-1। यह दो मामलों में उपयोगी है, जिसे मैं आपके उत्तर में उपयोग कर सकता हूं: कोष्ठक से छुटकारा पाना, क्योंकि -और ~अन्य गणितीय संचालनों पर ऑपरेटर पूर्वता है, इसलिए ऐसा (n+1)/2हो सकता है -~n/2। और दूसरा उपयोगी हिस्सा कुछ मामलों में रिक्त स्थान से छुटकारा पाने के लिए है, जैसा कि मैंने किया था or-~n-i।
— केविन क्रूज़सेन
1
: यहाँ दो प्रासंगिक युक्तियां आप इसके बारे में थोड़ा अधिक पढ़ना चाहते हैं कर रहे हैं एकल उपयोग ~के लिए x+1औरx-1 और उपयोग एकल ~के लिए a-b-1औरa+b+1 । सभी सामान्य युक्तियां, साथ ही साथ भाषा विशेष युक्तियां ( इस मामले में लुआ में गोल्फ के लिए टिप्स ) के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है। :)
— केविन क्रूज़सेन
3

सी (जीसीसी) , 118 108 बाइट्स

यह जीतने वाला नहीं है, लेकिन यह एक अलग दृष्टिकोण है (या कम से कम, मुझे ऐसा लगता है!) स्ट्रिंग जोड़तोड़ करने के बजाय, मैं इस तथ्य का उपयोग करता हूं कि 10एक्स-1 ऊपर [1 ..n]={9,99,999,।।।}, जो तब उपयुक्त पैटर्न प्राप्त करने के लिए गुणा किया जा सकता है; printf()फिर सही-औचित्य के लिए शून्य-गद्दी करता है।

अफसोस की बात है, intकेवल 9 अंकों (32-बिट प्लेटफार्मों) तक करने के लिए पर्याप्त सीमा है, इसलिए आपको longबड़े पैटर्न के लिए जाने की आवश्यकता है ; एक भाषा जो मूल रूप से सांसद अंकगणित करती है वह किसी चीज़ के लिए इसका उपयोग करने में सक्षम हो सकती है।

सुझाव के लिए सीलिंग के लिए धन्यवाद।

h,j,k;p(h){h=h?10*p(--h):1;}f(i){for(j=0,h=i++;k=++j>i/2?i-j:j,j<i;printf("%0*d\n",h,~-p(k)*p(j%2*(h-k))));}

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

अवधारणा का सबूत है कि यह सांसद अंकगणित के साथ काम करता है:

सी # (मोनो सी # संकलक) , 187 165 बाइट्स

( using System.Numerics;हेडर के लिए 143 बाइट्स + 22 बाइट्स )

q=>{var r="";for(int j=0,h=q+1,k;j<q;r+=((BigInteger.Pow(10,k)-1)*BigInteger.Pow(10,j%2*(q-k))).ToString("D"+q)+"\n")k=++j>h/2?h-j:j;return r;}

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

— ErikF
स्रोत
1
अधिकतम देशी पूर्णांक पर्वतमाला (C # और BigIntegers का उपयोग करके) के बाहर संख्याओं के साथ अवधारणा का प्रमाण: इसे ऑनलाइन आज़माएं!
— एरिक
3

विम, 99 कीस्ट्रोक्स

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

इनपुट को एक बफर में ही माना जाता है। रजिस्टरों को खाली माना जाता है। संपादक को स्क्रॉल किए बिना परिणाम को लंबा करने के लिए माना जाता है (यह तकनीकी रूप से कुछ कीस्ट्रोक्स की कीमत पर बचा जा सकता है)।

"nD@ni<cr><esc>MmaGddM
<c-v>'aI*<esc>qwgvjokoI*<esc>@wq@w<esc>
:set ve=all<cr>@nlh<c-v>@nkr#
:%s/ /#/g<cr>o<esc>
2Gqqdt#$p2j0@qq@q

व्याख्या

 | Buffer state (odd and even case):
 | 5                    6

"nD              read input into register n
@ni<cr><esc>     add n newlines
MmaGddM<c-v>'a   visual block select center row(s)
I*<esc>          prepend a column of *
qw               record macro w
  gvjoko         expand selection up and down
  I*<esc>
  @w             recurse
q
@w<esc>          run macro w and exit visual block select

 | Buffer state:
 | *                    *
 | **                   **
 | ***                  ***
 | **                   ***
 | *                    **
 |                      *

:set ve=all<cr>  move anywhere!
@nlh<c-v>@nkr#   add last column of #s

 | Buffer state:
 | *   #                *    #
 | **  #                **   #
 | *** #                ***  #
 | **  #                ***  #
 | *   #                **   #
 |                      *    #

:%s/ /#/g<cr>      replace spaces with #

 | Buffer state:
 | *####                *#####
 | **###                **####
 | ***##                ***###
 | **###                ***###
 | *####                **####
 |                      *#####

o<esc>2G           prep and jump to line 2
qqdt#$p2j0@qq@q    (effectively) flip every other onward

 | Buffer state:
 | *####                *#####
 | ###**                ####**
 | ***##                ***###
 | ###**                ###***
 | *####                **####
 |                      #####*

और बेस 64 में, वास्तविक वर्णों के साथ (इनपुट इन inputऔर कीस्ट्रोक्स डालें keysऔर उपयोग करके चलाएँ vim -u NONE -s keys input)

Im5EQG5pDRtNbWFHZGRNFidhSSobcXdndmpva29JKhtAd3FAdxs6c2V0IHZlPWFsbA1AbmxoFkBua3IjOiVzLyAvIy9nDW8bMkdxcWR0IyRwMmowQHFxQHE=
— algmyr
स्रोत
2

आर , 75 बाइट्स

function(n)outer(1:n,1:n,function(x,y,a=x<y|x>n-y+1)+ifelse(x%%2,a,rev(a)))

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

  • @ लियन जवाब से प्रेरित
  • फ़ंक्शन nपैरामीटर के रूप में हो रहा है और 0/1जहां से 0मेल खाती है '*'और उसके साथ 1मेल खाती है का एक मैट्रिक्स लौटाता है'#'
— digEmAll
स्रोत
2

के (ngn / k) , 22 बाइट्स

{"*#"i|:/'i>/:i&|i:!x}

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

{ } तर्क के साथ कार्य करें x

!xसूची (0;1;...;x-1)

i: को आवंटित i

i&|iminima ( &) iऔर इसका उल्टा ( |)

i>/:दाएं पर सूची से प्रत्येक तत्व के मुकाबले अधिक ( >) से तुलना करें i(/: - (बूलियन मैट्रिक्स लौटें) (सूचियों की सूची)

i|:/'प्रत्येक ( ') j के लिए i, रिवर्स ( |:- हमें एकरूप होने के :लिए बल |देने की आवश्यकता होती है ) संबंधित तत्व j समय ( समय पर n f/ xलागू होता f nहै x)। प्रभावी रूप से, हर दूसरी पंक्ति को उल्टा करें।

"*#" स्ट्रिंग में सूचक तत्वों के रूप में मैट्रिक्स तत्वों का उपयोग करें "*#"

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