Ti viene data una griglia rettangolare dei personaggi .e #, in questo modo:

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

Il tuo compito è riempire ulteriormente il riquadro di delimitazione allineato agli assi #con #:

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

Il rettangolo di selezione allineato all'asse è il rettangolo più piccolo che contiene tutto il #.

Voglio di più? Prova la parte II!

Regole

È possibile utilizzare due caratteri ASCII stampabili distinti (da 0x20 a 0x7E, inclusi), al posto di #e .. Continuerò a fare riferimento a loro come #e .per il resto delle specifiche.

L'input e l'output possono essere una stringa separata da un singolo avanzamento riga o un elenco di stringhe (una per ogni riga), ma il formato deve essere coerente.

Si può presumere che l'input contenga almeno una #e tutte le linee abbiano la stessa lunghezza.

È possibile scrivere un programma o una funzione e utilizzare uno dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ogni test case ha input e output uno accanto all'altro.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 byte 146 byte

Istruzione:

Creare una cartella di lavoro con due fogli di lavoro vuoti: Foglio1 e Foglio2. Impostare l'ingresso in Foglio1 e quindi inserire il seguente codice nel modulo di codice Foglio1

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 il codice:

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

Spiegazione:

1. Passa attraverso ogni cella dell'intervallo usato Foglio1
2. Impostare l'istruzione condizionale per copiare ogni cella contiene l'hashtag del carattere (#) nell'intervallo utilizzato Foglio1 e incollarlo nella cella in Foglio2 con lo stesso indirizzo di Foglio1.
3. Ripeti ciclicamente di nuovo ogni cella nell'intervallo Sheet2 usato per copiare ogni indirizzo di cella in esso e quindi usala per assegnare l'hashtag di carattere (#) alla cella in Sheet1 con lo stesso indirizzo dell'intervallo Sheet2 utilizzato.

Esempio I / O:

Avvertenza: assicurarsi che ogni cella in Sheet2 sia sempre vuota ogni volta che si esegue il programma.

05AB1E , 70 68 69 61 58 60 40 byte

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

Spiegazione

€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

Provalo online

Mathematica, 91 70 byte

^{21 byte salvati grazie a @MartinEnder .}

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

Funzione anonima. Prende una matrice di caratteri come input e restituisce una matrice di caratteri come output. Il carattere Unicode è U + F3C7 per \[Transpose].

C #, 262 251 byte

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 giocherò ulteriormente quando avrò più tempo.

Si compila in a Func<string[], string[]>.

Versione formattata:

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

Gelatina , 21 19 18 17 byte

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

Questo è un programma completo. Input e output sono stringhe di 0 'e 1 ', delimitate da avanzamenti di riga.

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Utilizza Aper .e Zper #.

Provalo online!

Scala, 317 caratteri

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)

Versione più leggibile, probabilmente avrebbe potuto giocare a golf di più:

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

Accetta l'input come stringa multilinea. Funziona rimuovendo ricorsivamente le linee iniziali e finali .di tutte le linee fino a quando almeno una linea inizia e una termina con una #, quindi seleziona quante più linee possibili ma inizia e termina su linee contenenti #e cambia tutte le .s in #. Probabilmente facilmente golfabile.

R, 158 155 byte

Questo programma comprende punti di input .e hashtag #, riga per riga.

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

Ecco i dettagli della terza riga:

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 byte

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

Accetta l'input come una matrice di stringhe $n, con 0invece di .e 1invece di #. Quindi, eseguiamo il loop $n, ogni iterazione verifica se la stringa corrente è più piccola di 0(cioè, c'è un 1in essa) e, in tal caso, genera una stringa. Utilizza una pseudo-ternaria al posto di un'operazione if/ else.

La stringa è costruita da anelli attraverso la larghezza della stringa di input. Ad ogni iterazione, puntiamo su una 0o una a 1seconda se 1si trova da qualche parte nella colonna verticale corrispondente. Per l'ultimo caso di test, ad esempio, questo si tradurrà in una stringa simile 0011001001. Richiede v3 + per l' -inoperatore. Quella stringa è accoppiata con un regex di fantasia per sostituire qualsiasi 0s "interna" con 1s. Mille grazie a Business Cat in chat per l'assistenza su questo. La nostra stringa sarebbe 0011111111a questo punto.

Altrimenti, genera la stringa corrente (tutti zeri) $_.

Le stringhe risultanti vengono lasciate sulla pipeline e l'output è implicito. Il valore predefinito Write-Outputper una matrice di stringhe è con una nuova riga tra ogni elemento, quindi è visivamente ciò che accade.

Esempi

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 byte

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]

(Anche se penso che un altro metodo potrebbe essere più breve)

Prende e restituisce un elenco di elenchi di caratteri.

Provalo su ideoone

Perl 6 , 62 byte

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

Una routine anonima a cui può essere passata una matrice di matrici di caratteri (che rappresentano la matrice) come argomento, e la modifica sul posto in modo che l'ambito chiamante abbia successivamente l'array modificato.

Utilizza ainvece #il carattere "on". Il personaggio "off" può essere qualsiasi cosa, non gliene importa.

Python 3, 153 byte

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

Input e output sono un elenco di stringhe.

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

teoria del funzionamento

L'idea principale è quella di rimuovere righe e colonne all'esterno dell'array se non hanno un '#'. Qualunque cosa rimanga dovrebbe essere compilata con '#'.

È implementato usando una funzione ricorsiva.

Caso 1: la riga 0 non contiene un '#'. Il risultato è la riga 0 + chiamata ricorsiva sulle righe rimanenti.

Caso 2: la riga 0 contiene un '#'. Non è possibile rimuovere più righe. Ruota l'array cw in modo che la colonna 0 sia ora la riga 0. Quindi elabora ricorsivamente l'array ruotato. Il risultato è ccw ruotato.

Caso di base: l'array è stato ruotato di 4 volte, il che significa che tutte le righe / colonne esterne sono state rimosse, se possibile. Qualunque cosa resti dovrebbe essere riempita con '#'

Perl, 51 byte

Include +2 per -0p

Fornisci input su STDIN, il carattere è spento A, il carattere è a, ad esempio:

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

Stessa lunghezza:

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

Python 2, 184 byte

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

Input e output sono un elenco di stringhe.

Provalo su Ideone (fork della pagina di test di Jonathan Allan)

Pyth , 50 byte

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

Provalo online!