(Rastgele esinlenerek https://codegolf.meta.stackexchange.com/a/17272/42963 )

Dikdörtgen bir basamak matrisi (yani 0 - 9) verildiğinde, matrisin "parçalarını" basamaklar basamaklar halinde artan bir sırada tek bir parça oluşturacak şekilde birbirine bağlanmış gibi çıkar. Parçaların sadece dikey olarak bağlanması garanti edilir - hiçbir parça çapraz olarak bağlanmaz. En fazla 10 3parça olacaktır (yani, bir parça aynı matriste iki kez görünmeyecektir).

Örneğin, matris verildiğinde

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

parçalar ve örnek çıktısı aşağıdadır:

0
0 0

1 1 1
  1

  2
2 2

3 3

Aralık, parçaların şeklini korumak için önemlidir, ancak parçalar mutlaka iç aralığa ihtiyaç duymaz. Parçaların kendileri bir şekilde tutarlı bir şekilde ayırt edilmelidir (örneğin, her biri farklı bir karakter olduğundan emin olmak için parçalar arasındaki bir satırsonu vb.). Ayrıca, yabancı boşluklara (örneğin, sondaki yeni satırlara veya önde gelen sütunlara) izin verilmez. Örneğin, aşağıdakiler de geçerli olacaktır:

0
00
111
 1
 2
22
33

veya

#
##

###
 #

 #
##

##

Ancak aşağıdakiler olmaz ( 0s'nin arkasındaki boşluklara dikkat edin ):

0      
0 0    

Dönüşlere veya yansımalara da izin verilmez. Örneğin,

 1
111

Yukarıdaki matris için de geçersizdir.

Matris parçalarının delikleri olabilir veya sadece tek bir eleman olabilir:

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

Veya, parça tüm matris olabilir:

0 0 0
0 0 0

İşte daha büyük, daha karmaşık bir test örneği:

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

Ve bir örnek çıktı:

00

11111

 22
222
2

3

444
 44

55
5
5

6666
6  66
666

 77
  7
777

88

9

Kurallar ve G / Ç

• Giriş ve çıkış herhangi bir uygun yöntemle verilebilir .
• STDOUT'a yazdırabilir veya işlev sonucu olarak geri gönderebilirsiniz.
• Tam bir program veya bir işlev kabul edilebilir.
• Şekli korumak için önde gelen boşluk gereklidir (örn 1., Örnekteki "T" şekli ), parçaları farklı kılmak için tutarlı bir boşluk gereklidir ve sonunda tek bir sondaki yeni satıra izin verilir, ancak başka boşluklara izin verilmez.
• Güvenle adet numaralandırılmış varsayabiliriz 0için N(örneğin), yani bitişik 3altı parçalı matris içinde atlanır olmaz.
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

05AB1E , 20 19 bayt

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

@ Mr.Xcoder sayesinde -1 bayt .

Yeni satır başına 2B parça listesi ( 1ve boşluk karakterleri ile " ") çıktılar .

Online Deneyin veya tüm test durumları doğrulamak veya tüm test durumları oldukça bastırabilecek .

Açıklama:

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 bayt

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

Matrisi bir dize listesi olarak alır ve bir dize listesi listesi döndürür.

Çevrimiçi deneyin!

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

Jöle , 18 bayt

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

Çevrimiçi deneyin!

1Bir parçanın bir kısmını temsil eden ve ' 'dolgu olduğu bir parça listesi döndürür . Sondaki ' 's kaldırılır.

Piton 3 , 271 209 206 183 176 172 191 bayt

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

Çevrimiçi deneyin!

Düzenleme: Bazı temizlik ve -5 Jonathan Frech sayesinde -5 .

Düzenleme: -3 -26 bir kez daha @ Jonathan Frech sayesinde .

Düzenleme: @ Jonathan Frech sayesinde tekrar -7 .

Düzenleme: +19: @ nimi tarafından belirtildiği gibi daha önce çıktı yanlış format vardı.

Liste listesi olarak girdi matristir:

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

Çıktı, matrislerin listesidir:

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

Piton 2 , 173 172 165 bayt

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)

Çevrimiçi deneyin!

Nimi'nin gözleminden -15 bayt .

Program formunda, girdi olarak tek karakter listelerinin bir listesini alır; karakterlerini kullanarak bulunan parçaları bastırarak çıktılar.

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

LINQ olmadan.

EDIT: Cehennem Tıbbı daha iyi var bildirimleri işaret! 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;};

Çevrimiçi deneyin!

Python 2 , 291 bayt

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'

Çevrimiçi deneyin!

Girdi olarak bir teklif sınırlamalı sokma bekler. Kodun yarı gülünç bir yüzdesi, boşlukla ayrılmamış / boşlukla doldurulmamış girdiyi işlemeye adanmıştır.

Golfsiz Açıklama:

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

Retina , 75 bayt

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

.$
$&¶

Çevrimiçi deneyin! Açıklama:

$
¶9

Girdiye bir rakam ekleyin. Bu döngü sayacını temsil eder. Yeni satır, sondaki boşluk kaldırma işlemini basitleştirir.

.-10{

Varsayılan çıkışı engelleyin ve tam olarak 10 kez tekrarlayın.

T`9d`d`.$

Döngü basamağını ilerletin.

*;(

Komut dosyasının geri kalanının çıktısını alın, ancak arabelleği geri yükleyin.

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

Döngü rakamıyla eşleşmeyen tüm basamakları boşluklarla değiştirin. (Çünkü bu bir önden okuma kullanıyor ve bu noktada döngü basamağının yerini alacak hiçbir şey yok.)

 +¶
¶

Tüm boşlukları kaldırın.

G`\d

Tüm boş çizgileri kaldırın.

/^\d|^$/m^+

Hiçbir rakam bir rakam ile başlamazsa tekrarlayın ...

m`^.

... her satırdaki ilk karakteri siler.

.$
$&¶

Kalan bir şey varsa, her şekli bir sonrakinden ayırmak için yeni bir satır ekleyin. (Bu, eksik basamaklar için başıboş satırlardan kaçınmak için yapılır.)

Kömür , 43 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

ＷＳ⊞υι

Girişi bir diziye okuyun. (Çirkin bir giriş biçimi kullanırsam bu kaldırılabilir.)

Ｆχ«

10 basamak üzerinden döngü yapın.

≔Φυ№κＩιθ

Bu rakamları içeren satırları alın.

¿θ«

Rakamın gerçekten bulunduğunu kontrol edin (sahte yeni satırların çıktısını önlemek için).

ＵＴ

Otomatik dolguyu kapatın.

Ｆθ«

Bulunan satırların üzerinden geçin.

Ｆκ«

Her sütunun üzerinden döngü yapın ...

¿⁼λＩιλ→»

... geçerli giriş karakteri geçerli döngü basamağına eşitse, yazdırın aksi takdirde imleci sağa hareket ettirin.

Ｍ±Ｌκ¹»

Sonraki satırın başına git. Bunun gibi hareket komutlarını kullanmak, Kömürün her iki taraftaki çıktıyı kesmesine izin verir.

Ｄ⎚

Sonraki rakama hazır olan tuvali dök ve temizle. Bu, farklı basamakların farklı miktarlarda kırpmaya sahip olmasını sağlar.

Programlı bir yaklaşım denedim, ancak 47 bayt ağırlığındaydı, ancak Equalsvektörleştirildiğinde de kısa bir süre için 43 bayt olurdu :

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

ＵＴ

Otomatik dolguyu kapatın.

ＷＳ⊞υι

Girişi bir diziye okuyun.

Ｆχ«

10 basamak üzerinden döngü yapın.

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

Her karakteri girişle karşılaştırın ve bir boole dizisi oluşturun, ancak daha sonra eşleşmeden satırları filtreleyin.

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

Kalan satırların üzerinden geçin ve herhangi bir satırdaki en eski eşleşmeden geçerli satırdaki en son eşleşmeye dilimleyin, ardından boolean dizisini tekrar bir dize dizisi olarak yazdırılan basamaklara veya boşluklara eşleyin.

Wolfram Dili 101 bayt

Bunu başarmanın çok daha verimli bir yolu olmalı.

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

Perl 5, 97 bayt

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

TIO

açıklama

-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 bayt ^SBCS

Anonim zımni önek fonksiyonu. Bağımsız değişken olarak sayısal bir matris alır ve listeler dizelerinin listesini döndürür. Her dizi listesi, boşlukla ayrılmış 1s içeren bir parçayı temsil eder . Önde gelen ve iç (ancak sondaki değil) alanlar boşluktur.

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

Çevrimiçi deneyin!

∪∘, ravel (düzleştirilmiş) matrisin benzersiz elemanları

⊂{… }¨ Her biri için ⍵, aşağıdaki matrisin tamamı ile aşağıdaki işlevi şu şekilde çağırın ⍺:

 ⍺=⍵ bu parçanın numarasının matriste nerede olduğunu belirtin

 ⊢ verim ki (ayırır 2gelen ⍺)

 {… }⍣2 Aşağıdaki işlevi iki kez uygulayın ( ⍵Boole matrisidir):

  ∨/ en az bir tane içeren satırlar için maske 1(sıralı VEYA azaltma)

  ⍵⌿⍨ satırları filtrelemek için bunu kullanın

  ⍉ devrik (bunu sütunlarda da yaparız, sonra devrik oluruz)

 ' '@~ olmayan konumlardaki boşluklarla değiştirin (örn. 0 )

 ⍕ karakter matrisi olarak biçimlendir

 ↓ dizeler listesine bölün

 ' +$'⎕R'' PCRE, sondaki boşlukları (herhangi bir sayıda boşluk ve ardından bir satır sonu) değiştirir

Japt , 29 bayt

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

Çevrimiçi deneyin!

Daha katı çıktı biçimlendirmesine uyacak şekilde güncellendi.

Dolgu karakteri olarak 2 kullanılarak, her bir parça bir satır listesi ile temsil edilen parçaların bir listesi olarak çıktılar.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Yeni satırdan ayrılmış bir dize alır, yeni satırdan ayrılmış dizelerin bir listesini döndürür. textwrap.dedentÖnde gelen alanlardan kurtulmak için kullanır .

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Matrisi giriş olarak alan ve parça başına bir düzensiz listenin bir listesini döndüren monadik bir bağlantı. Altbilgi bu güzel görüntüler, ama bence bu olmadan çıktı soru kuralları ile tutarlı.