この配列を行列に変換します

13

ネストされていない配列を入力として受け取ります。次の方法を使用して、マトリックスに変換します。

私の配列が [1, 2, 3, 4, 5]

最初に、その配列を5回繰り返します：（長さ）

[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

次に、対角線に沿って読みます：

[[1],
 [2, 1],
 [3, 2, 1],
 [4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2],
 [5, 4, 3],
 [5, 4],
 [5]]

この配列を平坦化し、5つの部分（長さ）に分割します。

[[1, 2, 1, 3, 2],
 [1, 4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2, 5],
 [4, 3, 5, 4, 5]]

これはコードゴルフです。少ないバイトが勝ちます。

code-golf  array-manipulation  matrix 
— グリフォン
ソース
次回は、物事を大文字にしてください。
— オリバーNi
元の配列の長さが5以外の場合、これはどのように機能しますか？
@ ais523同じことを仮定しています。「5」を長さに置き換えるだけです
— オリバー・ニ
数値は常に正の整数であると想定できますか？
— ルイスメンドー
7
@JohnCena最初の答えを受け入れるべきではありません。牽引力を得るための時間と、さらにいくつかの答えを投稿に与える必要があります。
— カーデ

回答:

2

05AB1E、13バイト

.p¹.sR¦«í˜¹gä

オンラインでお試しください！

説明：

                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print
— オリバー・ニ
ソース
印刷する必要はありません
そして、どのように入力を要求したのですか
1
05AB1Eなどのこれらのゴルフ言語の多くには、入力を要求して出力を生成するためのデフォルトのルールが組み込まれているため、プログラマーはバイトを無駄にする必要がありません。
1
出力は実際に目的の出力と一致しません。行列ではなく、数字が一致しません。
— カールナップ
1
まあ、それは行列ですが、数値は正しくありません（またはtryitonline.netが間違って計算します）
— カールNapf
6

ゼリー、11バイト

WẋLŒDUṙLFsL

オンラインでお試しください！

説明

               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)
— リン
ソース
うーん、それを試してみたときにL奇妙なことをしたので、レジスタを使用しました：/もう一度試してみましたが、動作します...
— ジョナサンアラン
1
もちろん、Jellyには「対角線」が組み込まれています。...:)
— グレッグマーティン
3

Python 2、105 96バイト

Flp.Tkcのおかげで-1および-4および-4バイト 

a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

forループは説明のような項目を追加します。本当の魔法はここからのzipで発生します

— カール・ナップ
ソース
スパムは申し訳ありませんが、Rは1回しか使用されていないので、そこに直接置くことができます。P
— FlipTack
@ Flp.Tkc問題ありません、私は幸せです:)
— カールナップ
3

JavaScriptの（ES6）100 101 105

a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

少ないゴルフ 

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v) 
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

テスト

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()
<input id=I value='1 2 3 4 5' oninput='update()'>
<pre id=O></pre>
スニペットを展開

— edc65
ソース
1
うわー、それは回避する非常に賢い方法returnです。そのことに関するヒントをES6のヒントスレッドに投稿する必要があります。
— ETHproductions
@ETHproductionsのスコープは非常に狭いです。ほとんどの場合、evalの方が優れています。
— edc65
@ETHproductionsは確かにeval優れてさえいるこの時間:(
— edc65
@ETHproductionsヒントを投稿しました。めったに役に立たない場合でも、
— 念のため-edc65
2

MATL、17バイト

!Gg*tRwZRhPXzGne!

オンラインでお試しください！

使い方

以下の説明では、入力[1 2 3 4 5]を例として使用します。中間結果を視覚化するに%は、コード内のステートメントの後に（コメント記号）を挿入します。

;は、行列の行区切り文字であることに注意してください。そう[1 2]行ベクトルは、ある[1; 2]列ベクトルであり、[1 0; 0 1]2×2単位行列です。

!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal 
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]
— ルイス・メンドー
ソース
1

JavaScript（ES6）、116バイト

a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

まあ、それは始まりです...

— ニール
ソース
1

R、84バイト

t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

stdinから入力を読み取り、Rマトリックスを出力/返します。

reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

説明した

この答えに関する最も興味深い側面は、対角線がどのように取得されるかです。一般に、オブジェクトが分割さsplitれる要因を含むオブジェクトが提供されている場合、関数を使用してオブジェクトを分割できます。これらの要素を作成するにはcol、とrowを使用して、それぞれ列と行のインデックスを含む行列を返します。違いを取ることによりrow(m)-col(m)、次のようなマトリックスを取得します。

     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

各対角線は一意に識別されます。このマトリックスに基づいて分割し、適用することで不規則なリストに変換できますsplit。

$`-4`
[1] 1
$`-3`
[1] 2 1 
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

（各ベクトルの名前が上記のマトリックスの対角値にどのように対応するかに注意してください）。

最後のステップは、単にフラット化して、次の形式のマトリックスに変換することです。

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    1    3    2
[2,]    1    4    3    2    1
[3,]    5    4    3    2    1
[4,]    5    4    3    2    5
[5,]    4    3    5    4    5
— ビリーウォブ
ソース
0

Mathematica 93バイト

Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

通常、このコード（109バイト）を記述する方法は次のとおりです。

Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

この行列プロットは、入力ベクトルが順次増加するため、構造から良いアイデアを提供します。

ここに画像の説明を入力してください

これは、ランダムな入力ベクトルを使用したマトリックスプロットです。明らかに、いくつかの構造がまだ存在しています。

ここに画像の説明を入力してください

— ケリー・ロウダー
ソース
0

Mathematica、92バイト

n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

引数をリストとして取る名前のない関数。このような機能には他の構造もあるかもしれませんが、うまくいけば、この構造をかなりうまく使ってみました。

最初の部分n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&はn2つの引数の関数を定義します：最初の部分は長さのリストですl、2番目の部分はリストに適用する関数です。nその関数l-1時間を逆引きされた引数リストに適用し、すべての結果を出力リストに保存します。（定義rしl、途中でちょうどゴルフです。）

nは、元のリストで2回呼び出されます。1回は関数でRest（リストの最初の要素をドロップ）、もう1回は関数でMost（最後の要素をドロップ）です。これにより、必要なすべてのサブリストが作成されますが、リスト全体が2回（したがって余分Most）あり、前半が逆順に（したがってr[...]）あります。最後に~ArrayReshape~{l,l}、現在のリスト構造を忘れて、強制的にlxにしますl配列にします。

— グレッグ・マーティン
ソース
0

Mathematica、85バイト

提案された手順を文字通り実行する：

(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

私の腸は、Partこれを短くするための賢い方法があるべきだと言っていますが、私が行ったすべての試みは85バイトを超えていました。

— ゲニシス
ソース
0

ルビー（110バイト）

n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a
  #=> [[1, 2, 1, 3, 2],
  #    [1, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 5],
  #    [4, 3, 5, 4, 5]]

sort操作が必要とされないかもしれませんが、可算＃GROUP_BYのためのドキュメントは、（配列である）ハッシュ値の値の順序を保証するものではありませんが、ルビーの現在のバージョンは1が期待される順序とあれば、私が必要となる順序を提供sortしたが私のコードから削除されました。

手順は次のとおりです。

n=a.size 
  #=> 5 
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4] 
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]] 
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]} 
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] 
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

最後に、f.to_a前に示した配列を返します。

— ケーリー・スウォヴランド
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.