블록-대각선 행렬 인쇄

27

간단한 바이트 크기 (바이트 크기의) 코드 골프는 다음과 같습니다. 10보다 작은 양의 정수로 구성된 비어 있지 않은 목록이 주어지면 블록-대각 행렬을 인쇄합니다 . 여기서 목록은 블록의 크기를 순서대로 지정합니다. 블록은 10보다 작은 양의 정수로 구성되어야합니다. 따라서 입력으로 주어지면

[5 1 1 2 3 1]

예를 들어, 출력은

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

또는

1 2 3 4 5 0 0 0 0 0 0 0 0
6 7 8 9 1 0 0 0 0 0 0 0 0
2 3 4 5 6 0 0 0 0 0 0 0 0
7 8 9 1 2 0 0 0 0 0 0 0 0
3 4 5 6 7 0 0 0 0 0 0 0 0
0 0 0 0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 9 0 0 0 0 0 0
0 0 0 0 0 0 0 1 2 0 0 0 0
0 0 0 0 0 0 0 3 4 0 0 0 0
0 0 0 0 0 0 0 0 0 5 6 7 0
0 0 0 0 0 0 0 0 0 8 9 1 0
0 0 0 0 0 0 0 0 0 2 3 4 0
0 0 0 0 0 0 0 0 0 0 0 0 5

또는 그런 것. 행렬의 요소는 (단일) 공백으로 구분되고 행은 (단일) 줄 바꿈으로 구분해야합니다. 행에 선행 또는 후행 공백이 없어야합니다. 후행 줄 바꿈을 인쇄하거나 인쇄하지 않을 수 있습니다.

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 편리한 문자열 또는 목록 형식 (전처리되지 않는 한)을 통해 입력을받는 함수 또는 프로그램을 작성할 수 있습니다. 그러나 결과는 함수에서 반환되는 것과 달리 STDOUT (또는 가장 가까운 대안)으로 인쇄되어야합니다.

블록 대각 행렬을 만들도록 설계된 내장 함수를 사용해서는 안됩니다.

이것은 코드 골프이므로 가장 짧은 제출 (바이트)이 이깁니다.

리더 보드

나는 배열 기반 언어 (J 및 APL과 같은)가 여기에 우위를 차지할 것으로 기대하지만, 사람들이 선택한 언어로 할 수있는 일을하지 못하게하기를 원하지 않습니다. 다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다. 그렇다면 왜 후자를 찾아 보지 않겠습니까?

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

코드 스 니펫 표시

code-golf  array-manipulation 
— 마틴 엔더
소스

답변:

20

J, 7 바이트

2 바이트 개선을 위한 FUZxxl 에 감사합니다 .

배열 기반 언어는 큰 이점이 있으므로 다른 경쟁에서 계산해야합니다. :)

   =/~@#<\

   (=/~@#<\) 3 1 1 2
1 1 1 0 0 0 0
1 1 1 0 0 0 0
1 1 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 1
0 0 0 0 0 1 1

또 다른 7 바이트 접근법 :

#]=@##\

이전 버전에 대한 설명 ([:=/~]#<\):

첫 번째 단계는 n모든 list 요소에 대해 비슷한 것들 (예 : 숫자)을 생성하는 것입니다 n. 이것들은 다른 요소들과 달라야합니다. 예를 들어 자연수를 사용하면 3 1 1 2이됩니다 0 0 0 1 2 3 3.

바이트를 절약하기 위해리스트의 박스 접두사를 사용합니다 :

   ]#<\ 3 1 1 2
┌─┬─┬─┬───┬─────┬───────┬───────┐
│3│3│3│3 1│3 1 1│3 1 1 2│3 1 1 2│
└─┴─┴─┴───┴─────┴───────┴───────┘

으로 =/~동사 우리는이 박스 접두사의 데카르트 제품의 테이블을 만들고 각 셀이 될 것입니다 1두 항목이 동일한 경우 0그렇지.

— 랜덤
소스
2
나는 괄호 [:=/~]#<\ 가 당신의 점수를 계산 한다고 생각하지 않습니다 . 또한 =/~@#<\ 2 바이트가 더 줄어 듭니다.
— FUZxxl
"그러나 함수에서 반환되는 것과 달리 결과는 STDOUT (또는 가장 가까운 대안)으로 인쇄되어야합니다 ." 명시 적 입력 (기능이 아니라) 또는 명시 적 출력이 필요할 수 있습니다.
— marinus
@marinus J는 변수에 바인딩되지 않은 식의 결과를 stdout에 출력합니다.
— FUZxxl
@FUZxxl : 예, 그러나 (=/~@#<\)단지 기능입니다. 당신이 명시 적으로 입력 (필요 했어, 그래서 당신은 실제로 식을 얻기 위해 무엇인가에 적용해야 할 것 ".1!:1[1), 또는 기능을 제출하려는 경우, 그 기능은 실제로 값을 출력한다뿐 아니라 (반환 같은 echo@또는 뭔가 ).
— marinus
=/~&I.­­­­­­­
— ngn
11

APL, 10

∘.=⍨∆/⍋∆←⎕

예:

      ∘.=⍨∆/⍋∆←⎕
⎕:
      5 1 1 2 3 1 
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

설명:

  • ∆←⎕: 입력을 읽고 저장 ∆합니다.
  • ⍋∆: 정렬 순열 찾기 ∆(입력의 각 값에 고유 한 값을 제공함)
  • ∆/: 고유 한 값 각각에 대해 N시간을 반복하십시오 . 여기서 N입력의 해당 값은
  • ∘.=⍨: 해당 목록의 각 값을 다른 값과 비교하는 행렬을 만듭니다.
— 마리 누스
소스
이 기능을 테스트하려면 http://tryapl.orgdfn을 사용하는 {∘.=⍨⍵/⍋⍵}것이 좋습니다. 사이트는 모든 용도 ⎕(예 : 제외)를 필터링합니다 ⎕IO.
— FUZxxl
1
@FUZxxl : "하지만 함수에서 반환 된 것과 달리 결과를 STDOUT (또는 가장 가까운 대안)으로 인쇄해야합니다 ."라고 표시되어 있으므로 {∘.=⍨⍵/⍋⍵}유효하지 않습니다. 당신은 {⎕←∘.=⍨⍵/⍋⍵}2 문자를 요구할뿐만 아니라 TryAPL에서 여전히 작동하지 않을 것입니다. (그리고 일반적으로 TryAPL은 너무 제한되어 유용하지 않습니다.)
— marinus
결과를 인쇄해야 ⎕←한다면 dfn이 없어도 어쨌든 필요 하지 않습니까?
— FUZxxl
@FUZxxl : 아니오, 다른 작업을 수행하지 않으면 표현식의 출력이 자동으로 인쇄됩니다.
— marinus
아, 알겠습니다 인터프리터를 대화식으로 사용할 때만 발생한다는 인상을 받았습니다.
— FUZxxl
8

R, 69 63

function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))

테스트 사례 :

(function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x)))(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
1 1 1 1 1 0 0 0 0 0 0 
0 0 0 0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 0 0 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 1 1 1 0 
0 0 0 0 0 0 0 0 0 0 1

외부 함수는 대부분의 작업을 수행 한 다음 출력을 올바르게 보는 경우입니다. @ Vlo 덕분에 도움을 주셔서 감사합니다.

— 미프
소스
아주 좋은 해결책
— MickyT
훌륭한 솔루션. -/+논리를 강요하기 위해 사용 하는 것에 대해 생각하지 마십시오 . 몇 바이트를 절약하십시오 function(x)write(+outer(i<-rep(1:length(x),x),i,"=="),1,sum(x))63
— Vlo
6

파이썬 3, 103 97 82 78 76 바이트

def P(L,n=0):k,*L=L;exec("print(*[0]*n+[1]*k+[0]*sum(L));"*k);L and P(L,n+k)

splat을 사용 print하여 약간의 재귀로 공간 분리 특성을 활용할 수 있습니다 .

— Sp3000
소스
6

루비, 86 90 83 바이트

내 첫 골프!

->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}

정수로 배열을 받고 예상 결과를 인쇄합니다.

$ (->l{n=l.reduce :+;s=0;l.map{|x|x.times{puts ([0]*s+[1]*x+[0]*(n-x-s))*" "};s+=x}}).call([5, 1, 1, 2, 3, 1])
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1

편집하다:

몇 가지를 줄 이도록 도와 준 Martin Büttner에게 감사합니다!

— 롤 로크
소스
1
더 많은 문자를 저장할 ->(l)수 있습니다 ->l. map보다 짧습니다 each. .join(" ")로 단축 할 수 있습니다 *" ".
— Martin Ender
6

Matlab, 60 54 바이트

이것이 Matlab의 특수 필드 IF내장 함수를 사용할 수 이것이 ...

내가 놓친 오류를 해결해 주셔서 감사합니다.

c=0;a=input('');for A=a;v=c+1:c+A;d(v,v)=1;c=c+A;end;d
— 플레어
소스
우와, 지금 까지이 js 스 니펫이 실제로 리더 보드를 생성한다는 것을 알았습니다 !!! 나는 이것을 어떻게 알지 못했습니까 ??? 이것을 지적 해 주셔서 감사합니다 =)
— flawr
알아요? 그것은 정말로 멋있어요!
— Alex A.
1
나는 거의 같은 대답 :-) 게시하고 있었다
— 루이스 Mendo
정확히 같거나 약간 다른가? =) (변수 이름 제외)
— flawr
내가 그것을 게시하기에 너무 비슷합니다 :-)
— Luis Mendo
6

Matlab, 53 바이트

다른 Matlab 조각보다 하나의 문자 만 짧지 만 새로운 대답을 보증하기에 코드가 충분히 다른 것으로 나타났습니다.

d=[];a=input('');for A=a;v=1:A;d(end+v,end+v)=1;end;d

주요 트릭은 물론 범위를 벗어난 인덱싱이지만 end변수로 사용하여 더 컴팩트하게 만듭니다.

— 데니스 예허 루딘
소스
1
젠장-나는 end+1:end+v'카운터'변수를 없애기 위해 골프 를 하려고 30 분을 보냈 지만이 해결책을 생각하지 못했습니다.
— Sanchises
실제로 @Geobits가 언급했듯이 익명의 편집 시도 blkdiag는 요구 사항을 위반합니다. 참고로 나는 그것의 핵심을 어쨌든 여기에 넣을 것이다 :blkdiag(A,ones(i))
— Dennis Jaheruddin
4

CJam, 21

q~{T):Ta*~}%_f{f=S*N}

http://cjam.aditsu.net/ 에서 시도 하십시오

설명:

q~          read and evaluate the input array
{…}%        transform each number using the block
    T):T    increment T (initially 0)
    a*      wrap T in an array and repeat it <number> times
    ~       dump the repeated numbers so they end up in a flat array
_           duplicate the array
f{…}        for each array item and the array
    f=      compare the current item with each item, resulting in an array of 1 and 0
    S*      join with spaces
    N       add a newline
— 아디 츠
소스
4

파이썬 3, 79

def f(l,s=0):
 for x in l:r=[0]*sum(l);r[s:s+x]=[1]*x;s+=x;exec("print(*r);"*x)

블록의 가장 왼쪽 인덱스를 추적하고 이후 s에 x항목을 만듭니다 ( 현재 블록 크기는 1어디에 있습니까 x). 그런 다음이 행이 인쇄 x됩니다. 파이썬 3이 필요합니다 print(*r).

— xnor
소스
그것은 어떻게 표현 단지 하나 개의 문자 짧다 r같은 [0]*s+[1]*x+[0]*(sum(l)-s-x),하지만 난 여전히 더 나은 방법을 찾고 있어요.
— xnor
4

하스켈, 118116 바이트

(#)=replicate
f i=putStr$[e#(unwords$sum h#"0"++e#"1"++sum t#"0")|(h,e:t)<-map(`splitAt`i)[0..length i-1]]>>=unlines

용법: f [2,1,1,3]

산출:

1 1 0 0 0 0 0
1 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 1 1
0 0 0 0 1 1 1
0 0 0 0 1 1 1

작동 방식 :

[0..length i-1]           for each index n of the input list i
(h,e:t)<-map(`splitAt`i)  split i at n and
                            let e be the element at index n
                            let h be the list of elements to the left of e
                            let t be the list of elements to the right of e
                          foreach triple h, e, t make a list of
sum h # "0" ++              sh copies of "0" (sh = the sum of the elements of h) followed by
e # "1" ++                  e copies of "1" followed by
sum t # "0"                 st copies of "0" (st = the sum of the elements of t)
unwords                   join those list elements with spaces inbetween
e #                       make e copies
>>=unlines                join those lists with newlines inbetween
putStr                    print
— 니미
소스
당신은 수행하여 2 바이트를 저장할 수 (h,e:t)<-map(`splitAt`i)[0..length i-1]있기 때문에, n외부 사용하지 않는 let바인딩.
— Zgarb
@ Zgarb : 좋은 발견. 감사!
— nimi
3

Pyth, 23 21 바이트

Pyth 용 GitHub 저장소

Ju+G*]GHQYFNJjdmsqdNJ

입력은와 같은 정수 목록입니다 [3, 1, 1, 2]. 온라인 사용해보기 : Pyth Compiler / Executor

randomra의 J 코드와 매우 유사한 아이디어를 사용합니다. 코드의 첫 부분Ju+G*]GHQYn 은 비슷한 부분을 생성 합니다. 예제 입력 [3, 1, 1, 2]의 경우 결과는 다음과 같습니다.

[
 [], 
 [], 
 [], 
 [[], [], []], 
 [[], [], [], [[], [], []]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]], 
 [[], [], [], [[], [], []], [[], [], [], [[], [], []]]]
]

처음 세 개의 동일한 요소가 하나의 요소보다, 하나의 요소가 다시, 마지막에 두 개의 동일한 요소가 있습니다. 

Ju+G*]GHQY
 u      QY  reduce the input Q, start with empty list G=[]
            for each H in input, replace the value of G by:
  +G*]GH       G+[G]*H
J           store the result in J

코드의 두 번째 부분은 데카르트 제품의 요소를 비교하여 인쇄하는 것입니다. 

FNJjdmsqdNJ
FNJ          for N in J:
     m    J     map each element d of J to
       qdN          the boolean value of d == N
      s             and convert it to an integer (0 = False, 1 = True)
   jd           print the resulting list seperated by d (=space)
— 자쿠 베
소스
3

C ++, 294 바이트

사용 된 컴파일러-GCC 4.9.2

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n,i,j,s,o;
main(){V v;while(cin>>n)v.push_back(n),s+=n;vector<V> m(s,V(s,0));F(i,v.size()){F(j,v[i])F(n,v[i])m[j+o][n+o]=1;o+=v[i];}F(j,s){F(n,s)cout<<m[j][n]<<((n==s-1)?"":" ");cout<<"\n";}}

설명-: 

#include<bits/stdc++.h>
using namespace std;
#define F(a,b) for(a=0;a<b;a++)
#define V vector<int>
int n, i, j, s, o;
/*
 n = Used to take inputs, and as an iterator after that
 i, j = Iterators
 s = sum of all the inputs
 o = offset ( used to find the location of the starting cell of the next matrix of 1's )
*/

main()
{
    V v;
    while ( cin >> n )  // Take input
    {
        v.push_back( n ), s += n;
    }

    vector<V> m( s, V( s, 0 ) ); // m is a matrix of size (s*s) with all elements initialized to 0
    F( i, v.size() )
    {
        F( j, v[i] )F( n, v[i] )m[j + o][n + o] = 1; // Assign 1 to the required cells
        o += v[i]; // Add the value of the current element to the offset
    }

    F( j, s )  // Output the matrix
    {
        F( n, s )cout << m[j][n] << ( ( n == s - 1 ) ? "" : " " ); // Prevent any trailing whitespace
        cout << "\n";
    }
}
— 안몰 싱 자기
소스
3

K, 30 바이트

{"i"$,/x#',:',/'g=\:\:x#'g:<x}

기본적으로 마리 누스의 대답을 훔쳤습니다.

k){"i"$,/x#',:',/' g=\:\:x#'g:<x}5 1 1 2 3 1
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
— 마틴
소스
2

자바, 163

a->{int n=a.stream().mapToInt(x->x).sum(),t=0,j,k;for(int i:a){for(j=0;j++<i;System.out.println("\b"))for(k=0;k<n;)System.out.print(k>=t&k++<t+i?"1 ":"0 ");t+=i;}}

정수 목록을 허용하는 소비자.

상용구 코드와 함께 읽을 수있는 버전 :

java.util.function.Consumer<java.util.List<Integer>> c = a -> {
    int n = a.stream().mapToInt(x -> x).sum(), t = 0, j, k;
    for (int i : a) {
        for (j = 0; j++ < i; System.out.println("\b")) {
            for (k = 0; k < n;) {
                System.out.print(k >= t & k++ < t + i ? "1 " : "0 ");
            }
        }
        t += i;
    }
};

다음을 사용하여 호출하십시오.

List list = Arrays.asList(5, 1, 1, 2, 3, 1);
c.accept(list);
— 입니 프
소스
2

파이썬 2, 163114 바이트

gnibbler는이 무리를 골프로 쳤다.

h=input()
r=range
l=len(h)
for i in r(l):
 for k in r(h[i]):print" ".join("01"[i==j]for j in r(l)for x in r(h[j]))
— KSFT
소스
3
방법은 print" ".join("01"[i==j]for j in r(l(h))for x in r(h[j]))?
— gnibbler
하 ! 나는 그런 식으로 할 수 있다고 생각했습니다.
— KSFT
이것은 각 블록의 한 행만 인쇄하는 것으로 보입니다.
— xnor
@xnor 당신이 맞아요; 나는 그것을 고쳤다.
— KSFT
2

파이썬 3, 74

def f(a,p=0):n=a.pop(0);exec("print(*'0'*p+'1'*n+'0'*sum(a));"*n);f(a,p+n)
— 페어 섬
소스
오류가 발생하지 않습니까?
— xnor
@ xnor 예 그렇습니다!
— feersum
1
@feersum 허용됩니까? 문제에 대한 메타 게시물이 없습니다. 어떻게 생각해, 마틴? 허용되는 경우 Sp3000은 and단락 을 제거하여 6 문자를 절약 할 수 있습니다 .
— xnor
@xnor 오류가 프로그램을 종료합니까 아니면 함수 호출 만 종료합니까? 이것이 프로그램을 종료하면 아니오라고 생각하지 않습니다. 여기 메타 에 대한 의견을 표명했습니다 . 나는 또한 만약 feersum이 이것이 완전히 합법적이라고 생각한다면, 그는 아무도 눈치 채지 않기를 바라는 대신에 그의 대답으로 진술했을 것입니다.
— Martin Ender 2019
@ MartinBüttner 내가 원하는 것을 이해하면 프로그램을 종료하십시오. 할 경우 f([1,2,3]);print("Done")블록 매트릭스를 인쇄 한 후 프로그램을 종료하면 오류가 발생하고 "완료"를 인쇄하지 못합니다.
— xnor
2

자바 스크립트 (ES6), 103 (107)

계산하지 않는 익명 함수로 103 바이트 F=(그러나 테스트하려면이 기능 이 필요함)

F=l=>alert(l.map((n,y)=>(l.map((n,x)=>Array(n).fill(x==y|0))+'\n').repeat(n))
.join('').replace(/,/g,' '))

Firefox / FireBug 콘솔에서 테스트

F([5,1,1,2,3,1])

산출

1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 1
— edc65
소스
1

피스, 31 30

FbQVbjd++*]0Z*b]b*]0--sQbZ)~Zb

꽤 순진한 프로그램은 stdin에서 입력을받습니다. 이것은 아마 더 골프 될 수 있습니다;)

낭비 문자를 지적 해 주셔서 감사합니다 @Jakube

여기 사용해보십시오

— FryAmTheEggman
소스
1

펄, 69

#!perl -na
$j=s/./0 x$&/ger;print+($j|$i.1x$_)=~s/\B/ /gr x($i.=0 x$_,$_)for@F

표준 입력을 사용합니다.

$ perl a.pl <<<"1 2 3"
1 0 0 0 0 0
0 1 1 0 0 0
0 1 1 0 0 0
0 0 0 1 1 1
0 0 0 1 1 1
0 0 0 1 1 1
— nutki
소스
이상하게도, 이것은 ideone 에서 나에게 줄 바꿈을 인쇄하지 않습니다 . 또한 이 게시물에 따르면 사용자 정의 shebang을 2가 아닌 4 바이트로 코딩해야합니다. shebag를 사용하지 않고 인터프리터에서 플래그를 사용하고 -e파일 대신 코드를 호출하여 문제를 해결할 수 있습니다 (메타 포스트의 예제 참조). 또한, 나는 당신이 필요하지 않은 생각 nperldoc을 따라, - 플래그를 a세트 n암시.
— Martin Ender
프로그램은 표준 입력에서 eol을 재사용합니다. 추가하면 설정이 작동합니다. 문자 수는 모든 대답 에서이 방법으로 계산되며 다른 사람들 도이 방법으로 수행하는 것을 보았습니다. 이전에 연결 한 게시물을 보았지만 "차이를 세어"라는 의미를 얻지 못했습니다 perl -nl file.pl. 원래 perlgolf 규칙은 하이픈을 계산하지만 공백은 포함하지 않으므로이 경우 3 자입니다.
— nutki
@ MartinBüttner, randomra의 접근 방식이 훨씬 짧은 솔루션을 제공하기 때문에 어쨌든 모두 혼란 -lna //,print join$",map$'==$_|0,@,for@,=map{(++$i)x$_}@F입니다. BTW 펄의 나의 버전은 설정하지 않습니다 -n와 함께 -a, 그것은 최근에 추가해야합니다.
— nutki
1

R, 117 144 137 133 129 123 bytes

Reasonably verbose at the moment. Should be able to shave a few more out. Gained a number of bytes formatting it correctly, but saved some swapping out the matrix for an array.

Thanks to Alex for the tip on the replacing sep with s and removing the function name.

Dropped the array completely and used a series of reps to build each line.

Although soundly beaten by Miff, his solution made me realise I could drop the s=' ' altogether.

function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T);if(d==n)b=d}}

And the test

> (function(i){s=sum(i);i=cumsum(i);b=0;for(n in 1:s){d=i[i>=n][1];cat(c(rep(0,b),rep(1,d-b),rep(0,s-d)),fill=T,s=' ');if(d==n)b=d}})(c(5,1,1,3,1))
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 1 1 1 0
0 0 0 0 0 0 0 0 0 0 1
>
— MickyT
소스
You can save 2 bytes using partial matching of function parameters. In cat(), change sep= to s= since no other recognized parameters for that function begin with "s".
— Alex A.
@Alex Thanks, didn't realise that. Still on a learning curve
— MickyT
You can save another 2 by removing f=. This gives you a function object. If you do that, you just have to stipulate that it be assigned using something like f= before running it. I didn't realize that was legit in contests like this until I saw Martin Büttner do it with Ruby.
— Alex A.
1

Batch - 226 Bytes

@echo off&setLocal enableDelayedExpansion&set c=0&for %%a in (%*)do set/ac+=1&for /l %%b in (1,1,%%a)do (set l=&set d=0&for %%c in (%*)do (set/ad+=1&for /l %%d in (1,1,%%c)do if !d!==!c! (set l=!l!1)else set l=!l!0)
echo !l!)

Takes input from stdin (C:\>script.bat 5 1 1 2 3 1) and echo's output. Unfortunately I couldn't get that last echo on the same line, otherwise I could probably call the whole line within cmd/von/c to avoid having to enable delayed expansion the long way.

Nice and neat - nothing but grunt work:

@echo off
setLocal enableDelayedExpansion
set c=0
for %%a in (%*) do (
    set /a c+=1
    for /l %%b in (1,1,%%a) do (
        set l=
        set d=0
        for %%c in (%*) do (
            set /a d+=1
            for /l %%d in (1,1,%%c) do if !d!==!c! (set l=!l!1) else set l=!l!0
        )
        echo !l!
    )
)
— unclemeat
소스
1

Haskell, 124

(%)=replicate
d l=fst$foldr(\x(m,n)->(m>>mapM_(\_->putStrLn$unwords$n%"0"++x%"1"++(sum l-n-x)%"0")[1..x],n+x))(return(),0)l

Produces output by combining IO actions through mapM_ and foldr. The function d should be given a list of ints.

— Jmac
소스
1

K (ngn/k), 10 bytes

{x=\:x:&x}

Try it online!

-19 thanks to ngn ... keeping my submission below haha

K (ngn/k), 29 bytes

{,/d#',:'-':+\[d:x,0]>\:!+/x}

Try it online!

edit: breaks for 1-element input case, needs work

edit1: now fixed. +4 bytes. boo

— scrawl
소스
1
{x=\:x:&x}­­­
— ngn
@ngn oh come on...
— scrawl
this challenge had been discussed in the apl room, i knew the solution from there :) k and j have an advantage here because their "where"-s (& in k or I. in j) work with int vectors, while apl's ⍸ works only with booleans.
— ngn
1

APL (Dyalog Extended), 5 bytes

∘.=⍨⍸

Try it online!

APL wins back against J and K with the extended domain for ⍸.

How it works

∘.=⍨⍸
    ⍸  ⍝ Where; convert to an array that,
       ⍝   for each element n at index i, has n copies of i
∘.=⍨   ⍝ Outer product by element-wise equality on self
— Bubbler
소스
0

STATA, 155 bytes

di _r(a)
forv x=1/wordcount($a){
gl b=word($a,`x')
gl c=_N+1
set ob _N+$b
forv y=$c/_N{
g d`y'=_n>=$c
}
}
forv z=1/_N{
replace d`z'=0 if d`z'>1
}
l,noo noh
— bmarks
소스
Can I test this online somewhere?
— Martin Ender
@MartinBüttner: As far as I know, there are no online compilers for Stata since it's proprietary. Same goes for languages like SAS.
— Alex A.
0

Jelly, 7 bytes

ĖŒṙ⁼þ`G

Try it online!

Same approach as the J answer.

      G    Grid format
   ⁼þ      a table of whether or not pairs of elements are equal, from
 Œṙ        the run-length decoded
Ė          enumeration of the input,
     `     compared with itself.
— Unrelated String
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.