(Випадково надихається 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

Правила та введення / виведення

• Введення та вихід можуть бути надані будь-яким зручним методом .
• Ви можете роздрукувати його в STDOUT або повернути його як результат функції.
• Прийнятна або повна програма, або функція.
• Провідна пробільна зона для збереження форми (наприклад, форма "Т" 1у прикладі) необхідна, послідовне пробіли, щоб зробити шматки чіткими, і одна кінцева нова лінія в кінці дозволена, але жодна інша пробіл не допускається.
• Можна сміливо припустити , що частини пронумеровані 0в Nсуміжно, а це означає , що (наприклад) 3не буде втрачена в шість частинах матриці.
• Стандартні лазівки заборонені.
• Це код-гольф, тому застосовуються всі звичайні правила гольфу, і найкоротший код (у байтах) виграє.

05AB1E , 20 19 байт

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

-1 байт завдяки @ Mr.Xcoder .

Виводить двовимірні списки фрагментів (із 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представлена ​​частина фрагмента, і ' 'є набиванням. Затримки ' 'видалено.

Пітон 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 завдяки @ Jonathan Frech .

Редагування: -3 -26 ще раз завдяки @ Джонатану Фреху .

Редагувати: знову -7 завдяки @ Jonathan Frech .

Редагувати: +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

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 байт зі спостереження за німі .

У програмній формі приймає як вхід список списків одиночних символів; виводить, друкуючи фрагменти, знайдені з використанням їх символів.

C # (.NET Core) , 258 , 238 байт

Без LINQ.

EDIT: Утілення Невігластва вказує на кращі вар-декларації! 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;};

Спробуйте в Інтернеті!

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 байт, хоча при Equalsвекторизації це також було б 43 байти за короткий проміжок часу :

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

ＵＴ

Вимкніть автоматичну прокладку.

ＷＳ⊞υι

Прочитайте вхід в масив.

Ｆχ«

Проведіть петлю на 10 цифр.

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

Порівняйте кожен символ із вхідним та складіть булевий масив, але потім відфільтруйте рядки без збігів.

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

Проведіть петлю над рештою рядків і відрізком від самого раннього збігу в будь-якому рядку до останнього збігу в поточному рядку, а потім відобразимо булевий масив назад до цифр або пробілів, які потім неявно друкуються як масив рядків.

Мова Вольфрама 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;$\.=$_}}{

ТІО

Пояснення

-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⊢⍺=⍵}¨∪∘,

Спробуйте в Інтернеті!

∪∘, унікальні елементи махової (сплющеної) матриці

⊂{… }¨ Для кожного з них ⍵викличте наступну функцію з усією матрицею як ⍺:

 ⍺=⍵ вкажіть, де в матриці знаходиться номер цього фрагмента

 ⊢ урожай, який (відокремлюється 2від ⍺)

 {… }⍣2 Застосувати таку функцію двічі ( ⍵є булева матриця):

  ∨/ маска для рядків, принаймні одна 1(освітлене рядок АБО скорочення)

  ⍵⌿⍨ використовуйте це для фільтрування рядків

  ⍉ транспонировать (так ми робимо це і на стовпцях, потім переносимо назад)

 ' '@~ замінити пробілами в позиціях, де немає (тобто де 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€⁶)

Спробуйте в Інтернеті!

Монадійне посилання, що приймає матрицю як вхідний і повертає список одного роздрібненого списку на шматок. Footer відображає це гарненько, але я вважаю, що вихід без цього відповідає правилам питання.