ท้าทาย:

กำหนดเมทริกซ์ NxN โดยที่และหนึ่งในแปด 'ตัวเลือกการพับ' ที่แตกต่างกันให้ส่งออกอาร์เรย์ / รายการแบบ 2D พร้อมค่าลบออก$N\geq2$

ตัวเลือกการพับแปดแบบ ได้แก่ ซ้ายไปขวา จากขวาไปซ้าย; ด้านบนลงล่าง; ด้านล่างไปด้านบน; topleft ไป bottomright; รายนามสมาชิกเพื่อ bottomleft; bottomleft เพื่อรายนามสมาชิก; bottomright ไป topleft

ตัวอย่างทีละขั้นตอน:

อินพุตเมทริกซ์:

[[ 1, 3, 5, 7],
 [ 0, 8, 6, 4],
 [ 1, 1, 1, 1],  (a'th row in the explanation below)
 [ 1,25, 0,75]]

ด้วยตัวเลือกการพับจากบนลงล่างเราจะแสดงผลลัพธ์ดังนี้:

[[ 1,-7,-5,-3],
 [ 0,22,-5,68]]

ทำไม? เราพับจากบนลงล่าง เนื่องจากขนาดเมทริกซ์ยังเท่ากันเราจึงไม่มีเลเยอร์กลางที่จะเก็บรักษาเหมือนเดิม 'แถววันจะถูกหักโดย ' แถว TH (จะได้รับ 'แถว TH สำหรับการฝึกอบรมมิติคี่); เพื่อให้กลายเป็น 'แถว TH แล้วจะถูกหักโดย ' แถว TH (จะได้รับ 'แถว TH สำหรับการฝึกอบรมมิติคี่); เพื่อให้กลายเป็น$a$[1, 1, 1, 1]$(a-1)$$(a-2)$[1-0, 1-8, 1-6, 1-4][1, -7, -5, -3]$(a+1)$[1, 25, 0, 75]$(a-2)$$(a-3)$[1-1, 25-3, 0-5, 75-7][0, 22, -5, 68]

ด้วยตัวเลือกการพับจากขวาไปซ้ายแทน (ด้วยเมทริกซ์อินพุตเดียวกันด้านบน) เราจะแสดงผลลัพธ์ดังนี้:

[[-74,  2,  1,  7],
 [  0,  7,  6],
 [-24,  1],
 [  1]]

ด้วยการลบการพับต่อไปนี้:

[[1-75,  3-1,  5-4,    7],
 [ 0-0,  8-1,    6],
 [1-25,    1],
 [   1]]

กฏท้าทาย:

• คุณสามารถใช้ตัวอักษรที่แตกต่างกันแปดตัว[A-Za-z]หรือตัวเลขที่ต่างกันในช่วงสำหรับตัวเลือกการพับ ตัวเลขหรืออาจเป็นตัวเลือกที่ใช้กันโดยทั่วไป แต่หากคุณต้องการใช้ตัวเลขต่าง ๆ ในช่วงสำหรับการคำนวณแบบสมาร์ทคุณสามารถทำได้ โปรดระบุตัวเลือกการพับที่คุณใช้ในคำตอบของคุณ$[-99,99]$$[1..8]$$[0..7]$
• อินพุต - เมทริกซ์จะเป็นเมทริกซ์ NxN สแควร์เสมอดังนั้นคุณไม่ต้องจัดการเมทริกซ์ NxM ใด ๆ จะต้องมีอย่างน้อย 2 เสมอเนื่องจากเมทริกซ์ว่างเปล่าหรือ 1x1 ไม่สามารถพับได้$N$
• อินพุตของเมทริกซ์จะมีตัวเลขที่ไม่เป็นลบเสมอในช่วง (ตัวเลขในเอาต์พุตจึงจะอยู่ในช่วง )$[0, 999]$$[-999, 999]$
• ด้วยการพับ (ต่อต้าน -) ในแนวทแยงหรือการพับในแนวตั้ง / แนวนอนคี่กลาง 'เลเยอร์' จะไม่เปลี่ยนแปลง
• I / O ยืดหยุ่นได้ สามารถเป็นอาร์เรย์ 2 มิติ / รายการจำนวนเต็ม สามารถส่งคืนหรือพิมพ์เป็นสตริงที่คั่นด้วยช่องว่างและขึ้นบรรทัดใหม่; คุณสามารถปรับเปลี่ยนอินพุทเมทริกซ์และแทนที่ตัวเลขที่ควรจะหายไปnullหรือตัวเลขที่อยู่นอก[-999, 999]ช่วงเพื่อระบุว่ามันหายไป; ฯลฯ

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
  อย่าปล่อยให้ภาษาโค้ดกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ได้เข้ารหัส พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานใช้สำหรับคำตอบของคุณด้วยกฎ I / O เริ่มต้นดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีพร้อมพารามิเตอร์ที่เหมาะสมและประเภทผลตอบแทนโปรแกรมเต็มรูปแบบ การโทรของคุณ
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม
• หากเป็นไปได้โปรดเพิ่มลิงก์พร้อมทดสอบรหัสของคุณ (เช่นTIO )
• นอกจากนี้ขอแนะนำให้เพิ่มคำอธิบายสำหรับคำตอบของคุณ

กรณีทดสอบ:

อินพุตเมทริกซ์ 1:

Input-matrix (for the following eight test cases):
[[ 1, 3, 5, 7],
 [ 0, 8, 6, 4],
 [ 1, 1, 1, 1],
 [ 1,25, 0,75]]

Input-folding option: left-to-right
Output: [[2,6],[-2,4],[0,0],[-25,74]]

Input-folding option: right-to-left
Output: [[-6,-2],[-4,2],[0,0],[-74,25]]

Input-folding option: top-to-bottom
Output: [[1,-7,-5,-3],[0,22,-5,68]]

Input-folding option: bottom-to-top
Output: [[0,-22,5,-68],[-1,7,5,3]]

Input-folding option: topleft-to-bottomright
Output: [[7],[6,-1],[1,-7,-2],[1,24,0,74]]

Input-folding option: topright-to-bottomleft
Output: [[1],[-3,8],[-4,-5,1],[-6,21,-1,75]]

Input-folding option: bottomleft-to-topright
Output: [[1,3,4,6],[8,5,-21],[1,1],[75]]

Input-folding option: bottomright-to-topleft
Output: [[-74,2,1,7],[0,7,6],[-24,1],[1]]

อินพุตเมทริกซ์ 2:

Input-matrix (for the following eight test cases):
[[17, 4, 3],
 [ 8, 1,11],
 [11, 9, 7]]

Input-folding option: left-to-right
Output: [[4,-14],[1,3],[9,-4]]

Input-folding option: right-to-left
Output: [[14,4],[-3,1],[4,9]]

Input-folding option: top-to-bottom
Output: [[8,1,11],[-6,5,4]]

Input-folding option: bottom-to-top
Output: [[6,-5,-4],[8,1,11]]

Input-folding option: topleft-to-bottomright
Output: [[3],[1,7],[11,1,-10]]

Input-folding option: topright-to-bottomleft
Output: [[17],[4,1],[8,-2,7]]

Input-folding option: bottomleft-to-topright
Output: [[17,-4,-8],[1,2],[7]]

Input-folding option: bottomright-to-topleft
Output: [[10,-7,3],[-1,1],[11]]

คู่ , 256 248 244 248 ไบต์

m=d=x=@(a,b=1)rot90(a,b)
y=@(a,b=2)flip(a,b)
z=@(a,b=1)tril(a+1e3,-1)+a-x(y(tril(a)))+b*diag(diag(a))
f=@(a,b){m=((a-y(a))(:,1:(d=size(a,2)/2))),-y(m),m=y(x((a=x(a))-y(a)))(d+1:end,:),y(m,1),-y(z(a,-1)),x(z(x(a,2)),2),z(a=x(a,3)),x(z(x(a,2)),2)}{b}

ลองออนไลน์!

-2 ไบต์ (และเป็นระเบียบเรียบร้อย) ขอบคุณLuis Mendo

+2 ไบต์เนื่องจากการแก้ไขสำหรับ TB

การดำเนินการ 1 ดัชนีสำหรับค่า b จาก 1-8:

R-L
L-R
B-T
T-B
BR-TL
TR-BL
BL-TR
TL-BR

สิ่งนี้ทำให้ฉันปวดหัวฉันจะเล่นกอล์ฟอย่างถูกต้องในภายหลัง

เจลลี่ ,  39  34 ไบต์

_{อาจมีความเป็นไปได้ที่จะเล่นกอล์ฟต่อไปโดยรวม "ฟังก์ชั่น" บางอย่างเข้าด้วยกัน}
... yep: -5ขอบคุณ NickKennedy!

ṃ“Z“Ṛ“U“ “ŒDṙL ZZṚ”ŒḄFḲj“ŒH_Ṛ}¥/”v

ลองออนไลน์!

ลิงก์ dyadic ยอมรับจำนวนเต็ม (คำสั่ง) และรายการของตัวเลข (เมทริกซ์)

ใช้ตัวเลือกในการใช้คำสั่งเป็นจำนวนเต็มในเพื่อประโยชน์ของเราและด้วยเหตุนี้จึงมีการทำแผนที่ที่แปลกประหลาดต่อไปนี้:$[-99,99]$

           Instruction  |  integer
------------------------+---------
         left-to-right  |     4
         right-to-left  |    14
         top-to-bottom  |     9
         bottom-to-top  |    39
topleft-to-bottomright  |    65
topright-to-bottomleft  |    15
bottomleft-to-topright  |    10
bottomright-to-topleft  |     0

อย่างไร?

ลิงก์จะสร้างรหัส Jelly ซึ่งประเมินจากการใช้ M เป็นอินพุต ...

ṃ“Z“Ṛ“U“ “ŒDṙL ZZṚ”ŒḄFḲj“ŒH_Ṛ}¥/”v - Link: integer, I; matrix, M
 “Z“Ṛ“U“ “ŒDṙL ZZṚ”                - list of lists of characters = ["Z", "Ṛ", "U", " ", "ŒDṙL ZZṚ"]
ṃ                                  - base decompress (I) using those lists as the digits
                                   -  ...i.e. convert to base 5 and then convert the digits:
                                   -          [1,2,3,4,0] -> ["Z", "Ṛ", "U", " ", "ŒDṙL ZZṚ"]
                   ŒḄ              - bounce
                                   -  ...e.g. [a, b, c] -> [a, b, c, b, a]
                     F             - flatten to a list of characters
                      Ḳ            - split at spaces
                       j           - join with:
                        “ŒH_Ṛ}¥/”  -   list of characters = "ŒH_Ṛ}¥/"
                                 v - evaluate as Jelly code with an input of M

ตัวเลือกทั้งแปดนั้นมีดังนี้:

left-to-right           (4): ŒH_Ṛ}¥/
right-to-left          (14): ṚŒH_Ṛ}¥/Ṛ
top-to-bottom           (9): ZŒH_Ṛ}¥/Z
bottom-to-top          (39): ZṚŒH_Ṛ}¥/ṚZ
topleft-to-bottomright (65): ṚUŒDṙLŒH_Ṛ}¥/ZZṚUṚ
topright-to-bottomleft (15): UŒDṙLŒH_Ṛ}¥/ZZṚU
bottomleft-to-topright (10): ṚŒDṙLŒH_Ṛ}¥/ZZṚṚ
bottomright-to-topleft  (0): ŒDṙLŒH_Ṛ}¥/ZZṚ

แต่ละตัว (ยกเว้น0และ4) ใช้การแปลงเพื่อMใช้บางส่วนของZ(แปลง), Ṛ(ย้อนกลับ) และU(ย้อนกลับแต่ละครั้ง) จากนั้นหนึ่งในสองฟังก์ชั่น (ดูด้านล่าง) จากนั้นค่าผกผันของการแปลงการตั้งค่า (ถ้ามี) นำมาใช้กับการย้อนกลับของรหัส

ฟังก์ชั่นภายในทั้งสองคือ:

ŒH_Ṛ}¥/ - Function A: Fold bottom-to-top: matrix, M
ŒH       - split M into two equal lists of rows (first half bigger by 1 if need be)
      / - reduce by:
     ¥  - last two links as a dyad:
    }   -  using the right argument (i.e. second half):
   Ṛ    -    reverse
  _     -  subtract

ŒDṙLŒH_Ṛ}¥/ZZṚ - Function B: Fold topright-to-bottomleft: matrix, M
ŒD             - diagonals of M
  ṙ            - rotate left by:
   L           -   length of M (puts them in order from bottom left most)
    ŒH_Ṛ}¥/    - same action as calling Function A on the diagonals
           Z   - transpose
            Z  - transpose
             Ṛ - reverse

JavaScript (ES6),  149 ... 133  128 ไบต์

(matrix)(d)$0\le d\le7$NaN

$0 =\;\rightarrow$$1 =\;\downarrow$$2 =\;\small\searrow$$3 =\;\small\swarrow$$4 =\;\leftarrow$$5 =\;\uparrow$$6 =\;\small\nwarrow$$7 =\;\small\nearrow$

m=>d=>m.map((r,y)=>r.map((v,x)=>v-=(w=m.length+~y)-(p=[x+x-y,y,x,q=w+y-x][d&3])&&[r[q],m[w][x],m[q][w],m[x][y]][d>3^p>w?d&3:m]))

ลองออนไลน์!

แสดงความคิดเห็น

m => d =>                   // m[] = matrix; d = direction
  m.map((r, y) =>           // for each row r[] at position y in m[]:
    r.map((v, x) =>         //   for each value v at position x in r[]:
      v -=                  //     subtract from v:
        (                   //       define w as:
          w = m.length + ~y //         the width of input matrix - y - 1
        ) - (               //       and compare it with
          p = [             //       p defined as:
            x + x - y,      //         2 * x - y for vertical folding
            y,              //         y for horizontal folding
            x,              //         x for diagonal folding
            q = w + y - x   //         q = w + y - x for anti-diagonal folding
          ][d & 3]          //       using d MOD 4
        ) &&                //       if p is equal to w, leave v unchanged
        [                   //       otherwise, subtract:
          r[q],             //         r[q] for vertical folding
          m[w][x],          //         m[w][x] for horizontal folding
          m[q][w],          //         m[q][w] for diagonal folding
          m[x][y]           //         m[x][y] for anti-diagonal folding
        ][                  //       provided that we're located in the target area:
          d > 3 ^           //         test p < w if d > 3 
          p > w ? d & 3     //         or p > w if d <= 3
                : m         //         and yield either d MOD 4 or m[]
        ]                   //       (when using m[], we subtract 'undefined' from v,
                            //       which sets it to NaN instead)
    )                       //   end of inner map()
  )                         // end of outer map()

เจลลี่ , 71 34 ไบต์

ḃ2ŒḄ,UZṚŒDṙLƊŒH_Ṛ}¥/$ZZṚƊṚZ8ƭ$ị@¥ƒ

ลองออนไลน์!

ชุดทดสอบ

โปรแกรมเต็มรูปแบบ อาร์กิวเมนต์ที่ถูกต้องคือเมทริกซ์ อาร์กิวเมนต์ซ้ายเป็นประเภทการพับ:

44 = L-R
40 = R-L
36 = T-B
32 = B-T
50 = TL-BR
34 = TR-BR
54 = BL-TR
38 = BR-TL

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

อ็อกเทฟ482 ไบต์ 459 ไบต์

ปัจจัยการผลิตสำหรับการตัดสินใจทิศทางพับคือ:
1) จากซ้ายไปขวา
2) ด้านล่างสู่ด้านบน
3) ขวาไปซ้าย
4) บนลงล่าง
5) TR จะ BL
6) br เพื่อ TL
7) BL เพื่อ TR
8) TL เพื่อ br
โทรแต่ละครั้ง สร้างการพับที่ระบุเท่านั้นแทนที่จะสร้างทั้งหมด (ซึ่งอาจจะใช้เวลาน้อยกว่าไบต์) ปัญหาที่ใหญ่ที่สุดก็คือในกรณีนี้ฉันไม่สามารถหาวิธีที่จะวาง folds 1-4 และ 5-8 ในลูปเดียวกัน แต่อย่างน้อยอ็อกเทฟก็มีเมทริกซ์ที่ดูดี

    function[m]=f(n,o)
    k=length(n);m=NaN(k);if(o<5)
    if(mod(o,2)>0)n=n'end
    q=[0,0,k+1,k+1](o)
    for x=1:ceil(k/2)if(x*2>k)m(x,:)=n(x,:)else
    for a=1:k
    m(abs(q-x),a)=n(abs(q-x),a)-n(abs(q-(k+1-x)),a)end
    end
    end
    if(mod(o,2)>0)m=flipud(m')end
    else
    if(mod(o,2)>0)n=flip(n)end
    q=[0,0,k+1,k+1](o-4)
    for x=1:k
    for a=1:k+1-x
    if(a==k+1-x)m(x,a)=n(x,a)else
    m(abs(q-x),abs(q-a))=n(abs(q-x),abs(q-a))-n(abs(q-(k+1-a)),abs(q-(k+1-x)))end
    end
    end
    end
    if(mod(o,2)>0)m=flip(m)end
    end

ลองออนไลน์!

ค่าใช้จ่ายในการปราบปรามเอาต์พุตไบต์ดังนั้นให้ละเว้นทุกสิ่งที่ไม่ใช่คำสั่ง return (ans =)

ถ่าน , 78 77 ไบต์

Ｆ⁴«ＵＭηＥ⮌η§μλ¿⁼ιθＵＭηＥκ⎇‹⊕⊗νＬη⁻μ§⮌κν⎇›⊕⊗νＬηωμ¿⁼ι﹪θ⁴ＵＭηＥκ⎇‹λν⁻짧ηνλ⎇›λνωμ»Ｅη⪫ι,

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ใช้ตัวเลือกการพับต่อไปนี้:

0   top-to-bottom
1   left-to-right
2   bottom-to-top
3   right-to-left
4   bottomright-to-topleft
5   topright-to-bottomleft
6   topleft-to-bottomright
7   bottomleft-to-topright

ค่าที่ถูกพับถูกแทนที่ด้วยสตริงว่าง คำอธิบาย:

Ｆ⁴«≔ＵＭηＥ⮌η§μλ

หมุนอาร์เรย์สี่ครั้ง

¿⁼ιθＵＭηＥκ⎇‹⊕⊗νＬη⁻μ§⮌κν⎇›⊕⊗νＬηωμ

พับอาร์เรย์ในแนวนอนตามความเหมาะสม

¿⁼ι﹪θ⁴ＵＭηＥκ⎇‹λν⁻짧ηνλ⎇›λνωμ

พับอาร์เรย์ในแนวทแยงมุมตามความเหมาะสม

»Ｅη⪫ι,

เอาท์พุทอาร์เรย์เมื่อมันถูกหมุนกลับไปที่การวางแนวดั้งเดิม