(Lấy cảm hứng ngẫu nhiên từ https://codegolf.meta.stackexchange.com/a/17272/42963 )

Cho một ma trận hình chữ nhật gồm các chữ số (nghĩa là 0 - 9), xuất ra các "mảnh" của ma trận như thể các chữ số được kết nối với nhau tạo thành một mảnh duy nhất, theo thứ tự tăng dần theo các chữ số. Các mảnh được đảm bảo chỉ kết nối trực giao - không có mảnh nào sẽ kết nối theo đường chéo. Sẽ chỉ có tối đa 10 mảnh (nghĩa là một 3mảnh sẽ không xuất hiện hai lần trong cùng một ma trận).

Ví dụ, đưa ra ma trận

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

Sau đây là các phần và một ví dụ đầu ra:

0
0 0

1 1 1
  1

  2
2 2

3 3

Khoảng cách là quan trọng để giữ hình dạng của các mảnh, nhưng các mảnh không nhất thiết cần khoảng cách bên trong. Bản thân các mảnh nên bằng cách nào đó được phân biệt một cách nhất quán (ví dụ: một dòng mới giữa các mảnh, đảm bảo mỗi mảnh là một ký tự khác nhau, v.v.). Ngoài ra, không được phép có khoảng trắng bên ngoài (ví dụ: theo dõi dòng mới hoặc cột hàng đầu). Ví dụ: những điều sau đây cũng sẽ hợp lệ:

0
00
111
 1
 2
22
33

hoặc là

#
##

###
 #

 #
##

##

Nhưng sau đây sẽ không được (lưu ý các dấu cách phía sau 0s):

0      
0 0    

Xoay hoặc phản xạ cũng không được phép. Ví dụ: xuất

 1
111

cho ma trận trên cũng không hợp lệ.

Các mảnh ma trận có thể có lỗ, hoặc chỉ là một yếu tố duy nhất:

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

Hoặc, mảnh có thể là toàn bộ ma trận:

0 0 0
0 0 0

Đây là một trường hợp thử nghiệm lớn hơn, phức tạp hơn:

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

Và một ví dụ đầu ra:

00

11111

 22
222
2

3

444
 44

55
5
5

6666
6  66
666

 77
  7
777

88

9

Quy tắc và I / O

• Đầu vào và đầu ra có thể được đưa ra bởi bất kỳ phương pháp thuận tiện .
• Bạn có thể in nó sang STDOUT hoặc trả lại dưới dạng kết quả chức năng.
• Hoặc là một chương trình đầy đủ hoặc một chức năng được chấp nhận.
• Khoảng trắng hàng đầu để giữ hình dạng (ví dụ: hình chữ "T" 1trong ví dụ) là bắt buộc, khoảng trắng nhất quán để làm cho các mảnh khác biệt và một dòng mới ở cuối được cho phép, nhưng không được phép có khoảng trắng khác.
• Bạn có thể giả định rằng các mảnh được đánh số 0để Nliên tục kế nhau, có nghĩa là (ví dụ) 3sẽ không thể bỏ qua trong một ma trận Sáu mảnh.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn để áp dụng tất cả các quy tắc chơi gôn thông thường và mã ngắn nhất (tính bằng byte) sẽ thắng.

05AB1E , 20 19 byte

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

-1 byte nhờ @ Mr.Xcoder .

Xuất ra danh sách 2D các mảnh (có 1và ký tự khoảng trắng " ") trên mỗi dòng mới.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm hoặc in đẹp tất cả các trường hợp thử nghiệm .

Giải trình:

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

Haskell, 133 132 129 byte

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>[]]

Lấy ma trận làm danh sách các chuỗi và trả về danh sách các chuỗi.

Hãy thử trực tuyến!

                                    -- 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"]]

Thạch , 18 byte

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

Hãy thử trực tuyến!

Trả về một danh sách các mảnh, trong đó 1đại diện cho một phần của mảnh và ' 'là phần đệm. Trailing ' 's được gỡ bỏ.

Python 3 , 271 209 206 183 176 172 191 byte

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,[])}]

Hãy thử trực tuyến!

Chỉnh sửa: Một số dọn dẹp và -5 nhờ @ Jonathan Frech .

Chỉnh sửa: -3 -26 một lần nữa nhờ @ Jonathan Frech .

Chỉnh sửa: -7 một lần nữa nhờ @ Jonathan Frech .

Chỉnh sửa: +19: Theo ghi nhận của @ nimi, đầu ra trước đó có định dạng không chính xác.

Đầu vào là ma trận dưới dạng danh sách các danh sách:

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

Đầu ra là danh sách các ma trận:

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

Ung dung:

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

Python 2 , 173 172 165 byte

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)

Hãy thử trực tuyến!

-15 byte từ một quan sát bởi nimi .

Ở dạng chương trình, lấy đầu vào là danh sách các danh sách các ký tự đơn; đầu ra bằng cách in các mảnh được tìm thấy bằng cách sử dụng ký tự của chúng.

C # (.NET Core) , 258 , 238 byte

Không có LINQ.

EDIT: Hiện thân của sự thiếu hiểu biết chỉ ra các tuyên bố var tốt hơn! Ty ty.

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;};

Hãy thử trực tuyến!

Python 2 , 291 byte

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'

Hãy thử trực tuyến!

Yêu cầu một trích dẫn phân định trích dẫn làm đầu vào. Một tỷ lệ phần trăm lố bịch của mã được dành riêng để xử lý đầu vào không phân tách không gian / không đệm.

Giải thích không chơi gô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'

Võng mạc , 75 byte

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

.$
$&¶

Hãy thử trực tuyến! Giải trình:

$
¶9

Nối một chữ số vào đầu vào. Điều này đại diện cho bộ đếm vòng lặp. Dòng mới đơn giản hóa việc loại bỏ khoảng trắng theo sau.

.-10{

Ức chế đầu ra mặc định và lặp lại chính xác 10 lần.

T`9d`d`.$

Nâng cao chữ số vòng lặp.

*;(

Xuất kết quả của phần còn lại của tập lệnh nhưng sau đó khôi phục bộ đệm.

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

Thay thế tất cả các chữ số không khớp với chữ số vòng lặp bằng dấu cách. (Bởi vì điều này sử dụng một cái nhìn và không có gì để nhìn về phía trước vào thời điểm này, điều này cũng thay thế cho chữ số vòng lặp.)

 +¶
¶

Xóa tất cả khoảng trắng theo sau.

G`\d

Xóa tất cả các dòng trống.

/^\d|^$/m^+

Lặp lại miễn là không có dòng nào bắt đầu bằng một chữ số ...

m`^.

... xóa ký tự đầu tiên trên mỗi dòng.

.$
$&¶

Nếu có bất cứ điều gì còn lại thì nối một dòng mới để tách từng hình dạng tiếp theo. (Điều này được thực hiện để tránh các dòng mới đi lạc cho các chữ số bị thiếu.)

Than , 43 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＷＳ⊞υι

Đọc đầu vào thành một mảng. (Điều này có thể được loại bỏ nếu tôi sử dụng một định dạng đầu vào xấu xí.)

Ｆχ«

Lặp lại trên 10 chữ số.

≔Φυ№κＩιθ

Lấy các hàng chứa các chữ số đó.

¿θ«

Kiểm tra xem chữ số trên thực tế đã được tìm thấy (để ngăn chặn xuất ra các dòng mới giả).

ＵＴ

Tắt đệm tự động.

Ｆθ«

Vòng qua các hàng tìm thấy.

Ｆκ«

Vòng qua từng cột ...

¿⁼λＩιλ→»

... Nếu ký tự đầu vào hiện tại bằng với chữ số vòng lặp hiện tại thì hãy in nó bằng cách khác di chuyển con trỏ sang phải.

Ｍ±Ｌκ¹»

Di chuyển đến đầu hàng tiếp theo. Sử dụng các lệnh di chuyển như thế này cho phép Char than cắt đầu ra ở cả hai bên.

Ｄ⎚

Đổ và xóa khung vẽ sẵn sàng cho chữ số tiếp theo. Điều này cho phép các chữ số khác nhau có số lượng cắt tỉa khác nhau.

Tôi đã thử một cách tiếp cận theo chương trình nhưng nó nặng tới 47 byte, mặc dù nó cũng có thể là 43 byte trong một khoảng thời gian ngắn khi được Equalsvector hóa:

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＵＴ

Tắt đệm tự động.

ＷＳ⊞υι

Đọc đầu vào thành một mảng.

Ｆχ«

Lặp lại trên 10 chữ số.

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

So sánh từng ký tự với đầu vào và xây dựng một mảng boolean, nhưng sau đó lọc ra các hàng không có kết quả khớp.

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

Lặp lại các hàng còn lại và cắt từ khớp sớm nhất trong bất kỳ hàng nào sang khớp mới nhất trong hàng hiện tại, sau đó ánh xạ mảng boolean trở lại các chữ số hoặc khoảng trắng, sau đó được in ngầm thành một chuỗi các chuỗi.

Ngôn ngữ Wolfram 101 byte

Phải có một cách hiệu quả hơn nhiều để thực hiện điều này.

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

Perl 5, 97 byte

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

TIO

Giải trình

-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 byte ^SBCS

Chức năng tiền tố ẩn danh. Lấy một ma trận số làm đối số và trả về một danh sách các chuỗi danh sách. Mỗi danh sách các chuỗi đại diện cho một mảnh có 1s được phân tách bằng dấu cách . Không gian hàng đầu và nội bộ (nhưng không theo dõi) là không gian.

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

Hãy thử trực tuyến!

∪∘, các yếu tố độc đáo của ma trận ravel (dẹt)

⊂{... }¨ cho mỗi người trong số những người như ⍵, gọi hàm sau với toàn bộ ma trận như ⍺:

 ⍺=⍵ cho biết số của mảnh đó ở đâu trong ma trận

 ⊢ mang lại (tách 2khỏi ⍺)

 {... }⍣2 áp dụng các chức năng sau hai lần ( ⍵là ma trận Boolean):

  ∨/ mặt nạ cho các hàng có ít nhất một 1(lit. khôn ngoan OR-giảm)

  ⍵⌿⍨ sử dụng để lọc các hàng

  ⍉ hoán vị (vì vậy chúng tôi cũng làm điều này trên các cột, sau đó chuyển trở lại)

 ' '@~ thay thế bằng khoảng trắng tại các vị trí không (tức là ở đâu 0)

 ⍕ định dạng như ma trận ký tự

 ↓ chia thành danh sách các chuỗi

 ' +$'⎕R'' PCRE thay thế các dấu cách (bất kỳ số lượng khoảng trắng nào được theo sau bởi một dòng cuối)

Japt , 29 byte

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

Hãy thử trực tuyến!

Cập nhật để tuân thủ định dạng đầu ra chặt chẽ hơn.

Xuất ra dưới dạng một danh sách các mảnh với mỗi mảnh được biểu thị bằng một danh sách các dòng, sử dụng 2 làm ký tự phụ.

Giải trình:

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

Python 3 , 133 byte

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

Hãy thử trực tuyến!

Lấy một chuỗi phân tách dòng mới, trả về một danh sách các chuỗi phân tách dòng mới. Sử dụng textwrap.dedentđể thoát khỏi không gian hàng đầu.

Thạch , 19 byte

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

Hãy thử trực tuyến!

Một liên kết đơn âm lấy ma trận làm đầu vào và trả về một danh sách một danh sách rách rưới trên mỗi mảnh. Footer hiển thị điều này một cách đẹp mắt, nhưng tôi nghĩ đầu ra mà không phù hợp với quy tắc của câu hỏi.