(Zufällig inspiriert von https://codegolf.meta.stackexchange.com/a/17272/42963 )

Bei einer rechteckigen Ziffernmatrix (dh 0 - 9) werden die "Teile" der Matrix so ausgegeben, als ob die Ziffern in aufsteigender Reihenfolge durch die Ziffern zu einem einzigen Stück zusammengefügt wären. Die Teile werden garantiert nur orthongonal verbunden - kein Teil wird diagonal verbunden. Es gibt immer nur maximal 10 Teile (dh ein Teil 3erscheint nicht zweimal in derselben Matrix).

Zum Beispiel angesichts der Matrix

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

Das Folgende sind die Stücke und eine Beispielausgabe:

0
0 0

1 1 1
  1

  2
2 2

3 3

Der Abstand ist wichtig, um die Form der Teile beizubehalten, aber die Teile benötigen nicht unbedingt einen Innenabstand. Die Teile selbst sollten auf einheitliche Weise voneinander unterschieden werden (z. B. eine neue Linie zwischen den Teilen, um sicherzustellen, dass jedes einen anderen Charakter hat usw.). Darüber hinaus sind überflüssige Leerzeichen (z. B. nachfolgende Zeilenumbrüche oder führende Spalten) nicht zulässig. Zum Beispiel wäre auch Folgendes gültig:

0
00
111
 1
 2
22
33

oder

#
##

###
 #

 #
##

##

Folgendes wäre jedoch nicht der Fall (beachten Sie die nachgestellten Leerzeichen hinter dem 0s):

0      
0 0    

Drehungen oder Reflexionen sind ebenfalls nicht zulässig. Zum Beispiel Ausgabe

 1
111

für die obige Matrix ist auch ungültig.

Die Matrixstücke können Löcher haben oder nur ein einzelnes Element sein:

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

Oder das Stück kann die gesamte Matrix sein:

0 0 0
0 0 0

Hier ist ein größerer, komplizierterer Testfall:

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

Und eine Beispielausgabe:

00

11111

 22
222
2

3

444
 44

55
5
5

6666
6  66
666

 77
  7
777

88

9

Regeln und E / A.

• Die Ein- und Ausgabe kann mit jeder geeigneten Methode erfolgen .
• Sie können es in STDOUT drucken oder als Funktionsergebnis zurückgeben.
• Entweder ein vollständiges Programm oder eine Funktion sind akzeptabel.
• Führende Leerzeichen zum Beibehalten der Form (z. B. die "T" -Form des 1Beispiels) sind erforderlich, konsistente Leerzeichen, um die Teile zu unterscheiden, und eine einzelne nachfolgende neue Zeile am Ende ist zulässig, aber keine anderen Leerzeichen sind zulässig.
• Sie können sicher davon ausgehen , dass die Stücke sind nummeriert , 0um Nzusammenhängend, was bedeutet , dass (beispielsweise) 3nicht in einer sechsteiligen Matrix übersprungen werden.
• Standardlücken sind verboten.
• Dies ist Code-Golf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Bytes) gewinnt.

05AB1E , 20 19 Bytes

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

-1 Byte dank @ Mr.Xcoder .

Gibt 2D-Stücklisten (mit 1und Leerzeichen " ") pro Zeilenumbruch aus.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle oder drucken Sie alle Testfälle aus .

Erläuterung:

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 Bytes

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

Nimmt die Matrix als Liste von Zeichenfolgen und gibt eine Liste von Zeichenfolgen zurück.

Probieren Sie es online aus!

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

Gelee , 18 Bytes

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

Probieren Sie es online aus!

Gibt eine Liste von Teilen zurück, wobei 1ein Teil eines Teils dargestellt wird und ' 'aufgefüllt wird. Nachgestellte ' 's werden entfernt.

Python 3 , 271 209 206 183 176 172 191 Bytes

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

Probieren Sie es online aus!

Edit: Einige Aufräumarbeiten und -5 dank @ Jonathan Frech .

Edit: -3 -26 noch einmal danke an @ Jonathan Frech .

Edit: -7 nochmal danke an @ Jonathan Frech .

Bearbeiten: +19: Wie von @ nimi angegeben, hatte die zuvor ausgegebene Ausgabe ein falsches Format.

Eingabe ist Matrix als Liste von Listen:

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

Ausgabe ist Liste der Matrizen:

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 Bytes

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)

Probieren Sie es online aus!

-15 Bytes aus einer Beobachtung von Nimi .

Nimmt in Programmform eine Liste von Listen mit einzelnen Zeichen als Eingabe; Ausgaben durch Drucken der gefundenen Teile anhand ihres Charakters.

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

Ohne LINQ.

EDIT: Verkörperung der Ignoranz, die auf bessere Var-Deklarationen hinweist! 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;};

Probieren Sie es online aus!

Python 2 , 291 Bytes

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'

Probieren Sie es online aus!

Erwartet einen durch Anführungszeichen getrennten Stich als Eingabe. Ein halb lächerlicher Prozentsatz des Codes ist für die Verarbeitung von nicht durch Leerzeichen getrennten / nicht durch Leerzeichen aufgefüllten Eingaben bestimmt.

Nicht Golf Golf Erklärung:

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

Netzhaut , 75 Bytes

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

.$
$&¶

Probieren Sie es online aus! Erläuterung:

$
¶9

Fügen Sie dem Eingang eine Ziffer hinzu. Dies stellt den Schleifenzähler dar. Die neue Zeile vereinfacht das Entfernen von nachgestellten Leerzeichen.

.-10{

Standardausgabe sperren und genau 10 Mal wiederholen.

T`9d`d`.$

Stellen Sie die Schleifenziffer vor.

*;(

Geben Sie das Ergebnis des restlichen Skripts aus, stellen Sie dann den Puffer wieder her.

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

Ersetzen Sie alle Ziffern, die nicht mit der Schleifenziffer übereinstimmen, durch Leerzeichen. (Da hierfür ein Lookahead verwendet wird und an dieser Stelle nichts zu sehen ist, wird auch die Schleifenziffer ersetzt.)

 +¶
¶

Entfernen Sie alle nachgestellten Leerzeichen.

G`\d

Entfernen Sie alle Leerzeilen.

/^\d|^$/m^+

Wiederholen, solange keine Zeile mit einer Ziffer beginnt ...

m`^.

... löschen Sie das erste Zeichen in jeder Zeile.

.$
$&¶

Wenn noch etwas übrig ist, fügen Sie eine neue Zeile hinzu, um jede Form von der nächsten zu trennen. (Dies geschieht, um verirrte Zeilenumbrüche für fehlende Ziffern zu vermeiden.)

Holzkohle , 43 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

ＷＳ⊞υι

Lesen Sie die Eingabe in ein Array. (Dies könnte entfernt werden, wenn ich ein hässliches Eingabeformat verwende.)

Ｆχ«

Schleife über die 10 Ziffern.

≔Φυ№κＩιθ

Holen Sie sich die Zeilen, die diese Ziffern enthalten.

¿θ«

Überprüfen Sie, ob die Ziffer tatsächlich gefunden wurde (um zu verhindern, dass falsche Zeilenumbrüche ausgegeben werden).

ＵＴ

Schalten Sie die automatische Polsterung aus.

Ｆθ«

Schleife über die gefundenen Zeilen.

Ｆκ«

Schleife über jede Spalte ...

¿⁼λＩιλ→»

... wenn das aktuelle Eingabezeichen der aktuellen Schleifenziffer entspricht, drucken Sie es aus, andernfalls bewegen Sie den Cursor nach rechts.

Ｍ±Ｌκ¹»

Gehen Sie zum Anfang der nächsten Zeile. Mit solchen Bewegungsbefehlen kann Charcoal den Ausgang auf beiden Seiten trimmen.

Ｄ⎚

Entleere und lösche die Leinwand für die nächste Ziffer. Dadurch können die verschiedenen Ziffern unterschiedlich beschnitten werden.

Ich habe einen programmatischen Ansatz ausprobiert, aber dieser wog 47 Bytes, obwohl er bei EqualsVektorisierung für kurze Zeit auch 43 Bytes gewesen wäre:

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

ＵＴ

Schalten Sie die automatische Polsterung aus.

ＷＳ⊞υι

Lesen Sie die Eingabe in ein Array.

Ｆχ«

Schleife über die 10 Ziffern.

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

Vergleichen Sie jedes Zeichen mit der Eingabe und erstellen Sie ein boolesches Array. Filtern Sie dann die Zeilen ohne Übereinstimmungen heraus.

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

Durchlaufen Sie die verbleibenden Zeilen und schneiden Sie von der frühesten Übereinstimmung in einer Zeile zur neuesten Übereinstimmung in der aktuellen Zeile. Ordnen Sie dann das boolesche Array wieder Ziffern oder Leerzeichen zu, die dann implizit als Array von Zeichenfolgen gedruckt werden.

Wolfram Language 101 Bytes

Es muss einen viel effizienteren Weg geben, um dies zu erreichen.

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

Perl 5, 97 Bytes

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

TIO

Erläuterung

-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

Anonyme stillschweigende Präfixfunktion. Nimmt eine numerische Matrix als Argument und gibt eine Liste von Listenzeichenfolgen zurück. Jede Liste von Zeichenfolgen repräsentiert ein Stück mit durch Leerzeichen getrennten 1s. Führende und interne (aber nicht nachfolgende) Räume sind Räume.

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

Probieren Sie es online aus!

∪∘, die einzigartigen Elemente der Ravel-Matrix (abgeflacht)

⊂{… Rufen Sie }¨ für jede dieser as ⍵die folgende Funktion mit der gesamten Matrix auf als ⍺:

 ⍺=⍵ Geben Sie an, wo sich die Nummer des Stücks in der Matrix befindet

 ⊢ ergeben, dass (trennt 2von ⍺)

 {… }⍣2 Wenden Sie die folgende Funktion zweimal an ( ⍵ist die Boolesche Matrix):

  ∨/ Maske für Zeilen mit mindestens einer 1(zeilenweise ODER-Reduktion)

  ⍵⌿⍨ Verwenden Sie dies, um die Zeilen zu filtern

  ⍉ transponieren (also machen wir das auch auf den Spalten, dann transponieren wir zurück)

 ' '@~ durch Leerzeichen an Positionen ersetzen, an denen dies nicht der Fall ist (dh wo 0)

 ⍕ Format als Zeichenmatrix

 ↓ in Liste von Zeichenfolgen aufgeteilt

 ' +$'⎕R'' PCRE ersetzt nachgestellte Leerzeichen (beliebig viele Leerzeichen, gefolgt von einem Zeilenende) durch nichts

Japt , 29 Bytes

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

Probieren Sie es online aus!

Aktualisiert, um der strengeren Ausgabeformatierung zu entsprechen.

Gibt als Stückliste aus, wobei jedes Stück durch eine Liste von Zeilen dargestellt wird, wobei 2 als Füllzeichen verwendet wird.

Erläuterung:

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 Bytes

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

Probieren Sie es online aus!

Nimmt eine durch Zeilenumbrüche getrennte Zeichenfolge und gibt eine Liste mit durch Zeilenumbrüche getrennten Zeichenfolgen zurück. Wird verwendet textwrap.dedent, um führende Leerzeichen zu entfernen.

Gelee , 19 Bytes

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

Probieren Sie es online aus!

Ein monadischer Link, der die Matrix als Eingabe verwendet und eine Liste mit einer unregelmäßigen Liste pro Stück zurückgibt. Die Fußzeile zeigt dies hübsch an, aber ich denke, dass eine Ausgabe ohne dies den Regeln der Frage entspricht.