(Losowo inspirowany https://codegolf.meta.stackexchange.com/a/17272/42963 )

Biorąc pod uwagę prostokątną matrycę cyfr (tj. 0 - 9), Wyślij „części” matrycy tak, jakby cyfry były połączone razem, tworząc jeden element, w porządku rosnącym według cyfr. Elementy są gwarantowane, że łączą się tylko prostopadle - żaden element nie połączy się po przekątnej. Zawsze będzie maksymalnie 10 sztuk (tj. 3Kawałek nie pojawi się dwukrotnie w tej samej matrycy).

Na przykład biorąc pod uwagę macierz

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

następujące elementy i przykładowe dane wyjściowe:

0
0 0

1 1 1
  1

  2
2 2

3 3

Odstępy są ważne, aby zachować kształt elementów, ale elementy niekoniecznie wymagają wewnętrznych odstępów. Same elementy powinny jakoś zostać rozróżnione w spójny sposób (np. Nowa linia między elementami, upewniając się, że każdy ma inny charakter itp.). Dodatkowo, zewnętrzne białe znaki (na przykład końcowe znaki nowej linii lub wiodące kolumny) są niedozwolone. Na przykład poprawne byłyby również:

0
00
111
 1
 2
22
33

lub

#
##

###
 #

 #
##

##

Ale nie byłoby (zwróć uwagę na końcowe spacje za 0):

0      
0 0    

Obroty lub odbicia są również niedozwolone. Na przykład wyprowadzanie

 1
111

dla powyższej macierzy jest również nieprawidłowa.

Elementy matrycy mogą mieć otwory lub być tylko jednym elementem:

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

Lub kawałek może być całą matrycą:

0 0 0
0 0 0

Oto większy, bardziej skomplikowany przypadek testowy:

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

I przykładowy wynik:

00

11111

 22
222
2

3

444
 44

55
5
5

6666
6  66
666

 77
  7
777

88

9

Reguły i I / O

• Dane wejściowe i wyjściowe można podać dowolną dogodną metodą .
• Możesz wydrukować go do STDOUT lub zwrócić jako wynik funkcji.
• Dopuszczalny jest pełny program lub funkcja.
• 1Wymagana jest wiodąca biała spacja, aby zachować kształt (np. Kształt litery „T” w przykładzie), spójna biała spacja, aby odróżnić elementy, i dozwolona jest pojedyncza nowa linia na końcu, ale żadna inna biała spacja nie jest dozwolona.
• Możesz bezpiecznie założyć, że elementy są ponumerowane w 0sposób Nciągły, co oznacza, że ​​(na przykład) 3nie zostanie pominięty w sześcioczęściowej matrycy.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

05AB1E , 20 19 bajtów

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

-1 bajt dzięki @ Mr.Xcoder .

Wyświetla listy 2D elementów (ze 1znakami spacji " ") na nowy wiersz.

Wypróbuj online lub sprawdź wszystkie przypadki testowe lub wydrukuj wszystkie przypadki testowe .

Wyjaśnienie:

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 bajtów

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

Pobiera macierz jako listę ciągów znaków i zwraca listę ciągów znaków.

Wypróbuj online!

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

Galaretka , 18 bajtów

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

Wypróbuj online!

Zwraca listę elementów, gdzie 1reprezentuje część elementu i ' 'jest wypełnieniem. Końcowe ' 's są usuwane.

Python 3 , 271 209 206 183 176 172 191 bajtów

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

Wypróbuj online!

Edycja: Trochę porządków i -5 dzięki @ Jonathan Frech .

Edycja: -3 -26 jeszcze raz dzięki @ Jonathan Frech .

Edycja: -7 ponownie dzięki @ Jonathan Frech .

Edycja: +19: Jak zauważył @ nimi poprzednio wyjście miało niepoprawny format.

Dane wejściowe są macierzą jako lista list:

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

Dane wyjściowe to lista matematyki:

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

Nie golfowany:

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 bajtów

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)

Wypróbuj online!

-15 bajty z obserwacji przez Nimi .

W formie programu przyjmuje jako dane wejściowe listę list pojedynczych znaków; drukuje elementy znalezione przy użyciu ich postaci.

C # (.NET Core) , 258 , 238 bajtów

Bez LINQ.

EDYCJA: Embodiment Of Ignorance wskazując lepsze deklaracje var! 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;};

Wypróbuj online!

Python 2 , 291 bajtów

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'

Wypróbuj online!

Oczekuje, że dane wejściowe będą rozdzielane cudzysłowem żądłem. Pół-niedorzeczny procent kodu jest przeznaczony do obsługi danych wejściowych niepodzielonych spacją / spacji.

Bez golfa Objaśnienie:

# 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'

Siatkówka , 75 bajtów

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

.$
$&¶

Wypróbuj online! Wyjaśnienie:

$
¶9

Dodaj cyfrę do wejścia. To reprezentuje licznik pętli. Nowa linia upraszcza końcowe usuwanie białych znaków.

.-10{

Wstrzymaj domyślne wyjście i powtórz dokładnie 10 razy.

T`9d`d`.$

Przesuń cyfrę w pętli.

*;(

Wyprowadza wynik pozostałej części skryptu, ale następnie przywraca bufor.

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

Zamień wszystkie cyfry, które nie pasują do cyfry pętli, spacjami. (Ponieważ używa to lookahead i nie ma nic do patrzenia w tym momencie, to również zastępuje cyfrę pętli).

 +¶
¶

Usuń wszystkie końcowe białe znaki.

G`\d

Usuń wszystkie puste linie.

/^\d|^$/m^+

Powtarzaj tak długo, jak żadna linia nie zaczyna się od cyfry ...

m`^.

... usuń pierwszy znak w każdej linii.

.$
$&¶

Jeśli pozostało coś, dodaj nową linię, aby oddzielić każdy kształt od następnego. (Ma to na celu uniknięcie zbłąkanych linii dla brakujących cyfr).

Węgiel drzewny , 43 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

ＷＳ⊞υι

Przeczytaj dane wejściowe do tablicy. (Można to usunąć, gdybym użył brzydkiego formatu wejściowego.)

Ｆχ«

Pętla powyżej 10 cyfr.

≔Φυ№κＩιθ

Uzyskaj wiersze zawierające te cyfry.

¿θ«

Sprawdź, czy cyfra została faktycznie znaleziona (aby zapobiec generowaniu fałszywych znaków nowej linii).

ＵＴ

Wyłącz automatyczne wypełnianie.

Ｆθ«

Pętla nad znalezionymi wierszami.

Ｆκ«

Pętla nad każdą kolumną ...

¿⁼λＩιλ→»

... jeśli bieżący znak wejściowy jest równy cyfrze bieżącej pętli, wydrukuj go, w przeciwnym razie przesuń kursor w prawo.

Ｍ±Ｌκ¹»

Przejdź na początek następnego rzędu. Używanie takich poleceń ruchu pozwala węgiel drzewny przyciąć wyjście po obu stronach.

Ｄ⎚

Zrzuć i wyczyść płótno gotowe na następną cyfrę. Pozwala to różnym cyfrom przycinać różne cyfry.

Wypróbowałem podejście programowe, ale ważyło 47 bajtów, chociaż Equalswektoryzacja byłaby również 43 bajtami przez krótki czas :

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

ＵＴ

Wyłącz automatyczne wypełnianie.

ＷＳ⊞υι

Przeczytaj dane wejściowe do tablicy.

Ｆχ«

Pętla powyżej 10 cyfr.

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

Porównaj każdy znak z danymi wejściowymi i utwórz tablicę boolowską, ale następnie odfiltruj wiersze bez dopasowań.

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

Pętlę nad pozostałymi wierszami i odcinać od najwcześniejszego dopasowania w dowolnym wierszu do najnowszego dopasowania w bieżącym wierszu, a następnie odwzorować tablicę boolowską z powrotem na cyfry lub spacje, które są następnie domyślnie drukowane jako tablica ciągów.

Język Wolfram 101 bajtów

Musi istnieć o wiele bardziej skuteczny sposób na osiągnięcie tego.

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

Perl 5, 97 bajtów

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

TIO

Wyjaśnienie

-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 bajtów ^SBCS

Anonimowa ukryta funkcja prefiksu. Bierze macierz liczbową jako argument i zwraca listę ciągów list. Każda lista ciągów reprezentuje element z oddzielonymi spacjami 1s. Wiodące i wewnętrzne (ale nie końcowe) spacje to spacje.

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

Wypróbuj online!

∪∘, unikalne elementy matrycy ravela (spłaszczonej)

⊂{… }¨ Dla każdego z nich jako ⍵wywołaj następującą funkcję z całą macierzą jako ⍺:

 ⍺=⍵ wskaż, gdzie znajduje się numer tego elementu w matrycy

 ⊢ dochód, (wydzielane 2z ⍺)

 {… }⍣2 Zastosuj następującą funkcję dwa razy ( ⍵jest to macierz boolowska):

  ∨/ maska ​​dla wierszy z co najmniej jednym 1(podświetlona redukcja OR dla rzędów )

  ⍵⌿⍨ użyj tego do filtrowania wierszy

  ⍉ transponuj (więc robimy to również w kolumnach, a następnie transponujemy z powrotem)

 ' '@~ zamień na spacje w pozycjach, gdzie nie (tj. gdzie 0)

 ⍕ format jako macierz znaków

 ↓ podzielony na listę ciągów

 ' +$'⎕R'' PCRE zastępuje końcowe spacje (dowolna liczba spacji, po których następuje koniec linii) niczym

Japt , 29 bajtów

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

Wypróbuj online!

Zaktualizowano w celu zapewnienia zgodności z bardziej rygorystycznym formatowaniem wyjściowym.

Wyprowadza jako listę elementów, przy czym każdy element jest reprezentowany przez listę linii, używając 2 jako znaku wypełniającego.

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

Bierze ciąg rozdzielony znakiem nowej linii, zwraca listę ciągów rozdzielonych znakiem nowej linii. Używa się, textwrap.dedentaby pozbyć się wiodących miejsc.

Galaretka , 19 bajtów

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

Wypróbuj online!

Monadyczny link przyjmujący macierz jako dane wejściowe i zwracający listę jednej obdartej listy na sztukę. Stopka ładnie to pokazuje, ale myślę, że wyjście bez tego jest zgodne z regułami pytań.