(แรงบันดาลใจแบบสุ่มโดยhttps://codegolf.meta.stackexchange.com/a/17272/42963 )

ให้เมทริกซ์รูปสี่เหลี่ยมผืนผ้าของตัวเลข (เช่น, 0 - 9), เอาท์พุท "ชิ้น" ของเมทริกซ์ราวกับว่าตัวเลขนั้นเชื่อมต่อกันไว้เป็นชิ้นเดียวตามลำดับจากน้อยไปมาก ชิ้นส่วนรับประกันว่าจะเชื่อมต่อแบบ orthongonally เท่านั้น - ไม่มีชิ้นใดที่จะเชื่อมต่อในแนวทแยงมุม จะมีได้สูงสุด 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ð:,

-1 ขอบคุณไบต์@ Mr.Xcoder

เอาต์พุตรายการ 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

Haskell, 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แสดงถึงส่วนหนึ่งของชิ้นส่วนและ' 'เติมเต็ม ต่อท้าย' 's จะถูกลบออก

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

ลองออนไลน์!

แก้ไข: ทำความสะอาดบางและ -5 ต้องขอบคุณ @ โจนาธาน Frech

แก้ไข: -3 -26 ขอบคุณ @ Jonathan Frechอีกครั้ง

แก้ไข: -7 อีกครั้งขอบคุณที่ @ โจนาธาน Frech

แก้ไข: +19: ตามที่บันทึกไว้โดย @ nimiก่อนหน้านี้เอาต์พุตมีรูปแบบที่ไม่ถูกต้อง

อินพุตเป็นเมทริกซ์ตามรายการ:

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

เอาท์พุทเป็นรายการของ matricies:

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

Ungolfed:

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 ไบต์

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 Core) , 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;};

ลองออนไลน์!

Python 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$)
 

แทนที่ตัวเลขทั้งหมดที่ไม่ตรงกับหลักวงด้วยช่องว่าง (เพราะสิ่งนี้ใช้ lookahead และไม่มีอะไรที่จะมองไปข้างหน้า ณ จุดนี้สิ่งนี้ยังมาแทนที่หลักวง)

 +¶
¶

ลบช่องว่างต่อท้ายทั้งหมด

G`\d

ลบบรรทัดว่างทั้งหมด

/^\d|^$/m^+

ทำซ้ำตราบใดที่ไม่มีบรรทัดขึ้นต้นด้วยตัวเลข ...

m`^.

... ลบอักขระแรกในแต่ละบรรทัด

.$
$&¶

หากมีสิ่งใดเหลืออยู่ให้ผนวกบรรทัดใหม่เพื่อแยกแต่ละรูปร่างออกจากถัดไป (สิ่งนี้ทำเพื่อหลีกเลี่ยงการขึ้นบรรทัดใหม่สำหรับตัวเลขที่หายไป)

ถ่าน 43 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＷＳ⊞υι

อ่านอินพุตเป็นอาร์เรย์ (สิ่งนี้สามารถลบได้ถ้าฉันใช้รูปแบบอินพุตที่น่าเกลียด)

Ｆχ«

วนซ้ำมากกว่า 10 หลัก

≔Φυ№κＩιθ

รับแถวที่มีตัวเลขเหล่านั้น

¿θ«

ตรวจสอบว่าพบความจริงแล้ว (เพื่อป้องกันการขึ้นบรรทัดใหม่แบบลวงตา)

ＵＴ

ปิดช่องว่างภายในอัตโนมัติ

Ｆθ«

วนซ้ำแถวที่พบ

Ｆκ«

วนซ้ำแต่ละคอลัมน์ ...

¿⁼λＩιλ→»

... หากอักขระอินพุตปัจจุบันเท่ากับหลักลูปปัจจุบันให้พิมพ์มิฉะนั้นเลื่อนเคอร์เซอร์ไปทางขวา

Ｍ±Ｌκ¹»

ย้ายไปที่จุดเริ่มต้นของแถวถัดไป การใช้คำสั่งการเคลื่อนไหวเช่นนี้ทำให้ถ่านสามารถตัดเอาต์พุตทั้งสองด้าน

Ｄ⎚

ถ่ายโอนและล้างผืนผ้าใบพร้อมสำหรับตัวเลขถัดไป วิธีนี้ทำให้ตัวเลขที่แตกต่างกันมีจำนวนการตัดที่แตกต่างกัน

ฉันลองใช้วิธีการเขียนโปรแกรม แต่ชั่งน้ำหนักที่ 47 ไบต์แม้ว่ามันจะเป็น 43 ไบต์ด้วยเวลาสั้น ๆ เมื่อEqualsvectorised:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＵＴ

ปิดช่องว่างภายในอัตโนมัติ

ＷＳ⊞υι

อ่านอินพุตเป็นอาร์เรย์

Ｆχ«

วนซ้ำมากกว่า 10 หลัก

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

เปรียบเทียบอักขระแต่ละตัวกับอินพุตและสร้างอาร์เรย์บูลีน แต่จากนั้นกรองแถวโดยไม่ต้องจับคู่

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

วนรอบแถวที่เหลือและส่วนแบ่งจากการจับคู่ที่เร็วที่สุดในแถวใดก็ได้จนถึงการจับคู่ล่าสุดในแถวปัจจุบันจากนั้นทำการแมปอาร์เรย์บูลีนกลับไปที่ตัวเลขหรือช่องว่างซึ่งจะถูกพิมพ์เป็นอาร์เรย์ของสตริงโดยปริยาย

ภาษา Wolfram 101 ไบต์

จะต้องมีวิธีที่มีประสิทธิภาพมากกว่านี้

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

Perl 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

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ รับเมทริกซ์ตัวเลขเป็นอาร์กิวเมนต์และส่งคืนรายการสตริงรายการ รายการของสตริงแต่ละชิ้นมีพื้นที่แยก1s ช่องว่างนำหน้าและภายใน (แต่ไม่ลาก) เป็นช่องว่าง

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

ลองออนไลน์!

∪∘, องค์ประกอบที่เป็นเอกลักษณ์ของเมทริกซ์ ravel (แบน)

⊂{... }¨ สำหรับแต่ละตัวเป็น⍵เรียกฟังก์ชันต่อไปนี้โดยใช้ matrix ทั้งหมดเป็น⍺:

 ⍺=⍵ ระบุตำแหน่งของหมายเลขชิ้นส่วนนั้นในเมทริกซ์

 ⊢ ให้ผลผลิตนั้น (แยก2จาก⍺)

 {… }⍣2 ใช้ฟังก์ชันต่อไปนี้สองครั้ง ( ⍵คือเมทริก Boolean):

  ∨/ มาสก์สำหรับแถวที่มีอย่างน้อยหนึ่ง1(lit. row-wise OR-reduction)

  ⍵⌿⍨ ใช้สิ่งนั้นเพื่อกรองแถว

  ⍉ ไขว้ (ดังนั้นเราจึงทำเช่นนี้ในคอลัมน์ด้วยจากนั้นย้ายกลับ)

 ' '@~ แทนที่ด้วยช่องว่างที่ตำแหน่งที่ไม่ (เช่นที่0)

 ⍕ จัดรูปแบบเป็นเมทริกซ์อักขระ

 ↓ แยกออกเป็นรายการสตริง

 ' +$'⎕R'' PCRE แทนที่ช่องว่างต่อท้าย (จำนวนช่องว่างใด ๆ ตามด้วยเส้นท้าย) โดยไม่มีอะไร

Japt 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

Python 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€⁶)

ลองออนไลน์!

ลิงก์ monadic ที่ใช้เมทริกซ์เป็นอินพุตและส่งคืนรายการของหนึ่งรายการที่ขาดการต่อชิ้น ท้ายกระดาษจะแสดงอย่างน่ารัก แต่ฉันคิดว่าผลลัพธ์ที่ไม่มีนั้นสอดคล้องกับกฎของคำถาม