ทอร์นาโดเมทริกซ์เหมือนกับพายุทอร์นาโดอื่น ๆ มันประกอบด้วยสิ่งต่าง ๆ ที่หมุนรอบจุดศูนย์กลาง ในกรณีนี้องค์ประกอบของเมทริกซ์แทนอากาศ

นี่คือตัวอย่างของทอร์นาโดเมทริกซ์:

ก่อนอื่นเราเริ่มจากการแบ่งเมทริกซ์เป็นวงแหวนสี่เหลี่ยมแต่ละส่วนประกอบด้วยองค์ประกอบที่อยู่ห่างจากชายแดนโดยระยะทางเดียวกัน ส่วนเหล่านี้จะหมุนตามเข็มนาฬิการอบศูนย์ ในพายุทอร์นาโดที่แท้จริงความรุนแรงจะเพิ่มขึ้นไปที่กึ่งกลางและขั้นตอนการหมุนในทอร์นาโดเมทริกซ์: ส่วนนอกสุด (สีแดงหนึ่ง) จะถูกหมุนด้วย 1 ขั้นตอนถัดไป (สีเหลือง) อันหนึ่งหมุนด้วย 2 และ บน. ขั้นตอนการหมุน 90 องศารอบศูนย์

งาน:

งานของคุณคุณควรยอมรับมันคือการเขียนฟังก์ชั่นหรือโปรแกรมที่ใช้เป็นเมทริกซ์จตุรัสนำเอฟเฟคทอร์นาโดมาใช้กับมันแล้วเอาท์พุทเมทริกซ์ที่ได้ออกมา

การป้อนข้อมูล:

การป้อนข้อมูลที่ควรจะเป็นเมทริกซ์ตารางของการสั่งซื้อที่n n >= 1ไม่มีข้อสันนิษฐานใด ๆ เกี่ยวกับองค์ประกอบของเมทริกซ์พวกมันอาจเป็นอะไรก็ได้

เอาท์พุท:

เมทริกซ์จตุรัสที่มีลำดับเดียวกันซึ่งจะเป็นผลมาจากการใช้เอฟเฟกต์ tronado กับเมทริกซ์อินพุต

ตัวอย่าง:

เมทริกซ์ของการสั่งซื้อn = 1:

[['Hello']]               ===>    [['Hello']]

เมทริกซ์ของการสั่งซื้อn = 2:

[[1 , 2],                 ===>    [[5 , 1],
 [5 , 0]]                          [0 , 2]]

เมทริกซ์ของการสั่งซื้อn = 5:

[[A , B , C , D , E],             [[+ , 6 , 1 , F , A],
 [F , G , H , I , J],              [- , 9 , 8 , 7 , B],
 [1 , 2 , 3 , 4 , 5],     ===>     [/ , 4 , 3 , 2 , C],
 [6 , 7 , 8 , 9 , 0],              [* , I , H , G , D],
 [+ , - , / , * , %]]              [% , 0 , 5 , J , E]]

Python 3 , 100 ไบต์

import numpy
def f(a):
 if len(a): a=numpy.rot90(a,axes=(1,0));a[1:-1,1:-1]=f(a[1:-1,1:-1]);return a

ลองออนไลน์!

ถ่านขนาด 44 ไบต์

≔ＥθＳθＷθ«≔Ｅθ⮌⭆觧θνλθθＭ¹⁻¹Ｌθ≔Ｅ✂θ¹±¹¦¹✂κ¹±¹¦¹θ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ใช้งานได้กับสี่เหลี่ยมอักขระเท่านั้นเนื่องจาก I / O ที่เป็นค่าเริ่มต้นของ Charcoal ไม่ได้ทำเรื่องความยุติธรรมตามปกติ คำอธิบาย:

≔ＥθＳθ

อ่านสแควร์ตัวละคร

Ｗθ«

วนซ้ำจนกว่าจะว่างเปล่า

≔Ｅθ⮌⭆觧θνλθ

หมุนมัน

θＭ¹⁻¹Ｌθ

พิมพ์มัน แต่จากนั้นเลื่อนเคอร์เซอร์ไปที่หนึ่งตารางทแยงมุมจากมุมเดิม

≔Ｅ✂θ¹±¹¦¹✂κ¹±¹¦¹θ

ตัดแต่งด้านนอกจากอาร์เรย์

เยลลี่ , 27 ไบต์

J«þ`UṚ«Ɗ‘ịZU$LСŒĖḢŒHEƊƇṁµG

ลองออนไลน์!

ฉันคิดว่านี่อาจสั้นกว่านี้มาก

           Input: n×n matrix A.
J          Get [1..n].
 «þ`       Table of min(x, y).
    UṚ«Ɗ   min with its 180° rotation.

Now we have a matrix like: 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

‘ị          Increment all, and use as indices into...
     LС    List of [A, f(A), f(f(A)), …, f^n(A)]
  ZU$       where f = rotate 90°

Now we have a 4D array (a 2D array of 2D arrays).
We wish to extract the [i,j]th element from the [i,j]th array.

ŒĖ     Multidimensional enumerate

This gives us: [[[1,1,1,1],X],
                [[1,1,1,2],Y],
                ...,
                [[n,n,n,n],Z]]

ḢŒHEƊƇ     Keep elements whose Ḣead (the index) split into equal halves (ŒH)
           has the halves Equal to one another. i.e. indices of form [i,j,i,j]
           (Also, the head is POPPED from each pair, so now only [X] [Y] etc remain.)

ṁµG        Shape this like the input and format it in a grid.

Perl 6 , 78 73 72 ไบต์

ขอบคุณ nwellnhof สำหรับ -5 ไบต์!

$!={my@a;{(@a=[RZ] rotor @_: sqrt @_)[1..*-2;1..@a-2].=$!}if @_;@a[*;*]}

ลองออนไลน์!

บล็อกโค้ดแบบเรียกซ้ำที่ใช้อาเรย์แบบสองมิติแบบแบนและส่งกลับอาเรย์แบบแบนราบในทำนองเดียวกัน

คำอธิบาย:

$!={      # Assign code block to pre-declared variable $!
    my@a; # Create local array variable a
   {
     (@a=[RZ]  # Transpose:
             rotor @_: sqrt @_;  # The input array converted to a square matrix
     )[1..*-2;1..@a-2].=$!  # And recursively call the function on the inside of the array
   }if @_;    # But only do all this if the input matrix is not empty
   @a[*;*]  # Return the flattened array
}

อ็อกเทฟ , 86 81 ไบต์

f(f=@(g)@(M,v=length(M))rot90({@(){M(z,z)=g(g)(M(z=2:v-1,z)),M}{2},M}{1+~v}(),3))

ลองออนไลน์!

ฉันทราบว่าฟังก์ชันที่ไม่ระบุชื่อแบบเรียกซ้ำไม่ใช่วิธีที่สั้นที่สุดในการทำสิ่งต่าง ๆ ใน Octave แต่มันเป็นวิธีที่สนุกที่สุดในตอนนี้ นี่เป็นฟังก์ชั่นนิรนามที่สั้นที่สุดที่ฉันสามารถหาได้ แต่ฉันชอบที่จะได้รับความนิยมมากกว่า

คำอธิบาย

ฟังก์ชั่นวนซ้ำถูกกำหนดตามคำแนะนำเคล็ดลับนี้ โดย ceilingcat เป็นโครงสร้างพื้นฐานของฟังก์ชั่นที่ไม่ระบุชื่อด้วยการเรียกซ้ำ ตั้งแต่นี้ไปเรื่อย ๆ จะ recurse เราห่อโทร recursive ในอาร์เรย์เซลล์เงื่อนไข: ฟังก์ชั่นที่ไม่ระบุชื่อที่มีรายการอาร์กิวเมนต์ว่างจะเลื่อนการประเมินไปหลังจากเงื่อนไขถูกเลือก (แม้ว่าภายหลังเราจะเห็นว่าเราสามารถใช้รายการอาร์กิวเมนต์นั้นเพื่อกำหนด) จนถึงตอนนี้มันเป็นเพียงการทำบัญชีขั้นพื้นฐานq=f(f=@(g)@(M) ... g(g)(M) ...g(g)(M){@()g(g)(M),M}{condition}()z

ตอนนี้สำหรับการทำงานจริง เราต้องการให้ฟังก์ชันส่งคืนrot90(P,-1)ด้วยเมทริกซ์ P ซึ่งg(g)เรียกซ้ำในส่วนศูนย์กลางของเอ็มเราเริ่มต้นด้วยการตั้งค่าz=2:end-1ซึ่งเราสามารถซ่อนในการจัดทำดัชนีของเอ็มด้วยวิธีนี้M(z,z)เลือกส่วนกลางของเมทริกซ์ที่ต้องการ จะถูกทอร์นาโดเพิ่มเติมโดยการโทรซ้ำ ,3ส่วนหนึ่งเพื่อให้แน่ใจว่าการหมุนจะหมุนตามเข็มนาฬิกา หากคุณอาศัยอยู่ในซีกโลกใต้คุณอาจลบบิตนี้เป็น -2 ไบต์

M(z,z)=g(g)M(z,z)จากนั้นเราจะทำอย่างไร อย่างไรก็ตามค่าผลลัพธ์ของการดำเนินการนี้เป็นเพียงส่วนกลางที่แก้ไขมากกว่าPเมทริกซ์ทั้งหมด ดังนั้นเราทำสิ่ง{M(z,z)=g(g)M(z,z),M}{2}ที่ถูกขโมยไปจากเคล็ดลับนี้ โดยสตีวีกริฟฟิน

ในที่สุดconditionก็คือว่าการเรียกซ้ำหยุดเมื่ออินพุตว่างเปล่า

R , 87 ไบต์

function(m,n=nrow(m)){for(i in seq(l=n%/%2))m[j,j]=t(apply(m[j<-i:(n-i+1),j],2,rev));m}

ลองออนไลน์!

• เครดิตสำหรับคำตอบ StackOverFlowนี้สำหรับรหัสการหมุน

MATL , 25 24 23 22

t"tX@Jyq-ht3$)3X!7Mt&(

ลองออนไลน์!

การจัดทำดัชนีใน MATL ไม่ใช่เรื่องง่าย แต่ด้วยการตีกอล์ฟบางครั้งมันจะเป็นคำตอบของ Jelly ที่ดีที่สุดในปัจจุบัน ...

t                       % Take input implicitly, duplicate.  
 "                      % Loop over the columns of the input*
   X@                   % Push iteration index, starting with 0. Indicates the start of the indexing range.
     Jyq-               % Push 1i-k+1 with k the iteration index. Indicates the end of the indexing range
         t              % Duplicate for 2-dimensional indexing.
  t       3$)           % Index into a copy of the matrix. In each loop, the indexing range gets smaller
             3X!        % Rotate by 270 degrees anti-clockwise
                7Mt&(   % Paste the result back into the original matrix. 

* สำหรับn x nเมทริกซ์โปรแกรมนี้ทำการnวนซ้ำในขณะที่คุณต้องการn/2การหมุน อย่างไรก็ตามการจัดทำดัชนีใน MATL (AB) มีความยืดหยุ่นเพียงพอที่การจัดทำดัชนีช่วงที่เป็นไปไม่ได้เป็นเพียงแค่ไม่มี op วิธีนี้ไม่จำเป็นต้องเสียจำนวนไบต์ในการทำให้จำนวนการทำซ้ำถูกต้อง

Python 2 , 98 ไบต์

def f(a):
 if a:a=zip(*a[::-1]);b=zip(*a[1:-1]);b[-2:0:-1]=f(b[-2:0:-1]);a[1:-1]=zip(*b)
 return a

ลองออนไลน์!

K (ngn / k) , 41 39 38 ไบต์

{s#(+,/'4(+|:)\x)@'4!1+i&|i:&/!s:2##x}

ลองออนไลน์!

{ } ฟังก์ชั่นที่มีข้อโต้แย้ง x

#xความยาวx- ความสูงของเมทริกซ์

2##x สำเนาสองชุด - ความสูงและความกว้าง (ถือว่าเหมือนกัน)

s:กำหนดให้กับs"รูปร่าง"

!sดัชนีทั้งหมดของเมทริกซ์ที่มีรูปร่างsเช่น!5 5คือ

(0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4
 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4)

นี่คือเมทริกซ์ 2 แถว (รายการของรายการ) และคอลัมน์ของคอลัมน์นั้นสอดคล้องกับดัชนีในเมทริกซ์ 5x5

&/ อย่างน้อยสองแถว:

0 0 0 0 0 0 1 1 1 1 0 1 2 2 2 0 1 2 3 3 0 1 2 3 4

i&|i:กำหนดให้iย้อนกลับ ( |) และรับ minima ( &) ด้วยi

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

นี่คือหมายเลขวงแหวนที่แบนของเมทริกซ์ 5x5:

4!1+ เพิ่ม 1 และรับส่วนที่เหลือแบบโมดูโล 4

(+|:)เป็นฟังก์ชั่นที่หมุนโดยการย้อนกลับ ( |- เราต้องการ:บังคับให้เป็น monadic) และจากนั้น transposing ( +- เนื่องจากไม่ใช่คำกริยาที่ถูกต้องที่สุดใน "รถไฟ" เราไม่ต้องการ a :)

4(+|:)\xใช้มัน 4 ครั้งในxการรักษาผลกลาง

,/' แผ่แบน

+ transpose

( )@' จัดทำดัชนีแต่ละค่าทางด้านซ้ายด้วยแต่ละค่าทางด้านขวา

s# ก่อร่างใหม่เป็น s

JavaScript (ES6), 99 ไบต์

f=(a,k=m=~-a.length/2)=>~k?f(a.map((r,y)=>r.map(v=>y-m>k|m-y>k|--x*x>k*k?v:a[m+x][y],x=m+1)),k-1):a

ลองออนไลน์!

อย่างไร?

$W$

$t_{x,y}$$W=5$$m=2$

$k=m$$(x,y)$

ในขณะที่คนอื่น ๆ ที่เหลือไม่มีการเปลี่ยนแปลง

นี่เทียบเท่ากับบอกว่าเซลล์ไม่หมุนถ้าเรามี:

ซึ่งเป็นการทดสอบที่ใช้ในรหัส:

a.map((r, y) =>
  r.map(v =>
    y - m > k | m - y > k | --x * x > k * k ?
      v
    :
      a[m + x][y],
    x = m + 1
  )
)

$k$$k=-1$$k=-3/2$$W$

~k === 0

เยลลี่ 24 ไบต์

ṙ⁹ṙ€
ḊṖ$⁺€ßḷ""ç1$ç-ZUµḊ¡

ลองออนไลน์!

ฉันคิดว่านี่อาจสั้นกว่านี้มาก

- ลินน์

Haskell , 108 ไบต์

e=[]:e
r=foldl(flip$zipWith(:))e
g!(h:t)=h:g(init t)++[last t]
f[x,y]=r[x,y]
f[x]=[x]
f x=r$(r.r.r.(f!).r)!x

ลองออนไลน์!

ฉันใช้ไขว้ของ Laikoniและแก้ไขมันเล็กน้อยเพื่อหมุนอาร์เรย์ 90 °:

  e=[]:e;foldr(zipWith(:))e.reverse
≡ e=[]:e;foldl(flip$zipWith(:))e

คำอธิบาย

r หมุนอาร์เรย์โดย 90 °

(!)เป็นฟังก์ชั่นระดับสูงกว่า:“ นำไปใช้กับศูนย์” เป็นg![1,2,3,4,5][1] ++ g[2,3,4] ++ [5]

f เป็นฟังก์ชันของพายุทอร์นาโด: เคสพื้นฐานคือขนาด 1 และ 2 (อย่างใด 0 ไม่ทำงาน)

บรรทัดสุดท้ายคือสิ่งที่เวทมนตร์เกิดขึ้น: เราใช้r.r.r.(f!).rกับแถวกลางของxแล้วหมุนผลลัพธ์ ขอเรียกผู้ที่อยู่ตรงกลางแถวM เราต้องการที่จะ recurse บนกลางคอลัมน์ของMและจะได้รับอย่างที่เราสามารถหมุนM(f!)และการใช้งานแล้ว จากนั้นเราใช้r.r.rเพื่อหมุนMกลับไปสู่การวางแนวดั้งเดิม

Java 10, 198 192 ไบต์

m->{int d=m.length,b=0,i,j;var r=new Object[d][d];for(;b<=d/2;b++){for(i=b;i<d-b;i++)for(j=b;j<d-b;)r[j][d+~i]=m[i][j++];for(m=new Object[d][d],i=d*d;i-->0;)m[i/d][i%d]=r[i/d][i%d];}return r;}

-6 ไบต์ขอบคุณที่@ceilingcat

ลองออนไลน์

คำอธิบาย:

m->{                         // Method with Object-matrix as both parameter and return-type
  int d=m.length,            //  Dimensions of the matrix
      b=0,                   //  Boundaries-integer, starting at 0
      i,j;                   //  Index-integers
  var r=new Object[d][d];    //  Result-matrix of size `d` by `d`
  for(;b<=d/2;b++){          //  Loop `b` in the range [0, `d/2`]
    for(i=b;i<d-b;i++)       //   Inner loop `i` in the range [`b`, `d-b`)
      for(j=b;j<d-b;)        //    Inner loop `j` in the range [`b`, `d-b`)
        r[j][d+~i]=          //     Set the result-cell at {`j`, `d-i-1`} to:
          m[i][j++];         //      The cell at {`i`, `j`} of the input-matrix
    for(m=new Object[d][d],  //   Empty the input-matrix
        i=d*d;i-->0;)        //   Inner loop `i` in the range (`d*d`, 0]
      m[i/d][i%d]            //     Copy the cell at {`i/d`, `i%d`} from the result-matrix
        =r[i/d][i%d];}       //      to the replaced input-matrix
  return r;}                 //  Return the result-matrix as result

bโดยทั่วไปจะใช้เพื่อระบุแหวนที่เราอยู่ และมันจะหมุนวงแหวนนี้รวมถึงทุกอย่างภายในวงตามเข็มนาฬิกาในระหว่างการวนซ้ำทุกครั้ง

การแทนที่อินพุทเมทริกซ์นั้นทำได้เนื่องจาก Java เป็นการอ้างอิงแบบส่งผ่านดังนั้นการตั้งค่าr=mก็หมายความว่าทั้งเมทริกซ์นั้นจะถูกแก้ไขเมื่อคัดลอกจากเซลล์ทำให้เกิดผลลัพธ์ที่ไม่ถูกต้อง ดังนั้นเราจึงต้องสร้างObject-matrix ใหม่(การอ้างอิงใหม่) และคัดลอกค่าในทุกเซลล์ทีละหนึ่งแทน

MATLAB, 93 ไบต์

function m=t(m),for i=0:nnz(m),m(1+i:end-i,1+i:end-i)=(rot90(m(1+i:end-i,1+i:end-i),3));end;end

ฉันแน่ใจว่านี่สามารถเล่นกอล์ฟได้อีก

คำอธิบาย

function m=t(m),                                                                          end % Function definition
                for i=0:nnz(m),                                                       end;    % Loop from 0 to n^2 (too large a number but matlab indexing doesn't care)
                                                            m(1+i:end-i,1+i:end-i)            % Take the whole matrix to start, and then smaller matrices on each iteration
                                                      rot90(                      ,3)         % Rotate 90deg clockwise (anti-clockwise 3 times)
                               m(1+i:end-i,1+i:end-i)=                                        % Replace the old section of the matrix with the rotated one

C (gcc) , 128 118 115 ไบต์

-15 ไบต์จาก @ceilingcat

j,i;f(a,b,w,s)int*a,*b;{for(j=s;j<w-s;j++)for(i=s;i<w-s;)b[~i++-~j*w]=a[i*w+j];wmemcpy(a,b,w*w);++s<w&&f(a,b,w,s);}

ลองออนไลน์!

Haskell, 274 ไบต์

wเป็นฟังก์ชั่นหลักซึ่งมีประเภท[[a]] -> [[a]]ที่คุณคาดหวัง

ฉันแน่ใจว่านักกอล์ฟ Haskell ที่มีประสบการณ์มากขึ้นสามารถปรับปรุงเรื่องนี้ได้

w m|t m==1=m|0<1=let m'=p m in(\a b->[h a]++x(\(o,i)->[h o]++i++[f o])(zip(tail a)b)++[f a])m'(w(g m'))
p m|t m==1=m|0<1=z(:)(f m)(z(\l->(l++).(:[]))(r(x h(i m)):(p(g m))++[r(x f(i m))])(h m))
t[]=1
t[[_]]=1
t _=0
h=head
f=last
x=map
i=tail.init
g=x i.i
z=zipWith
r=reverse