( https://codegolf.meta.stackexchange.com/a/17272/42963에서 무작위로 영감을 얻음 )

숫자의 직사각형 행렬 (즉, 0 - 9)이 주어진 경우, 숫자가 단일 조각을 구성하는 것처럼 숫자의 오름차순으로 행렬의 "조각"을 출력합니다. 조각은 직교로만 연결되도록 보장되며 조각은 대각선으로 연결되지 않습니다. 최대 10 개의 조각 만있을 수 있습니다 (즉, 3조각이 같은 행렬에 두 번 표시되지 않음).

예를 들어, 주어진 매트릭스

0 1 1 1
0 0 1 2
3 3 2 2

다음은 조각과 예제 출력입니다.

0
0 0

1 1 1
  1

  2
2 2

3 3

간격은 조각의 모양을 유지하는 데 중요하지만 조각에 반드시 내부 간격이 필요하지는 않습니다. 조각 자체는 어떻게 든 일관된 방식으로 구분되어야합니다 (예 : 조각 사이의 줄 바꿈, 각기 다른 특성인지 확인). 또한 불필요한 공백 (예 : 후행 줄 바꿈 또는 선행 열)은 허용되지 않습니다. 예를 들어 다음도 유효합니다.

0
00
111
 1
 2
22
33

또는

#
##

###
 #

 #
##

##

그러나 다음과 같지 않습니다 ( 0s 뒤에 후행 공백에 유의하십시오 ).

0      
0 0    

회전 또는 반사도 허용되지 않습니다. 예를 들어, 출력

 1
111

위의 행렬에 대해서도 유효하지 않습니다.

매트릭스 조각에는 구멍이 있거나 단일 요소 일 수 있습니다.

0 0 0 1
0 2 0 1
0 0 0 3

또는 조각이 전체 행렬 일 수 있습니다.

0 0 0
0 0 0

더 크고 복잡한 테스트 사례는 다음과 같습니다.

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

그리고 예제 출력 :

00

11111

 22
222
2

3

444
 44

55
5
5

6666
6  66
666

 77
  7
777

88

9

규칙 및 I / O

• 입력 및 출력은 편리한 방법 으로 제공 할 수 있습니다 .
• STDOUT에 인쇄하거나 함수 결과로 리턴 할 수 있습니다.
• 전체 프로그램 또는 기능이 허용됩니다.
• 모양을 유지하기위한 선행 공백 (예 : "T"모양의 1예)이 필요하고, 조각을 구별하기 위해 일정한 공백이 필요하며 끝 부분에 단일 후행 줄 바꿈이 허용되지만 다른 공백은 허용되지 않습니다.
• 안전하게 조각이 번호가 있다고 가정 할 수 있습니다 0에 N(예를 들어) 즉, 인접 3여섯 조각 매트릭스에 건너 뛸 수 없다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

05AB1E , 20 19 바이트

ZƒNQ2Fζʒà}}ε0Ü}0ð:,

@ Mr.Xcoder 덕분에 -1 바이트 .

개행마다 2D 조각 ( 1공백 문자 포함 " ") 목록을 출력합니다 .

온라인으로 시도 또는 모든 테스트 케이스를 확인 하거나 모든 테스트 케이스를 꽤 - 인쇄 .

설명:

Z              # Get the maximum digit of the (implicit) matrix-input (implicitly flattens)
 ƒ             # Loop in the range [0, max]:
  NQ           #  Check for each digit in the (implicit) matrix if it's equal to the index
    2F    }    #  Inner loop two times:
      ζ        #   Zip/transpose; swapping rows/columns
       ʒ }     #   Filter the inner lists by:
        à      #    Get the max of the list
               #  (so all rows/columns containing only 0s are removed)
  ε  }         #  Map the remaining rows:
   0Ü          #   Remove all trailing 0s
  0ð:          #  Then replace any remaining 0 with a space " "
     ,         #  And output the piece-matrix with a trailing newline

하스켈, 133 (132) 129 바이트

f x=[until(any(>"!"))(tail<$>)m|m<-[[until((>'!').last)init r|r<-[[last$' ':[s|s==n]|s<-z]|z<-x],any(>'!')r]|n<-['0'..'9']],m>[]]

행렬을 문자열 목록으로 가져와 문자열 목록 목록을 반환합니다.

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

                                    -- example matrix: ["0111","0012","3322"] 
                                    --
[          |n<-[0..9]]              -- for each digit 'n' from '0' .. '9'
  [  |z<-x]                         --   for each line 'z' of the input matrix 'x'
   [      |s<-z]                    --     for each digit 's' of line 'z'
      last$' ':[s|s==n]             --       take 's' if 's'=='n', else a space
                                    --       now we have a list of 10 matrices where
                                    --       each matrix contains only the
                                    --       corresponding digit 'n' at it's original
                                    --       position and spaces for all other digits
                                    --       -> [["0   ","00  ","    "],[" 111","  1 ","    "],["    ","   2","  22"],["    ","    ","33  "],["    ","    ","    "],["    ","    ","    "],["    ","    ","    "],["    ","    ","    "],["    ","    ","    "],["    ","    ","    "]]
   [     |r<-[    ],any(>'!')r]     --     loop through rows 'r' and keep those with
                                    --     at least one non-space element
    until((>'!').last)init r        --     and remove trailing spaces
                                    --     -> [["0","00"],[" 111","  1"],["   2","  22"],["33"],[],[],[],[],[],[]]
   [     |m<-[   ],m>[]]            --   loop through matrices 'm' and keep only
                                    --   non-empty
    until(any(>"!"))(tail<$>)m      --   and remove common leading spaces
                                    --   -> [["0","00"],["111"," 1"],[" 2","22"],["33"]]

젤리 , 18 바이트

ẎQṢ=€ẸƇZ$⁺œr€ɗ€0o⁶

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

조각 1의 일부를 나타내고 조각으로 채워진 조각 목록을 반환합니다 ' '. 후행 ' '이 제거됩니다.

파이썬 (3) , 271 (209) 206 183 176 172 191 바이트

lambda t:[[[*"".join(' #'[i==d]for i in r).rstrip()]for r in[w[min(r.index(d)for r in t if d in r):max(len(R)-R[::-1].index(d)for R in t if d in R)]for w in t if d in w]]for d in{*sum(t,[])}]

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

편집 : @ Jonathan Frech 덕분에 일부 정리 및 -5 .

편집 : @ Jonathan Frech 덕분에 다시 한 번 -3 -26 .

편집 : @ Jonathan Frech 덕분에 다시 -7 .

편집 : +19 : @ nimi가 지적했듯이 이전에 출력 형식이 잘못되었습니다.

입력은 목록의 목록으로 매트릭스입니다.

Input =  [[0, 1, 1, 1],
          [0, 0, 1, 2],
          [3, 3, 2, 2]]

출력은 수학 목록입니다.

Output = [[['#'],
           ['#', '#']],
          [['#', '#', '#'],
           [' ', '#']],
          [[' ', '#'],
           ['#', '#']],
          [['#', '#']]],

언 골프 드 :

O = ' '
X = '#'

def digits(t):
    return {d for r in t for d in r}

def rows_with_digit(table, digit):
    return [row for row in table if digit in row]

def table_with_digit(table, digit):
    subtable = rows_with_digit(table, digit)
    left_most_column = min([row.index(digit) for row in subtable])
    right_most_column = max([len(row) - row[::-1].index(digit) for row in subtable])
    return [row[left_most_column:right_most_column] for row in subtable]

def format_table(table, digit):
    return [[X if i==digit else O for i in row] for row in table]

def f(table):
    D = digits(table)
    R = []
    for d in D:
        digit_table = table_with_digit(table, d)
        R.append(format_table(digit_table, d))    
    return R

파이썬 (2) , 173 (172) 165 바이트

s=input()
for i in sorted(set(sum(s,[]))):R=[''.join([' ',i][c==i]for c in r)for r in s if i in r];print'\n'.join(t[min(r.find(i)for r in R):t.rfind(i)+1]for t in R)

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

-15에 의한 관찰에서 바이트 nimi .

프로그램 형식에서 단일 문자 목록의 목록을 입력으로 사용합니다. 캐릭터를 사용하여 찾은 조각을 인쇄하여 출력합니다.

C # (. NET 코어) , 258 , 238 바이트

LINQ없이.

편집 : 더 나은 var 선언을 지적하는 무지의 구체화! 타이 타이

p=>{int j=0,o=0,l=0,x=p.GetLength(1),d=p.Length;while(j<d){int t=j/x,u=j++%x,z=p[t,u];o=z>o?z:o;l=z<l?z:l;}var s="";for(var m=l;m<=o;m++){j=0;while(j<d){int t=j/x,u=j++%x;s+=(p[t,u]==m?p[t,u]+"":" ")+(u==x-1?"\n":"");}s+="\n";}return s;};

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

파이썬 2 , 291 바이트

import re
t=input()
a,b=t.split(),{c for c in t if' '<c}
for c in sorted((b,a)[int(max(a))==len(a)],key=int):s=re.sub(r'[^%s\s]'%c,' ',t).split('\n');print"\n".join(''.join(l[i]for i in sorted({i for l in s for i,j in enumerate(l)if j in c})if i<len(l)).rstrip()for l in s if l.strip())+'\n'

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

따옴표로 구분 된 찌르기가 입력으로 예상됩니다. 코드의 반투명 비율은 비 공백으로 구분되고 비 공백으로 채워진 입력을 처리하는 데 사용됩니다.

언 골프 설명 :

# built-in python regex handling.
import re
# get argument from STDIN
t=input()
# get elements which are whitespace separated, and all distinct non-whitespace characters
a,b=set(t.split()),{c for c in t if' '<c}
                # choose whichever set has the appropriate number of values based on its max element
                # for non-space separated inputs, this prevents values like '333' for 4-piece sets
                (b,a)[int(max(a))==len(a)]
# get elements in order by their integer value
# this will force the items to print in order, since sets are unordered
for c in sorted(..........................,key=int):
      # using regex substitute, replace any instance that DOESN'T match the current value or a whitespace with a space
      re.sub(r'[^%s\s]'%c,' ',t)
    # split replaced string into lines on line breaks
    s=...........................split('\n')
                # for each line in replaced input
                for l in s
                           # get the index and value of each item in line
                           for i,j in enumerate(l)
             # get distinct indexes which have a value that appears in the current piece
             {i ..................................if j in c}
    # get ordered list of distinct indexes
    a=sorted(...............................................)
                                                               # for each line in the replaced input
                                                               # only return values where line has non-whitespace values
                                                               for l in s if l.strip()
                           # get the value for each index that has a non-space value on other lines
                           # as long as that index exists (for non-space-padded inputs)
                           # this ensures that the spaces between values, if any, are removed
                           # there may still be trailing spaces
                           l[i]for i in a if i<len(l)
                   # join characters back into one string, and remove trailing whitespace
                   ''.join(..........................).rstrip()
    # join the lines back together with line breaks, and terminate with an extra line break
    # print output to screen
    print"\n".join(...................................................................)+'\n'

망막 , 75 바이트

$
¶9
.-10{T`9d`d`.$
*;(s`(\d)(?!.*\1$)
 
 +¶
¶
G`\d
/^\d|^$/m^+m`^.

.$
$&¶

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

$
¶9

입력에 숫자를 추가하십시오. 루프 카운터를 나타냅니다. 개행은 후행 공백 제거를 단순화합니다.

.-10{

기본 출력을 금지하고 정확히 10 번 반복하십시오.

T`9d`d`.$

루프 숫자를 전진시킵니다.

*;(

나머지 스크립트 결과를 출력 한 다음 버퍼를 복원하십시오.

s`(\d)(?!.*\1$)
 

루프 숫자와 일치하지 않는 모든 숫자를 공백으로 바꾸십시오. (이것은 미리보기를 사용하고이 시점에서 미리 볼 것이 없으므로 루프 자리를 대체합니다.)

 +¶
¶

후행 공백을 모두 제거하십시오.

G`\d

빈 줄을 모두 제거하십시오.

/^\d|^$/m^+

줄이 숫자로 시작하지 않는 한 반복하십시오 ...

m`^.

... 각 줄에서 첫 번째 문자를 삭제하십시오.

.$
$&¶

남은 것이 있으면 개행을 추가하여 각 모양을 다음 모양과 구분하십시오. (이것은 누락 된 숫자에 대한 길 잃은 줄 바꿈을 피하기 위해 수행됩니다.)

숯 , 43 바이트

ＷＳ⊞υιＦχ«≔Φυ№κＩιθ¿θ«ＵＴＦθ«Ｆκ«¿⁼λＩιλ→»Ｍ±Ｌκ¹»Ｄ⎚

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＷＳ⊞υι

입력을 배열로 읽습니다. (추악한 입력 형식을 사용하면 제거 할 수 있습니다.)

Ｆχ«

10 자리를 반복합니다.

≔Φυ№κＩιθ

해당 숫자가 포함 된 행을 가져옵니다.

¿θ«

가짜 줄 바꿈이 출력되지 않도록 숫자가 실제로 있는지 확인하십시오.

ＵＴ

자동 패딩을 끕니다.

Ｆθ«

찾은 행을 반복하십시오.

Ｆκ«

각 열을 반복합니다 ...

¿⁼λＩιλ→»

... 현재 입력 문자가 현재 루프 숫자와 같으면 인쇄하고 그렇지 않으면 커서를 오른쪽으로 이동하십시오.

Ｍ±Ｌκ¹»

다음 행의 시작으로 이동하십시오. 이와 같은 이동 명령을 사용하면 Charcoal이 양쪽에서 출력을 다듬을 수 있습니다.

Ｄ⎚

다음 자리에 대비하여 캔버스를 덤프하고 지우십시오. 이것은 다른 숫자가 다른 양의 트리밍을 가질 수있게합니다.

프로그래밍 방식을 시도했지만 47 바이트로 무게가 달았지만 Equals벡터화 할 때 짧은 시간 동안 43 바이트였습니다 .

ＵＴＷＳ⊞υιＦχ«≔ΦＥυＥκ⁼μＩιΣκθＥθ⭆✂κ⌊Ｅθ⌕μ¹⁻Ｌκ⌕⮌κ¹¦¹⎇μι 

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＵＴ

자동 패딩을 끕니다.

ＷＳ⊞υι

입력을 배열로 읽습니다.

Ｆχ«

10 자리를 반복합니다.

≔ΦＥυＥκ⁼μＩιΣκθ

각 문자를 입력과 비교하고 부울 배열을 작성한 다음 일치하지 않는 행을 필터링하십시오.

Ｅθ⭆✂κ⌊Ｅθ⌕μ¹⁻Ｌκ⌕⮌κ¹¦¹⎇μι 

나머지 행을 반복하고 모든 행의 가장 빠른 일치 항목에서 현재 행의 최신 일치 항목으로 슬라이스 한 다음 부울 배열을 숫자 또는 공백에 다시 매핑 한 다음 암시 적으로 문자열 배열로 인쇄합니다.

Wolfram 언어 101 바이트

이를 달성하기 위해서는 훨씬 더 효율적인 방법이 있어야합니다.

(g=#;Column[Table[Grid@Map[Replace[#,Thread[Complement[u=Union@Flatten@g,{n}]->""]]&/@#&,g],{n,u}]])&

펄 5, 97 바이트

$x=$_;for$i(0..9){$_=$x;y/ //d;s/(?!$i)./ /g;s/ *$//gm;s/^
//gm;s/^ //gm until/^(?! )/m;$\.=$_}}{

TIO

설명

-p0777                       # options to read whole intput and print special var by default

$x=$_;                       # save default var (input) into $x
for$i(0..9){                 # for $i in 0..9
    $_=$x;                   #   restore default var 
    y/ //d;                  #   remove all space char
    s/(?!$i)./ /g;           #   replace all char except $i by a space
    s/ *$//gm;               #   remove trailing space
    s/^\n//gm;               #   remove empty lines
    s/^ //gm until/^(?! )/m; #   remove leading space until there is no more
    $\.=$_                   #   append default var to output record separator
}
}{                           # trick with -p to output only reacord separator

APL (Dyalog Unicode) , 38 바이트 ^SBCS

익명의 암묵적 접두사 기능. 숫자 형 행렬을 인수로 받아서 목록 문자열 목록을 반환합니다. 각 문자열 목록은 공백으로 구분 된 조각을 나타냅니다 1. 선행 및 내부 (후행은 아님) 공간은 공백입니다.

⊂{' +$'⎕R''↓⍕' '@~{⍉⍵⌿⍨∨/⍵}⍣2⊢⍺=⍵}¨∪∘,

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

∪∘, 라벨 (평평한) 행렬의 고유 한 요소

⊂{… }¨ 와 같이 각각에 ⍵대해 다음과 같이 전체 행렬을 다음 함수로 호출하십시오 ⍺.

 ⍺=⍵ 해당 조각의 번호가 행렬에서 어디에 있는지 표시

 ⊢ 그 수율 (분리형 2에서 ⍺)

 {… }⍣2 다음 함수를 두 번 적용하십시오 ( ⍵부울 매트릭스).

  ∨/ 하나 이상의 행이있는 마스크 1(행에 따른 OR 감소)

  ⍵⌿⍨ 이를 사용하여 행을 필터링하십시오.

  ⍉ 조옮김 (따라서 열 에서도이 작업을 수행 한 다음 다시 조옮김)

 ' '@~ 위치가 아닌 곳 (예 : where 0)의 공백으로 교체

 ⍕ 문자 행렬로 형식화

 ↓ 문자열 목록으로 분할

 ' +$'⎕R'' PCRE는 후행 공백 (줄 끝이 뒤 따르는 임의의 수의 공백)을 아무것도 대체하지 않습니다.

apt , 29 바이트

AÆ®®¥X ÑÃÃÕfx Õfx ®¬r0S x1
fl

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

보다 엄격한 출력 형식을 준수하도록 업데이트되었습니다.

2를 필러 문자로 사용하여 각 조각이 행 목록으로 표시되는 조각 목록으로 출력합니다.

설명:

AÆ                            #For the numbers 0-9:
  ®®    ÃÃ                    # Map over each digit in the input:
    ¥X                        #  True if it equals the current number, false otherwise
       Ñ                      #  Multiply by 2 to turn the bool into a number
          Õfx                 # Remove columns that are all 0
              Õfx             # Remove rows that are all 0
                  ®           # For each remaining row:
                   ¬          #  Turn it into a string
                    r0S       #  Replace "0" with " "
                        x1    #  Trim spaces from the right
fl                            #Remove unused pieces

파이썬 3 , 133 바이트

lambda s:[dedent(re.sub(" *$","",re.sub(f"[^{c}\\n]"," ",s),0,8)).strip("\n")for c in sorted(*s)[1:]]
from textwrap import*
import re

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

줄 바꿈으로 구분 된 문자열을 가져와 줄 바꿈으로 구분 된 문자열 목록을 반환합니다. 용도는 textwrap.dedent선행 공백을 제거합니다.

젤리 , 19 바이트

ŒĠµŒṬZSƇ$⁺ị⁾# œr€⁶)

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

행렬을 입력으로 받아서 조각 당 하나의 거친 목록을 반환하는 모나드 링크. 바닥 글이이를 예쁘게 표시하지만 그없는 출력은 질문 규칙과 일치한다고 생각합니다.