19

आपको पात्रों का एक आयताकार ग्रिड दिया जाता है .और #, इस तरह:

..........
..#.......
....#..#..
...#......
..........

आपका कार्य #आगे के साथ पूरे अक्ष-संरेखित बाउंडिंग बॉक्स को भरना है #:

..........
..######..
..######..
..######..
..........

अक्ष-संरेखित बाउंडिंग बॉक्स सबसे छोटा आयत है जिसमें सभी शामिल हैं #।

और चाहिए? भाग II का प्रयास करें!

नियम

आप किसी भी दो का उपयोग कर सकते अलग के स्थान पर प्रिंट योग्य ASCII वर्ण (0x20 0x7E करने के लिए, सम्मिलित), #और .। मैं उन्हें विनिर्देशन के शेष भाग के रूप में #और फिर भी जारी रखना चाहूंगा .।

इनपुट और आउटपुट या तो एक एकल पंक्ति-अलग-अलग स्ट्रिंग या स्ट्रिंग की सूची (प्रत्येक पंक्ति के लिए एक) हो सकता है, लेकिन प्रारूप को सुसंगत होना चाहिए।

आप मान सकते हैं कि इनपुट में कम से कम एक है #और सभी लाइनें समान लंबाई की हैं।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

परीक्षण के मामलों

प्रत्येक परीक्षण मामले में एक दूसरे के बगल में इनपुट और आउटपुट होता है।

#    #

...    ...
#..    #..
...    ...

...    ...
#..    ###
..#    ###

.#.    ###
#..    ###
..#    ###

.....    .....
.#.#.    .###.
.....    .....

...    ...
.#.    .#.
...    .#.
.#.    .#.
...    ...

..........    ..........
..........    ..........
....#.....    ....#.....
..........    ..........

..........    ..........
..........    ..........
....#.....    ...##.....
...#......    ...##.....

..........    ..........
..#.......    ..###.....
....#.....    ..###.....
...#......    ..###.....

..........    ..........
..#.......    ..######..
....#..#..    ..######..
...#......    ..######..

.........#    ..########
..#.......    ..########
....#..#..    ..########
...#......    ..########

code-golf ascii-art grid

— मार्टिन एंडर
स्रोत

"प्रारूप के अनुरूप होना चाहिए" से आपका क्या तात्पर्य है? क्या इनपुट प्रारूप को आउटपुट प्रारूप के अनुरूप होना चाहिए या इसका मतलब यह है कि इनपुट प्रारूप के अनुरूप होने की आवश्यकता है और आउटपुट प्रारूप भी सुसंगत होना चाहिए?

— एमिगा

@Emigna इनपुट और आउटपुट फॉर्मेट समान होने चाहिए।

— मार्टिन एंडर

@MartinEnder मेरा प्रोग्राम एक 2 डी चार सरणी इनपुट करता है और इसे प्रोसेस करता है। परिणाम अभी भी एक 2 डी चार सरणी है, लेकिन यह डिफ़ॉल्ट रूप से सरणी की सामग्री के रूप में प्रदर्शित होता है, अर्थात नए सिरे से अलग तार। क्या यह स्वीकार्य है? या प्रदर्शित आउटपुट उस 2D सरणी का एक स्ट्रिंग प्रतिनिधित्व होना चाहिए?

— लुइस मेंडो

@LuisMendo मैं टाइप के एक स्ट्रिंग प्रतिनिधित्व की उम्मीद है। Linefeed द्वारा अलग किए गए तार चाहे कर रहे हैं मैं यह नहीं कह सकते अपनी भाषा में नेस्टेड सरणी के प्राकृतिक स्ट्रिंग प्रतिनिधित्व। (हालाँकि, चूंकि यह "प्रतिवर्ती" प्रतिनिधित्व प्रतीत नहीं होता है, चूंकि आपका इनपुट प्रारूप भिन्न है, शायद नहीं।)

— मार्टिन एंडर

ग्राफिकल आउटपुट की अनुमति है?

— 12M2121

17

VBA एक्सेल, 150 बाइट्स 146 बाइट्स

निर्देश:

दो रिक्त वर्कशीट के साथ एक वर्कबुक बनाएं: शीट 1 और शीट 2। शीट 1 में इनपुट सेट करें और फिर शीट कोड मॉड्यूल में निम्नलिखित कोड डालें

Sub A:For Each C In UsedRange:If C.Value="#"Then Sheet2.Range(C.Address)="#"
Next:For Each C In Sheet2.UsedRange:Range(C.Address)="#":Next:End Sub

कोड को अनफॉलो किया गया:

Sub A()

For Each C In UsedRange
    If C.Value = "#" Then Sheet2.Range(C.Address) = "#"
Next

For Each C In Sheet2.UsedRange
    Range(C.Address) = "#"
Next

End Sub

स्पष्टीकरण:

प्रयुक्त रेंज Sheet1 में प्रत्येक सेल के माध्यम से लूप
प्रत्येक सेल को कॉपी करने के लिए सशर्त विवरण सेट करें जिसमें प्रयुक्त रेंज Sheet1 में वर्ण हैशटैग (#) शामिल हो और उसे Sheet2 में उसी पते के साथ Sheet2 में सेल में पेस्ट करें।
प्रयुक्त सेल शीट 2 में प्रत्येक सेल को एक बार फिर से लूप करें ताकि इसमें प्रत्येक सेल एड्रेस कॉपी किया जा सके और फिर इसका उपयोग कैरेक्टर हैशटैग (#) को शीट 1 में सेल में इस्तेमाल किए गए रेंज शीट 2 के समान पते के साथ करने के लिए किया।

उदाहरण I / O:

कैविएट: सुनिश्चित करें कि हर बार जब आप प्रोग्राम चलाते हैं, तो शीट 2 में हर सेल खाली हो।

— अनास्तासिया-रोमानोवा ova
स्रोत

1

कर सके =C.Valueपहली पंक्ति में हो ="#"?

— रिले

@ रिले हां, यह हो सकता है। धन्यवाद।

— अनास्तासिया-रोमानोवा

ऐसा लगता है कि मैं उप और अंत उप भागों को हटाकर कुछ और बाइट्स बचा सकता हूं, फिर तत्काल विंडो में प्रोग्राम चला रहा हूं। मैं कोशिश करूँगा कि यह काम करे या न करे। अभी एक्सेल तक नहीं पहुंच सका ...

— अनस्तासिया-रोमानोवा '

लेकिन क्या यह अभी भी एक कार्यक्रम या फ़ंक्शन के रूप में गिना जाएगा यदि आपने ऐसा किया है?

— नील

@ नील दन्नो औपचारिक परिभाषा के बारे में लेकिन मेरे लिए, एक कार्यक्रम निर्देशों का एक सेट है और यह अभी भी सामान्य कार्यक्रम की तरह काम करता है अगर हम कोड को तत्काल विंडो में रखते हैं, हालांकि सीमाएं हैं। उनमें से एक है इस कोड को वहाँ निष्पादित नहीं किया जा सकता है। हा-हा: डी

— अनास्तासिया-रोमानोवा '

8

05AB1E , 70 68 69 61 58 60 40 बाइट्स

€S`¹gG~}Dg©L*0KŸ<U¹v¼y1åi®FXNå}ë0®×}J}¾ä

व्याख्या

€S`                                       # split each string in input to a charlist and place separately on stack
   ¹gG~}                                  # OR the char arrays to produce a single list with 1's in the columns that have 1's and 0 in the rest
        Dg L*                             # multiply by indices (1-indexed)
          ©                               # store row length in register
             0K                           # remove 0's (the indices which should not have 1's
               Ÿ<U                        # store a list of the indices that should have 1's in X
                  ¹v                 }    # for each string in input
                    ¼                     # increase counter
                     y1åi      ë   }      # if the row contains at least one 1
                         ®FXNå}           # push 1 for indices which should have 1 and else 0
                                0®×       # else push a row of 0's
                                    J     # join into a string
                                      ¾ä  # split the string in rows

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

— Emigna
स्रोत

7

गणितज्ञ, 91 70 बाइट्स

^{@MartinEnder की वजह से 21 बाइट बच गईं ।}

ReplacePart["."+0#,Tuples[Range@@@MinMax/@(#~Position~"#")]]->"#"]&

अनाम फ़ंक्शन। एक वर्ण मैट्रिक्स को इनपुट के रूप में लेता है और एक वर्ण मैट्रिक्स को आउटपुट के रूप में देता है। यूनिकोड वर्ण U + F3C7 है \[Transpose]।

— LegionMammal978
स्रोत

5

सी #, 262 251 बाइट्स

s=>{int l,t,r,b,i,j,k;l=t=r=b=i=-1;for(;++i<s.Length;){j=s[i].IndexOf('#');if(j>-1){k=s[i].LastIndexOf('#');l=l==-1|j<l?j:l;t=t==-1?i:t;r=k>r?k:r;b=i;}}for(i=t;i<=b;++i)for(j=l;j<=r;){var c=s[i].ToCharArray();c[j++]='#';s[i]=new string(c);}return s;};

जब मेरे पास अधिक समय होगा तब इसे आगे बढ़ाएंगे।

यह एक में संकलित करता है Func<string[], string[]>।

प्रारूपित संस्करण:

s =>
{
    int l, t, r, b, i, j, k;
    l = t = r = b = i = -1;

    for (; ++i < s.Length;)
    {
        j = s[i].IndexOf('#');
        if (j > -1)
        {
            k = s[i].LastIndexOf('#');

            l = l == -1 | j < l ? j : l;

            t = t == -1 ? i : t;

            r = k > r ? k : r;

            b = i;
        }
    } 

    for (i = t; i <= b; ++i)
        for (j = l; j <= r;)
        {
            var c = s[i].ToCharArray();
            c[j++] = '#';
            s[i] = new string(c);
        }

    return s;
};

— TheLethalCoder
स्रोत

5

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

|/Tr/FṬ|
ỴµZÇZ&ÇY

यह एक पूर्ण कार्यक्रम है। इनपुट और आउटपुट 0 's और 1 ' s के तार हैं , जिन्हें लाइनफीड द्वारा सीमांकित किया गया है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ỴµZÇZ&ÇY  Main link. Argument: s (string)

Ỵ         Split s at linefeeds into the array A.
 µ        Begin a new, monadic chain. Argument: A
  Z       Zip/transpose A.
   Ç      Apply the helper link to the transpose.
    Z     Zip/transpose to restore the original order.
      Ç   Apply the helper link to A.
     &    Take the bitwise AND of both results.
       Y  Join, separating by linefeeds.

|/Tr/FṬ|  Helper link. Argument: A (array of strings)

|/        Reduce A columnwise by bitwise OR. This casts to integer.
  T       Truth; yield the indices of 1's.
   r/     Reduce by range. This yields an exponentially growing, nested, ragged
          array that contains all integers between the lowest and highest index
          in the previous result, at least once but possibly multiple times.
     F    Flatten the result.
      Ṭ   Untruth; yield an array with 1's at the specified indices.
          Multiple occurrences of the same index are ignored.
       |  Take the bitwise OR of the result and each row of A.

— डेनिस
स्रोत

4

रेटिना , 87 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

Tm`A` `^\GA+¶|(¶A+)+\Z|^(A+?)(?<=(?=\D*^\2Z)\A\D*)|(A+)$(?=\D*\Z(?<!(?<!\3)$\D*))
T`p`L

के Aलिए .और के Zलिए उपयोग करता है #।

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

— मार्टिन एंडर
स्रोत

3

स्काला, 317 वर्ण

val a=input.split("\n");val e=a.map{s=>(s.indexOf("#"),s.lastIndexOf("#"))}.zipWithIndex.filter(_._1._1!= -1);val b=(e.map{s=>s._1._1}.min,e.map{s=>s._1._2}.max,e.head._2,e.last._2);print((0 to a.length-1).map{y=>(0 to a(y).length-1).map{x=>if(x>=b._1&&x<=b._2&&y>=b._3&&y<=b._4)"#" else "."}.mkString+"\n"}.mkString)

अधिक पठनीय संस्करण, शायद इसे और अधिक बढ़ा सकता है:

val a=input.split("\n")
val e=a.map{s=>
    (s.indexOf("#"),s.lastIndexOf("#"))
}.zipWithIndex        // Need the indexes for the Y values
.filter(_._1._1!= -1) // Ugly because of tupleception: (actual tuple, index)

val b=(
    e.map{s=>s._1._1}.min,
    e.map{s=>s._1._2}.max,
    e.head._2,
    e.last._2)

print(
    (0 to a.length-1).map{y=>
        (0 to a(y).length-1).map{x=>
            if(x>=b._1&&x<=b._2&&y>=b._3&&y<=b._4)"#" 
            else "."
        }.mkString+"\n"
    }.mkString
)

— AmazingDreams
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 168 बाइट्स

s=>/^#/gm.test(s)?/#$/gm.test(s)?s.replace(/^.*#[^]*#.*$/m,s=>s.replace(/./g,'#'))?f(s.replace(/.$/gm,'')).replace(/$/gm,'.'):f(s.replace(/^./gm,'')).replace(/^/gm,'.')

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

— नील
स्रोत

3

आर, 158 155 बाइट्स

यह कार्यक्रम इनपुट पॉइंट .और हैशटैग #, लाइन बाय लाइन में लेता है ।

v=c();f=which((d=matrix(strsplit(paste0(a<-scan(,""),collapse=""),"")[[1]],nr=sum(a<0),b=T))=="#",a=T);d[min(f[,1]):max(f[,1]),min(f[,2]):max(f[,2])]="#";d

अधूरा:

a<-scan(,"")             #Input

v=c()                   #Empty vector
f=which((d=(matrix(strsplit(paste0(a,collapse=""),"")[[1]],nr=length(a),b=T)))=="#",a=T) #Main work is here !


d[min(f[,1]):max(f[,1]),min(f[,2]):max(f[,2])]="#"                        #Creates 
                                                                          #the new figure

d                       #Displays it

यहां तीसरी पंक्ति का विवरण दिया गया है:

paste0(a,collapse="") 
#Collapses the input into a single string

strsplit(paste0(a,collapse=""),"")[[1]] 
#Split this string character-wise

matrix(strsplit(paste0(a,collapse=""),"")[[1]],nr=sum(a<0),b=T) 
#Creates and fills (by row) a matrix with number of row the number of line of the input

which((d=(matrix(strsplit(paste0(a,collapse=""),"")[[1]],nr=l,b=T)))=="#",a=T)
#Gives the index of the matrix's elements that are "#"

— फ़्रेडरिक
स्रोत

3

PowerShell v3 +, 215 162 148 144 139 बाइट्स

param($n)$n|%{(((-join(0..($n[0].length-1)|%{$i=$_;+('1'-in(0..($n.length-1)|%{$n[$_][$i]}))}))-replace'(?<=1.*?).(?=.*?1)',1),$_)[0-ge$_]}

$nके 0बजाय .और के साथ तार की एक सरणी के रूप में इनपुट लेता 1है #। फिर, हम लूप के माध्यम से $n, प्रत्येक पुनरावृत्ति परीक्षण करते हैं कि क्या वर्तमान स्ट्रिंग की तुलना में छोटा है 0(यानी, इसमें एक 1है), और यदि ऐसा है, तो एक स्ट्रिंग को आउटपुट करें। / ऑपरेशन के स्थान पर एक छद्म-त्रिगुट का उपयोग करता है ।ifelse

स्ट्रिंग का निर्माण इनपुट स्ट्रिंग की चौड़ाई के माध्यम से छोरों से किया जाता है। प्रत्येक पुनरावृत्ति, हम 0एक पर 1निर्भर करता है या अगर 1एक ही ऊर्ध्वाधर स्तंभ में कहीं पाया जाता है। उदाहरण के लिए, अंतिम परीक्षण के मामले में, यह एक स्ट्रिंग की तरह होगा 0011001001। -inऑपरेटर के लिए v3 + की आवश्यकता होती है । उस स्ट्रिंग को एक फैंसी-डेन्सी रेगेक्स के साथ जोड़ा गया है जो किसी भी "इनर" 0एस को बदलने के लिए प्रतिस्थापित करता है 1। उस पर सहायता के लिए चैट में बिजनेस कैट को बहुत धन्यवाद । हमारा तार 0011111111इस बिंदु पर होगा ।

एल्स, आउटपुट करंट (ऑल-जीरो) स्ट्रिंग $_।

परिणामी तारों को पाइप लाइन पर छोड़ दिया जाता है, और आउटपुट निहित है। Write-Outputस्ट्रिंग की एक सरणी के लिए डिफ़ॉल्ट प्रत्येक तत्व के बीच एक नई रेखा के साथ है, इसलिए यह नेत्रहीन क्या होता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\highlight-the-bounding-box-cartesian.ps1 '0000000001','0010000000','0000100100','0001000000'
0011111111
0011111111
0011111111
0011111111

PS C:\Tools\Scripts\golfing> .\highlight-the-bounding-box-cartesian.ps1 '0000000000','0000000000','0000100000','0001000000'
0000000000
0000000000
0001100000
0001100000

— AdmBorkBork
स्रोत

2

पायथन, 219 212 बाइट्स

def b(a):j=len(a[0]);g=range;z=g(len(a));h=[i for i in z if'#'in a[i]];w=[i for i,c in[(i,[r[i]for r in a])for i in g(j)]if'#'in c];return[[any((r<h[0],h[-1]<r,c<w[0],w[-1]<c))and'.'or'#'for c in g(j)]for r in z]

(हालांकि मुझे लगता है कि एक और तरीका अच्छा हो सकता है)

ले जाता है और चार्ट की सूची की सूची देता है।

इसे आइडोन पर टेस्ट करें

— जोनाथन एलन
स्रोत

2

पर्ल 6 , 62 बाइट्स

{.[.grep(/a/,:k).minmax;$_».grep('a',:k).flat.minmax]='a'xx*}

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

aइसके बजाय #"पर" चरित्र के रूप में उपयोग करता है । "बंद" चरित्र कुछ भी हो सकता है, यह परवाह नहीं करता है।

— SMLS
स्रोत

2

पायथन 3, 153 बाइट्स

r=lambda w:list(zip(*w[::-1]))
f=lambda w,n=4:list(map(''.join,n and(('#'in w[0])and r(r(r(f(r(w),n-1))))or[w[0]]+foo(w[1:],n))or['#'*len(w[0])]*len(w)))

इनपुट और आउटपुट स्ट्रिंग्स की एक सूची है।

ungolfed

r=lambda w:list(zip(*w[::-1]))   # rotate grid cw 90 degrees

def f(w,n=4):
    if n:
        if '#' in w[0]:
            u = r(r(r(f(r(w), n-1))))

        else:
            u = [w[0]] + foo(w[1:], n)

    else:
        u = ['#'*len(w[0])]*len(w)

 return list(map(''.join,u))

संचालन का सिद्धांत

यदि उनके पास '#' नहीं है, तो मुख्य विचार सरणी के बाहर की पंक्तियों और स्तंभों को निकालना है। जो कुछ बचा है उसे '' के साथ भरना चाहिए।

यह एक पुनरावर्ती फ़ंक्शन का उपयोग करके कार्यान्वित किया जाता है।

केस 1: पंक्ति 0 में '#' नहीं है। परिणाम पंक्ति 0 है + शेष पंक्तियों पर पुनरावर्ती कॉल करें।

केस 2: पंक्ति 0 में एक '#' है। अधिक पंक्तियों को हटाया नहीं जा सकता है। बारी बारी से सरणी cw ताकि स्तंभ 0 अब पंक्ति 0 है। फिर घुमाए गए सरणी को पुन: संसाधित करें। परिणाम ccw घुमाया जाता है।

आधार मामला: सरणी को 4 बार घुमाया गया है, जिसका अर्थ है कि यदि संभव हो तो सभी बाहरी पंक्तियों / स्तंभों को हटा दिया गया है। जो कुछ भी बचता है, उसे in # ’से भरना चाहिए

— RootTwo
स्रोत

2

पर्ल, 51 बाइट्स

के लिए +2 शामिल है -0p

एसटीडीआईएन पर इनपुट दें, ऑफ कैरेक्टर है A, चरित्र पर है a, जैसे:

bounding.pl
AAAAAAAAAA
AAaAAAAAAA
AAAAaAAaAA
AAAaAAAAAA
AAAAAAAAAA
^D

bounding.pl:

#!/usr/bin/perl -0p
s%(?=\D*a).+%$a|=$&%eg;s%.*a.*%$a%g;s/a.*a/\L$&/g

एक ही लंबाई:

#!/usr/bin/perl -0p
s%.+%${a./a/g}|=$&%eg;s%.*a.*%$a1%g;s/a.*a/\L$&/g

— टन हास्पेल
स्रोत

1

पायथन 2, 184 बाइट्स

def c(i):
 m=n=();e,z=enumerate,'for j,r in e(i):\n for k,c in e(r):%s'
 exec z%'\n  if"#"==c:m+=j,;n+=k,'
 exec z%'\n  if min(m)<=j<=max(m)<[]>min(n)<=k<=max(n):i[j][k]="#"'
 return i