43

इसके संपीड़न एल्गोरिदम के हिस्से के रूप में, जेपीईजी मानक एक वेक्टर को वेक्टर में बारी-बारी से दिशा के एंटीडिओगोनल के साथ नियंत्रित करता है:

आपका कार्य एक मैट्रिक्स लेना है (जरूरी नहीं कि वर्ग) और इसे अनियंत्रित रूप में वापस करना है। उदहारण के लिए:

[1 2 3 4
 5 6 7 8
 9 1 2 3]

उपज चाहिए

[1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]

नियम

आप मान सकते हैं कि मैट्रिक्स तत्व सकारात्मक पूर्णांक से कम हैं 10।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।

इनपुट मैट्रिक्स किसी भी सुविधाजनक, अस्पष्ट, नेस्टेड सूची या स्ट्रिंग प्रारूप में या दोनों मैट्रिक्स आयामों के साथ एक फ्लैट सूची के रूप में दिया जा सकता है। (या, निश्चित रूप से, एक मैट्रिक्स प्रकार के रूप में यदि आपकी भाषा उन है।)

आउटपुट वेक्टर किसी भी सुविधाजनक, अस्पष्ट, फ्लैट सूची या स्ट्रिंग प्रारूप में हो सकता है।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

[[1]]                                               => [1]
[[1 2] [3 1]]                                       => [1 2 3 1]
[[1 2 3 1]]                                         => [1 2 3 1]
[[1 2 3] [5 6 4] [9 7 8] [1 2 3]]                   => [1 2 5 9 6 3 4 7 1 2 8 3]
[[1 2 3 4] [5 6 7 8] [9 1 2 3]]                     => [1 2 5 9 6 3 4 7 1 2 8 3]
[[1 2 6 3 1 2] [5 9 4 7 8 3]]                       => [1 2 5 9 6 3 4 7 1 2 8 3]
[[1 2 5 9 6 3 4 7 1 2 8 3]]                         => [1 2 5 9 6 3 4 7 1 2 8 3]
[[1] [2] [5] [9] [6] [3] [4] [7] [1] [2] [8] [3]]   => [1 2 5 9 6 3 4 7 1 2 8 3]

जे, 31 30 14 12 11 बाइट्स

[:;<@|.`</.

~~यच । बहुत बड़ा।~~

इनपुट के रूप में एक मैट्रिक्स लेता है।

व्याख्या

J का यहाँ एक फायदा है। एक आदेश है जिसे तिरछा ( /.) कहा जाता है जो तिरछी रेखाओं को बदले में लेता है और उन पर एक क्रिया लागू करता है। इस मामले में, मैं दो क्रियाओं को वैकल्पिक रूप से लागू करने के लिए एक gerund का उपयोग कर रहा हूं: <( बॉक्स ) और <@|.( रिवर्स और बॉक्स)। तो फिर यह सब कुछ का उपयोग ;( raze ) unboxing की बात है ।

— गैरेथ
स्रोत

26

J एकमात्र ऐसी भाषा है जो मुझे ऐसा महसूस कराती है कि इसे समझने के लिए मुझे अंग्रेजी में एक उन्नत डिग्री की आवश्यकता है।

— एलेक्स ए।

2

@AlexA। btw, "कमांड" शब्द "क्रिया विशेषण" होना चाहिए था।

— अड्म

11

पायथ, 24 23 21 20 19 18 17 बाइट्स

ssm_W=!Td.T+LaYkQ

वैकल्पिक 17-बाइट संस्करण: ssuL_G=!T.T+LaYkQ

                Q  input
           +L      prepend to each subarray...
             aYk   (Y += ''). Y is initialized to [], so this prepends [''] to
                     the first subarray, ['', ''] to the second, etc.
                   ['' 1  2  3  4
                    '' '' 5  6  7  8
                    '' '' '' 9  1  2  3]
         .T        transpose, giving us
                   ['' '' ''
                    1  '' ''
                    2  5  ''
                    3  6  9
                    4  7  1
                    8  2
                    3]
  m_W=!Td          black magic
 s                 join subarrays together
s                  join *everything* on empty string (which means ''s used for
                     padding disappear)

के लिए धन्यवाद @FryAmTheEggman एक बाइट के लिए, @Jakube 2 बाइट्स के लिए, और @isaacg एक बाइट के लिए!

"काला जादू" की व्याख्या ऊपर की ओर संकेत करती है: m_W=!Tdअनिवार्य रूप से हर दूसरे अवगुण को उलट देता है। यह _W=!Tप्रत्येक सबर्रे पर मैप करके ऐसा करता है ; Wसशर्त अनुप्रयोग है, इसलिए यह सत्य है, _जहां सभी उपकथाएं (उलट) करती हैं =!T। Tदस (सत्य), और =!Tसाधन के लिए एक चर है (T = !T)। तो यह एक चर के मान को टॉगल करता है जो सत्य की शुरुआत करता है और नए मूल्य को लौटाता है, जिसका अर्थ है कि यह बदले में झूठे, सत्य, झूठे, सत्य के बीच वैकल्पिक होगा ... (इस विचार के लिए जेक्यूब का श्रेय)

यहां टेस्ट सूट ।

— Doorknob
स्रोत

11

जेली, 24 19 15 13 11 बाइट्स

pS€żị"¥pỤị⁵

अलग-अलग कमांड-लाइन तर्कों के रूप में पंक्तियों की संख्या, स्तंभों की संख्या और एक फ्लैट सूची लेती है।

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

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

pS€żị"¥pỤị⁵  Main link. Argument: m (rows), n (columns), A (list, flat)

p            Compute the Cartesian product [1, ..., m] × [1, ..., n]. This yields
             the indices of the matrix M, i.e., [[1, 1], [1, 2], ..., [m, n]].
 S€          Compute the sums of all index pairs.
       p     Yield the Cartesian product.
      ¥      Dyadic chain. Arguments: Sums, Cartesian product.
    ị"       For each index pair in the Cartesian product, retrieve the coordinate
             at the index of its sum, i.e., map [i, j] to i if i + j is odd and to
             j if i + j is even.
   ż         Zip the sums with the retrieved indices.
       Ụ     Sort [1, ..., mn] by the corresponding item in the resulting list.
        ị⁵   Retrieve the corresponding items from A.

— डेनिस
स्रोत

Tsk। मुझे यकीन नहीं है कि अगर मैं अब किसी को भी छोटा कर सकता हूं। : -एस

— गारेथ

यह कहना नहीं है कि मैं हालांकि कोशिश नहीं करूँगा ...

— गैरेथ

जेली को ओब्लिक विरासत में क्यों नहीं मिला है? क्या मैं एपीएल ग्लिफ़ का सुझाव दे सकता हूं ⍁और ⍂? या शायद स्कैंडिनेवियाई øऔर ǿ?

— आदम

7

MATL , 28 27 बाइट्स

tZyZ}:w:!+-1y^7MGn/*-X:K#S)

यहाँ मेरे उत्तर से अनुकूलित । सामान्य विचार इनपुट के समान आकार का 2 डी सरणी बनाना है, जो मानों से भरा है जो उसी क्रम में zig-zag पथ के रूप में बढ़ता है। फिर उस सरणी के रैखिक (चपटा) संस्करण को सॉर्ट किया जाता है, और उस सॉर्टिंग के सूचक को रखा जाता है। वे सूचकांक हैं जिन्हें ज़िग-ज़ैग पथ का उत्पादन करने के लिए इनपुट पर लागू करने की आवश्यकता है।

इनपुट फॉर्म में है

[1 2 3; 5 6 4; 9 7 8; 1 2 3]

व्याख्या

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

t       % input 2D array. Duplicate
ZyZ}    % get size as length-2 vector. Split into two numbers: r, c
:       % range [1,2,...,c] as a row vector
w:!     % swap, range [1;2;...;r] as a column vector
+       % add with broadcast. Gives a 2D array
-1      % push -1
y^      % duplicate previous 2D array. Compute -1 raised to that
7M      % push [1;2;...;r] again
Gn/     % divide by input matrix size, that is, r*c
*       % multiply
-       % subtract
X:      % linearize 2D array into column array
K#S     % sort and push the indices of the sorting. Gives a column vector
)       % index input matrix with that column vector

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

4

मतलाब, 134 बाइट्स

मैंने बस माटलैब में अपने कोड को छोटा करने की पूरी कोशिश की, जैसे इसे टेलीग्राफ करना।

function V=z(M)
[m,n]=size(M);
a=(1:m)'*ones(1,n);
b=ones(m,1)*(1:n);
A=a+b-1;
B=a-b;
C=(A.^2+(-1).^A.*B+1);
[~,I]=sort(C(:));
V=M(:);
V=V(I)';

टिप्पणियाँ:

Mएक m×nमैट्रिक्स है।
aऔर bदोनों समान आकार के होते हैं M, प्रत्येक पंक्ति में aइसकी पंक्ति संख्या के बराबर संख्याएँ होती हैं, जबकि प्रत्येक स्तंभ bअपने स्तंभ संख्या के बराबर होता है। इस प्रकार, a+ bएक मैट्रिक्स है जिसका तत्व इसकी पंक्ति और स्तंभ संख्या के योग के बराबर है, अर्थात matrix(p,q)=p+q।
इस प्रकार A(p,q)=p+q-1; और B(p,q)=p-q।
Cनीचे गणितीय रूप से समीकरण के रूप में कहा गया है। समीकरण के साथ, एक zigzagifiedly बढ़ मैट्रिक्स नीचे दिखाए गए की तरह बनाया जा सकता है।

C =
     1     2     6     7
     3     5     8    14
     4     9    13    18
    10    12    19    25

CZigzagified परिणामों में M के तत्वों के क्रम को इंगित करता है। फिर, [~,I]=sort(C(:));आदेश लौटाता है, अर्थात I, इस प्रकार, V=V(I)'परिणाम है।

— गौयांग किन
स्रोत

हां, मैंने इसे अभी पाया है, अब मैं इसे अपडेट करता हूं।

— गुओयांग किन

@AlexA। धन्यवाद, एलेक्स। क्योंकि मैं इसके लिए नया हूं और मैं इसे छोटा करना चाहता हूं लेकिन इसे छोटा बनाना है। अब मैंने अपना कोड अभी तय कर लिया है।

— गुओयांग किन

अछा लगता है। अच्छी पहली पोस्ट! :)

— एलेक्स ए।

3

जावास्क्रिप्ट (स्पाइडरमैन 30+), 99 बाइट्स

x=>[for(y of[...x,...x[0]].keys())for(z of Array(y+1).keys())if(a=x[y%2?z:y-z])if(b=a[y%2?y-z:z])b]

फ़ायरफ़ॉक्स 44 में परीक्षण किया गया। इनपुट को 2 डी सरणी के रूप में लिया गया।

— ETHproductions
स्रोत

3

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

lambda N,w,h:[N[i*w+s-i]for s in range(w+h+1)for i in range(h)[::s%2*2-1]if-1<s-i<w]

पोर्टिंग निम्मी का उत्तर । दी गई चौड़ाई और ऊंचाई के साथ एक फ्लैट सरणी लेता है। xsot ने एक बाइट को बचाया।

88 बाइट्स:

lambda M,w,h:[M[i]for i in sorted(range(w*h),key=lambda i:(i/w+i%w,-i*(-1)**(i/w+i%w)))]

दी गई चौड़ाई और ऊंचाई के साथ एक फ्लैट सरणी लेता है। इसी 2 डी का निर्देशन (i/w,i%w)करता है कि विकर्ण प्राप्त करने के लिए बढ़ती हुई राशि के आरेख के क्रम में, पंक्ति मान स्तंभ या विषम है या नहीं, इसके आधार पर पंक्ति मान बढ़ाकर या घटाकर टाईब्रेक किया जाता है।

— XNOR
स्रोत

कि अगर हालत को और छोटा किया जा सके।

— xsot

@xsot अच्छा कैच।

— xnor

3

हास्केल, 79 78 73 बाइट्स

(m#h)w=[m!!(y*w+x-y)|x<-[0..h+w],y<-g!!x$[0..x],y<h,x-y<w]
g=reverse:id:g

इनपुट पंक्तियों और स्तंभों की संख्या के साथ एक फ्लैट सूची है, जैसे ( [1,2,6,3,1,2,5,9,4,7,8,3] # 2) 6-> [1,2,5,9,6,3,4,7,1,2,8,3]।

यह कैसे काम करता है: दो नेस्टेड छोरों में मैट्रिक्स ( hपंक्तियों, wकॉलम) के x और y निर्देशांक के माध्यम से चलना :

  | 0 1 2 3 4 5 6 7 8    outer loop               Index is y*w+x-y, i.e.
--+------------------    x from 0 to h+w          the elements are accessed
0 | 1 2 6 3 1 2                                   in the following order:
1 | 5 9 4 7 8 3
2 |                                               1 2 4 6  8 10 
3 |                                               3 5 7 9 11 12
4 |
5 |
6 |
7 | inner loop:
8 | y from 0 to x

ऊपर से / नीचे करने के लिए सही यानी / छोड़ दिया, बाध्य सूचकांक से बाहर लंघन ( yऔर xपूरा करना चाहिए y<hऔर x-y<w)। जब xभी होता है, तो आंतरिक लूप का क्रम उलट yजाता है: से जाता xहै 0। मैं y- श्रेणी के लिए एक संशोधित कार्य चुनकर करता हूं [0..x]जो कि xवें तत्व है [reverse,id,reverse,id,...]।

संपादित करें: @xnor ने लूप को फिर से व्यवस्थित किया और 5 बाइट्स को बचाया। धन्यवाद!

— nimi
स्रोत

मुझे लगता है कि आप कर सकते हैं g=id:reverse:g।

— xnor

(y-x)*wसमस्या का समाधान करके बहुसंकेतन के परगनों को काटा जा सकता है (m#h)w=[m!!(x*w+y-x)|y<-[0..h+w],x<-g!!y$[0..y],x<h,y-x<w] g=reverse:id:g:। पायथन में अनुवाद करने से मेरे पास जो कुछ था, उस पर 3 चार्ट बचते हैं।

— xnor

1

पायथन 2 + न्यूमपी, 122 बाइट्स

मैं इसे स्वीकार करता हूं। मैंने आगे काम किया। दुर्भाग्य से, इस समान विधि को अन्य 2 संबंधित चुनौतियों को हल करने के लिए आसानी से संशोधित नहीं किया जा सकता है ...

import numpy
def f(m):w=len(m);print sum([list(m[::-1,:].diagonal(i)[::(i+w+1)%2*-2+1])for i in range(-w,w+len(m[0]))],[])

इनपुट के रूप में एक संख्यात्मक सरणी लेता है। एक सूची को आउटपुट करता है।

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

स्पष्टीकरण:

def f(m):
    w=len(m)    # the height of the matrix, (at one point I thought it was the width)
    # get the anti-diagonals of the matrix. Reverse them if odd by mapping odd to -1
    d=[list(m[::-1,:].diagonal(i)[::(i+w+1)%2*-2+1])for i in range(-w,w+len(m[0]))]
            # w+len(m[0]) accounts for the width of the matrix. Works if it's too large.
    print sum(d,[]) # join the lists

एक लंबोदर एक ही लंबाई है:

import numpy
lambda m:sum([list(m[::-1,:].diagonal(i)[::(i+len(m)+1)%2*-2+1])for i in range(-len(m),len(m)+len(m[0]))],[])

— mbomb007
स्रोत

1

पायथन 3, 131 118 115 107 बाइट्स

देउसोवी की चुनौती के मेरे जवाब के आधार पर उसी प्रिंसिपल के आधार पर

मुझे लगता है कि इनपुट मैट्रेस में हम शून्य नहीं हो सकते

e=enumerate
lambda s:[k for j,i in e(zip(*[([0]*n+i+[0]*len(s))for n,i in e(s)]))for k in i[::j%2*2-1]if k]

व्याख्या

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

            pad with 0      transpose    remove 0    reverse line           concatenate 
                                                     with even index
1 2 3       1 2 3 0 0        1 0 0        1            1                
4 5 6   --> 0 4 5 6 0    --> 2 4 0    --> 2 4     -->  2 4              -->  1 2 4 7 5 3 6 8 9
7 8 9       0 0 7 8 9        3 5 7        3 5 7        7 5 3             
                             0 6 8        6 8          6 8               
                             0 0 9        9            9

परिणाम

>>> [print([i,f(i)]) for i in [[[1]], [[1, 2], [3, 1]], [[1, 2, 3, 1]], [[1, 2, 3], [5, 6, 4], [9, 7, 8], [1, 2, 3]], [[1, 2, 3, 4], [5, 6, 7, 8], [9, 1, 2, 3]], [[1, 2, 6, 3, 1, 2], [5, 9, 4, 7, 8, 3]], [[1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]], [[1], [2], [5], [9], [6], [3], [4], [7], [1], [2], [8], [3]]]]
# [input,                                                          output]
[[[1]],                                                            [1]]
[[[1, 2], [3, 1]],                                                 [1, 2, 3, 1]]
[[[1, 2, 3, 1]],                                                   [1, 2, 3, 1]]
[[[1, 2, 3], [5, 6, 4], [9, 7, 8], [1, 2, 3]],                     [1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]]
[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 1, 2, 3]],                       [1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]]
[[[1, 2, 6, 3, 1, 2], [5, 9, 4, 7, 8, 3]],                         [1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]]
[[[1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]],                           [1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]]
[[[1], [2], [5], [9], [6], [3], [4], [7], [1], [2], [8], [3]],     [1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3]]

— एर्वान
स्रोत

इसके बजाय होना reverse even lineचाहिए reverse odd lines?

— nwp

@nwp सूचकांक 0 पर ^^ शुरू

— एर्वान

आह, आप पंक्ति संख्या के बारे में बात कर रहे हैं, रेखा की लंबाई नहीं। मैंने उन लोगों को भ्रमित किया, क्षमा करें।

— nwp

@nwp एनपी, btw मैं इसे से बचने के भ्रम की स्थिति के लिए बदल

— एर्वान

एक मैट्रिक्स Zigzagify

नियम

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

संबंधित चुनौतियां

जे, 31 30 14 12 11 बाइट्स

पायथ, 24 23 21 20 19 18 17 बाइट्स

जेली, 24 19 15 13 11 बाइट्स

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

MATL , 28 27 बाइट्स

व्याख्या

मतलाब, 134 बाइट्स

जावास्क्रिप्ट (स्पाइडरमैन 30+), 99 बाइट्स

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

हास्केल, 79 78 73 बाइट्स

पायथन 2 + न्यूमपी, 122 बाइट्स

स्पष्टीकरण:

पायथन 3, 131 118 115 107 बाइट्स

व्याख्या

परिणाम