Вам дана прямоугольная сетка символов .и #вот так:

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

Ваша задача состоит в том, чтобы заполнить всю выровненный по осям ограничивающего прямоугольника #с последующим #:

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

Выровненный по оси ограничивающий прямоугольник - это самый маленький прямоугольник, который содержит все #.

Хочу больше? Попробуйте Часть II!

правила

Вы можете использовать любые два различных печатных символа ASCII (от 0x20 до 0x7E включительно) вместо #и .. Я буду продолжать ссылаться на них как #и .для остальной части спецификации, хотя.

Ввод и вывод могут быть либо строкой, разделенной переводом строки, либо списком строк (по одной на каждую строку), но формат должен быть согласованным.

Вы можете предположить, что вход содержит как минимум одну #и все строки одинаковой длины.

Вы можете написать программу или функцию и использовать любой из наших стандартных методов получения ввода и предоставления вывода.

Вы можете использовать любой язык программирования , но учтите, что эти лазейки по умолчанию запрещены.

Это код-гольф , поэтому самый короткий действительный ответ - измеренный в байтах - выигрывает.

Тестовые случаи

Каждый тестовый пример имеет вход и выход рядом друг с другом.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 байт, 146 байт

Инструкция:

Создайте рабочую книгу с двумя пустыми листами: Sheet1 и Sheet2. Установите вход в Sheet1 и затем поместите следующий код в модуль кода 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

Разрушил код:

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

Объяснение:

1. Цикл каждой ячейки в используемом диапазоне Sheet1
2. Установите условный оператор для копирования каждой ячейки, содержащей символьный хэштег (#) в используемом диапазоне Sheet1, и вставьте его в ячейку в Sheet2 с тем же адресом, что и Sheet1.
3. Повторно просмотрите каждую ячейку в используемом диапазоне Sheet2, чтобы скопировать каждый адрес ячейки в нем, а затем используйте его для назначения хэштега символа (#) для ячейки в Sheet1 с тем же адресом, что и в используемом диапазоне Sheet2.

Пример ввода / вывода:

Предостережение: убедитесь, что каждая ячейка в Sheet2 всегда пуста при каждом запуске программы.

05AB1E , 70 68 69 61 58 60 40 байтов

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

объяснение

€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

Попробуйте онлайн

Mathematica, 91 70 байт

^{21 байт сохранен благодаря @MartinEnder .}

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

Анонимная функция. Принимает матрицу символов в качестве входных данных и возвращает матрицу символов в качестве выходных данных. Символ Unicode - это U + F3C7 для \[Transpose].

C #, 262 251 байт

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

Будет ли это гольф дальше, когда у меня будет больше времени.

Он компилируется в Func<string[], string[]>.

Отформатированная версия:

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

Желе , 21 19 18 17 байт

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

Это полная программа. Ввод и вывод - это строки с 0 и 1 , разделенные переводом строки.

Попробуйте онлайн! или проверьте все контрольные примеры .

Как это устроено

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

Сетчатка , 87 байт

Число байтов предполагает кодировку ISO 8859-1.

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

Использует Aдля .и Zдля #.

Попробуйте онлайн!

Scala, 317 символов

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)

Более читаемая версия, вероятно, могла бы сыграть в нее больше:

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 байт

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

Принимает ввод в виде многострочной строки. Работает путем рекурсивного удаления начальных и конечных .s из всех строк до тех пор, пока не начинается хотя бы одна строка, а одна не заканчивается на a #, затем выбирается максимально возможное количество строк, но начинается и заканчивается строки, содержащие #и заменяет все .s на #. Вероятно, легко гольф.

R, 158 155 байт

Эта программа построчно принимает входные точки .и хэштеги #.

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

Вот детали третьей строки:

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 байт

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

Принимает ввод как массив строк $n, с 0вместо .и 1вместо #. Затем мы перебираем циклы $n, каждую итерацию проверяем, меньше ли текущая строка 0(то есть есть ли 1в ней), и если да, выводим строку. Использует псевдо-тройной на месте в if/ elseоперации.

Строка состоит из циклов по ширине входной строки. На каждой итерации мы добавляем a 0или a в 1зависимости от того 1, найден ли где-нибудь в соответствующем вертикальном столбце. Например, в последнем тестовом примере это приведет к появлению строки типа 0011001001. Требуется v3 + для -inоператора. Эта строка в паре с необычным регулярным выражением заменяет любые "внутренние" 0на 1s. Большое спасибо Business Cat в чате за помощь в этом. Наша строка будет 0011111111в этой точке.

В противном случае выведите текущую (все нули) строку $_.

Результирующие строки остаются в конвейере, а вывод неявным. По умолчанию Write-Outputдля массива строк используется новая строка между каждым элементом, так что визуально так и происходит.

Примеры

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 байт

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]

(Хотя я думаю, что другой метод может быть короче)

Принимает и возвращает список списка символов.

Проверьте это на ideoone

Perl 6 , 62 байта

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

Анонимная подпрограмма, которой можно передать массив массивов символов (представляющих матрицу) в качестве аргумента и изменить его на месте так, чтобы вызывающая область впоследствии имела измененный массив.

Используется aвместо #символа «вкл». Персонаж «выключен» может быть чем угодно, ему все равно.

Python 3, 153 байта

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

Ввод и вывод - это список строк.

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

Теория Операции

Основная идея заключается в удалении строк и столбцов вокруг внешней части массива, если у них нет знака #. Все, что осталось, должно быть заполнено символом #.

Это реализовано с использованием рекурсивной функции.

Случай 1: строка 0 не содержит «#». Результатом является строка 0 + рекурсивный вызов оставшихся строк.

Случай 2: строка 0 содержит «#». Больше строк не может быть удалено. Поверните массив cw так, чтобы столбец 0 стал строкой 0. Затем рекурсивно обработайте повернутый массив. Результат вращается по часовой стрелке.

Базовый случай: массив был повернут 4 раза, что означает, что все внешние строки / столбцы были удалены, если это возможно. Все, что осталось, должно быть заполнено знаком "#"

Perl, 51 байт

Включает +2 для -0p

Дайте вход на STDIN, от персонажа A, на характер a, например:

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

Одинаковая длина:

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

Python 2, 184 байта

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

Ввод и вывод - это список строк.

Попробуйте это на Ideone (развилка тестовой страницы Джонатана Аллана)

Pyth , 50 байтов

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

Попробуйте онлайн!