Te dan una cuadrícula rectangular de los personajes .y #, así:

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

Su tarea es llenar todo el cuadro delimitador alineado con el eje #con #:

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

El cuadro delimitador alineado con el eje es el rectángulo más pequeño que contiene todo el #.

¿Quieren más? ¡Prueba la parte II!

Reglas

Puede utilizar dos caracteres ASCII imprimibles distintos (0x20 a 0x7E, inclusive), en lugar de #y .. Sin embargo , continuaré refiriéndome a ellos como #y .para el resto de la especificación.

La entrada y la salida pueden ser una sola cadena separada por salto de línea o una lista de cadenas (una para cada línea), pero el formato debe ser coherente.

Puede suponer que la entrada contiene al menos una #y todas las líneas tienen la misma longitud.

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

Cada caso de prueba tiene entrada y salida una al lado de la otra.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 bytes 146 bytes

Instrucción:

Cree un libro de trabajo con dos hojas de trabajo en blanco: Hoja1 y Hoja2. Establezca la entrada en Sheet1 y luego coloque el siguiente código en el módulo de código Sheet1

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 el código:

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

Explicación:

1. Recorre cada celda en el rango utilizado Hoja1
2. Establezca la instrucción condicional para copiar cada celda que contiene el hashtag de caracteres (#) en el rango utilizado Sheet1 y péguelo en la celda de Sheet2 con la misma dirección que Sheet1.
3. Vuelva a recorrer cada celda del rango usado Sheet2 para copiar cada dirección de celda y luego úsela para asignar el hashtag de caracteres (#) a la celda en Sheet1 con la misma dirección que el rango usado Sheet2.

Ejemplo de E / S:

Advertencia: asegúrese de que cada celda de Sheet2 siempre esté en blanco cada vez que ejecute el programa.

05AB1E , 70 68 69 61 58 60 40 bytes

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

Explicación

€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

Pruébalo en línea

Mathematica, 91 70 bytes

^{21 bytes guardados debido a @MartinEnder .}

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

Función anónima. Toma una matriz de caracteres como entrada y devuelve una matriz de caracteres como salida. El carácter Unicode es U + F3C7 para \[Transpose].

C #, 262251 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;};

Lo jugaré más cuando tenga más tiempo.

Se compila en a Func<string[], string[]>.

Versión formateada:

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

Jalea , 21 19 18 17 bytes

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

Este es un programa completo. La entrada y la salida son cadenas de 0 y 1 , delimitadas por saltos de línea.

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Retina , 87 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Usos Apara .y Zpara #.

Pruébalo en línea!

Scala, 317 caracteres

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)

Versión más legible, probablemente podría haber jugado más al golf:

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 bytes

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

Toma la entrada como una cadena multilínea. Funciona al quitar recursivamente los .s iniciales y finales de todas las líneas hasta que al menos una línea comience y una termine con una #, luego selecciona tantas líneas como sea posible pero comienza y termina en las líneas que contienen #y cambia todas las .s a #. Probablemente fácilmente golfable.

R, 158155 bytes

Este programa toma puntos de entrada .y hashtags #, línea por línea.

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

Sin golf:

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

Aquí están los detalles de la tercera línea:

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$_]}

Toma la entrada como una matriz de cadenas $n, en 0lugar de .y en 1lugar de #. Luego, recorremos $ncada iteración probando si la cadena actual es más pequeña que0 (es decir, hay una 1en ella), y si es así, genera una cadena. Utiliza un pseudoternario en lugar de una operación if/ else.

La cadena se construye a partir de bucles a través del ancho de la cadena de entrada. Cada iteración, añadimos una 0o una 1dependiendo de si 1se encuentra en algún lugar de la columna vertical correspondiente. Para el último caso de prueba, por ejemplo, esto dará como resultado una cadena como 0011001001. Requiere v3 + para-in operador. Esa cadena se combina con un reemplazo de expresión regular elegante para reemplazar cualquier s "interno" 0con 1s. Muchas gracias a Business Cat en el chat por la ayuda en eso. Nuestra cuerda estaría 0011111111en este punto.

De lo contrario, genera la cadena actual (todos ceros) $_.

Las cadenas resultantes se dejan en la tubería, y la salida es implícita. El valor predeterminado Write-Outputpara una matriz de cadenas es con una nueva línea entre cada elemento, por lo que eso es visualmente lo que sucede.

Ejemplos

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]

(Aunque creo que otro método puede ser más corto)

Toma y devuelve una lista de la lista de caracteres.

Pruébalo en ideoone

Perl 6 , 62 bytes

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

Una rutina anónima a la que se le puede pasar una matriz de matrices de caracteres (que representa la matriz) como argumento, y la modifica en el lugar para que el alcance de la llamada tenga la matriz modificada después.

Se utiliza en alugar de #como el carácter "activado". El carácter "apagado" puede ser cualquier cosa, no le importa.

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

Entrada y salida son una lista de cadenas.

sin golf

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

teoría de operación

La idea principal es eliminar filas y columnas alrededor del exterior de la matriz si no tienen un '#'. Lo que queda debe rellenarse con '#' s.

Se implementa utilizando una función recursiva.

Caso 1: la fila 0 no contiene un '#'. El resultado es la fila 0 + llamada recursiva en las filas restantes.

Caso 2: la fila 0 contiene un '#'. No se pueden eliminar más filas. Gire la matriz cw para que la columna 0 sea ahora la fila 0. Luego, procese recursivamente la matriz girada. El resultado es girado hacia la izquierda.

Caso base: la matriz se ha girado 4 veces, lo que significa que todas las filas / columnas externas se han eliminado si es posible. Lo que quede debe llenarse con '#' s

Perl, 51 bytes

Incluye +2 para -0p

Dar entrada en STDIN, el carácter apagado es A, el carácter encendido es a, por ejemplo:

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

Mismo largo:

#!/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

Entrada y salida son una lista de cadenas.

Pruébelo en Ideone (tenedor de la página de prueba de Jonathan Allan)

Pyth , 50 bytes

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

Pruébalo en línea!