Einführung

Arrays können auch als Feld für einen springenden Ball betrachtet werden. Das klingt natürlich sehr vage, daher hier ein Beispiel für eine Eingabe:

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

Die Herausforderung besteht darin, die zurückgeworfenen Arrays auszugeben . Diese bestehen aus diagonalen Mustern, die an den Feldrändern abprallen. Dieser Weg ist nach oben gerichtet . Der Pfad für das erste zurückgeworfene Array (in dem der Pfad direkt von der egde zurückgeworfen wird) lautet:

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

Dies würde von links nach rechts zur Folge haben [1, 8, 3, 6, 5, 4, 7, 2, 9]. Dies ist unser erstes abgepralltes Array. Der Pfad für das zweite zurückgeworfene Array:

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

Dies führt zu [9, 2, 7, 4, 5, 6, 3, 8, 1]. Der Pfad für das dritte zurückgeworfene Array lautet:

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

Dies führt zu [1, 8, 3, 6, 5, 4, 7, 2, 9]. Die drei abgeprallten Arrays sind also:

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

Aufgabe

Bei mindestens einem Array, das nur nicht negative Ganzzahlen enthält und bei dem alle Arrays die gleiche Länge haben, werden alle zurückgeworfenen Arrays ausgegeben.

Testfälle

Testfall 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]

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Pyth, 17 Bytes

>lQC.e.>bkC+_PtQQ

Erläuterung:

                      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

Probieren Sie es hier aus .

JavaScript (ES6), 70

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

PRÜFUNG

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>

CJam, 31 30 Bytes

q~__W%1>W<+_z,_@*<zee::m>z\,<p

Ein- und Ausgabe als Liste von Arrays im CJam-Stil.

Teste es hier.

Auf jeden Fall golfen ...

Jelly, 29 25 24 Bytes

ṖḊm-³;Z
,ZL€R_€/‘ż€Çị/€€

Vielen Dank für @ Sp3000, dass Sie mir geholfen haben, 5 Bytes Golf zu spielen!

Probieren Sie es online!

Ruby (2.2.2p95), 124 Bytes

->*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}}}

Das könnte wahrscheinlich viel besser sein. Ich werde später herausfinden, wie!

Japt, 55 49 41 39 Bytes

Wow, das war wirklich knifflig und hat wahnsinnig Spaß gemacht.

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

Online testen!

Ausgänge in umgekehrter Reihenfolge zu den Beispielen. Bei Eingaben von mehr als 100 Arrays wird dies leicht unterbrochen. hoffentlich macht das nicht allzu viel aus.

           // 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.

Nicht konkurrierende Version, 36 Bytes

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

Ich hatte diese beiden Nummernfunktionen vor der Herausforderung implementiert:

• ò- wie o, kehrt aber zurück [X..Y]statt[X..Y)
• ó- wie o, kehrt aber zurück [X..X+Y)statt[X..Y)

Aufgrund eines Verlegers 0waren sie jedoch fehlerhaft und gaben immer leere Arrays zurück. Dies wurde nun behoben.

Online testen!

Python 2, 107 106 108 105 104 Bytes

(Einige zusätzliche Parens entfernt) (Falscher Startort (ب_ب)) (hatte bereits eine Liste mit dieser Länge)

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

Es ist legal, die Eingabe als Argument für eine Funktion zu haben, oder? Dies ist mein erstes Mal, dass ich meine Code Golf Antwort abschicke.

APL, 33 Zeichen

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

Angenommen, ⎕IO ← 0. Die Idee ist, dass die Sprungbewegung durch einfaches Verschieben einer Matrix nach oben erhalten werden kann, wenn die ursprüngliche Matrix entlang der ersten Dimension vergrößert wird, wobei die Matrix mit der ersten und der letzten rasierten Reihe umgekehrt wird. Grafisch:

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

von

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

In APL reverseund upward rotateist das gleiche Symbol: ⊖.

Clojure, 125 Bytes

Wow, das hat sich ziemlich schnell angesammelt.

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

letIch versuche nur, Bytes zu speichern, indem ich häufig verwendete Werte definiere.

Jelly *, 15 Bytes

JṚŒḄṖṙ’Ʋị⁸Jị"$€

Probieren Sie es online!

^{* Neuere Version}