ঘূর্ণন সংমিশ্রণ

26

ইনপুট হিসাবে ধনাত্মক পূর্ণসংখ্যাযুক্ত একটি বর্গক্ষেত্রের ম্যাট্রিক্স নিন এবং ম্যাট্রিক্সের "ঘোরানো সমষ্টি" গণনা করুন।

ঘোরানো সমষ্টি:

আসল ম্যাট্রিক্সের যোগফল নিন এবং একই ম্যাট্রিক্স 90, 180 এবং 270 ডিগ্রি ঘোরানো।

ধরুন ম্যাট্রিক্সটি হ'ল:

 2    5    8
 3   12    8
 6    6   10

তাহলে ঘোরানো যোগফলটি হবে:

2    5    8     8    8   10    10    6    6     6    3    2
3   12    8  +  5   12    6  +  8   12    3  +  6   12    5  = 
6    6   10     2    3    6     8    5    2    10    8    8   

26   22   26
22   48   22
26   22   26

পরীক্ষার কেস:

ইনপুট এবং আউটপুট ড্যাশ দ্বারা পৃথক করা হয়েছে, বিভিন্ন পরীক্ষার কেসগুলি একটি নতুন লাইন দ্বারা পৃথক করা হয়েছে। আরও সুবিধাজনক বিন্যাসে পরীক্ষার কেসগুলি এখানে পাওয়া যাবে ।

1
-------------
4

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

14    6    7   14
 6   12   13   13
 6    2    3   10
 5    1   12   12
-------------
45   37   24   45
24   30   30   37
37   30   30   24
45   24   37   45    

14    2    5   10    2
18    9   12    1    9
 3    1    5   11   14
13   20    7   19   12
 2    1    9    5    6
-------------
24   29   31   41   24
41   49   31   49   29
31   31   20   31   31
29   49   31   49   41
24   41   31   29   24

প্রতিটি ভাষার জিতে বাইটের মধ্যে সংক্ষিপ্ততম কোড। ব্যাখ্যা অত্যন্ত উত্সাহিত হয়!

code-golf  math  number  array-manipulation  matrix 
— স্টিও গ্রিফিন
সূত্র

উত্তর:

9

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

আমার আগের পুনরাবৃত্ত পদ্ধতির বাইরে দুটি বাইট গল্ফ করার জন্য ডেনিসকে ধন্যবাদ ।

f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)

এটি অনলাইন চেষ্টা করুন! অথবা একটি পরীক্ষার স্যুট দেখুন।

পাইথন 2 , 80 81 83 85 বাইট (অ-পুনরাবৃত্ত)

সিঙ্গেলটন তালিকার হিসাবে ইনপুট নেয় ।

l=input()
exec"l+=zip(*l[-1][::-1]),;"*3
print[map(sum,zip(*d))for d in zip(*l)]

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

কোড কার্যকারিতা

এটি সামগ্রিকভাবে বিশ্লেষণ করার জন্য এটি বেশ দৈর্ঘ্য-ইশ, সুতরাং এটি একে একে টুকরো টুকরো পরীক্ষা করে দেখুন:

f = lambda *l:                # This defines a lambda-function that can accept any number
                              # of arguments (the matrix) using starred expressions.
l[3:] and ...X... or ...Y...  # If l[3:] is truthy (that is, the length of the list is
                              # higher than 3), return X, otherwise Y.

[map(sum,zip(*d))for d in zip(*l)]     # The first expression, X.
[                                ]     # Start a list comprehension, that:
                 for d in              # ... Iterates using a variable d on:
                          zip(*l)      # ... The "input", l, transposed.
         zip(*d)                       # ... And for each d, transpose it...
 map(sum,       )                      # ... And compute the sum of its rows.
                                       # The last two steps sum the columns of d.

f(zip(*l[0][::-1]),*l)     # The second expression, Y. This is where the magic happens.
f(                   )     # Call the function, f with the following arguments:
  zip(*          )         # ... The transpose of:
       l[0][::-1]          # ...... The first element of l (the first arg.), reversed.
                  ,        # And:
                   *l      # ... l splatted. Basically turns each element of l
                           # into a separate argument to the function.

এবং দ্বিতীয় প্রোগ্রামের জন্য:

l=input()                                # Take input and assign it to a variable l.
                                         # Note that input is taken as a singleton list.

exec"l+=zip(*l[-1][::-1]),;"*3           # Part 1. Create the list of rotations.
exec"                     ;"*3           # Execute (Do) the following 3 times:
     l+=                 ,               # ... Append to l the singleton tuple:
        zip(*           )                # ...... The transpose of:
             l[-1][::-1]                 # ......... The last element of l, reversed.

print[map(sum,zip(*d))for d in zip(*l)]  # Part 2. Generate the matrix of sums.
print                                    # Output the result of this expression:
     [                for d in        ]  # Create a list comprehension, that iterates
                                         # with a variable called "d" over:
                               zip(*l)   # ... The transpose of l.
      map(sum,       )                   # ... And computes the sum:
              zip(*d)                    # ... Of each row in d's transpose.
                                         # The last 2 steps generate the column sums.

টিএল; ডিআর: 90 ডিগ্রি দ্বারা 3 বার ইনপুটটি ঘোরানো এবং ফলাফল সংগ্রহের মাধ্যমে প্রয়োজনীয় ম্যাট্রিকগুলির তালিকা তৈরি করুন। তারপরে, ফলাফলের ট্রান্সপোজে প্রতিটি ম্যাট্রিক্সের কলামগুলির যোগফল পান।

— মিঃ এক্সকোডার
সূত্র
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)"সাধারণ" ইনপুট দিয়ে দুটি বাইট সংরক্ষণ করে। এটি অনলাইন চেষ্টা করুন!
— ডেনিস
@ ডেনিস আপনাকে ধন্যবাদ! আমি ভেবেছিলাম lambda*lপাইথন 2 এ কোনও কারণে সম্ভব হয়নি।
— মিঃ এক্সকোডার
আপনি x,*y=1,2,3পাইথন ২.7 বা [*x]পাইথন ৩.৪ এ করতে পারবেন না , তবে তারাযুক্ত অভিব্যক্তিগুলি পাইথন ১.6 এ এমনকি ফাংশন আর্গুমেন্টের জন্য ব্যবহার করা যেতে পারে। এটি অনলাইন চেষ্টা করুন!
— ডেনিস
8

অক্টাভা , 29 বাইট

@(x)(y=x+rot90(x))+rot90(y,2)

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

ব্যাখ্যা

এটি নিজের 90 ডিগ্রি ঘোরানো সংস্করণ সহ ইনপুট ম্যাট্রিক্স যুক্ত করে। এরপরে ফলাফলটি 180 ডিগ্রি ঘোরানো সংস্করণের সাথে যুক্ত করা হয়।

— লুইস মেন্ডো
সূত্র
5

পরিষ্কার , 110 বাইট

import StdEnv,StdLib
r=reverse
t=transpose
z=zipWith(+)
$m=[z(z(r b)a)(z(r c)d)\\a<-m&b<-r m&c<-t m&d<-r(t m)]

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

ম্যাট্রিক থেকে:

  • X = transpose(reverse M): 90 ডিগ্রি ঘূর্ণন
  • Y = reverse(map reverse M): 180 ডিগ্রি ঘূর্ণন
  • Z = reverse(transpose M): 270-ডিগ্রি ঘূর্ণন

এটি অতিরিক্ত অপারেটরটিকে জিপ করে Mএবং Xপাশাপাশি এবং Yএবং Zফলাফলগুলি পরে over

— Οurous
সূত্র
5

জুলিয়া 0.6 , 29 বাইট

x*y=rotr90(y,x)
!x=x+1x+2x+3x

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

আমি লুকসের সমাধানের নিচে নামতে পারিনি

তবে চেষ্টা করার সময় আমি এটিকে সামনে এনেছিলাম, যা আমি মনে করি খুব সুন্দর বুদ্ধিমান।

প্রথমে আমরা ঘুরানোর অপারেশন হিসাবে গুনটির নতুন সংজ্ঞা দিই, যেখানে প্রথমবার ঘুরানোর সময় সংখ্যা। সুতরাং সন্নিধি দ্বারা জুলিয়া multipes তারপর থেকে: 1xহয়ে rotr90(x,1)এবং 3xহয়ে rotr90(x,3)ইত্যাদি

তারপরে আমরা যোগফলটি লিখি।

— লিন্ডন হোয়াইট
সূত্র
5

জুলিয়া 0.6 , 28 24 বাইট

~A=sum(rotr90.([A],0:3))

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

~A=sum(rotr90.([A],0:3)) #
~                        # redefine unary operator ~
 A                       # function argument
               [A]       # put input matrix A into a list with one element
                   0:3   # integer range from 0 to 3
       rotr90.(   ,   )  # apply function rotr90 elementwise, expand singleton dimensions
       rotr90.([A],0:3)  # yields list of rotated matrices:
                         # [rotr90(A,0), rotr90(A,1), rotr90(A,2), rotr90(A,3)]
  sum(                )  # sum
— LukeS
সূত্র
1
সম্ভবত এটি লক্ষণীয় যে [1]উদাহরণটি করা উচিত ~reshape([1], (1,1))যা করা উচিত কারণ সেভাবে জুলিয়ায় 0x তে 1x1 ম্যাট্রিক্স ঘোষণা করা হয়।
— লিন্ডন হোয়াইট
4

এমএটিএল , 9 বাইট

i3:"G@X!+

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

ব্যাখ্যা

i       # Explicitly grab the input matrix
3:"     # Loop through the values [1, 2, 3], and for each value, N:
  G     # Grab the input again
  @X!   # Rotate the value by 90 degrees N times
  +     # Add it to the previous value on the stack
        # Implicitly end the for loop and display the resulting matrix
— Suever
সূত্র
4

অক্টাভা , 33 বাইট

@(a)a+(r=@rot90)(a)+r(a,2)+r(a,3)

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

ব্যাখ্যা:

(r=@rot90)rম্যাট্রিক্স 90 ডিগ্রি ঘোরানোর জন্য ব্যবহৃত একটি ফাংশন হ্যান্ডেল তৈরি করার একটি ইনলাইন পদ্ধতিতে । যদি দ্বিতীয় যুক্তি, kদেওয়া হয় rতবে তা ম্যাট্রিক্স k*90ডিগ্রি ঘোরান । সুতরাং এটি সিউডো কোডের সমতুল্য:

a + rot90(a) + rot180(a) + rot270(a)
— স্টিও গ্রিফিন
সূত্র
3

আর , 69 64 বাইট

function(x,a=function(y)apply(y,1,rev))x+a(x)+a(a(x))+a(a(a(x)))

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

কোডগল্ফে তিন নম্বর চেষ্টা করুন। জিউসেপিকে 69 থেকে 64 বাইট পর্যন্ত ধন্যবাদ!

— ফ্লোরিয়ান
সূত্র
aএকটি ফাংশন যুক্তিতে সরানো আপনাকে {}ফাংশন বডির চারপাশ থেকে মুক্তি দেওয়ার অনুমতি দিয়ে বাইটস সংরক্ষণ করবে । এছাড়াও, লুইস মেন্ডোর অক্টাভ পদ্ধতির পোর্টিং কিছু বাইট বাঁচাতে পারে? অবশেষে, আমি 100% নিশ্চিত নই তবে এর t(apply(x,2,rev))সমান apply(x,1,rev)?
— জিউসেপ
ধন্যবাদ, আমি টিপ # 1 এবং # 3 দিয়ে উন্নত করতে সক্ষম হয়েছি। আমি একটি আর্গুমেন্ট যোগ করে বাইট সংরক্ষণে সফল হয়নি nকরতে a()অপারেশন যদিও পুনরাবৃত্তি।
— ফ্লোরিয়ান
1
আমি কিছু বোঝানো ভালো
— : Giuseppe
2

জাভাস্ক্রিপ্ট (ES6), 77 বাইট

a=>a.map((b,i)=>b.map((c,j)=>c+a[j][c=l+~i]+a[c][c=l+~j]+a[c][i]),l=a.length)
— নিল
সূত্র
2

জেলি , 7 বাইট

ṚZ$3СS

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

এরিক দ্য আউটগল্ফারকে 1 বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে (বাগ সংশোধন করার জন্য একটি পরামর্শের জন্য ধন্যবাদ)।

কিভাবে?

ṚZ $ 3СS || সম্পূর্ণ প্রোগ্রাম (একাকী)

   3С || এটি 3 বার করুন এবং একটি তালিকার ফলাফল সংগ্রহ করুন
  $ || -> শেষ দুটি লিঙ্ককে মোনাড হিসাবে প্রয়োগ করুন
Ṛ || –––> বিপরীত,
 জেড || –––> ট্রান্সপোজ করুন।
      এস || সঙ্কলন।
— মিঃ এক্সকোডার
সূত্র
2

এপিএল (ডায়ালগ ক্লাসিক) , 17 বাইট

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

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

এপিএল NARS 34 17 21 অক্ষর বর্জন করে

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

-2 অক্ষর এনএনজি ধন্যবাদ

-2 অক্ষর কারণ অপারেটর সংমিশ্রণ + এর উপর + এর প্রাধান্য রয়েছে

মনে হচ্ছে এটি 90 90 থেকে একটি ঘোরান, 180 ডিগ্রি থেকে একটি ঘোরান, ⌽⍉⌽⊖a 270 from থেকে rot হিসাবে ঘোরান

অপারেটর পি এর উপস্থিতি থাকলে:

∇r←(g p)n;a;i;k
   a←⌽,n⋄r←⍬⋄i←0⋄k←⍴a⋄→C
A: →B×⍳r≡⍬⋄r←g¨r
B: r←r,⊂i⊃a
C: →A×⍳k≥i+←1
   r←⌽r
∇

উপরের অপারেটর পিটি এমন হবে যে জি যদি 1 টি আর্গুমেন্ট ফাংশন হয় (মোনাদিক?) এটি হওয়া উচিত:

"g f a a a a" is "a ga gga ggga"

সমাধান 15 অক্ষর pheraps হবে

  g←{⊃+/⌽∘⍉ p 4⍴⊂⍵}
  a←2 2⍴1 3 2 4
  g a
10 10 
10 10 
  g 1
4

তবে আরও ভাল হতে পারে একজন অপারেটর "কমপোজড এন টাইম" ডি যেমন "3 ডিএফ ডাব্লু" এফ (ফ (চ (চ (ডাব্লু))) হতে পারে।

এখন আমি কিছু লিখেছি তবে এটি প্রয়োজনীয় প্রকারের পরীক্ষা করা ছাড়াই খুব ভঙ্গুর।

তবে আমি আরও বেশি অপারেটর q পছন্দ করি যা আর্গুমেন্ট এম দিয়ে চ এর রচনা পুনরাবৃত্তি করে (এটি সম্পূর্ণ হয় না কারণ ধরণের ত্রুটির ক্ষেত্রে লেখা হয় না)

∇r←(n q f)m;i;k;l
   r←⍬⋄k←⍴,n⋄→A×⍳k≤1⋄i←0⋄→D
C: r←r,⊂(i⊃n)q f m
D: →C×⍳k≥i+←1
   →0
A: l←n⋄r←m⋄→0×⍳n≤0
B: l-←1⋄r←f r⋄→B×⍳l≥1
∇

সমাধান 17 অক্ষর হবে তবে আমি এটি পছন্দ করি

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~
— RosLuP
সূত্র
270 ন্যায়সঙ্গত হতে পারে ⍉⌽এবং পুরো জিনিসটি ট্রেনের
— ngn
Gfwwww ডাব্লু gw ggw gggw এর একটির অস্তিত্ব থাকলে উত্তরটি হবে + / 4f 4 / rho
— ডাব্লু
মানে +/⌽∘⍉f 4⍴⊂⍵? এর চারটি অনুলিপি পেতে ⍵প্রথমে আপনাকে এটিটি সংযুক্ত করা উচিত ⊂। আছে ⌽⍉অপেরান্ড হিসেবে f, আপনি এটি ভালো একটি একক কার্যকারিতা মধ্যে রচনা করতে হবে: ⌽∘⍉। রহস্যময় fস্ক্যান (ব্যাকস্ল্যাশ) হতে পারে, তবে যত্ন নেওয়ার জন্য আরও একটি বিশদ রয়েছে - ⌽∘⍉একটি বাম যুক্তি পাবে, তাই আমাদের অবশ্যই এটি এড়ানোর জন্য তৈরি করতে হবে: +/{⌽⍉⍵}\4⍴⊂⍵বা +/⊢∘⌽∘⍉\4⍴⊂⍵।
— এনএনজি
আমার প্রথম মন্তব্যে আমি এই ট্রেনে পরামর্শ ছিল: ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽। আপনি যদি চতুরতার সাথে স্কুইগলগুলি পুনরায় সাজিয়ে রাখেন এবং ট্রেনগুলির ভাল ব্যবহার করেন তবে এটি আরও সংক্ষিপ্ত সমাধানের দিকে নিয়ে যেতে পারে।
— ngn
@ngn এমনকি একটি সাধারণ n ⍵ + ⍺} \ 1 2 3 4 রিটার্ন ডোমেন ত্রুটি
— রোজলুপি
2

কে 4 / কে (ওকে) , 23 8 বাইট

সমাধান:

+/(|+:)\

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

উদাহরণ:

+/(|+:)\5 5#14 2 5 10 2 18 9 12 1 9 3 1 5 11 14 13 20 7 19 12 2 1 9 5 6
24 29 31 41 24
41 49 31 49 29
31 31 20 31 31
29 49 31 49 41
24 41 31 29 24

ব্যাখ্যা:

সরলীকৃত রূপান্তর প্রযুক্তির জন্য ngn ধন্যবাদ ।

+/(|+:)\ / the solution
       \ / converge
  (   )  / function to converge
    +:   / flip
   |     / reverse
+/       / sum over the result

অতিরিক্ত:

প্রশ্নে এই হিসাবে লেখা যেতে পারে

sum (reverse flip @) scan
— streetster
সূত্র
— ngn
আমি জানতাম রূপান্তরগুলি প্রয়োগ করার আরও ভাল উপায় ছিল!
— স্ট্রিস্টার
+ / (| +:) io tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMFCwVjB0AhImQGhocH//wA দুঃখজনকভাবে একই গণনা ... গাহ মোবাইলে মার্কআপ বের করতে পারে না।
— স্ট্রিস্টার
মনে হচ্ছে মন্তব্যে মার্কআপের একটি বাগ রয়েছে, কেবল মোবাইলে নয় - ব্যাককোটি জিনিসগুলি মিস করার আগে ব্যাকস্ল্যাশ। আমি একটি স্পেস byোকিয়ে এড়িয়ে চললাম।
— ngn
2

রুবি , 74 72 66 বাইট

->a{r=0...a.size;r.map{|i|r.map{|j|(0..3).sum{i,j=j,~i;a[i][j]}}}}

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

এটি অ্যারে ঘোরানোর পরিবর্তে গাণিতিকভাবে যুক্ত উপাদানগুলি খুঁজে বের করে একটি উপাদান দ্বারা উপাদান ভিত্তিতে কাজ করে। মূল অংশটি হ'ল i,j=j,~i, যা ঘড়ির কাঁটার দিকে 90 ডিগ্রি পরিণত হয়।

-২ বাইটস মিঃ এক্সকোডারকে ধন্যবাদ

-6 বাইট কারণ sum

— MegaTom
সূত্র
1

রুবি 89 79 বাইট

-১০ বাইট ইউনিহেড্রনকে ধন্যবাদ 

->m{n=m;3.times{n=n.zip(m=m.transpose.reverse).map{|i,j|i.zip(j).map &:sum}};n}

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

— আসোন তুহিদ
সূত্র
1
আমি প্রায় নিশ্চিত আপনি প্রতিস্থাপন করতে পারেন .map &:dupসঙ্গে *1অক্ষরের একটি অনেক কাটা বন্ধ। array*lengthএকটি নতুন অ্যারে তৈরি করে এবং অগভীর ক্লোনটির একটি সহজ উপায়।
— ইউনিহীড্রন
আসলে, n=*mএমনকি আরও খাটো।
— ইউনিহীড্রন
@ উনিহিড্রন যে সমস্যা, আমাকে গভীর ক্লোন করতে হবে
— অসোন তুহিদ
আমার কাছে মনে হচ্ছে এটি আউটপুটকে প্রভাবিত করে না; আমি এটি আপনার "এটি চেষ্টা করুন অনলাইনে" লিঙ্কে
— ফিড করেছি
আপনি ঠিক বলেছেন, আসলে আপনার এমনকি অগভীর transpose
— ক্লোনও
1

হাস্কেল , 84 83 67 বাইট

z=zipWith
e=[]:e
f l=foldr(\_->z(z(+))l.foldr(z(:).reverse)e)l"123"

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

লাইকনি এবং সম্পূর্ণ বৌদ্ধিককে প্রচুর বাইট সংরক্ষণ করার জন্য ধন্যবাদ !

— ক্রিশ্চিয়ান লুপাস্কু
সূত্র
— নিখুঁত
@totallyhuman যে চালাক! ধন্যবাদ!
— ক্রিশ্চিয়ান লুপাস্কু
— লাইকনি
1

কাস্তে , 9 বাইট

F‡+↑4¡(↔T

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

ব্যাখ্যা

F‡+↑4¡(↔T)  -- implicit input M, for example: [[1,0,1],[2,3,4],[0,0,2]]
     ¡(  )  -- repeat infinitely times starting with M  
        T   -- | transpose: [[1,2,0],[0,3,0],[1,4,2]]
       ↔    -- | reverse: [[1,4,2],[0,3,0],[1,2,0]]
            -- : [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]],[[1,0,1],[2,3,4],[0,0,2]],…
   ↑4       -- take 4: [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]]]
F           -- fold (reduce) the elements (example with [[1,0,1],[2,3,4],[0,0,2]] [[1,4,2],[0,3,0],[1,2,0]])
 ‡+         -- | deep-zip addition (elementwise addition): [[2,4,3],[2,6,4],[1,2,2]]
            -- : [[4,6,4],[6,12,6],[4,6,4]]
— ბიმო
সূত্র
1

টিনাইলিস্প , 132 বাইট

আসুন transposeএকটি স্পিনের জন্য সম্প্রতি যুক্ত করা লাইব্রেরি ফাংশনটি গ্রহণ করি !

(load library
(d T transpose
(d R(q((m #)(i #(c m(R(reverse(T m))(dec #)))(
(q((m)(foldl(q(p(map(q((r)(map sum(T r))))(T p))))(R m 4

শেষ লাইনটি একটি নামবিহীন ল্যাম্বদা ফাংশন যা ঘূর্ণন সংশ্লেষ সম্পাদন করে। আসলে এটি ব্যবহার করতে, আপনি dএটি একটি নামের সাথে আবদ্ধ করতে চাইবেন । এটি অনলাইন চেষ্টা করুন!

উগল্ফড, মন্তব্য সহ

(load library) (comment Get functions from the standard library)

(comment Rotating a matrix by 90 degrees is just transpose + reverse)
(def rotate
 (lambda (matrix)
  (reverse (transpose matrix))))

(comment This function recursively generates a list of (count) successive rotations
          of (matrix))
(def rotations
 (lambda (matrix count)
  (if count
   (cons matrix
    (rotations (rotate matrix) (dec count)))
   nil)))

(comment To add two matrices, we zip them together and add the pairs of rows)
(def matrix-add
 (lambda two-matrices
  (map row-sum (transpose two-matrices))))

(comment To add two rows of a matrix, we zip them together and add the pairs of numbers)
(def row-sum
 (lambda (two-rows)
  (map sum (transpose two-rows))))

(comment Our final function: generate a list containing four rotations of the argument
          and fold them using matrix-add)
(def rotated-sum
 (lambda (matrix)
  (foldl matrix-add (rotations matrix 4))))
— DLosc
সূত্র
1

সংযুক্তি , 20 বাইট

Sum@MatrixRotate&0:3

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

ব্যাখ্যা

Sum@MatrixRotate&0:3

MatrixRotate&0:3, এর বিস্তৃতি ইনপুট দিয়ে x, MatrixRotate[x, 0:3], যেটা ঘুরে exapnds করা [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]। এটি বলতে গেলে এটি আরএইচএসের উপর ভেক্টরাইজ করে or তারপরে, Sumএই ম্যাট্রিকগুলির যোগফল এক স্তর দ্বারা নেয়। এটি পছন্দসই ফলাফল দেয়।

— কনর ও ব্রায়ান
সূত্র
1

জাভা 8, 135 133 বাইট

a->{int l=a.length,r[][]=new int[l][l],i=0,j;for(;i<l;i++)for(j=0;j<l;)r[i][j]=a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];return r;}

-2 বাইটস @ সিলিংক্যাটকে ধন্যবাদ ।

ব্যাখ্যা:

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

a->{                        // Method with integer-matrix as both parameter and return-type
  int l=a.length,           //  Dimensions of the input-matrix
      r[][]=new int[l][l],  //  Result-matrix of same size
      i=0,j;                //  Index-integers
  for(;i<l;i++)             //  Loop over the rows
    for(j=0;j<l;)           //   Loop over the columns
      r[i][j]=              //    Set the cell of the result-matrix to:
              a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];
                            //     The four linked cells of the input-matrix
  return r;}                //  Return the result-matrix
— কেভিন ক্রুইজসেন
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.