Meydan okuma:

$N\geq2$ ve sekiz farklı 'katlama seçeneğinin' olduğu bir NxN matrisi göz önüne alındığında , çıkartılan değerlerle birlikte bir 2D dizi / liste çıkar.

Sekiz katlama seçeneği: soldan sağa; sağdan sola; üst-tabanı; alt-üst; topleft-için-bottomRight; topright-için-bottomleft; bottomleft-için-topright; bottomright-to-topleft.

Adım adım örnekler:

Giriş matrisi:

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

Yukarıdan aşağıya doğru katlama seçeneği ile aşağıdakileri çıktı olarak veririz:

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

Niye ya? Yukarıdan aşağıya doğru katlanırız. Matris boyutları eşit olduğundan, koruyacak orta katman yoktur. $a$ 'inci satır [1, 1, 1, 1]ile çıkarılacaktır $(a-1)$ ' inci satır (olurdu $(a-2)$ 'tek boyut matrisleri için inci satır); öyle [1-0, 1-8, 1-6, 1-4]olur [1, -7, -5, -3]. $(a+1)$ 'inci satır [1, 25, 0, 75]o sırada çıkartılır olacak $(a-2)$ ' inci satır (olurdu $(a-3)$ 'tek boyut matrisleri için inci satır); yani[1-1, 25-3, 0-5, 75-7]olur [0, 22, -5, 68].

Bunun yerine alttan tepeye katlama seçeneğiyle (yukarıdaki aynı giriş matrisi ile) sonuç olarak aşağıdakileri çıkarırız:

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

Aşağıdaki katlama çıkarma işlemleriyle:

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

Meydan okuma kuralları:

• Katlama seçenekleri için [ - 99 , 99 ][A-Za-z] aralığında sekiz farklı harf veya farklı rakam kullanabilirsiniz . Sayılar [ 1..8 ] veya [ 0..7 ] muhtemelen en yaygın seçenek vardır, ancak bazı akıllı hesaplamalar için aralık içinde farklı sayılar kullanmak istiyorsanız, bunu yapmak için çekinmeyin. Lütfen cevabınızda hangi katlama seçeneklerini kullandığınızı belirtin.$[-99,99]$$[1..8]$$[0..7]$
• Giriş matrisi her zaman bir kare NxN matrisi olacak, böylece herhangi bir dikdörtgen NxM matrisi ile çalışmak zorunda değilsiniz. $N$ , her zaman en az 2 olacaktır, çünkü boş veya 1x1'lik bir matris katlanamaz.
• Matrisin girişi her zaman $[0, 999]$ aralığında negatif olmayan sayılar içerecektir (çıktıdaki sayılar $[-999, 999]$ aralığında olacaktır ).
• (Anti-) çapraz katlama veya tek boyutlu dikey / yatay katlama ile, orta 'katman' değişmeden kalacaktır.
• G / Ç esnektir. 2B dizi / tamsayı listesi olabilir; boşluk ve newline ayrılmış bir dize olarak döndürülebilir veya yazdırılabilir; giriş matrisini değiştirebilir ve gitmiş olduklarını belirtmek için gitmesi gereken sayıları nullveya [-999, 999]aralığın dışındaki bir sayıyı değiştirebilirsiniz; vesaire vesaire.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Giriş matrisi 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]]

Giriş matrisi 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]]

Octave , 256 248 244 248 bayt

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}

Çevrimiçi deneyin!

-2 bayt (ve bir miktar toparlanma) sayesinde Luis Mendo

TB düzeltmesi nedeniyle +2 bayt

1-8 arasındaki b değerleri için 1-Endeksli işlemler:

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

Bu bana bir baş ağrısı verdi, daha sonra düzgün golf yapacağım

Jöle ,  39  34 bayt

_{İki "fonksiyondan" bazılarını birleştirerek golf oynamak da mümkün olabilir.}
... evet: -5 NickKennedy'e teşekkürler!

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

Çevrimiçi deneyin!

Bir tamsayıyı kabul eden iki yönlü bir bağlantı (komut) ve sayı listelerinin bir listesi (matris).

$[-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

Nasıl?

Bağlantı, daha sonra bir girdi olarak M kullanılarak değerlendirilen Jelly kodunu yaratır ...

ṃ“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

Sekiz seçenekten her biri:

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Ṛ

Bunların her biri (hariç 0 ve 4) bir dönüşümü uygulamak Mbazılarını kullanarak Z, (devrik)Ṛ (ters) veU (her birini ; daha sonra iki fonksiyondan biri (aşağıya bakınız), ardından kurulum dönüşümünün tersi (varsa) kodun tersi ile uygulanır.

İki iç fonksiyon:

Œ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 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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

Jöle , 71 34 bayt

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

Çevrimiçi deneyin!

Test odası

Tam bir program. Doğru argüman matristir. Sol argüman katlama türüdür:

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

Giriş olarak 5 bitlik bijective binary kullanacak şekilde yeniden yazıldı. Yukarıda verilen programın çoklu katlamalar için tekrar tekrar çalışmayacağını unutmayın.

Oktav , 482 bayt , 459 Bayt

Katlama yön karar vermek için girişler:
soldan sağa 1)
üst 2) alt
sağdan sola) 3
alt 4) en
5) tr için bl
tl 6) br
7) bl TR
br 8) tl
Her çağrı hepsi (yalnızca daha az bayt alacaktır) değil, yalnızca belirtilen katlamayı oluşturur. En büyük sorun, bu durumda 1-4 ve 5-8 kıvrımlarının aynı döngüye nasıl yerleştirileceğini çözemem. Fakat en azından oktav güzel görünümlü matrislere sahiptir.

    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

Çevrimiçi deneyin!

Bastırma maliyeti bayt olarak verilir, bu nedenle return ifadesi olmayan her şeyi yoksayın (ans =).

Kömür , 78 77 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Aşağıdaki katlama seçeneklerini kullanır:

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

Katlanmış değerler boş dizelerle değiştirilir. Açıklama:

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

Diziyi dört kez döndürün.

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

Uygun olduğunda diziyi yatay olarak katlayın.

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

Gerektiğinde diziyi çapraz olarak katlayın.

»Ｅη⪫ι,

Diziyi, orijinal oryantasyonuna geri döndürüldükten sonra çıkar.