স্নেকের মতো স্লাইড

21

বুদ্ধিটা

আমরা এর আগে ম্যাট্রিক্স সর্পিল এবং সম্পূর্ণ ঘূর্ণন এবং এমনকি তির্যক ঘূর্ণনও করেছি , তবে যতটা খুজে পাচ্ছি না, সাপের আবর্তন !

সাপের আবর্তন কী?

ম্যাট্রিক্সের সারিগুলি পিছনে পিছনে ছিটকে পড়ার কল্পনা করুন, দীর্ঘ কাতারের বিভাজনের মতো তাদের মাঝে বিভাজকগুলি নিয়ে:

    +--------------+
      1  2  3  4  5|
    +------------  |
    |10  9  8  7  6|
    |  +-----------+
    |11 12 13 14 15|
    +------------  |
     20 19 18 17 16|
    +--------------+

এখন এই আইটেমগুলিকে ২ দ্বারা আবর্তিত করার কল্পনা করুন প্রতিটি আইটেম অগ্রসর হয়, যেমন একটি লাইনে চলা লোকেরা এবং শেষে আইটেমগুলি ছড়িয়ে পড়ে এবং শুরুতে ফিরে আসে:

    +--------------+
-->  19 20  1  2  3|
    +------------  |
    | 8  7  6  5  4|
    |  +-----------+
    | 9 10 11 12 13|
    +------------  |
<--  18 17 16 15 14|
    +--------------+

যদি সারিগুলির একটি বিজোড় সংখ্যা থাকে তবে এটি ডান থেকে প্রস্থান করবে, তবে এখনও শুরুতে মোড়ানো হবে। উদাহরণস্বরূপ, এখানে একটি 3 আবর্তন রয়েছে:

    +--------------+
      1  2  3  4  5|
    +------------  |
    |10  9  8  7  6|
    |  +-----------+
    |11 12 13 14 15
    +--------------+


    +--------------+
-->  13 14 15  1  2|
    +------------  |
    | 7  6  5  4  3|
    |  +-----------+
    | 8  9 10 11 12  -->
    +--------------+

একটি নেতিবাচক ঘূর্ণন আপনাকে পিছনের দিকে নিয়ে যাবে। এখানে একটি -2 ঘূর্ণন:

    +--------------+
<--   3  4  5  6  7|
    +------------  |
    |12 11 10  9  8|
    |  +-----------+
    |13 14 15  1  2  <--
    +--------------+

চ্যালেঞ্জ

আপনার ফাংশন বা প্রোগ্রামটি কোনও সুবিধাজনক বিন্যাসে 2 ইনপুট গ্রহণ করবে:

  • একটি ম্যাট্রিক্স
  • একটি পূর্ণসংখ্যা (ধনাত্মক বা negativeণাত্মক) এটি নির্দেশ করে যে এটি কত স্থানে ঘোরাতে হবে।

এটি ফিরে আসবে:

  • ঘোরানো ম্যাট্রিক্স

নোট:

  • কোড গল্ফ। সবচেয়ে কম বাইট জেতা
  • ম্যাট্রিক্সগুলির বর্গক্ষেত্র হওয়া উচিত নয়, তবে এতে কমপক্ষে 2 টি সারি এবং 2 টি কলাম থাকবে
  • ধনাত্মক পূর্ণসংখ্যার সারি 1 টি ডান দিকে ঘোরানো হবে
  • Gণাত্মক পূর্ণসংখ্যার সারি 1 বাম দিকে ঘোরানো হবে
  • সুবিধাজনক হলে আপনি ইতিবাচক / নেতিবাচক ঘূর্ণন সংখ্যার অর্থটি বিপরীত করতে পারেন
  • আবর্তনের সংখ্যা আইটেমের সংখ্যার চেয়ে বড় হতে পারে। সেক্ষেত্রে এটি মোড়ানো হবে। এটি হ'ল আইটেমের সংখ্যার সাথে মডুলোর সমান হবে।
  • ম্যাট্রিক্সে কেবলমাত্র পূর্ণসংখ্যা থাকবে তবে এতে পুনরাবৃত্তি সহ যে কোনও পূর্ণসংখ্যা থাকতে পারে

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

বিন্যাস:

  • জরায়ু
  • ঘূর্ণন নম্বর
  • প্রত্যাশিত প্রত্যাবর্তনের মান
4 5
6 7

1

6 4
7 5

2  3  4  5
6  7  8  9
10 11 12 13

-3

5  9  8  7
12 11 10 6
13 2  3  4 

8 8 7 7
5 5 6 6

10

5 5 8 8
6 6 7 7
code-golf  array-manipulation  matrix 
— দুর্ভাগ্যআনয়নকারী
সূত্র
4
বিপরীত অর্থ +/- ঠিক আছে। আমি মনে করি প্রবেশদ্বারটি যদিও বাম দিকের শীর্ষে থাকবে।
— যোনা
7
পাইথনে অবশ্যই এর উত্তর দরকার needs
— 640 কেবি

উত্তর:

7

জেলি , 10 বাইট

UÐeẎṙṁ⁸UÐe

একটি ডায়াডিক লিঙ্কটি বামদিকে মেরিক্স এবং ডানে ঘূর্ণন পূর্ণসংখ্যা গ্রহণ করে (ইতিবাচক / নেতিবাচক বিপরীত অর্থ ব্যবহার করে)

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

UÐeẎṙṁ⁸UÐe - Link: matrix of integers, M; integer, R
 Ðe        - apply to even indices of M:
U          -   reverse each
   Ẏ       - tighten
    ṙ      - rotate left by R
     ṁ     - mould like:
      ⁸    -   chain's left argument, M
        Ðe - apply to even indices:
       U   -   reverse each
— জোনাথন অ্যালান
সূত্র
6

আর , 121 110 101 বাইট

function(m,n,o=t(m)){o[,j]=o[i<-nrow(o):1,j<-c(F,T)];o[(seq(o)+n-1)%%sum(1|o)+1]=o;o[,j]=o[i,j];t(o)}

এটি অনলাইন চেষ্টা করুন!

walkthrough

function(m,n) {           # Input: m - matrix, n - shift
  o <- t(m)               # Transpose the matrix, since R works in column-major order
                          # while our snake goes in row-major order
  i <- nrow(o):1          # Take row indices in reverse
  j <- c(F,T)             # Take even column indices (FALSE, TRUE, FALSE, TRUE, ...)
  o[,j] <- o[i,j]         # "Normalize" the matrix by reversing every second column
  o[(seq(o)+n-1) %%       # Perform the shift: add n-1 to indices,
    length(o)+1] <- o     # Modulo sequence length, and +1 again
  o[,j] <- o[i,j]         # Reverse even columns again to return to snake form
  t(o)                    # Transpose the matrix back to orginal shape and return
}
— কিরিল এল।
সূত্র
3

পাইথন ৩.৮ (প্রাক-রিলিজ এসএসএস) , ১১৯ বাইট

lambda m,r,n=-1:[[m[(k:=(j+(s:=r+i)//w)%h)][::n**k][s%w]for i in range(w:=len(m[0]))][::n**j]for j in range(h:=len(m))]

একটি নামহীন ফাংশন গ্রহণযোগ্য matrix, rotationযা নতুন ম্যাট্রিক্স দেয়।
বিপরীত ঘূর্ণন চিহ্ন ব্যবহার করে।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

আমরা n=-1পরবর্তী বন্ধনীগুলিতে সংরক্ষণের জন্য সামনে সেট করেছিলাম এবং ম্যাট্রিক্স হিসাবে mএবং ঘূর্ণনটি গ্রহণ করি r।

একটি নতুন ম্যাট্রিক্স হিসাবে একই মাত্রা দিয়ে নির্মিত হয় m- প্রস্থে w( w:=len(m[0])) এবং উচ্চতা h( h:=len(m))।

এই ম্যাট্রিক্সের অন্যান্য প্রতিটি সারি বিপরীত ( [::n**j]) রয়েছে।

আসল mউপাদান সারি i, এবং কলামটি ব্যবহার করে মূলটিতে তাদের সারি এবং কলামটি গণনা করে মানগুলি সন্ধান করা হবে j...

আমরা সেট sকরতে r+iএবং kকরতে (j+s//w)%h। kআমাদের বর্তমান উপাদানটির অ্যাক্সেসের জন্য আসলের সারি।

ডান দিক থেকে বিজোড় সূচকযুক্ত সারিগুলি সহজে অ্যাক্সেস করার জন্য আমরা এই জাতীয় সারিগুলিকে তাদের উপাদানগুলির সাথে (তার আগে) অ্যাক্সেস করার আগে বিপরীত করি [:n**k], এর অর্থ আগ্রহের উপাদানটি রয়েছে s%w।

— জোনাথন অ্যালান
সূত্র
3

জে , 41 30 21 বাইট

-11 বাইট জোনাকে ধন্যবাদ!

-9 বাইট ফ্রাউনফ্রোগ এবং এনএনজি-কে ধন্যবাদ!

$@]t@$(|.,@t=.|.@]/\)

এটি অনলাইন চেষ্টা করুন!

বিপরীত +/-

— গ্যালেন ইভানভ
সূত্র
1
30 বাইট, +/- বিপরীত নয়, তবে এখনও সহায়ক ব্যবহার করে: $@]t@$(|.,@(t=.#\,`(|.@,)/.]))( অনলাইনে এটি চেষ্টা করুন! )
— জোনাহ
সংশোধন: +/- এখনও বিপরীত।
— যোনা
@ জোনাঃ এখন জে! আমি মনে করি আপনি সম্প্রতি বিকল্প বিপরীতে একই কৌশল প্রয়োগ করতে দেখেছেন, তবে দৃশ্যত এটি সম্পর্কে ভুলে গেছেন। ধন্যবাদ! চেষ্টা করার সময় &.আমি সমস্ত সময় বাম যুক্তিটি হারিয়েছিলাম, সে কারণেই আমি হাল ছেড়ে দিয়েছি।
— গ্যালেন ইভানভ
1
21 বাইট , THX @ngn
— ফ্রাউনফ্রোগ
@ ফ্রভনিফ্রোগ বাহ, এখন এটি প্রাথমিক আকারের অর্ধেক। আমি বোকা বোধ করছি ... ধন্যবাদ!
— গ্যালেন ইভানভ 13
2

জাভাস্ক্রিপ্ট (নোড.জেএস) , ১০২ বাইট

হিসাবে ইনপুট লাগে (matrix)(integer)। পূর্ণসংখ্যার চিহ্নের অর্থ উল্টো হয়।

m=>n=>(g=m=>m.map(r=>r.sort(_=>~m,m=~m)))(m.map(r=>r.map(_=>a[(l+n++%l)%l]),l=(a=g(m).flat()).length))

এটি অনলাইন চেষ্টা করুন!

সহায়ক ফাংশন

ছ

g = m =>        // m[] = input matrix
  m.map(r =>    // for each row r[] in m[]:
    r.sort(_ => //   sort r[]:
      ~m,       //     using either 0 (don't reverse) or -1 (reverse)
      m = ~m    //     and toggling m before each iteration
                //     (on the 1st iteration: m[] is coerced to 0, so it yields -1)
    )           //   end of sort()
  )             // end of map()

প্রধান ফাংশন

m => n =>                    // m[] = matrix, n = integer
  g(                         // invoke g on the final result
    m.map(r =>               //   for each row r[] in m[]:
      r.map(_ =>             //     for each entry in r[]:
        a[(l + n++ % l) % l] //       get the rotated value from a[]; increment n
      ),                     //     end of inner map()
      l = (                  //     l is the length of a[]:
        a = g(m).flat()      //       a[] is the flatten result of g(m)
      ).length               //       (e.g. [[1,2],[3,4]] -> [[1,2],[4,3]] -> [1,2,4,3])
    )                        //   end of outer map()
  )                          // end of call to g
— Arnauld
সূত্র
1

কাঠকয়লা , 36 বাইট

ＦＥθ⎇﹪κ²⮌ιιＦι⊞υκＩＥ⪪Ｅυ§υ⁻κηＬ§θ⁰⎇﹪κ²⮌ιι

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা:

Ｅθ⎇﹪κ²⮌ιι

ইনপুটটির বিকল্প সারিগুলি বিপরীত করুন।

Ｆ...Ｆι⊞υκ

অ্যারে সমতল করুন।

Ｅυ§υ⁻κη

সমতল অ্যারেটি ঘোরান।

⪪...Ｌ§θ⁰

অ্যারেটিকে আবার সারিগুলিতে বিভক্ত করুন।

Ｅ...⎇﹪κ²⮌ιι

বিকল্প সারি বিপরীত।

Ｉ...

প্রতিটি এন্ট্রি স্ট্রিং এবং আউটপুট রূপান্তর করুন ডিফল্ট আউটপুট বিন্যাসে যা সারি ডাবল-স্পেস সহ প্রতি লাইনে এক নম্বর। (একটি বিভাজকের সাথে ফর্ম্যাট করতে পৃথককারীটির দৈর্ঘ্য পড়তে হবে))

— নিল
সূত্র
1

জাপট , 28 বাইট

mÏ%2©XÔªX
c éV òUÎl
W©UªßV1V

চেষ্টা করে দেখুন

Arnauld এর উত্তর বন্দর । সবচেয়ে বড় চ্যালেঞ্জ ছিল একটি পুনরায় ব্যবহারযোগ্য ফাংশন তৈরি করা। বিশেষত, প্রতিটি অন্যান্য সারি বিপরীত করতে একটি সহায়ক ফাংশন রয়েছে। আমি যে পদ্ধতিটি গ্রহণ করছি তা হ'ল পুনরাবৃত্তি কল করা এবং কোনও ভেরিয়েবল সেট করা আছে কি না তার উপর নির্ভর করে।

ট্রান্সপ্লাইলড জেএস:

// U: first input argument (matrix)
// m: map it through a function
U = U.m(function(X, Y, Z) {
  // if the row index is even, don't alter it
  // if the row index is odd, reverse it (w)
  return Y % 2 && X.w() || X
});
V = U
  // flatten the matrix
  .c()
  // shift by the amount specified in second argument
  .é(V)
  // partition back to matrix
  .ò(
    // the number of columns should be the same as input
    U.g().l()
  );
// if W is specified, return the result from the first line
W && U ||
  // otherwise, make a recursive call with the shifted matrix
  rp(V, 1, V)
— Dana
সূত্র
1

পাইথন 3 , 94 বাইট

lambda m,n:g(roll(g(m),n))
g=lambda b:[b[i][::(-1)**i]for i in r_[:len(b)]]
from numpy import*

এটি অনলাইন চেষ্টা করুন!

জোনাথন অ্যালান এর উত্তর থেকে বিজোড়-সারি-বিপরীত ব্যবহার করুন ।

lambda m,n:g(roll(g(m),n))  #reverse odd rows, shift elements, then reverse odd rows again.
g=lambda b:[b[i][::(-1)**i] #reverse odd rows
    for i in r_[:len(b)]]   #r_[:x] = range(x)
from numpy import*          #roll() and r_[]
— attinat
সূত্র
1

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 141 বাইট

a=>n=>{for(dynamic l=a.Length,w=a.GetLength(1),i=l,j,b=a.Clone();i-->0;)a[(j=(i+n%l+l)%l)/w,j/w%2<1?j%w:w-j%w-1]=b[i/w,i/w%2<1?i%w:w-i%w-1];}

এটি অনলাইন চেষ্টা করুন!

-5 বাইটস মোট সোমোনে ধন্যবাদ!

বেনামে ফাংশন যা ইনপুট ম্যাট্রিক্সে একটি স্থান-স্থান পরিবর্তন করে।

একটি একক লুপ ঘরের উপর পুনরাবৃত্তি করে। নিম্নলিখিত সূত্রগুলি ব্যবহার করে আপনি উপর থেকে নীচে এবং বাম থেকে ডানদিকে স্ক্যান করতে পারেন:

  • row=i/w
  • col=i%w

কোথায় iলুপ পাল্টা এবং wকলামের সংখ্যা। একটি সাপের ধরণে স্ক্যান করার সময় এটি কিছুটা পরিবর্তিত হয়।

  • row=i/w
  • col=i%w (০ য়, ২ য়, ৪ র্থ ইত্যাদি সারিতে)
  • col=w-i%w-1 (1 ম, 3 তম, 5 ম, ইত্যাদি সারিতে)

আরেকটি বিষয় লক্ষণীয় যে %সি # তে অন্য কয়েকটি ভাষায় যেমন ইতিবাচক মান রূপান্তরিত হয় না। এটির জন্য অ্যাকাউন্টে অতিরিক্ত কয়েকটি বাইট প্রয়োজন।

// a: input matrix
// n: number of cells to rotate
a=>n=>{
  for(
    // l: total number of cells
    // w: number of columns
    // i: loop index
    // j: offset index
    // b: copy of input matrix
    dynamic
      l=a.Length,
      w=a.GetLength(1),
      i=l,j,
      b=a.Clone();
    // iterate from i down to 0
    i-->0;
  )
    // calculate the offset `j` and use
    // the above formulas to index
    // into `a` for setting a value
    a[
      (j=(i+n%l+l)%l)/w,
      j/w%2<1?j%w:w-j%w-1
    ]=
    // use the un-offset index `i` and
    // the above formulas to read a
    // value from the input matrix
    b[
      i/w,
      i/w%2<1?i%w:w-i%w-1
    ];
}
— Dana
সূত্র
আপনি ডিক্লেশনগুলি মার্জ করে 3 বাইট সংরক্ষণ করতে পারেন dynamic; মন্তব্য খুব l। এটি অনলাইন চেষ্টা করুন!
— আমার সর্বনাম
চমৎকার :) এই ঘোষণাটি লুপের মধ্যেও স্থানান্তরিত হতে পারে। আমি varগল্ফিংয়ের জন্য ব্যবহার করি যা আপনাকে ভেরিয়েবলের একটি তালিকা ঘোষণা করতে দেয় না। সম্ভবত আমি কেন এটি মিস করেছি। ভালো বল ধরা!
— দানা
y2 বাইট সংরক্ষণ করতে সম্পূর্ণ মুক্তি পান : এটি অনলাইনে চেষ্টা করুন!
— আমার সর্বনাম
@ সুমোন - ধন্যবাদ!
— দানা
টিআইও 135 1 ডি অ্যারে এবং প্রস্থ ইনপুট সহ।
— আমার সর্বনাম
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.