(Случайно вдохновлено 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 .

Выводит 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представляет часть фрагмента и ' 'выполняет заполнение. Трейлинг ' 'с удалены.

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 благодаря @ Джонатан Фрех .

Изменить: -3 -26 еще раз благодаря @ Джонатан Фрех .

Редактировать: -7 еще раз благодаря @ Джонатан Фрех .

Редактировать: +19: Как отметил @ nimi, ранее вывод имел неверный формат.

Ввод матрицы в виде списка списков:

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

Выводится список матриц:

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 байт от наблюдения Ними .

В форме программы принимает в качестве входных данных список списков отдельных символов; вывод, печатая куски, найденные с использованием их характера.

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

Без LINQ.

РЕДАКТИРОВАТЬ: Embodiment Of Ignorance указывает на лучшие объявления вар! Ты ты.

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'

Попробуйте онлайн!

Ожидается, что в качестве входных данных указывается строка с кавычками. Полу смехотворный процент кода посвящен обработке ввода без пробелов / пробелов.

Un-golfing Объяснение:

# 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 цифр.

≔Φυ№κＩιθ

Получить строки, которые содержат эти цифры.

¿θ«

Убедитесь, что цифра была действительно найдена (чтобы предотвратить вывод ложных символов новой строки).

ＵＴ

Выключите автоматическое заполнение.

Ｆθ«

Зациклитесь на найденных строках.

Ｆκ«

Цикл над каждым столбцом ...

¿⁼λＩιλ→»

... если текущий вводимый символ равен текущей цифре цикла, выведите его, иначе переместите курсор вправо.

Ｍ±Ｌκ¹»

Перейти к началу следующего ряда. Использование таких команд перемещения позволяет углю обрезать выход с обеих сторон.

Ｄ⎚

Дамп и очистить холст готов к следующей цифре. Это позволяет различным цифрам иметь различное количество обрезки.

Я попробовал программный подход, но он весил 47 байтов, хотя это также было бы 43 байта в течение короткого промежутка времени при Equalsвекторизации:

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

ＵＴ

Выключите автоматическое заполнение.

ＷＳ⊞υι

Читать входные данные в массив.

Ｆχ«

Зациклите 10 цифр.

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

Сравните каждый символ с вводом и создайте логический массив, но затем отфильтруйте строки без совпадений.

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

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

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

Попробуйте онлайн!

∪∘, уникальные элементы равноправной (сплющенной) матрицы

⊂{… }¨ Для каждого из них ⍵вызовите следующую функцию со всей матрицей как ⍺:

 ⍺=⍵ указать, где находится номер этой фигуры в матрице

 ⊢ дать это (отделяется 2от ⍺)

 {… }⍣2 Примените следующую функцию дважды ( ⍵это булева матрица):

  ∨/ маска для строк, по крайней мере, с одним 1(подсвеченное по строкам OR-сокращение)

  ⍵⌿⍨ использовать это для фильтрации строк

  ⍉ транспонировать (поэтому мы делаем это на столбцах, а затем транспонировать обратно)

 ' '@~ заменить пробелами в местах, где нет (т.е. где 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€⁶)

Попробуйте онлайн!

Монадическая ссылка, принимающая матрицу в качестве входных данных и возвращающая список из одного рваного списка на элемент. Нижний колонтитул показывает это красиво, но я думаю, что вывод без этого согласуется с правилами вопроса.