चुनौती:

एक NxN मैट्रिक्स को देखते हुए जहां और आठ अलग-अलग 'तह विकल्पों' में से एक है, घटाए गए मूल्यों के साथ एक 2D सरणी / सूची का उत्पादन करता है। $N\geq2$

आठ तह विकल्प हैं: बाएं से दाएं; दाएं से बाएं; ऊपर से नीचे; नीचे से ऊपर; topleft करने वाली bottomright; Topright करने वाली bottomleft; bottomleft करने वाली Topright; 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 पंक्ति) होगा; ऐसा बन जाता है । $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]

तह विकल्प के साथ नीचे-से-toftft के साथ (ऊपर एक ही इनपुट-मैट्रिक्स के साथ) हम परिणाम के रूप में निम्न आउटपुट करते हैं:

[[-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]सीमा के बाहर या एक संख्या के साथ जाना चाहिए ; आदि आदि।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
डिफ़ॉल्ट 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]]

— केविन क्रूज़सेन
स्रोत

क्या फोल्डिंग विकल्पों का क्रम मायने रखता है?

— डेटा

इसके अलावा, क्या हम सभी संभावित तह के 8xNxN मैट्रिक्स का उत्पादन कर सकते हैं?

— डेटा

क्या यह परीक्षण नमूना इनपुट-तह विकल्प नहीं होना चाहिए: निचला-से-शीर्ष आउटपुट: [[-1,7,5,3], [0, -22,5, -68]] फ़्लिप किया जाए?

— ऑरेंजक्रैस

मैट्रिक्स 2 के लिए भी, 17-11 6 है, 4 नहीं?

— ऑरेंजचेयर

@ExpiredData नियमों में निर्दिष्ट के रूप में, आप किसी भी पत्र A-Za-zया श्रेणी में किसी भी पूर्णांक का उपयोग कर सकते हैं [-999,999], इसलिए आदेश कोई फर्क नहीं पड़ता। और क्षमा करें, लेकिन आपको इनपुट के आधार पर सही गुना आउटपुट करना होगा, इसलिए सभी आठों को आउटपुट करने की अनुमति नहीं है।

— केविन क्रूज़सेन

5

ऑक्टेव , 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 बाइट्स (और ऊपर की ओर झुकते हुए)

टीबी के सुधार के कारण +2 बाइट्स

1-8 से बी के मूल्यों के लिए 1-अनुक्रमित संचालन:

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

इसने मुझे सिरदर्द दिया, मैं इसे बाद में ठीक से गोल्फ करूँगा

— समय सीमा समाप्त डेटा
स्रोत

सुझाएँ rows(a)बजायsize(a,2)

— ceilingcat

5

जेली , 39 34 बाइट्स

_{दो "कार्यों" में से कुछ को मिलाकर संभवत: आगे गोल्फिंग है।}
... हाँ: -5 NickKennedy के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

एक पूर्णांक लिंक जो एक पूर्णांक (निर्देश) और संख्याओं की सूची (मैट्रिक्स) को स्वीकार करता है।

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

कैसे?

लिंक जेली कोड बनाता है जो तब इनपुट के रूप में एम का उपयोग करके मूल्यांकन किया जाता है ...

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

— जोनाथन एलन
स्रोत

1

आह अच्छा, मैं सोच रहा था कि क्या कोई व्यक्ति कुछ लचीले इनपुट-विकल्पों का उपयोग करेगा! यह देखने के लिए अच्छा है कि आपने वांछित तह का मूल्यांकन करने के लिए जेली कोड के लिए एक सुविधाजनक आधार-रूपांतरण के लिए मूल्यों का उपयोग कैसे किया है। :)

— केविन क्रूज़सेन

मेरे उत्तर में से कुछ कोड का उपयोग करना, और दोनों के लिए कॉमन कोड का पुन: उपयोग करना, यहाँ एक 34- बाईटर है

— निक केनेडी

अगर हमें 16 बिट पूर्णांक की अनुमति दी गई तो यह और भी छोटा हो सकता है

— निक कैनेडी

गैर-प्रतिस्पर्धी 23 बाइट उत्तर जो कि गुना चुनने के लिए पैरामीटर के रूप में 16-बिट पूर्णांक का उपयोग करते हैं: tio.run/##y0rNyan8///…

— निक कैनेडी

@NickKennedy - धन्यवाद। मुझे विभाजन पसंद है और इसमें शामिल हों! मुझे वर्णन पूरी तरह से बदलने के लिए बाद में वापस आना होगा।

— जोनाथन एलन

3

जावास्क्रिप्ट (ईएस 6), 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()

— Arnauld
स्रोत

3

जेली , 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-बिट बायजेक्टिव बाइनरी का उपयोग करने के लिए फिर से लिखा गया। ध्यान दें कि ऊपर दिया गया प्रोग्राम कई गुना के लिए बार-बार काम नहीं करेगा।

— निक केनेडी
स्रोत

1

ऑक्टेव , 482 बाइट्स , 459 बाइट्स

तह निर्देश तय करने के लिए इनपुट इस प्रकार हैं:
1) बाएं से दाएं
2) नीचे से ऊपर
3) बाएं से दाएं
4) ऊपर से नीचे 4) ऊपर से नीचे
5) tr से लेकर
6) br से tl
7) bl से tr
8) tl से br तक
प्रत्येक कॉल केवल उन सभी के बजाय निर्दिष्ट गुना उत्पन्न करता है (जो शायद कम बाइट्स लेता है)। सबसे बड़ी समस्या यह है कि इस मामले के लिए मैं यह पता नहीं लगा सकता कि एक ही लूप में 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

इसे ऑनलाइन आज़माएं!

आउटपुट दमन की लागत बाइट्स होती है, इसलिए हर उस चीज़ को अनदेखा करें जो रिटर्न स्टेटमेंट (ans =) नहीं है।

— OrangeCherries
स्रोत

"अंत" लिखने के लिए आपने कितने बाइट खो दिए?

— समय सीमा समाप्त डेटा

क्या आपको अंत नहीं लिखना है?

— OrangeCherries

आप तब तक करते हैं जब तक कि आप इसका पुनर्गठन नहीं करते हैं, इसलिए यह / / और बयानों का एक गुच्छा नहीं है

— समय सीमा समाप्त डेटा

वाह tbh अपने कोड को देख वहाँ टन सामान है मैं भी नहीं जानता था कि आप matlab में कर सकते हैं।

— ऑरेंजचेयर

मैं ऑक्टेव tbh के बारे में ज्यादा नहीं जानता कि यह शायद 50-100 बाइट्स को आसानी से बचा सकता है

— एक्सपायर डाटा

1

चारकोल , 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

मुड़े हुए मूल्यों को खाली तारों द्वारा बदल दिया जाता है। स्पष्टीकरण:

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

चार बार सरणी को घुमाएं।

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

उपयुक्त होने पर सरणी को क्षैतिज रूप से मोड़ो।

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

उपयुक्त होने पर तिरछे आरेख को मोड़ें।

»Ｅη⪫ι,

एक बार सरणी को आउटपुट करने के बाद इसे अपने मूल अभिविन्यास पर वापस घुमाया जाता है।

— नील
स्रोत

मुड़ा हुआ मैट्रिक्स घटाना

चुनौती:

चुनौती नियम:

सामान्य नियम:

परीक्षण के मामलों:

ऑक्टेव , 256 248 244 248 बाइट्स

जेली , 39 34 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 149 ... 133 128 बाइट्स

टिप्पणी की गई

जेली , 71 34 बाइट्स

ऑक्टेव , 482 बाइट्स , 459 बाइट्स

चारकोल , 78 77 बाइट्स