23

एक पिरामिड मैट्रिक्स एक वर्ग मैट्रिक्स है जहां सभी बिंदु केंद्र बिंदु से बढ़ते या घटते हैं, जैसे नीचे दो मैट्रिक्स:

1  1  1  1  1
1  2  2  2  1
1  2  3  2  1
1  2  2  2  1
1  1  1  1  1

या:

3  3  3  3  3
3  2  2  2  3
3  2  1  2  3
3  2  2  2  3
3  3  3  3  3

एक गैर शून्य पूर्णांक को देखते हुए n, एक पिरामिड मैट्रिक्स बनाने जहां नंबरों से चला जाता है 1के लिए nबढते क्रम में या तो (यदि n <0), या घटते क्रम (अगर n> 0) के केंद्र से। यदि nहै, तो 4 केंद्र संख्याएँ होंगी (उदाहरण देखें)।

हमेशा की तरह:

वैकल्पिक इनपुट और आउटपुट स्वरूप
- रिक्त स्थान, सीमांकक आदि की संख्या वैकल्पिक है

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

1
1

-1
1

5
1  1  1  1  1  1  1  1  1
1  2  2  2  2  2  2  2  1
1  2  3  3  3  3  3  2  1
1  2  3  4  4  4  3  2  1
1  2  3  4  5  4  3  2  1
1  2  3  4  4  4  3  2  1
1  2  3  3  3  3  3  2  1
1  2  2  2  2  2  2  2  1
1  1  1  1  1  1  1  1  1

-5
5  5  5  5  5  5  5  5  5
5  4  4  4  4  4  4  4  5
5  4  3  3  3  3  3  4  5
5  4  3  2  2  2  3  4  5
5  4  3  2  1  2  3  4  5
5  4  3  2  2  2  3  4  5
5  4  3  3  3  3  3  4  5
5  4  4  4  4  4  4  4  5
5  5  5  5  5  5  5  5  5

2
1  1  1  1
1  2  2  1
1  2  2  1
1  1  1  1

-2
2  2  2  2
2  1  1  2
2  1  1  2
2  2  2  2

-4
4  4  4  4  4  4  4  4
4  3  3  3  3  3  3  4
4  3  2  2  2  2  3  4
4  3  2  1  1  2  3  4
4  3  2  1  1  2  3  4
4  3  2  2  2  2  3  4
4  3  3  3  3  3  3  4
4  4  4  4  4  4  4  4

code-golf number matrix

— स्टीवी ग्रिफिन
स्रोत

10

सम विषम मामले से अलग मामला भी क्यों है? ऐसा कोई कारण नहीं है कि मैट्रिस सभी एक ही पैटर्न का पालन नहीं कर सकते हैं।

— ग्रेग मार्टिन

2

क्योंकि इनपुट को साइड की दीवार की लंबाई माना जाता था, इस स्थिति में विषम और यहां तक कि अंतर होता है। मैंने इसके बजाय अधिकतम मूल्य के लिए जाने का फैसला किया, लेकिन अजीब और यहां तक कि अंतर भी रखा। यह अजीब लग सकता है, और एक अच्छी व्याख्या नहीं हो सकती है, लेकिन यह स्पष्टीकरण है कि इसमें अंतर क्यों है। :-)

— स्टेवि ग्रिफिन

2

क्या हम मान सकते हैं -10 < n < 10?

— टाइटस

2

यह ठीक है अगर यह एक पूर्ण वर्ग की तरह नहीं दिखता है , जब तक कि यह एक संख्यात्मक रूप से बोल रहा है। यदि 10 के साथ पंक्तियाँ व्यापक हैं कि कुछ 10 के साथ हैं तो ठीक है ...

— Stewie Griffin

5

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

|1ŒḄfR«þ`
AÇạẋ¡CG

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

|1ŒḄfR«þ`  Helper link. Argument: k (positive integer)

|1         Take the bitwise OR with 1. This increments k if it is even.
  ŒḄ       Bounce; yield [1, 2, ..., k | 1, ..., 2, 1].
    fR     Filter range; remove elements not in [1, ..., k] from the array.
           This results in [1, 2, ..., k, ..., 2, 1] if k is odd and in
           [1, 2, ..., k, k, ..., 2, 1] if k is even.
        `  Pass the last return value as left and right argument to:
      «þ     Minimum table; take the minimum of each pair of elements in the
             generated array, returning a 2D array.


AÇạẋ¡CG      Main link. Argument: n

A            Take the absolute value of n.
 Ç           Call the helper link on the result.
     C       Complement; yield 1 - n.
    ¡        Conditional application:
   ẋ           If repeating the return value of Ç 1 - n times results in a non-
               empty array, i.e., if n < 1:
  ạ              Take the absolute differences of the generated integers and 1 - n.
      G      Grid; join columns by spaces, rows by linefeeds.

— डेनिस
स्रोत

7

EXCEL: 126 बाइट्स

=MAX(MIN(MIN(CELL("row",RC)-1,CELL("col",RC)-1),MIN(((ABS(R1C1)-1)*2+3)-CELL("row",RC),((ABS(R1C1)-1)*2+3)-CELL("col",RC))),0)

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

नोट: यह उत्तर R1C1 संकेतन का उपयोग करता है। यदि आप स्वयं यह प्रयास करने जा रहे हैं। आपको इसे एक्सेल विकल्पों में चालू करना होगा।

दिए गए सूत्र को हर सेल में मौजूद होने की जरूरत है (2,2)। अपने इच्छित पिरामिड आकार को (1,1) में रखें।

कार्रवाई में सूत्र का त्वरित स्क्रीन-कैप:

यहाँ सशर्त स्वरूपण के साथ कुछ मजेदार की एक अतिरिक्त तस्वीर है!

* वर्तमान में अपडेट होने में बहुत लंबा समय लगता है।

यह नकारात्मक मामलों या यहां तक कि मामलों को ठीक से नहीं संभालता है। साथ ही आप उस कोड को छोटा कर सकते हैं =MAX(MIN(MIN(ROW()-1,COLUMN()-1),MIN(((ABS(A1)-1)*2+3)-ROW(),((ABS(A1)-1)*2+3)-COLUMN())),0)जो 92 बाइट्स का है। यह अभी भी मामलों को संभाल नहीं करता है और सूत्र को घसीटा नहीं जा सकता क्योंकि सेल संदर्भ लॉक नहीं है।

— gtwebb

1

अधिक गोल्फिंग हालांकि वही मुद्दे। =MEDIAN(MIN(ROW()-1,COLUMN()-1),ABS(A1)*2+1-MAX(ROW(),COLUMN()),0)

— gtwebb

@gtwebb मुझे बताने के लिए धन्यवाद। मुझे तय करना होगा

-1। यह काम नहीं करता है। यह नकारात्मक इनपुट को हैंडल नहीं करता है। यह इनपुट भी नहीं संभालता है। यदि आप इस फॉर्मूले को प्रत्येक लागू सेल में डाल रहे हैं, तो आपको या तो Range126 बाइट्स की आवश्यकता है या आपको बहुत अधिक हेक की आवश्यकता है।

— AdmBorkBork

7

अजगर 2, 109 99 98

n=input()
r=range(1,abs(n)+1)
l=r+r[~n|-2::-1]
for j in l:print[abs((n<0)*~-n+min(i,j))for i in l]

सूची बनाएं

l = [1,2,3,4,5,4,3,2,1]

और इसके साथ थोड़ा खेलो।

संपादित करें: दो बाइट्स के लिए सूची + thx लिन बनाने का नया तरीका

— pacholik
स्रोत

If n is even, then there will be 4 center numbers

— रॉड

@ नहीं, नहीं होगा। ऐसा सोचने का क्या कारण है?

— पचोलीक

3

यह नियमों में से एक है

— रॉड

@ रोड ओह। अभी कुछ मिनट पहले। संपादित।

— पचोलिक

2

यह नया नहीं है, बस हाइलाइट नहीं किया गया है: c

— रॉड

6

MATL , 26 24 बाइट्स

oXyG|to-:"TTYaQ]G0<?G+q|

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (परीक्षण सूट के रूप में सेवा करने के लिए थोड़ा संशोधित कोड)।

व्याख्या

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

उदाहरण के लिए, इनपुट के लिए चरण nहैं:

प्रारंभिक सरणी:
```
1
```
फ्रेम के साथ बढ़ाएँ:
```
0 0 0
0 1 0
0 0 0
```
जोड़ें 1:
```
1 1 1
1 2 1
1 1 1
```
फ्रेम के साथ बढ़ाएँ:
```
0 0 0 0 0
0 1 1 1 0
0 1 2 1 0
0 1 1 1 0
0 0 0 0 0
```

जोड़ें 1:

यह सकारात्मक इनपुट के लिए सही आउटपुट देता है। यदि इनपुट ऋणात्मक है, तो इनपुट माइनस को जोड़कर 1और निरपेक्ष मान लेकर सरणी को संशोधित किया जाना चाहिए :

MATL ऑनलाइन पर आप ऐरे को बढ़ते हुए (मध्यवर्ती चरणों को दिखाने के लिए संशोधित कोड) देख सकते हैं ! दुभाषिया अभी भी एक बीटा है। यदि यह फिर से "रन" प्रेस नहीं करता है या पृष्ठ को फिर से लोड करता है।

टिप्पणी कोड

o        % Take input implicitly and push 0 if even or 1 if odd
Xy       % Identity matrix of that size. Gives either 1 or empty array
G|       % Absolute value of input
to-      % Subtract 1 if odd
:"       % For loop: repeat that many times
  TTYa   %   Add a frame of zeros in the two dimensions
  Q      %   Add 1 to all elements
]        % End for
G        % Push input again
0>       % is it negative?
?        % If so
  G      %   Push input again
  +      %   Add
  q      %   Subtract 1
  |      %   Absolute value
         % End if implicitly
         % Display implicitly

— लुइस मेंडो
स्रोत

मैं देख रहा हूं कि आपने एनिमेशन प्रश्न से कोड का पुन: उपयोग किया है। बहुत बढ़िया! मजेदार हिस्सा यह है कि यह कोड उस प्रश्न में भी जीत जाएगा, भले ही यह आपके अन्य संस्करण की तुलना में लंबा हो;)।

— मैजिक ऑक्टोपस उर्फ़

1

@carusocomputing हाँ, यह समान है: डुप्लिकेट, प्रदर्शन, ठहराव 1 सेकंड, स्पष्ट आउटपुट :-)

— लुइस

इसके अलावा, निश्चित रूप से क्यों नहीं, लेकिन 14 से ऊपर के किसी भी इनपुट पर 14. बंद हो जाता है। रद्द करें, यह ऑनलाइन कंसोल "ऑपरेशन टाइम आउट" की एक सीमा है।

— मैजिक ऑक्टोपस उर्फ़

@carusocomputing त्रुटि "ऑपरेशन टाइम आउट" कहती है। मुझे लगता है कि यह दुभाषिया के लिए बहुत लंबा समय लगता है। सेकंड कहने के लिए ठहराव कम करने की.2

— लुइस मेंडू सेप

@carusocomputing हाँ यह ऑनलाइन दुभाषिया पर मध्यांतर है। वर्तमान में हम नौकरियों को 30 सेकंड तक सीमित करते हैं। लुइस पता चलता है, आप विराम समय कम कर सकते हैं

— Suever

3

पायथन 2.7: 123 122 120 बाइट्स

probs अभी भी कुछ बाइट्स बचा सकता है ...

from numpy import*
n=input()
N=abs(n)
e=N*2-N%2
a=ones([e,e])
for i in range(N):a[i:e-i,i:e-i]=(i+1)*(n>0)or-n-i
print a

edit1: N=abs(n)1 बाइट बचाने के लिए

edit2: (i+1)*(n>0)or-n-i2 बाइट्स को बचाने के लिए

— हारून
स्रोत

3

हास्केल, 119 113 110 104 102 101 बाइट्स

f x|(h,t)<-splitAt(mod x 2)$[x,x-1..1]++[1.. -x]=foldl(\m n->(n#)<$>(n<$m)#m)[[y]|y<-h]t
x#y=x:y++[x]

मैट्रिक्स को पूर्णांकों की सूची की सूची के रूप में लौटाता है, उदाहरण के लिए: f 2-> [[1,1,1,1],[1,2,2,1],[1,2,2,1],[1,1,1,1]]।

यह काम किस प्रकार करता है:

            [x,x-1..1]++[1.. -x]      -- make list from x down to 1 followed by
                                      -- 1 to (-x). One of the sublists will be
                                      -- empty. The resulting list contains the
                                      -- numbers of the pyramid from inside to out.
   (h,t)<-splitAt(mod x 2)            -- bind h to the first element if x is odd
                                      -- or to the empty list if x is even
                                      -- bind t to the rest (tail or full list)

foldl (     ) [[y]|y<-h] t            -- fold the following function into t with a
                                      -- starting value of [] if x is even or
                                      -- [[h]] if x is odd

   \m n ->                            -- the current matrix m with the next number
                                      -- n is transformed into a new matrix:

               (n#)<$>(n<$m)#m        -- prepend and append a n to 
                                      -- m prepended and append by a line of n's

x#y=x:y++[x]                          -- helper function to prepend and append an
                                      -- element x to a list y

— nimi
स्रोत

2

पर्ल, 175 बाइट्स

के लिए 1 बाइट्स शामिल है -p।

($t,$v,$w)=($_,(abs)x2);$k=$_.$k for 1..$v;map{$r.=$_ for(@v=1..$_-1),$_ x(2*$v---$w%2),reverse@v;$r.=$/}1..$v;$_=$r.~~reverse$r;eval"y/1-$w/$k/"if$t<0;$w%2&&s/

.*//||s;

;

(एक नई बात यह है कि मुझे नहीं पता कि मार्कशीट के साथ कैसे दिखाना है, लेकिन आपको इसकी आवश्यकता है)।

आवश्यकताओं के -pसाथ-साथ -M5.010या -Eचलाने के लिए:

perl -pE '($t,$v,$w)=($_,(abs)x2);$k=$_.$k for 1..$v;map{$r.=$_ for(@v=1..$_-1),$_ x(2*$v---$w%2),reverse@v;$r.=$/}1..$v;$_=$r.~~reverse$r;eval"y/1-$w/$k/"if$t<0;$w%2&&s/

.*//||s;

;
' <<< 5

अरे, यह बहुत लंबा है ... जब मेरे पास कुछ समय होता है तो मैं कुछ अन्य तरीकों की कोशिश करूँगा।

— बापू
स्रोत

आप क्यों इस्तेमाल करते हैं eval?

— टाइटस

@ टाइटस y///इंटरपोलेट नहीं करता है, इसलिए इंटरप्रेट करने के लिए डबल कोट्स का उपयोग करें $wऔर $kफिर evalनिष्पादित करें y///।

— दादा

2

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

n=input()
a=abs(n)
s=a*2-a%2
r=range(s)
for y in r:print[(min,max)[n<0](x+1,s-x,y+1,s-y)-(n<0)*s/2for x in r]

— लिन
स्रोत

2

जे, 29 26 बाइट्स

1+**[:<./~**i.,2&|1&}.i.@-

प्रयोग

   f =: 1+**[:<./~**i.,2&|1&}.i.@-
   f 1
1
   f _1
1
   f 2
1 1 1 1
1 2 2 1
1 2 2 1
1 1 1 1
   f _2
2 2 2 2
2 1 1 2
2 1 1 2
2 2 2 2
   f 3
1 1 1 1 1
1 2 2 2 1
1 2 3 2 1
1 2 2 2 1
1 1 1 1 1
   f _3
3 3 3 3 3
3 2 2 2 3
3 2 1 2 3
3 2 2 2 3
3 3 3 3 3

व्याख्या

श्रेणी i.क्रिया [0, 1, ..., n-1]सकारात्मक nऔर [n-1, n-2, ..., 0]नकारात्मक के लिए आउटपुट nकरती है जो यहां उपयोगी है।

1+**[:<./~**i.,2&|1&}.i.@-  Input: integer n
                         -  Negate n
                      i.@   Creates range for -n
               2&|          Take n modulo 2, returns 0 or 1
                  1&}.      If n is odd, drop the first value from the range for -n
                            Else do nothing and pass it unmodified
              ,             Append it to
            i.              The range for n
          *                 Get the sign of n
           *                Multiply elementwise with the joined ranges
    [:<./~                  Form a table of the minimum values of the range
  *                         Get the sign of n
   *                        Multiply elementwise with the joined ranges
1+                          Add 1 to each and return

— मील की दूरी पर
स्रोत

2

गणितज्ञ, 78 बाइट्स

Abs[Fold[ArrayPad[#,1,#2]&,Table[0,#,#]&@Mod[#,2,1],Range[Abs@#-1]]+1~Min~-#]&

व्याख्या

Table[0,#,#]&@Mod[#,2,1]

प्रारंभिक मैट्रिक्स बनाएं: 1x1 यदि विषम हो, तो 2x2 भी यदि।

Range[Abs@#-1]

1 से एब्स (इनपुट) की सूची बनाएं - 1।

Fold[ArrayPad[#,1,#2]&, ..., ...]

पूर्वोक्त सूची का उपयोग करके प्रारंभिक सरणी को पैड करें।

... +1~Min~-#

1 या -पुट जोड़ें, जो भी छोटा हो।

Abs

संपूर्ण मैट्रिक्स पर पूर्ण मान लागू करें।

— जंगहवान मिन
स्रोत

1

PHP, 177 157 बाइट्स

for($y=-$n=abs($z=$argv[1])+1;++$y<$n;)if($y&&($n&1||$y-1)){for($x=-$n;++$x<$n;)if($x&&($n&1||$x-1)){$v=max(abs($x),abs($y));echo$z<0?$v:$n-$v," ";}echo"
";}

साथ दौड़ो php -r '<code>

पंक्तियों और स्तंभों के माध्यम से लूप, केंद्र तक उनकी दूरी के आधार पर मूल्यों को प्रिंट करता है।

$n=abs($z)+1: के +1एक जोड़े को बचाता है +1और-1 बाद के भावों में
छोरों से जाना -$n+1(पूर्व वेतन वृद्धि हालत में!) $n-1( -abs($z)में abs($z))
लाइन / कॉलम 0 (और विषम के लिए $n: 1) छोड़ दिया जाता है
( $n&1यहां कॉलम के लिए भी सही है +1? याद रखें ?)
सकारात्मक $ z के लिए मुद्रण से भी लाभ होता है +1।

— टाइटस
स्रोत

1

हास्केल, 191 183 173 169 168 बाइट्स

r=reverse;m=map
x!y=(((++)<*>(x.r)).).zipWith(++).m y
g n|n<0=m(m$abs.((n-1)+)).g$abs n|1<2=[id!id,tail!init]!!mod n 2=<<m r$r$m(\x->(x<$[1..x])++[x+1..n])[1..n]
g.(0-)

उपयोग:

mapM_ print $ (g.(0-)) 3

[1,1,1,1,1]
[1,2,2,2,1]
[1,2,3,2,1]
[1,2,2,2,1]
[1,1,1,1,1]

2 10 20 24 बाइट्स के लिए निम्मी को धन्यवाद !

— BlackCap
स्रोत

1

negateहै (0-)

— nimi

1

आप बदल सकते हैं fकरने के लिए [id!id,tail!init]!!mod n 2और फिर इनलाइन इसे में gऔर प्रयोग 1<2शाखा का एक मध्यवर्ती परिणाम बाध्य करने के लिए गार्ड: g n| ... |q<-r<$>a n=([id!id,tail!init]!!mod n 2)q$a n। आपको मुख्य फ़ंक्शन के लिए नाम की आवश्यकता नहीं है।

— निकमी

1

ओह, आप इनलाइन aभी कर सकते हैं (और 1<2गार्ड पर वापस जाएँ ) g n| ... |1<2=[id!id,tail!init]!!mod n 2=<<map r$r$(\x->(x<$[1..x])++[x+1..n])<$>[1..n]:।

— nimi

1

आज के लिए पिछले एक: m=map, में !: ...(++).m yऔर g: g n|n<0=m(m(abs.((n-1)+)))$g$abs n|1<2=[id!id,tail!init]!!mod n 2=<<m r$r$m(\x->(x<$[1..x])++[x+1..n])[1..n]।

— nimi

1

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

(n,l=Math.abs(n+n-n%2))=>[...Array(l--)].map((_,i,a)=>a.map((_,j)=>(j=Math.min(i,l-i,j,l-j),n<0?-n-j:j+1)))

lसरणी का आकार है। n<0?-n-j:j+1अजीब लगता है, लेकिन मैं कुछ भी बेहतर नहीं मिल रहा।

— नील
स्रोत

1

विम, 152 143 बाइट्स

मुझे यकीन है कि यह और अधिक गढ़ा जा सकता है, खासकर उन आखिरी दो पंक्तियों को, लेकिन मेरा मस्तिष्क तला हुआ है।

D:let@z=@-/abs(@-)
a"nywYp:s/\d/x/g<C-v>
YggP:%s/.*/x \0 x<C-v>
:%s/x\+/\=@n-@z/g<C-v>
<Esc>v0"qda<C-r>=@z<0?1:@-*@z
<Esc>@=@-%2?"":"YPJYp"
@=@-*@z-1.(@-*@z>1?"@q":"")

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

यहाँ यह xxd प्रारूप में अनपेक्षित वर्णों के साथ है:

0000000: 443a 6c65 7440 7a3d 402d 2f61 6273 2840  D:let@z=@-/abs(@
0000010: 2d29 0a61 226e 7977 5970 3a73 2f5c 642f  -).a"nywYp:s/\d/
0000020: 782f 6716 0a59 6767 503a 2573 2f2e 2a2f  x/g..YggP:%s/.*/
0000030: 7820 5c30 2078 160a 3a25 732f 785c 2b2f  x \0 x..:%s/x\+/
0000040: 5c3d 406e 2d40 7a2f 6716 0a1b 7630 2271  \=@n-@z/g...v0"q
0000050: 6461 123d 407a 3c30 3f31 3a40 2d2a 407a  da.=@z<0?1:@-*@z
0000060: 0a1b 403d 402d 2532 3f22 223a 2259 504a  ..@=@-%2?"":"YPJ
0000070: 5970 220a 403d 402d 2a40 7a2d 312e 2840  Yp".@=@-*@z-1.(@
0000080: 2d2a 407a 3e31 3f22 4071 223a 2222 29    -*@z>1?"@q":"")

व्याख्या

यह केंद्र से बाहर पिरामिड बनाता है, xतों के साथ केंद्र संख्या के आसपास :

x x x
x 5 x
x x x

फिर यह xअगले नंबर के साथ es की जगह लेता है और फिर से es के साथ इसे घेरता है x:

x x x x x
x 4 4 4 x
x 4 5 4 x
x 4 4 4 x
x x x x x

...और इसी तरह। यहां तक कि संख्याओं के लिए भी यह वही काम करता है लेकिन 2x2 बेस के साथ शुरू होता है।

यहाँ कोड "ungolfed है।" यह कुछ हद तक अपरंपरागत है कि मैं इसे एक बफर (इसलिए सभी <C-v>एस) में टाइप करके एक मैक्रो रिकॉर्ड करता हूं और फिर इसे एक रजिस्टर में हटा देता हूं, जो कि वास्तव में कीस्ट्रोक्स को निष्पादित किए बिना मैक्रो की रचना करने का सबसे अच्छा तरीका है।

D:let@z=@-/abs(@-)<CR>       " Delete the input (into @-) and set @z to -1 if @- is negative; otherwise 1
a                            " Enter insert mode to compose the macro
  "nyw                         " Copy the number under the cursor to @n
  Yp                           " Copy this line and paste it below
  :s/\d/x/g<C-v><CR>           " Replace digits in the copy with 'x'
  YggP                         " Copy this line and paste it at the top of the buffer
  :%s/.*/x \0 x<C-v><CR>       " Add an 'x' before and after each line
  :%s/x\+/\=@n-@z/g<C-v><CR>   " Replace all 'x'es (and 'xx'es etc.) with the next number
<Esc>v0"qd                   " Done composing macro; delete it into @q (buffer is now empty)
a<C-r>=@z<0?1:@-*@z          " Append the center number (1 or abs(@-)) to the buffer
<Esc>@=@-%2?"":"YPJYp"       " If the input is even, make a 2x2 square
@=@-*@z-1.(@-*@z>1?"@q":"")  " Execute the macro abs(@-)-1 times if it's > 1

— जॉर्डन
स्रोत

0

PHP, 215 बाइट्स

for($i=0;$i<$m=($r=($s=abs($n=$argv[1]))*2-$s%2)**2;){$i%$r?:print"\n";$l=min(($x=$i%$r+1)<$s?$x:$x=$r-$x+1,($z=1+floor($i++/$r))<$s?$z:$z=$r-$z+1);$o=($n>0)?$l:$s+1-$l;echo str_pad(" ",1+strlen($s)-strlen($o)).$o;}

— जार्ग हुल्सरमैन
स्रोत

0

आर, 112 बाइट्स

k=abs(n);l=2*k;m=diag(l);for(i in 1:k){m[i:(l+1-i),i:(l+1-i)]=i};if(n%%2==1){m=m[-k,-k]};if(n<0){m=abs(m-1+n)};m

nकार्यक्षेत्र में पूर्णांक की आवश्यकता है , अन्यथा n=scan()अतिरिक्त 8 बाइट्स के लिए चलाएं ।

k=abs(n)
l=2*k
m=diag(l)                    # Initialize quadratic 2*|n| matrix
for(i in 1:k){
    m[i:(l+1-i),i:(l+1-i)]=i # Assign values to matrix elements according
                             # to their index
}
if(n%%2==1){
   m=m[-k,-k]                # If n is odd, delete middle row and column
}
if(n<0){
    m=abs(m-1+n)             # If n < 0, flip values
}
m                            # Print matrix

— सिर की टक्कर
स्रोत

एक पिरामिड मैट्रिक्स बनाएँ

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

यह काम किस प्रकार करता है

EXCEL: 126 बाइट्स

अजगर 2, 109 99 98

MATL , 26 24 बाइट्स

व्याख्या

टिप्पणी कोड

पायथन 2.7: 123 122 120 बाइट्स

हास्केल, 119 113 110 104 102 101 बाइट्स

पर्ल, 175 बाइट्स

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

जे, 29 26 बाइट्स

प्रयोग

व्याख्या

गणितज्ञ, 78 बाइट्स

व्याख्या

PHP, 177 157 बाइट्स

हास्केल, 191 183 173 169 168 बाइट्स

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

विम, 152 143 बाइट्स

व्याख्या

PHP, 215 बाइट्स

आर, 112 बाइट्स