Otrzymujesz prostokątną siatkę postaci .i #, w ten sposób:

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

Twoim zadaniem jest, aby wypełnić całą oś wyrównany obwiedni #z dodatkowo #:

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

Obwiednia wyrównana do osi jest najmniejszym prostokątem, który zawiera wszystkie #.

Chcieć więcej? Spróbuj część II!

Zasady

Możesz użyć dowolnych dwóch różnych drukowalnych znaków ASCII (0x20 do 0x7E włącznie), zamiast #i .. Będę nadal odnosząc się do nich, jak #i .dla pozostałej części specyfikacji chociaż.

Dane wejściowe i wyjściowe mogą być albo pojedynczym ciągiem oddzielonym od linii, albo listą ciągów (po jednym dla każdej linii), ale format musi być spójny.

Możesz założyć, że wejście zawiera co najmniej jeden, #a wszystkie wiersze mają tę samą długość.

Możesz napisać program lub funkcję i użyć dowolnej z naszych standardowych metod otrzymywania danych wejściowych i dostarczania danych wyjściowych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

To jest golf golfowy , więc wygrywa najkrótsza ważna odpowiedź - mierzona w bajtach .

Przypadki testowe

Każdy przypadek testowy ma wejścia i wyjścia obok siebie.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 bajtów 146 bajtów

Instrukcja:

Utwórz skoroszyt z dwoma pustymi arkuszami: Arkusz1 i Arkusz2. Ustaw dane wejściowe w arkuszu Arkusz1, a następnie umieść następujący kod w module kodu Arkusz1

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 kod:

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

Wyjaśnienie:

1. Pętlę przez każdą komórkę w używanym zakresie Arkusz 1
2. Ustaw instrukcję warunkową, aby skopiować każdą komórkę zawierającą znak hashtag (#) w używanym zakresie Arkusz1 i wklej ją do komórki w Arkuszu 2 o tym samym adresie co Arkusz1.
3. Pętlę jeszcze raz każdą komórkę w używanym zakresie Arkusz2, aby skopiować każdy adres komórki w nim, a następnie użyć go do przypisania hashtagu znakowego (#) do komórki w Arkuszu1 o tym samym adresie co użyty zakres Arkusz2.

Przykład I / O:

Uwaga: Upewnij się, że każda komórka w arkuszu 2 jest zawsze pusta przy każdym uruchomieniu programu.

05AB1E , 70 68 69 61 58 60 40 bajtów

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

Wyjaśnienie

€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

Wypróbuj online

Mathematica, 91 70 bajtów

^{21 bajtów zapisanych z powodu @MartinEnder .}

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

Funkcja anonimowa. Pobiera macierz znaków jako dane wejściowe i zwraca macierz znaków jako dane wyjściowe. Znak Unicode to U + F3C7 dla \[Transpose].

C #, 262 251 bajtów

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

Będę grać w golfa dalej, gdy będę miał więcej czasu.

Kompiluje się w Func<string[], string[]>.

Wersja sformatowana:

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

Galaretka , 21 19 18 17 bajtów

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

To jest pełny program. Wejście i wyjście są ciągi 0 „s oraz 1 ” S, ograniczonej przez karetki.

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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

Siatkówka , 87 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Zastosowania Adla .i Zdla #.

Wypróbuj online!

Scala, 317 znaków

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)

Bardziej czytelna wersja, prawdopodobnie mogłaby to zrobić w golfa:

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 bajtów

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

Pobiera dane wejściowe jako ciąg multilinii. Działa poprzez rekurencyjne usuwanie początkowych i końcowych liter .s ze wszystkich linii, aż co najmniej jedna linia zaczyna się i kończy na literę a #, a następnie wybiera tyle linii, ile to możliwe, ale zaczyna i kończy na liniach zawierających #i zmieniających wszystkie .litery na #. Prawdopodobnie łatwo do gry w golfa.

R, 158 155 bajtów

Ten program pobiera punkty wejściowe .i hashtagi #, linia po linii.

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

Nie golfowany:

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

Oto szczegóły trzeciej linii:

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 bajtów

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

Pobiera dane wejściowe jako tablicę ciągów $n, z 0zamiast .i 1zamiast #. Następnie przechodzimy przez pętlę $n, sprawdzając, czy bieżący ciąg znaków jest mniejszy niż0 (tzn. Jest 1w nim), a jeśli tak, wyprowadzamy ciąg. Używa pseudo-trójki zamiast operacji if/ else.

Łańcuch jest zbudowany z pętli na całej szerokości łańcucha wejściowego. Przy każdej iteracji przyczepiamy się do 0lub w 1zależności od tego, czy 1znajduje się gdzieś w odpowiedniej kolumnie pionowej. Na przykład w ostatnim przypadku testowym powstanie ciąg podobny do 0011001001. Wymaga v3 + dla-in operatora. Ten ciąg znaków jest połączony z wyrażeniem fantazyjno-tanecznym, zastępującym dowolne „wewnętrzne” 0litery 1s. Ogromne podziękowania dla Business Cat na czacie za pomoc w tym zakresie. Nasz sznur byłby 0011111111w tym momencie.

W przeciwnym razie wypisz bieżący ciąg znaków (wszystkie zera) $_.

Powstałe ciągi są pozostawione w potoku, a dane wyjściowe są niejawne. Domyślnie Write-Outputtablica ciągów znaków ma nowy wiersz między każdym elementem, więc wizualnie tak się dzieje.

Przykłady

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 bajtów

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]

(Chociaż myślę, że inna metoda może być krótsza)

Pobiera i zwraca listę znaków.

Przetestuj na ideoone

Perl 6 , 62 bajtów

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

Anonimowa procedura, która może zostać przekazana jako tablica tablic znaków (reprezentujących matrycę) i zmodyfikowana w miejscu, tak aby zasięg wywołujący miał następnie zmodyfikowaną tablicę.

Używa azamiast #znaku „on”. Postać „off” może być dowolna, nie ma znaczenia.

Python 3, 153 bajty

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

Dane wejściowe i wyjściowe są listą ciągów.

bez golfa

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 operacji

Głównym pomysłem jest usunięcie wierszy i kolumn na zewnątrz tablicy, jeśli nie mają one znaku „#”. Cokolwiek pozostało, należy wpisać „#”.

Jest realizowany za pomocą funkcji rekurencyjnej.

Przypadek 1: wiersz 0 nie zawiera znaku „#”. Wynikiem jest wiersz 0 + wywołanie rekurencyjne w pozostałych wierszach.

Przypadek 2: wiersz 0 zawiera „#”. Nie można usunąć więcej wierszy. Obróć tablicę cw, tak aby kolumna 0 była teraz wierszem 0. Następnie rekurencyjnie przetwarzaj obróconą tablicę. Wynik jest obrócony ccw.

Przypadek podstawowy: tablica została obrócona 4 razy, co oznacza, że ​​wszystkie zewnętrzne rzędy / kolumny zostały usunięte, jeśli to możliwe. Cokolwiek pozostało, należy wpisać „#”

Perl, 51 bajtów

Obejmuje +2 za -0p

Podaj dane na STDIN, wyłączony jest znak A, włączony znak to anp .:

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

Ta sama długość:

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

Python 2, 184 bajty

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

Dane wejściowe i wyjściowe są listą ciągów.

Wypróbuj na Ideone (rozwidlenie strony testowej Jonathana Allana)

Pyth , 50 bajtów

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

Wypróbuj online!