1. bölümdeki matris listeleri için notumu düzeltin

21

Bazen kodumda sürekli matris listeleri var:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

Bu ekran gayrimenkulünün korkunç bir kullanımı. Onları yanyana yazmayı tercih ederim:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

Bunun hâlâ sözdizimsel olarak geçerli bir yuvalanmış liste olduğunu göreceksiniz, artık sadece dikdörtgen değil ve çok farklı bir yapıya sahip (özellikle 1x1'den büyük bir matris eklediğimde daha da derinleşiyor). Bununla birlikte, ilk matris listesini bu yeni listeden yeniden oluşturmak mümkündür.

Gelecekte bu sözdizimini kullanabilmem için, yatay bir düzende yazılmış dizileri temsil ettikleri matris listesine dönüştüren bazı kodlar yazmanıza ihtiyacım var.

Yanıtların kaynak koddaki düzende 2B desen eşleştirmesi yapmadığından emin olmak için girişe yalnızca dizi nesnesi olarak veya bir dize temsili alırsanız, girişin nasıl yapıldığını belirten herhangi bir boşluk içermez. değişmez kodda yazılmıştır. Böylece şöyle bir girdi elde edersiniz:

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

Ve çıktı şu dizi veya dizge gösterimi olmalıdır (yine, başka bir düzen gerekmez):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

Bu, iki bölümden oluşan bir mücadelenin ilk ve daha kolay kısmı. Bu bölümde, tüm matrislerin kare olduğunu ve aynı boyutlara sahip olduğunu ve yan yana düzgün bir şekilde hizalandığını varsayabilirsiniz. İkinci bölümde bu varsayımları rahatlatacağız.

kurallar

Girdi, iç içe geçmiş bir liste veya kanonik dize temsili olacaktır (tercih ettiğiniz dilde) ve sonucu aynı biçimde vermelisiniz. Sonuç daima en az bir matris içerecektir ve matrisler 1x1 kadar küçük olabilir. Matrisler, yalnızca mutlak değeri 128'den küçük olan (işaretli) tam sayıları içerir.

Bir program veya fonksiyon yazabilir ve giriş alma ve çıkış sağlama standart yöntemlerinden herhangi birini kullanabilirsiniz .

Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Bu kod-golf , yani en kısa geçerli cevap - bayt olarak ölçülen - kazanır.

Test Kılıfları

Her test durumu onlar kodunda olacağı gibi liste matrisleri (bu yanyana güzel ortaya koydu) bir sahiptir değil girişinizi), b) yabancı boşluk olmadan biçimlendirilmemiş listesi ( bu ) sizin girdidir, c) beklenen çıktı.

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]
code-golf  array-manipulation  matrix  syntax 
— Martin Ender
kaynak
1
Sanırım bu mücadeleye neyin ilham verdiğini biliyor olabilirim ...
— Neil
[([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]Üçüncü test çantası için geçerli çıktı mı ? Karışık liste ve demet.
— ovs
@ovs Hayır, özür dilerim. Giriş ve çıkış formatlarının eşleşmesi gerektiğinden, karşılık gelen giriş olacaktır [([1,0], ([1, 0}, ...ve bu size ek bilgi verecektir.
— Martin Ender
@Bu bu mücadeleden ilham alan ne?
— caird coinheringaahing
@RandomUser Her şeyi golf yapma arzusu. Ekrandaki en az miktarda emlak kazanır!
— Dennis

Yanıtlar:

14

Jöle , 20 15 13 11 bayt

Fðs⁹œsZµḢḢL

Çevrimiçi deneyin!

Arka fon

Çoğu şey gibi, ne yapmanız gerektiğine karar verdikten sonra bu zorluk oldukça basittir. Ve sonunda yaptım, üç silme ve bir geri alma işleminden sonra ...

İlk önce, matrislerin boyutlarını bulmalıyız. Söylemesi yapmaktan daha kolay: ilk elemanın ilk elemanı ilk çıkış matrisinin ilk satırıdır, dolayısıyla uzunluğu kare çıkış matrislerinin sütun sayısına eşittir.

Örneğin, giriş

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

ilk elemanın ilk elemanı, [1, 0, 0]uzunluğu ℓ = 3 olan .

Girdiyi düzleştirir ve bu uzunluktaki topaklara bölersek, çıkış matrislerinin tüm satırlarını yanlış sırada olsa bile alırız. Örnek girdi için, bu verir

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

Son çıktıyı elde etmek için, önce satır dizisini eşit uzunlukta ℓ parçalara bölmeliyiz . Örnek girdi için, bu verir

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

Her sütun şimdi çıktı matrislerinden biri olduğundan, sonuçta elde edilen dizi matrisini transpose etmek, geriye kalan tek şeydir. Örnek girişimiz için bu

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

istediğiniz gibi.

Nasıl çalışır

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.
— Dennis
kaynak
6

Pyth , 12 bayt

CcJlhhQc.nQJ

Bu Jelly cevabımın bir limanı.

Çevrimiçi deneyin!

Nasıl çalışır

Pyth programı aşağıdaki gibi ayrıştırır (sözde kodu).

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q , girişi tutan bir değişkendir. J tanımsız bir değişkendir.

İlk J = l(h(h(Q)))kafasının depolar kafası (birinci elemanın) uzunluğu Q olarak J .

Daha sonra, Q.n(Q) düzleştirilir ve sonucu J uzunluğunda parçalara böler .c(..., J)

Daha sonra c(J, ...)sonucu J parçalarına böler .

Sonunda C(...)sonucu aktarır.

— Dennis
kaynak
1
sancta mater dei
— Sızdıran Rahibe
3

Pyth , 29 bayt

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

Test odası.

Nasıl çalışır

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

Algoritma

Girdi üzerinde çalışalım [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Burada saf string işlemleri kullanacağız.

İlk olarak, girdiyi en derin listenin parçası olmayan virgüllerden ayırırız (bu, regex'te bölerek yapılır \B,):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

Sonra, birlikte başlamaz ilk alt dizenin dizinini bulmak [[(bu dizinde karakter olup olmadığını kontrol ederek yapılır 1ise [). Bu durumda, 44 numaralı indeksteki alt dizenin [0,1]]başlamadığı durumdur [[.

Sonra, alt dizileri 4'lü gruplar halinde gruplandırırız ve sonra transpoze ederiz:

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

Ve sonra virgüllerle onlara katılırız:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]
— Sızdıran Rahibe
kaynak
2
Sen sadece Dennis tarafından çok büyük bir şekilde kızdın .
— Outgolfer Erik,
3

JavaScript (ES6), 132 130 bayt

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

Dört vaka var:

  • Sadece döndürülen 1 × n dizisi (bu ilk sınama, ancak ters çevrilmiş)
  • Henüz düzleştirilmemiş bir m × n dizisi n, aynı anda sayarak bir adım tekrarlayarak düzleştirdik .
  • Her bir nelementi filtrelediğimiz düzleştirilmiş bir m × n dizisi .
  • Sadece döndürülen bir m × 1 dizisi
— Neil
kaynak
1

Mathematica, 104 bayt

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

Giriş

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

çıktı

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

giriş

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {0, 0, 0}}}

çıktı

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}

{{{0}}} ve {{{-1}}, {{0}}, {{1}}}

Martin Ender sayesinde -11 bayt

— J42161217
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.