एक सरणी में शेख़ी

25

परिचय

बाउंसिंग बॉल के लिए एरर्स को एक मैदान के रूप में भी देखा जा सकता है। यह पाठ्यक्रम बहुत अस्पष्ट लगता है, इसलिए यहां एक इनपुट का उदाहरण दिया गया है:

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

चुनौती बाउंस सरणियों का उत्पादन करना है । ये विकर्ण पैटर्न से बने होते हैं जो मैदान के किनारों पर उछलते हैं। यह रास्ता ऊपर की तरफ बताया गया है । पहले बाउंस किए गए एरे के लिए पथ (जिसमें मार्ग ईजाद से सीधे बाउंस होता है), है:

[1, -, -, -, 5, -, -, -, 9]
[-, 8, -, 6, -, 4, -, 2, -]
[-, -, 3, -, -, -, 7, -, -]

बाएं से दाएं, यह परिणाम होगा [1, 8, 3, 6, 5, 4, 7, 2, 9]। यह हमारा पहला बाउंस सरणी है। दूसरे बाउंस सरणी के लिए पथ:

[-, 2, -, -, -, 6, -, -, -]
[9, -, 7, -, 5, -, 3, -, 1]
[-, -, -, 4, -, -, -, 8, -]

इस में परिणाम है [9, 2, 7, 4, 5, 6, 3, 8, 1]। तीसरे बाउंस सरणी के लिए रास्ता है:

[-, -, 3, -, -, -, 7, -, -]
[-, 8, -, 6, -, 4, -, 2, -]
[1, -, -, -, 5, -, -, -, 9]

इस में परिणाम है [1, 8, 3, 6, 5, 4, 7, 2, 9]। तो तीन बाउंस सरणियाँ हैं:

[1, 8, 3, 6, 5, 4, 7, 2, 9]
[9, 2, 7, 4, 5, 6, 3, 8, 1]
[1, 8, 3, 6, 5, 4, 7, 2, 9]

कार्य

केवल गैर-ऋणात्मक पूर्णांकों वाले कम से कम 1 सरणी को देखते हुए, सभी सरणियों की लंबाई समान होने के साथ, सभी बाउंस किए गए सरणियों का उत्पादन होता है।

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

टेस्ट केस 1:

Input:                       Output:
[1, 2, 3, 4, 5]              [1, 7, 3, 9, 5]
[6, 7, 8, 9, 0]              [6, 2, 8, 4, 0]


Input:                       Output:
[1, 2, 3, 4, 5]              [1, 2, 3, 4, 5]


Input:                       Output:
[0, 0, 0, 0, 0, 0, 0, 0]     [0, 9, 0, 9, 0, 9, 0, 100]
[9, 9, 9, 9, 9, 9, 9, 100]   [9, 0, 9, 0, 9, 0, 9, 0]
[0, 0, 0, 0, 0, 0, 0, 0]     [0, 9, 0, 9, 0, 9, 0, 100]


Input:                       Output:
[0, 1, 2, 3, 4, 5]           [0, 7, 14, 9, 4, 11]
[6, 7, 8, 9, 10, 11]         [6, 1, 8, 15, 10, 5]
[12, 13, 14, 15, 16, 17]     [12, 7, 2, 9, 16, 11]


Input:                       Output:
[0, 0, 0, 0, 0, 0]           [0, 2, 2, 6, 2, 6]
[1, 2, 3, 4, 5, 6]           [1, 0, 3, 2, 5, 2]
[2, 2, 2, 2, 2, 2]           [2, 2, 0, 4, 2, 4]
[9, 8, 7, 6, 5, 4]           [9, 2, 3, 0, 5, 2]

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

code-golf  array-manipulation 
— अदनान
स्रोत
2
जेली इसे जीतती है।
— lirtosiast
क्या आप कृपया तीन-सरणी टेस्टकेस जोड़ सकते हैं जहां अंतिम सरणी अलग है फिर पहली और चार-सरणी टेस्टकेस?
— ETHproductions
1
मुझे समस्या का वर्णन नहीं मिल रहा है। क्या कोई मुझे बता सकता है कि वह कहां है?
— feersum
हाँ। मुझे कार्य का विवरण नहीं मिल रहा है।
— feersum
1
@LuisMendo यह उछाल का एकमात्र तरीका है, लाइन 0 पर यह अधिक नहीं जा सकता है
— edc65

जवाबों:

7

पायथ, 17 बाइट्स

>lQC.e.>bkC+_PtQQ

स्पष्टीकरण:

                      implicit: Q=input
>                     First
  l Q                   len(Q) elements of the
  C .e                  Transpose of enumerated map lambda b,k:
       .>                 Rotate the kth element rightwards by
          b
          k               k.
       C +              Transpose of: Q concatenated to
           _ P t Q        itself reversed without first and last elements.
           Q

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 70

a=>a.map((r,k)=>r.map((e,j)=>(a[k-=d]||a[d=-d,k-=d+d]||r)[j],d=1,++k))

परीक्षा

F = a=>a.map((r,k)=>r.map((e,j)=>(a[k-=d]||a[d=-d,k-=d+d]||r)[j],d=1,++k))

test = [{
  I: [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 0]
  ],
  O: [
    [1, 7, 3, 9, 5],
    [6, 2, 8, 4, 0]
  ]
}, {
  I: [
    [1, 2, 3, 4, 5]
  ],
  O: [
    [1, 2, 3, 4, 5]
  ]
}, {
  I: [
    [0, 0, 0, 0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9, 9, 9, 100],
    [0, 0, 0, 0, 0, 0, 0, 0]
  ],
  O: [
    [0, 9, 0, 9, 0, 9, 0, 100],
    [9, 0, 9, 0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0, 9, 0, 100]
  ]
}, {
  I: [
    [0, 1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10, 11],
    [12, 13, 14, 15, 16, 17]
  ],
  O: [
    [0, 7, 14, 9, 4, 11],
    [6, 1, 8, 15, 10, 5],
    [12, 7, 2, 9, 16, 11]
  ]
}, {
  I: [
    [0, 0, 0, 0, 0, 0],
    [1, 2, 3, 4, 5, 6],
    [2, 2, 2, 2, 2, 2],
    [9, 8, 7, 6, 5, 4]
  ],
  O: [
    [0, 2, 2, 6, 2, 6],
    [1, 0, 3, 2, 5, 2],
    [2, 2, 0, 4, 2, 4],
    [9, 2, 3, 0, 5, 2]
  ]
}];

console.log = x => O.textContent += x + '\n';

test.forEach(t => {
  var r = F(t.I),
    ok = r.join `\n` == t.O.join `\n`
  console.log((ok ? 'OK' : 'KO') + '\nInput\n' + t.I.join `\n` + '\nOutput\n' + r.join `\n` + '\n')
})
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
2

रूबी (2.2.2p95), 124 बाइट्स

->*a{b=a.length;b<2?a:b.times.map{|i|d=i>0?-1:1;c=i;a[0].length.times.map{|j|r=a[c][j];c+=d;d*=-1if c==0||c==a.length-1;r}}}

यह शायद बहुत बेहतर हो सकता है। मैं बाद में पता लगाऊंगा!

— कॉनर क्लार्क
स्रोत
2

जाप, 55 49 41 39 बाइट्स

वाह, यह वास्तव में मुश्किल और पागलपन दोनों था।

C=2*Nl -2Nw £YoY+Ul)£NgLmX%CC-X%C)gY} ·

इसे ऑनलाइन टेस्ट करें!

उदाहरण के लिए रिवर्स ऑर्डर में आउटपुट। यह 100 से अधिक सरणियों के इनपुट पर थोड़ा टूट जाएगा; उम्मीद है कि इससे बहुत ज्यादा फर्क नहीं पड़ता।

           // Implicit: N = array of input arrays, U = first input array, J = -1, L = 100
           // Let's use the first example. 3 input arrays, each of length 9.
C=2*Nl -2  // Set variable C to 2*N.length - 2. In the example, C is 4.
Nw      }  // Reverse N and map each index Y to:
YoY+Ul)    //  Create the range [Y...U.length+Y).
           //  The first time through (Y=0), we have   [0, 1, 2, 3, 4, 5, 6, 7, 8]
£       }  //  Map each item X and index Y to:
X%C        //   Take X mod C.                          [0, 1, 2, 3, 0, 1, 2, 3, 0]
C-X%C      //   Take C - (X mod C).                    [4, 3, 2, 1, 4, 3, 2, 1, 4]
Lm         //   Take the minimum of these and 100.     [0, 1, 2, 1, 0, 1, 2, 1, 0]
Ng         //   Get the array at the resulting index.
gY         //   Get the item at index Y in this array. [1, 8, 3, 6, 5, 4, 2, 7, 9]
·          // Join the result with newlines. I guess this isn't necessary, but it helps with readability.

गैर-प्रतिस्पर्धात्मक संस्करण, 36 बाइट्स

C=J+Nl)òC±C ®óUl)£NgLmX%CC-X%C)gY} ·

मैंने चुनौती से पहले इन दो नंबर कार्यों को लागू किया था:

  • ò- के रूप में ही o, लेकिन के [X..Y]बजाय रिटर्न[X..Y)
  • ó- के रूप में ही o, लेकिन के [X..X+Y)बजाय रिटर्न[X..Y)

लेकिन एक गलत स्थान के कारण 0, वे छोटी गाड़ी थे और हमेशा खाली सरणियाँ देते थे। अब यह सुधर गया है।

इसे ऑनलाइन टेस्ट करें!

— ETHproductions
स्रोत
2

अजगर 2, 107 106 108 105 104 बाइट्स

(कुछ अतिरिक्त परगनों को हटा दिया गया) (गलत स्थान शुरू करना (ب_ب)) (पहले से ही उस लंबाई की एक सूची थी)

def b(a):
 r,e=len(a)-1,enumerate
 print[[a[abs((i-o-r)%(r*2or 1)-r)][i]for i,_ in e(q)]for o,q in e(a)]

यह एक फ़ंक्शन के तर्क के रूप में इनपुट के लिए कानूनी है, है ना? यह मेरा पहली बार है जब मैंने अपना कोड गोल्फ उत्तर सबमिट किया।

— orez
स्रोत
हाँ, यह कानूनी है :)
— अदनान
1

एपीएल, 33 वर्ण

{(⍳≢⍵){0⌷(⍺-⍳≢⍉⍵)⊖⍵⍪1↓¯1↓⊖⍵}¨⊂↑⍵}

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

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

से

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

एपीएल में reverseऔर upward rotateएक ही प्रतीक हैं ⊖:।

— lstefano
स्रोत
पहले चरण का उपयोग करें। ⊃के बजाय 0⌷।
— ज़ाचरी जूल
मुझे डर है "पहले" और "0⌷" दो अलग-अलग परिणाम देते हैं जब एक नेस्टेड सरणी पर लागू किया जाता है। इसे अपने लिए आजमाएं। सबसे पहले बनाम 0⌷
— lstefano
1

क्लोजर, 125 बाइट्स

वाह, यह बहुत तेजी से संचित वर्ण।

(fn[v](let[H(count v)r range R(r H)](for[i R](map #((v %2)%)(r(count(v 0)))(drop i(cycle(concat R(reverse(r 1(dec H))))))))))

बस बाइट्स को बचाने के लिए letअक्सर इस्तेमाल किए जाने वाले मानों को बचाने की कोशिश कर रहा है ।

— NikoNyrh
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.