Sie erhalten ein rechteckiges Raster der Zeichen .und #wie folgt:

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

Ihre Aufgabe ist es, den gesamten achsenbündigen Begrenzungsrahmen des #mit weiter zu füllen #:

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

Der achsenausgerichtete Begrenzungsrahmen ist das kleinste Rechteck, das alle Zeichen enthält #.

Mehr wollen? Versuchen Sie Teil II!

Regeln

Sie können zwei beliebige verwenden verschiedene druckbaren ASCII - Zeichen (0x20 bis 0x7E, inklusive), anstelle von #und .. Ich werde sie weiterhin als bezeichnen# und .für den Rest der Spezifikation bezeichnen.

Eingabe und Ausgabe können entweder eine durch Zeilenvorschub getrennte Zeichenfolge oder eine Liste von Zeichenfolgen sein (eine für jede Zeile), das Format muss jedoch konsistent sein.

Sie können davon ausgehen, dass die Eingabe mindestens eine enthält # und alle Zeilen gleich lang sind.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden verwenden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , aber beachten Sie, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Jeder Testfall hat Ein- und Ausgänge nebeneinander.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 Bytes 146 Bytes

Anweisung:

Erstellen Sie eine Arbeitsmappe mit zwei leeren Arbeitsblättern: Sheet1 und Sheet2. Legen Sie die Eingabe in Sheet1 fest, und fügen Sie dann den folgenden Code in dem Codemodul Sheet1 ein

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

Ungolfed den Code:

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

Erläuterung:

1. Durchlaufen Sie jede Zelle im verwendeten Bereich Sheet1
2. Stellen Sie die bedingte Anweisung zu kopieren jede Zelle enthält Zeichen Hashtag (#) in dem verwendeten Bereich Sheet1 und einfügen Sie sie in die Zelle in Tabelle2 mit derselben Adresse wie Sheet1.
3. Durchlaufen Sie noch einmal jede Zelle in dem verwendeten Bereich Sheet2, um jede Zellenadresse darin zu kopieren , und weisen Sie dann der Zelle in Sheet1 mit der gleichen Adresse wie dem verwendeten Bereich Sheet2 Zeichen-Hashtag (#) zu.

Beispiel I / O:

Vorsichtsmaßnahme: Stellen Sie sicher, dass jede Zelle in Sheet2 immer leer ist, wenn Sie das Programm ausführen.

05AB1E , 70 68 69 61 58 60 40 Byte

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

Erläuterung

€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

Probieren Sie es online aus

Mathematica, 91-70 Bytes

^{21 Bytes aufgrund von @MartinEnder gespeichert .}

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

Anonyme Funktion. Nimmt eine Zeichenmatrix als Eingabe und gibt eine Zeichenmatrix als Ausgabe zurück. Das Unicode-Zeichen ist U + F3C7 für \[Transpose].

C #, 262 251 Bytes

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

Werde weiter Golf spielen, wenn ich mehr Zeit habe.

Es kompiliert in eine Func<string[], string[]>.

Formatierte Version:

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

Jelly , 21 19 18 17 Bytes

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

Dies ist ein volles Programm. Eingabe und Ausgabe sind Zeichenfolgen von 0 und 1 , die durch Zeilenvorschübe begrenzt werden.

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

Wie es funktioniert

Ỵµ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.

Netzhaut , 87 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Verwendet Afür .und Zfür #.

Probieren Sie es online!

Scala, 317 Zeichen

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)

Mehr lesbare Version, hätte es wohl mehr golfen können:

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
)

JavaScript (ES6), 168 Byte

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,'.')

Übernimmt die Eingabe als mehrzeilige Zeichenfolge. Entfernt rekursiv führende und nachfolgende .s aus allen Zeilen, bis mindestens eine Zeile mit einem beginnt und endet. #Wählt dann so viele Zeilen wie möglich aus, beginnt und endet jedoch in Zeilen, die #alle .s enthalten, und ändert sie in #. Wahrscheinlich leicht golfbar.

R 158 Bytes

Dieses Programm nimmt zeilenweise Eingabepunkte .und Hashtags auf #.

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

Ungolfed:

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

Hier sind die Details der dritten Zeile:

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

PowerShell v3 +, 215 162 148 144 139 Bytes

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

Nimmt Eingaben als ein Array von Zeichenfolgen $nmit 0anstelle von .und 1anstelle von #. Dann durchlaufen wir eine Schleife $n, wobei bei jeder Iteration geprüft wird, ob die aktuelle Zeichenfolge kleiner ist als 0(dh, 1sie enthält eine), und geben in diesem Fall eine Zeichenfolge aus. Verwendet ein Pseudoternäres anstelle einer if/ else-Operation.

Die Zeichenfolge besteht aus Schleifen über die Breite der Eingabezeichenfolge. Bei jeder Iteration wenden wir uns einem 0oder einem zu, 1je nachdem, ob 1sich irgendwo in der entsprechenden vertikalen Spalte etwas befindet. Für den letzten Testfall führt dies beispielsweise zu einer Zeichenfolge wie 0011001001. Benötigt v3 + für den -inOperator. Diese Zeichenfolge wird mit einem ausgefallenen regulären Ausdruck kombiniert, um "innere" durch " 0s " zu ersetzen 1. Vielen Dank an Business Cat im Chat für die Unterstützung. Unsere Saite wäre 0011111111an diesem Punkt.

Anderenfalls geben Sie die aktuelle Zeichenfolge (nur Nullen) aus $_.

Die resultierenden Zeichenfolgen verbleiben in der Pipeline, und die Ausgabe ist implizit. Der Standardwert Write-Outputfür ein Array von Zeichenfolgen ist ein Zeilenumbruch zwischen den einzelnen Elementen. Dies geschieht also visuell.

Beispiele

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

Python, 219 212 Bytes

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]

(Obwohl ich denke, dass eine andere Methode möglicherweise kürzer ist)

Nimmt eine Liste von Zeichen und gibt sie zurück.

Teste es auf ideoone

Perl 6 , 62 Bytes

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

Eine anonyme Routine, der ein Array von Zeichenarrays (die die Matrix darstellen) als Argument übergeben werden kann und die das Array direkt so ändert, dass der aufrufende Bereich das geänderte Array anschließend hat.

Wird aanstelle des #"Ein" -Zeichens verwendet. Das "Aus" -Zeichen kann alles sein, es ist egal.

Python 3, 153 Bytes

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)))

Eingabe und Ausgabe sind eine Liste von Zeichenfolgen.

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))

Theorie der Arbeitsweise

Die Hauptidee ist, Zeilen und Spalten außerhalb des Arrays zu entfernen, wenn sie kein '#' haben. Was noch übrig ist, muss mit '#' ausgefüllt werden.

Es wird mit einer rekursiven Funktion implementiert.

Fall 1: Zeile 0 enthält kein '#'. Ergebnis ist Zeile 0 + rekursiver Aufruf für die verbleibenden Zeilen.

Fall 2: Zeile 0 enthält ein '#'. Es können keine weiteren Zeilen entfernt werden. Drehen Sie das Array im Uhrzeigersinn, sodass Spalte 0 jetzt Zeile 0 ist. Verarbeiten Sie dann das gedrehte Array rekursiv. Das Ergebnis wird im Uhrzeigersinn gedreht.

Basisfall: Das Array wurde viermal gedreht, dh alle äußeren Zeilen / Spalten wurden nach Möglichkeit entfernt. Was übrig bleibt, sollte mit '#' ausgefüllt werden

Perl, 51 Bytes

Beinhaltet +2 für -0p

Geben Sie STDIN ein, aus Zeichen ist A, ein Zeichen ist a, zB:

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

Die gleiche Länge:

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

Python 2, 184 Bytes

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

Eingabe und Ausgabe sind eine Liste von Zeichenfolgen.

Probieren Sie es auf Ideone (Gabel von Jonathan Allans Testseite)

Pyth , 50 Bytes

L}hbebjuXGhHX@GhHeH\#*yhMJs.e,Lkfq\#@bTUb.zySeMJ.z

Probieren Sie es online!