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 বাইট

[:;<@|.`</.

~~ইচ্ছু । খুব বড়.~~

ইনপুট হিসাবে একটি ম্যাট্রিক্স লাগে।

ব্যাখ্যা

জে এখানে একটি সুবিধা আছে। ওলিক ( /.) নামে একটি কমান্ড রয়েছে যা তির্যক রেখাগুলিকে ঘুরিয়ে নেয় এবং তাদের জন্য একটি ক্রিয়া প্রয়োগ করে। এক্ষেত্রে আমি দুটি ক্রিয়া পর্যায়ক্রমে প্রয়োগ করতে একটি অভ্যাস ব্যবহার করছি: <( বাক্স ) এবং <@|.( বিপরীত এবং বাক্স)। তারপরে এটি ;( রাজে ) ব্যবহার করে সমস্ত কিছু আনবক্সিং করার বিষয় ।

— গ্যারেথ
সূত্র

26

জে হ'ল একমাত্র ভাষা যা অনুভব করে যে এটিকে বোঝার জন্য আমার ইংরেজিতে একটি উচ্চতর ডিগ্রি প্রয়োজন।

— অ্যালেক্স এ।

2

@AlexA। বিটিডব্লিউ, "কমান্ড" শব্দটির "ক্রিয়াকলাপ" হওয়া উচিত ছিল।

— অ্যাডম

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মূলত প্রতিটি অন্যান্য subarray বিপরীত। এটি _W=!Tপ্রতিটি সুবারে ম্যাপিংয়ের মাধ্যমে এটি করে ; Wশর্তসাপেক্ষ অ্যাপ্লিকেশন, সুতরাং এটি সত্য _যেখানে সমস্ত subarrays (বিপরীত) =!T। Tদশ (সত্যবাদী), এবং এর =!Tঅর্থ একটি পরিবর্তনশীল পূর্বনির্ধারিত (T = !T)। সুতরাং এটি এমন একটি ভেরিয়েবলের মান টগল করে যা সত্যবাদী হয়ে শুরু করে এবং নতুন মানটি ফেরত দেয়, যার অর্থ এটি মিথ্যা, সত্যবাদী, মিথ্যাবাদী, সত্যবাদী ... (এই ধারণাটির জন্য জাকুবের কাছে জমা) ফেরানোর মধ্যে বিকল্প হবে

টেস্ট স্যুট এখানে ।

— ডোরকনব
সূত্র

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

এমএটিএল , 28 27 বাইট

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

আমার উত্তর থেকে এখানে অভিযোজিত । সাধারণ ধারণাটি হ'ল জিগ-জাগ পাথের মতো একই ক্রমবর্ধমান মানগুলির সাথে ইনপুট হিসাবে একই আকারের 2D অ্যারে তৈরি করা to তারপরে সেই অ্যারের লিনিয়ারাইজড (সমতল) সংস্করণটি সাজানো হয় এবং সেই বাছাইয়ের সূচকগুলি রাখা হয়। জিগ-জাগ পথ তৈরি করতে সেগুলি সূচকগুলি ইনপুটটিতে প্রয়োগ করা প্রয়োজন।

ইনপুট ফর্ম হয়

[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গাণিতিকভাবে নীচে সমীকরণ হিসাবে বর্ণনা করা হয়েছে। সমীকরণের সাথে, একটি জিগজিগাইফাইফায়েলি ক্রমবর্ধমান ম্যাট্রিক্স নীচের মতো দেখানো যেতে পারে।

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

Cজিগজিগাইফাইড ফলাফলগুলিতে এম এর উপাদানগুলির ক্রম নির্দেশ করে। তারপর, [~,I]=sort(C(:));অর্ডার ফেরৎ, অর্থাত্, I, এইভাবে, V=V(I)'ফল।

— গুয়্যাং কিন
সূত্র

হ্যাঁ, আমি এটি সন্ধান করেছি, এখন আমি এটি আপডেট করছি update

— গুয়িয়াং কিন

@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-এ পরীক্ষা করা হয়েছে input 2D অ্যারে হিসাবে ইনপুট নেয়।

— 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]

পোর্টিং nimi এর উত্তর । প্রদত্ত প্রস্থ এবং উচ্চতা সহ একটি সমতল অ্যারে নেয়। এক্সসট একটি বাইট সংরক্ষণ করে।

৮৮ বাইট:

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)))]

প্রদত্ত প্রস্থ এবং উচ্চতা সহ একটি সমতল অ্যারে নেয়। (i/w,i%w)সারি প্লাস কলামটি বিজোড় বা এমনকি পৃথক কিনা তার উপর ভিত্তি করে, ক্রমের মান বাড়ানো বা হ্রাস করে টাইব্রোকন পেতে ক্রমবর্ধমান অঙ্কের জিগজ্যাগ ক্রমের সাথে সম্পর্কিত 2 ডি স্থানাঙ্কগুলি সাজায় ।

— 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কলাম) এর এক্স এবং 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। আমি ওয়াই-রেঞ্জের জন্য একটি পরিবর্তনকারী ফাংশন বাছাই করে এটি করি [0..x]যা এর xতমতম উপাদান [reverse,id,reverse,id,...]।

সম্পাদনা করুন: @ এক্সনোর লুপগুলি পুনরায় সাজিয়েছেন এবং 5 বাইট সংরক্ষণ করেছেন। ধন্যবাদ!

— nimi
সূত্র

আমি মনে করি আপনি করতে পারেন g=id:reverse:g।

— xnor

Multication উপর ডান বন্ধনী (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। পাইথনে অনুবাদ করা আমার যা ছিল তার চেয়ে তিনটি অক্ষর সাশ্রয় করে।

— 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 বাইট

আমার হিসাবে একই প্রিন্সিপি উপর ভিত্তি করে উত্তর এর Deusovi চ্যালেঞ্জ

আমি ধরে নিই ইনপুট ম্যাট্রিসে আমাদের শূন্য থাকতে পারে না

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]]

— Erwan
সূত্র

পরিবর্তে হওয়া reverse even lineউচিত reverse odd lines?

— nwp

@nwp সূচক 0 at এ শুরু হয়

— এরওয়ান

আহ, আপনি লাইন সংখ্যা সম্পর্কে কথা বলছেন, লাইনের দৈর্ঘ্য নয় not আমি তাদের গুলিয়ে ফেলেছি, দুঃখিত।

— nwp

@nwp এনপি, বিটিডব্লিউ আমি বিভ্রান্তি এড়ানোর জন্য এটি পরিবর্তন করেছি

— এরওয়ান

ম্যাট্রিক্সকে জিগজিগাইফাই করুন

বিধি

পরীক্ষার মামলা

সম্পর্কিত চ্যালেঞ্জ

জে, 31 30 14 12 11 বাইট

পাইথ, 24 23 21 20 19 18 17 বাইট

জেলি, 24 19 15 13 11 বাইট

কিভাবে এটা কাজ করে

এমএটিএল , 28 27 বাইট

ব্যাখ্যা

মতলব, 134 বাইট

জাভাস্ক্রিপ্ট (স্পাইডারমনকি 30+), 99 বাইট

পাইথন 2, 84 বাইট

হাস্কেল, 79 78 73 বাইট

পাইথন 2 + নুমপি, 122 বাইট

ব্যাখ্যা:

পাইথন 3, 131 118 115 107 বাইট

ব্যাখ্যা

ফলাফল