Você recebe uma grade retangular dos caracteres .e #, assim:

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

Sua tarefa é preencher toda a caixa delimitadora alinhado ao eixo da #com ainda mais #:

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

A caixa delimitadora alinhada ao eixo é o menor retângulo que contém todos os #.

Quero mais? Tente a parte II!

Regras

Você pode usar dois caracteres ASCII imprimíveis distintos (0x20 a 0x7E, inclusive), no lugar de #e .. Continuarei me referindo a eles como #e .pelo restante da especificação.

Entrada e saída podem ser uma única sequência separada por avanço de linha ou uma lista de sequências (uma para cada linha), mas o formato precisa ser consistente.

Você pode assumir que a entrada contém pelo menos uma #e todas as linhas têm o mesmo comprimento.

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

Cada caso de teste tem entrada e saída próximos um do outro.

#    #

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

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

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

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

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

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

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

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

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

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

Excel VBA, 150 bytes 146 bytes

Instrução:

Crie uma pasta de trabalho com duas planilhas em branco: Sheet1 e Sheet2. Defina a entrada na Planilha1 e coloque o seguinte código no módulo de código da Planilha1

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

Explicação:

1. Faça um loop em todas as células do intervalo usado Sheet1
2. Defina a instrução condicional para copiar cada célula que contém a hashtag de caractere (#) no intervalo usado Sheet1 e cole -a na célula da Sheet2 com o mesmo endereço da Sheet1.
3. Percorra novamente todas as células do intervalo usado Sheet2 para copiar todos os endereços de células nele e, em seguida, use-o para atribuir a hashtag de caractere (#) à célula na Sheet1 com o mesmo endereço do intervalo usado Sheet2.

Exemplo de E / S:

Advertência: verifique se todas as células da Planilha2 estão sempre em branco toda vez que você executa o programa.

05AB1E , 70 68 69 61 58 60 40 bytes

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

Explicação

€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

Experimente online

Mathematica, 91 70 bytes

^{21 bytes salvos devido a @MartinEnder .}

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

Função anônima. Pega uma matriz de caracteres como entrada e retorna uma matriz de caracteres como saída. O caractere Unicode é 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;};

Golf mais ainda quando eu tiver mais tempo.

Compila em um Func<string[], string[]>.

Versão formatada:

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

Geléia , 21 19 18 17 bytes

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

Este é um programa completo. Entrada e saída são cadeias de 0 e 1 , delimitadas por feeds de linha.

Experimente online! ou verifique todos os casos de teste .

Como 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

A contagem de bytes assume a codificação ISO 8859-1.

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

Usa Apara .e Zpara #.

Experimente online!

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)

Versão mais legível, provavelmente poderia ter jogado mais:

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

Recebe a entrada como uma sequência multilinha. Funciona removendo recursivamente .s à esquerda e à direita de todas as linhas até que pelo menos uma linha comece e uma termine com a #, depois seleciona o máximo de linhas possível, mas iniciando e finalizando nas linhas que contêm #e alteram todos os .s para #. Provavelmente facilmente jogável.

R, 158 155 bytes

Este programa recebe pontos de entrada .e hashtags #, linha por linha.

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

Aqui estão os detalhes da terceira linha:

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

Recebe entrada como uma matriz de strings $n , em 0vez de .e em 1vez de #. Em seguida, percorremos $n, cada iteração testando se a cadeia atual é menor que 0(ou seja, existe uma 1nela) e, em caso afirmativo, produz uma cadeia. Usa um pseudo-ternário no lugar de uma operação if/ else.

A sequência é construída a partir de loops através da largura da sequência de entrada. A cada iteração, aderimos a um 0ou a um 1dependendo de se 1for encontrado em algum lugar na coluna vertical correspondente. Para o último caso de teste, por exemplo, isso resultará em uma sequência como 0011001001. Requer v3 + para o -inoperador. Essa string é emparelhada com um regex de fantasia para substituir qualquer "interior" 0s por 1s. Muito obrigado ao Business Cat no chat pela ajuda nisso. Nossa string seria 0011111111neste ponto.

Senão, imprima a string atual (todos os zeros) $_.

As seqüências resultantes são deixadas no pipeline e a saída é implícita. O padrão Write-Outputpara uma matriz de strings é com uma nova linha entre cada elemento, então é isso que acontece visualmente.

Exemplos

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]

(Embora eu ache que outro método pode ser mais curto)

Pega e retorna uma lista de lista de caracteres.

Teste no ideoone

Perl 6 , 62 bytes

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

Uma rotina anônima que pode receber uma matriz de matrizes de caracteres (representando a matriz) como argumento e modifica-a no local para que o escopo da chamada tenha a matriz modificada posteriormente.

Usa em avez de #como o caractere "ativado". O personagem "desligado" pode ser qualquer coisa, não 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 e saída são uma lista de strings.

destroçado

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

Teoria de Operação

A idéia principal é remover linhas e colunas do lado de fora da matriz se elas não tiverem um '#'. Tudo o que resta deve ser preenchido com '#'.

É implementado usando uma função recursiva.

Caso 1: a linha 0 não contém um '#'. O resultado é a linha 0 + chamada recursiva nas linhas restantes.

Caso 2: a linha 0 contém um '#'. Não é possível remover mais linhas. Gire a matriz cw para que a coluna 0 agora seja a linha 0. Em seguida, processe recursivamente a matriz rotacionada. O resultado é girado ccw.

Caso base: a matriz foi girada 4 vezes, o que significa que todas as linhas / colunas externas foram removidas, se possível. O que restar deve ser preenchido com '#'

Perl, 51 bytes

Inclui +2 para -0p

Dê entrada em STDIN, off caractere é A, on caractere é a, por exemplo:

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

Mesmo comprimento:

#!/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 e saída são uma lista de strings.

Experimente na Ideone (bifurcação da página de teste de Jonathan Allan)

Pitão , 50 bytes

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

Experimente online!