मैट्रिक्स आरा पहेली टुकड़े

Question

(बेतरतीब ढंग से https://codegolf.meta.stackexchange.com/a/17272/42963 से प्रेरित )

अंकों के आयताकार मैट्रिक्स (यानी 0 - 9) को देखते हुए, मैट्रिक्स के "टुकड़ों" को आउटपुट करें जैसे कि अंकों को एक एकल टुकड़ा बनाने के लिए अंकों के साथ आरोही क्रम में एक साथ जोड़ा जाता है। टुकड़ों को केवल orthongonally कनेक्ट करने की गारंटी है - कोई भी टुकड़ा तिरछे नहीं जुड़ेगा। केवल कभी अधिकतम 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

या

#
##

###
 #

 #
##

##

लेकिन निम्नलिखित नहीं होगा ( 0एस के पीछे अनुगामी रिक्त स्थान पर ध्यान दें ):

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छह-टुकड़ा मैट्रिक्स में छोड़ा नहीं जाएगा।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

क्या आउटपुट वास्तव में टुकड़ों की सूची हो सकता है? या I / O स्ट्रिंग्स के साथ नहीं बल्कि मैट्रिसेस और पूर्णांकों के साथ किया जा सकता है ( -1यदि किसी रिक्त स्थान का प्रतिनिधित्व करता है या किसी तत्व की अनुपस्थिति या संभव हो तो)?

— आउटगॉल्फ

क्या यह स्वीकार्य है यदि इनपुट 1-आधारित है (इसमें शून्य नहीं है) और आउटपुट 0फिलर मान के रूप में उपयोग करता है ? इसलिए प्रत्येक टुकड़ा मैट्रिक्स के बाकी मूल्यों के साथ आउटपुट होगा0

— लुइस मेंडो

मेरे पिछले प्रश्न का स्वतंत्र: कोई अन्य व्हाट्सएप की अनुमति नहीं है: सभी लाइनों को समान लंबाई बनाने के लिए रिक्त स्थान भी नहीं?

— लुइस मेंडो

एक तत्व की @EriktheOutgolfer अनुपस्थिति ठीक होगी, क्योंकि यह केवल "टुकड़ा" का उत्पादन कर रहा है। -1कुछ भी नहीं / व्हाट्सएप के बजाय प्रत्येक टुकड़े के लिए एक पूरे मैट्रिक्स का आउटपुट या कुछ अन्य मूल्य ठीक नहीं होगा, हालांकि।

— AdmBorkBork

@AdmBorkBork ओह, तो ' 'उस स्थिति में अंतरिक्ष ( ) का उपयोग किया जाना चाहिए ?

— आउटगोल्फर

Answer 1

05AB1E , 20 19 बाइट्स

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

-1 बाइट @ मिस्टरकोड के लिए धन्यवाद ।

Newline के अनुसार टुकड़ों की ( 1और अंतरिक्ष पात्रों के साथ " ") 2 डी सूचियों को आउटपुट करता है ।

यह ऑनलाइन का प्रयास करें या सभी प्रकार के परीक्षण की पुष्टि या सभी प्रकार के परीक्षण सुंदर-मुद्रित ।

स्पष्टीकरण:

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

Answer 2

हास्केल, 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"]]

Answer 3

जेली , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टुकड़ों की सूची लौटाता है, जहां 1एक टुकड़े का एक हिस्सा दर्शाता है, और ' 'पैडिंग है। ट्रेलिंग ' 'एस हटा दिए गए हैं।

Comments

ẎQ=€हालांकि, हमें आरोही क्रम में टुकड़ों की आवश्यकता होती है, इसलिए 9Ż=€(जब तक कि हमें "गैर-मौजूद टुकड़े" को शामिल नहीं करना चाहिए ẎQṢ=€)

— जोनाथन एलन

@JonathanAllan ने इस मुद्दे को ठीक किया, हालांकि मुझे पूरा यकीन है कि 9Ż=€मैं काम नहीं करूंगा (मुझे लगता है कि "एक्स्ट्रासियस व्हाट्सएप [...] की अनुमति नहीं है" के रूप में अच्छी तरह से सरणियों तक फैली हुई है, यही कारण है कि मैं ट्रिमिंग कर रहा हूं)।

— 19 को आउटगॉल्फ को एरिक

हाँ, यह समझ में आता है।

— जोनाथन एलन

Answer 4

पायथन 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

Comments

176 बाइट्स ।

— जोनाथन फ्रेच

Answer 5

पायथन 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 बाइट्स एक अवलोकन से निम्मी द्वारा ।

कार्यक्रम के रूप में, इनपुट के रूप में एकल पात्रों की सूची की सूची लेता है; उनके चरित्र का उपयोग करके पाए गए टुकड़ों को प्रिंट करके आउटपुट।

Comments

@AdmBorkBork - राइट, उस मापदंड से चूक गया। अब तय हो गया।

— चास ब्राउन

Answer 6

सी # (.NET कोर) , 258 , 238 बाइट्स

LINQ के बिना।

संपादित करें: बेहतर संस्करण घोषणाओं को इंगित करते हुए अज्ञानता का अवतार! टाय टाय

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;};

इसे ऑनलाइन आज़माएं!

Comments

२३

— इग्नोरेंस

Answer 7

पायथन 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'

Comments

यदि आप अपना कोड गोल्फर बनाते हैं, तो आपको इनपुट प्रारूप (उदाहरण के लिए, सूची की सूची के रूप में, या अंतरिक्ष से अलग किए गए पैराग्राफ) को निर्दिष्ट करने की अनुमति है।

— AdmBorkBork

Answer 8

रेटिना , 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`^.

... प्रत्येक पंक्ति पर पहला वर्ण हटाएं।

.$
$&¶

अगर कुछ बचा है, तो प्रत्येक आकृति को अगले से अलग करने के लिए एक नई रेखा जोड़ें। (यह लापता अंकों के लिए आवारा नई कहानियों से बचने के लिए किया जाता है।)

Comments

अगर आपके कोड को छोटा बना दिया जाए तो "लापता अंक" नहीं होने की गारंटी है।

— AdmBorkBork

@AdmBorkBork मुझे नहीं लगता कि इससे मदद मिलेगी। संख्यात्मक क्रम में टुकड़ों को आउटपुट करने में मदद करने की अधिक संभावना क्या होगी। क्या इसकी अनुमति है?

— नील

नहीं, यह आधी चुनौती है, अन्यथा यह बहुत आसान होगा। ;-)

— AdmBorkBork

Answer 9

चारकोल , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＷＳ⊞υι

एक सरणी में इनपुट पढ़ें। (इसे हटाया जा सकता है यदि मैंने एक बदसूरत इनपुट प्रारूप का उपयोग किया है।)

Ｆχ«

10 अंकों पर लूप करें।

≔Φυ№κＩιθ

उन पंक्तियों को प्राप्त करें जिनमें वे अंक हों।

¿θ«

जांच लें कि अंक वास्तव में पाया गया था (चुस्त न्यूट्रीशन को रोकने के लिए)।

ＵＴ

स्वचालित पैडिंग बंद करें।

Ｆθ«

पाया पंक्तियों पर लूप।

Ｆκ«

प्रत्येक स्तंभ पर लूप ...

¿⁼λＩιλ→»

... यदि वर्तमान इनपुट चरित्र वर्तमान लूप अंक के बराबर है, तो इसे प्रिंट करें अन्यथा कर्सर को दाएं घुमाएं।

Ｍ±Ｌκ¹»

अगली पंक्ति की शुरुआत में जाएं। इस तरह मूवमेंट कमांड का इस्तेमाल करने से चारकोल आउटपुट को दोनों तरफ से ट्रिम कर देता है।

Ｄ⎚

अगले अंक के लिए तैयार कैनवास को डंप और साफ़ करें। यह अलग-अलग अंकों को अलग-अलग मात्रा में ट्रिमिंग की अनुमति देता है।

मैंने एक प्रोग्रामेटिक दृष्टिकोण की कोशिश की, लेकिन इसका वजन 47 बाइट्स में था, हालांकि यह Equalsवेक्टर की मात्रा के लिए 43 बाइट्स भी होता था :

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＵＴ

स्वचालित पैडिंग बंद करें।

ＷＳ⊞υι

एक सरणी में इनपुट पढ़ें।

Ｆχ«

10 अंकों पर लूप करें।

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

इनपुट के साथ प्रत्येक वर्ण की तुलना करें और बूलियन एरे का निर्माण करें, लेकिन फिर बिना मिलान वाले पंक्तियों को फ़िल्टर करें।

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

शेष पंक्तियों पर लूप करें और किसी भी पंक्ति में सबसे पुराने मैच से स्लाइस करें वर्तमान पंक्ति में नवीनतम मैच के लिए, फिर बूलियन सरणी को अंकों या रिक्त स्थान पर मैप करना, जो बाद में स्ट्रिंग्स की एक सरणी के रूप में मुद्रित होते हैं।

Answer 10

वोल्फ्राम भाषा 101 बाइट्स

इसे पूरा करने के लिए और अधिक कुशल तरीका होना चाहिए।

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

Answer 11

पर्ल 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

Answer 12

एपीएल (Dyalog यूनिकोड) , 38 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह। एक सांख्यिक मैट्रिक्स को तर्क के रूप में लेता है और सूची स्ट्रिंग की सूची लौटाता है। स्ट्रिंग्स की प्रत्येक सूची अंतरिक्ष-पृथक 1एस के साथ एक टुकड़े का प्रतिनिधित्व करती है । अग्रणी और आंतरिक (लेकिन अनुगामी नहीं) रिक्त स्थान हैं।

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

इसे ऑनलाइन आज़माएं!

∪∘, ravel (चपटे) मैट्रिक्स के अद्वितीय तत्व

⊂{... }¨ उनमें से प्रत्येक के लिए ⍵, निम्न मैट्रिक्स को पूरे मैट्रिक्स के साथ कॉल करें ⍺:

 ⍺=⍵ इंगित करें कि मैट्रिक्स में उस टुकड़े की संख्या कहां है

 ⊢ कि (अलग उपज 2से ⍺)

 {… }⍣2 दो बार निम्न फ़ंक्शन लागू करें ( ⍵बूलियन मैट्रिक्स है):

  ∨/ कम से कम एक के साथ पंक्तियों के लिए मुखौटा 1(lit. पंक्ति-वार या कमी)

  ⍵⌿⍨ पंक्तियों को फ़िल्टर करने के लिए इसका उपयोग करें

  ⍉ स्थानान्तरण (इसलिए हम इसे स्तंभों पर भी करते हैं, फिर वापस स्थानांतरित करें)

 ' '@~ उन स्थानों पर रिक्त स्थान से प्रतिस्थापित करें, जहां नहीं (अर्थात जहां 0)

 ⍕ चरित्र मैट्रिक्स के रूप में प्रारूप

 ↓ तार की सूची में विभाजित

 ' +$'⎕R'' PCRE कुछ नहीं के साथ अनुगामी रिक्त स्थान (पंक्ति-समाप्ति के बाद किसी भी स्थान की संख्या) को प्रतिस्थापित करता है

Answer 13

जाप , 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

Comments

आप falseआंतरिक सूचियों से सभी अनुगामी को निकालना भूल गए । यहाँ एक pastebin तो मैं बेहतर समझा सकता हूँ कि आउटपुट क्या होना चाहिए। ओपी को स्पष्ट करने के लिए स्वतंत्र महसूस करें, लेकिन जहां तक ​​मैं चुनौती से समझता हूं, सभी अनुगामी व्हाट्सएप आउटपुट में बिल्कुल भी नहीं होना चाहिए।

— केविन क्रूज़सेन

Answer 14

पायथन 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अग्रणी स्थानों से छुटकारा पाने के लिए उपयोग करता है।

Comments

@AdmBorkBork ने उस नियम को नजरअंदाज किया, तय किया

— ब्लैक उल्लू काई

Answer 15

जेली , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मैट्रिक्स को इनपुट के रूप में लेते हुए एक मोनाडिक लिंक और प्रति टुकड़े पर एक रैग्ड सूची की सूची लौटाता है। पाद लेख इसे पहले से प्रदर्शित करता है, लेकिन मुझे लगता है कि इसके बिना आउटपुट प्रश्न के नियमों के अनुरूप है।