모든 n 열에 1에서 L (n)까지의 행렬


18

도전:

입력으로 양의 정수를 포함하는 L 을 목록으로 만드십시오 .

3 5 2 1 6

n 번째 열에 벡터 1 : L (n)이 포함 된 행렬을 만듭니다. 여기서 짧은 행에는 0이 채워집니다.

테스트 사례 :

3   5   2   1   6
-----------------
1   1   1   1   1
2   2   2   0   2
3   3   0   0   3
0   4   0   0   4
0   5   0   0   5
0   0   0   0   6

1
-
1

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

규칙 :

  • 선택적 입력 및 출력 형식
    • 목록 목록은 허용되는 출력 형식입니다.
  • 행렬은 가능한 작아야합니다 (필요한 것보다 더 많은 0으로 채울 수는 없습니다)
  • 각 언어에서 가장 짧은 코드가 승리합니다
  • 설명을 적극 권장합니다

대신 범위를 수평으로 분포시킬 수 있습니까?
Mr. Xcoder

아니요, 수직이어야합니다. 가로 / 세로라는 단어가 의미가없는 언어를 사용하는 경우 선택 사항입니다. (목록 목록이 가로 / 세로 방향과 관련이없는 언어와 관련이있을 수 있음)
Stewie Griffin

1
@StewieGriffin 어떤 깔끔한 언어가 차원을 중첩 목록과 연관시키지 않습니까?
Outgolfer Erik

4
@EriktheOutgolfer,이 사이트에는 몇 개의 제정신이 사용됩니까?
Stewie Griffin

2
하나의 @EriktheOutgolfer R은 행렬을 중첩 목록으로 보지 않고 하나의 긴 목록으로 보아 행 단위로 감 쌉니다.
JAD

답변:


18

R , 40 38 바이트

function(l)outer(m<-1:max(l),l,"<=")*m

온라인으로 사용해보십시오!

설명:

outer(A)의 매트릭스 생성 처음 두 인수의 요소의 모든 조합을 세 번째 인자 (함수)을 적용 TRUEFALSE각 열에 갖는 경우 TRUE여기서 1:max(l)미만 또는 초과의 해당 요소와 동일한 l예를 들어, 여기서 l=c(3,5,2,1,6):

      [,1]  [,2]  [,3]  [,4] [,5]
[1,]  TRUE  TRUE  TRUE  TRUE TRUE
[2,]  TRUE  TRUE  TRUE FALSE TRUE
[3,]  TRUE  TRUE FALSE FALSE TRUE
[4,] FALSE  TRUE FALSE FALSE TRUE
[5,] FALSE  TRUE FALSE FALSE TRUE
[6,] FALSE FALSE FALSE FALSE TRUE

그런 다음 결과 행렬이 A이고 A*m-> 1과 0으로 A[i,j]=A[i,j]*i강제 변환 TRUE되어 FALSE원하는 결과를 생성한다고 가정합니다 .


내 생각에 – 당신은function(l)l=scan();
AndriusZ

@AndriusZ 그러나 그때 나는 모든 print바이트를 잃어 버릴 수 있도록 모든 것을 포장해야 합니다.
주세페

나는 당신이 모든 것을 포장 할 필요는 없다고 생각한다 – TOI
AndriusZ

2
@AndriusZ 우리는 전에 이것에 대해 분명히 이야기했습니다. 이 메타 질문에 대한 유일한 대답 source(...,echo=TRUE)은 대안 제안이있는 경우 stdin을 전체 프로그램으로 사용 하고 읽는 데 +4의 벌금을 부과합니다. 전체 프로그램에 대한 R 합의에 이르렀다.
주세페

게임 후반 : [이 팁] ( codegolf.stackexchange.com/a/111578/80010 )을 사용하여 2 바이트 저장
JayCe

7

MATL , 8 바이트

"@:]Xho!

온라인으로 사용해보십시오!

설명

"      % Implicit input, L. For each k in L
  @    %   Push k
  :    %   Range [1 2 ... k]
]      % End
Xh     % Collect all stack contents in a cell array
o      % Convert to double matrix. The content of each cell is
       % right-padded with zeros if needed
!      % Transpose. Implicitly display


5

Mathematica, 20 바이트

PadRight@Range@#&

U + F3C7 (Mathematica의 내장 Transpose함수) 포함

Wolfram Sandbox에서 사용해보십시오

용법

PadRight@Range@#&[{3, 5, 2, 1, 6}]
{
 {1, 1, 1, 1, 1},
 {2, 2, 2, 0, 2},
 {3, 3, 0, 0, 3},
 {0, 4, 0, 0, 4},
 {0, 5, 0, 0, 5},
 {0, 0, 0, 0, 6}
}

설명

PadRight@Range@#&

         Range@#    (* Generate {1..n} for all elements of input *)
PadRight@           (* Right-pad 0s so that all lists are equal length *)
                   (* Transpose the result *)

@ downvoters 왜 downvotes입니까? 모두 설명해 주시겠습니까?
JungHwan Min

나는 공감하지는 않았지만 함수 서명이나 인수 입력이 없기 때문에 코드 스 니펫이 블랙 박스가되지 않기 때문이라고 생각합니다!
sergiol

5

옥타브 , 26 바이트

@(x)((y=1:max(x))'<=x).*y'

행 벡터를 입력하고 행렬을 출력하는 익명 함수.

온라인으로 사용해보십시오!

설명

입력을 고려하십시오 x = [3 5 2 1 6]. 이것은 1x5 크기의 행 벡터입니다.

1:max(x)[1 2 3 4 5 6]variable에 지정된 행 벡터를 제공합니다 y.

그 전치 즉 열 벡터 [1; 2; 3; 4; 5; 6]<=입력으로 (소자 와이즈 방송 포함) -compared [3 5 2 1 6]. 결과는 6 × 5 행렬입니다

[1 1 1 1 1;
 1 1 1 0 1;
 1 1 0 0 1;
 0 1 0 0 1;
 0 1 0 0 1;
 0 0 0 0 1]

마지막으로, 조옮김으로 [1; 2; 3; 4; 5; 6]얻은 열 벡터에 (요소별로 브로드 캐스트를 곱한) 곱 y하면 원하는 결과가 나타납니다.

[1 1 1 1 1;
 2 2 2 0 2;
 3 3 0 0 3;
 0 4 0 0 4;
 0 5 0 0 5;
 0 0 0 0 6]

1
MATLAB / Octave 제출을 기대하고있었습니다. 나는 이것을 전혀 생각하지 않고 이것을 구현 했으므로 아마도 40 바이트 이상일 것입니다. 아주 좋은 해결책 :)
Stewie Griffin



3

Pyth , 6 바이트

.tSMQZ

여기 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 (예쁜 프린트).


설명

.tSMQZ-전체 프로그램.

  SMQ-각각에 대한 포괄적 인 단항 범위를 가져옵니다.
.t-조옮김, 사본으로 패딩 ...
     Z-... 영.
         -암시 적 인쇄.

내장되지 않은 조옮김 버전 은 다음과 같습니다.

mm*hd<dkQeS

이것은 다음과 같이 작동합니다.

mm*hd<dkQeS   - Full program.

m        eS   - Map over [0, max(input)) with a variable d.
 m      Q     - Map over the input with a variable k.
   hd         - d + 1.
  *           - Multiplied by 1 if...
     <dk      - ... d is smaller than k, else 0.
              - Output implicitly.


3

실제로 17 바이트

;M╗♂R⌠╜;0@α(+H⌡M┬

온라인으로 사용해보십시오!

설명:

;M╗♂R⌠╜;0@α(+H⌡M┬
;M╗                store the maximal element (M) of the input in register 0
   ♂R              range(1, n+1) for each n in input
     ⌠╜;0@α(+H⌡M   for each range:
      ╜;0@α          push a list containing M 0s
           (+        append to range
             H       take first M elements
                ┬  transpose

네, 실제로 패딩을 지원하는 지퍼가 필요합니다 ...
Outgolfer Erik

2

파이크 , 3 바이트

Pyke의 새로운 기능인 16 진 인코딩을 사용합니다. 가장 중요한 부분은 젤리를 묶는 것입니다! 원시 바이트 :

4D 53 AC

여기 사용해보십시오!

ASCII-Pyke와 동등한 것은 4 바이트입니다 .

MS.,

어떻게?

4D 53 AC-전체 프로그램.

4D-지도.
   53-포함 범위.
      AC-0으로 바꿉니다.
           -암시 적으로 출력합니다.

-------------------------------------

MS.,-전체 프로그램.

M-지도.
 S-포함 범위.
  .,-0으로 바꿉니다.
       -암시 적으로 출력합니다.

여기에 ASCII 꽤 인쇄 버전이며, 여기 진수 인코딩 한 것입니다.


2

펄 6 , 39 바이트

{zip (1 X..$_).map:{|@_,|(0 xx.max-1)}}

시도 해봐

넓히는:

{                # bare block lambda with implicit parameter 「$_」

  zip

    (1 X.. $_)   # turn each input into a Range that starts with 1

    .map:        # map each of those Ranges using the following code

    {            # bare block lambda with implicit parameter 「@_」 
                 # (「@_」 takes precedence over 「$_」 when it is seen)

      |@_,       # slip the input into a new list

      |(         # slip this into the list

        0        # a 「0」
        xx       # list repeated by

          .max   # the max of 「$_」 (implicit method call)
          - 1    # minus 1 (so that zip doesn't add an extra row)
      )
    }
}

참고 zip최단 입력리스트가 일단 종료 배출된다.


2

C # , 136 바이트


데이터

  • 입력 Int32[] i 정수 배열
  • 출력 Int32[,] 쌍방향 배열.

골프

i=>{int m=System.Linq.Enumerable.Max(i),l=i.Length,x,y;var o=new int[m,l];for(y=0;y<m;y++)for(x=0;x<l;)o[y,x]=i[x++]>y?y+1:0;return o;};

언 골프

i => {
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    var o = new int[ m, l ];

    for( y = 0; y < m; y++ )
        for( x = 0; x < l; )
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    return o;
};

언 골프 가능

// Take an array of Int32
i => {

    // Store the max value of the array, the length and declare some vars to save some bytes
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    // Create the bidimensional array to output
    var o = new int[ m, l ];

    // Cycle line by line...
    for( y = 0; y < m; y++ )

        // ... and column by column...
        for( x = 0; x < l; )

            // And set the value of the line in the array if it's lower than the the value at the index of the input array
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    // Return the bidimentional array.
    return o;
};

전체 코드

using System;
using System.Collections.Generic;

namespace TestBench {
    public class Program {
        // Methods
        static void Main( string[] args ) {
            Func<Int32[], Int32[,]> f = i => {
                int
                    m = System.Linq.Enumerable.Max( i ),
                    l = i.Length,
                    x, y;
                var o = new int[ m, l ];
                for( y = 0; y < m; y++ )
                    for( x = 0; x < l; )
                        o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;
                return o;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new[] { 1, 2, 5, 6, 4 },
                    new[] { 3, 5, 2, 1, 6 },
                    new[] { 1, 2, 3, 4, 3, 2, 1 },
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( " INPUT: " );
                PrintArray( testCase );

                Console.WriteLine( "OUTPUT: " );
                PrintMatrix( f( testCase ) );
            }

            Console.ReadLine();
        }

        public static void PrintArray<TSource>( TSource[] array ) {
            PrintArray( array, o => o.ToString() );
        }
        public static void PrintArray<TSource>( TSource[] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 index = 0; index < array.Length; index++ ) {
                output.Add( valueFetcher( array[ index ] ) );
            }

            Console.WriteLine( $"[ {String.Join( ", ", output )} ]" );
        }

        public static void PrintMatrix<TSource>( TSource[,] array ) {
            PrintMatrix( array, o => o.ToString() );
        }
        public static void PrintMatrix<TSource>( TSource[,] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 xIndex = 0; xIndex < array.GetLength( 0 ); xIndex++ ) {
                List<String>
                    inner = new List<String>();

                for( Int32 yIndex = 0; yIndex < array.GetLength( 1 ); yIndex++ ) {
                    inner.Add( valueFetcher( array[ xIndex, yIndex ] ) );
                }

                output.Add( $"[ {String.Join( ", ", inner )} ]" );
            }

            Console.WriteLine( $"[\n   {String.Join( ",\n   ", output )}\n]" );
        }
    }
}

자료

  • V1.0 - 136 bytes- 초기 솔루션입니다.

노트

  • 없음


1

자바 10, 115 바이트

a->{int l=a.length,m=0;for(int j:a)m=j>m?j:m;var r=new int[m][l];for(;l-->0;)for(m=0;m<a[l];r[m][l]=++m);return r;}

설명:

온라인으로 사용해보십시오.

a->{                  // Method with integer-array parameter and integer-matrix return-type
  int l=a.length,     //  Length of the array
      m=0;            //  Largest integer in the array, 0 for now
  for(int j:a)        //  Loop over the array
    m=j>m?            //   If the current item is larger than `m`:
       j              //    Set `m` to this item as new max
      :               //   Else:
       m;             //    Leave `m` the same
  var r=new int[m][l];//  Result-matrix of size `m` by `l`, filled with zeroes by default
  for(;l-->0;)        //  Loop over the columns
    for(m=0;m<a[l];   //   Inner loop over the rows
      r[m][l]=++m);   //    Set the cell at position `m,l` to `m+1`
  return r;}          //  Return the result-matrix


0

양성자 , 38 바이트

a=>[[i<j?-~i:0for j:a]for i:0..max(a)]

온라인으로 사용해보십시오!


내가 생각하기에, 버그는 그 이후의 공간입니까?
caird coinheringaahing

@cairdcoinheringaahing 예. 물음표는 다른 물음표가 아닌지 확인하기 위해 문자를 소비하지만 추가 문자를 건너 뛰는 것을 보상하는 것을 잊었습니다.
HyperNeutrino

당신은 풀을 가지고있는 것, 당신은 이제 통지를 제거 할 수 있습니다 :)
에릭 The Outgolfer


당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.