Bạn được cung cấp một lưới hình chữ nhật của các ký tự .và #, như thế này:

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

Nhiệm vụ của bạn là lấp đầy toàn bộ khung giới hạn được điều chỉnh theo trục của #hơn nữa #:

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

Hộp giới hạn căn chỉnh trục là hình chữ nhật nhỏ nhất chứa tất cả #.

Muốn thêm? Hãy thử phần II!

Quy tắc

Bạn có thể sử dụng bất kỳ hai ký tự ASCII có thể in riêng biệt (0x20 đến 0x7E, bao gồm), thay cho #và .. Tôi sẽ tiếp tục đề cập đến họ như là# và .cho phần còn lại của đặc tả.

Đầu vào và đầu ra có thể là một chuỗi được phân tách theo dòng cấp dữ liệu hoặc một danh sách các chuỗi (một chuỗi cho mỗi dòng), nhưng định dạng phải nhất quán.

Bạn có thể cho rằng đầu vào chứa ít nhất một # và tất cả các dòng có cùng độ dài.

Bạn có thể viết chương trình hoặc hàm và sử dụng bất kỳ phương thức chuẩn nào của chúng tôi để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Các trường hợp thử nghiệm

Mỗi trường hợp thử nghiệm có đầu vào và đầu ra cạnh nhau.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 byte 146 byte

Chỉ dẫn:

Tạo một bảng tính với hai bảng tính trống: Sheet1 và Sheet2. Đặt đầu vào trong Sheet1 và sau đó đặt mã sau vào mô-đun mã 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

Mã hóa:

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

Giải trình:

1. Lặp lại qua mọi ô trong phạm vi được sử dụng Sheet1
2. Đặt câu lệnh có điều kiện để sao chép mọi ô chứa hashtag ký tự (#) trong phạm vi Sheet1 được sử dụng và dán nó vào ô trong Sheet2 có cùng địa chỉ với Sheet1.
3. Lặp lại một lần nữa mỗi ô trong phạm vi Sheet2 đã sử dụng để sao chép mọi địa chỉ ô trong đó và sau đó sử dụng nó để gán hashtag ký tự (#) cho ô trong Sheet1 có cùng địa chỉ với phạm vi Sheet2 được sử dụng.

Ví dụ I / O:

Hãy cẩn thận: Đảm bảo mọi ô trong Sheet2 luôn trống mỗi khi bạn chạy chương trình.

05AB1E , 70 68 69 61 58 60 40 byte

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

Giải trình

€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

Dùng thử trực tuyến

Toán học, 91 70 byte

^{21 byte được lưu do @MartinEnder .}

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

Chức năng ẩn danh. Lấy một ma trận ký tự làm đầu vào trả về một ma trận ký tự làm đầu ra. Ký tự Unicode là U + F3C7 cho \[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;};

Sẽ chơi golf hơn nữa khi tôi có nhiều thời gian hơn.

Nó biên dịch thành một Func<string[], string[]> .

Phiên bản được định dạng:

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

Thạch , 21 19 18 17 byte

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

Đây là một chương trình đầy đủ. Đầu vào và đầu ra là các chuỗi 0 và 1 , được giới hạn bởi các nguồn cấp.

Hãy thử trực tuyến! hoặc là xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

Võng mạc , 87 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Sử dụng Acho .và Zcho #.

Hãy thử trực tuyến!

Scala, 317 ký tự

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)

Phiên bản dễ đọc hơn, có thể đã đánh gôn nó nhiều hơn:

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

Đưa đầu vào dưới dạng một chuỗi nhiều dòng. Hoạt động bằng cách đệ quy tước dẫn đầu và theo dõi .từ tất cả các dòng cho đến khi ít nhất một dòng bắt đầu và một kết thúc bằng a #, sau đó chọn càng nhiều dòng càng tốt nhưng bắt đầu và kết thúc trên các dòng chứa #và thay đổi tất cả các .s thành #. Có lẽ là dễ chơi golf.

R, 158 155 byte

Chương trình này lấy điểm đầu vào .và hashtags #, từng dòng một.

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

Ung dung:

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

Dưới đây là chi tiết của dòng thứ ba:

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

Lấy đầu vào là một chuỗi các chuỗi $n, 0thay vì .và 1thay vì #. Sau đó, chúng tôi lặp lại $n, mỗi lần kiểm tra xem chuỗi hiện tại có nhỏ hơn 0(nghĩa là có một chuỗi 1trong đó không) và nếu vậy, hãy xuất ra một chuỗi. Sử dụng một ternary giả thay cho một if/ elsehoạt động.

Chuỗi được xây dựng từ các vòng lặp thông qua chiều rộng của chuỗi đầu vào. Mỗi lần lặp, chúng ta giải quyết một 0hoặc một 1tùy thuộc nếu 1được tìm thấy ở đâu đó trong cột dọc tương ứng. Ví dụ, đối với trường hợp thử nghiệm cuối cùng, điều này sẽ dẫn đến một chuỗi như thế nào 0011001001. Yêu cầu v3 + cho -intoán tử. Chuỗi đó được ghép nối với một biểu thức regex ưa thích để thay thế bất kỳ "bên trong" nào 0bằng 1s. Rất cám ơn Business Cat trong trò chuyện đã hỗ trợ về điều đó. Chuỗi của chúng tôi sẽ 0011111111ở điểm này.

Khác, xuất chuỗi hiện tại (tất cả các số không) $_ .

Các chuỗi kết quả được để lại trên đường ống và đầu ra là ẩn. Mặc định Write-Outputcho một chuỗi các chuỗi là với một dòng mới giữa mỗi phần tử, vì vậy đó là điều trực quan xảy ra.

Ví dụ

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]

(Mặc dù tôi nghĩ rằng một phương pháp khác có thể ngắn hơn)

Lấy và trả về một danh sách các danh sách ký tự.

Kiểm tra nó trên ideoone

Perl 6 , 62 byte

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

Một thường trình ẩn danh có thể được truyền một mảng các mảng ký tự (đại diện cho ma trận) làm đối số và sửa đổi nó tại chỗ để phạm vi gọi có mảng được sửa đổi sau đó.

Sử dụng athay vì #như ký tự "bật". Nhân vật "tắt" có thể là bất cứ điều gì, nó không quan tâm.

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

Đầu vào và đầu ra là một danh sách các chuỗi.

vô dụng

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

Nguyên lý hoạt động

Ý tưởng chính là xóa các hàng và cột xung quanh bên ngoài mảng nếu chúng không có '#'. Bất cứ điều gì còn lại nên được điền vào bằng '#'.

Nó được thực hiện bằng cách sử dụng một hàm đệ quy.

Trường hợp 1: hàng 0 không chứa '#'. Kết quả là hàng 0 + cuộc gọi đệ quy trên các hàng còn lại.

Trường hợp 2: hàng 0 không chứa '#'. Không có nhiều hàng có thể được gỡ bỏ. Xoay mảng cw sao cho cột 0 bây giờ là hàng 0. Sau đó xử lý đệ quy mảng đã xoay. Kết quả là xoay ccw.

Trường hợp cơ sở: Mảng đã được xoay 4 lần, nghĩa là tất cả các hàng / cột bên ngoài đã bị xóa nếu có thể. Bất cứ điều gì còn lại nên được điền vào với '#' s

Perl, 51 byte

Bao gồm +2 cho -0p

Cung cấp đầu vào trên STDIN, tắt ký tự A, trên ký tự là a, ví dụ:

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

Cùng chiều dài:

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

Đầu vào và đầu ra là một danh sách các chuỗi.

Dùng thử trên Ideone (ngã ba trang thử nghiệm của Jonathan Allan)

Bình thường , 50 byte

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

Hãy thử trực tuyến!