On vous donne une grille rectangulaire des personnages .et #, comme ceci:

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

Votre tâche consiste à remplir tout le cadre de délimitation aligné sur l'axe du #avec #:

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

Le cadre de délimitation aligné sur l'axe est le plus petit rectangle qui contient tous les #.

Vouloir plus? Essayez la partie II!

Règles

Vous pouvez utiliser deux caractères ASCII imprimables distincts (0x20 à 0x7E, inclus), à la place de #et .. Je continuerai à me référer à eux au fur #et .à mesure du reste de la spécification.

L'entrée et la sortie peuvent être soit une chaîne séparée par un saut de ligne, soit une liste de chaînes (une pour chaque ligne), mais le format doit être cohérent.

Vous pouvez supposer que l'entrée contient au moins une #et que toutes les lignes ont la même longueur.

Vous pouvez écrire un programme ou une fonction et utiliser l'une de nos méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de code-golf , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Cas de test

Chaque scénario de test a une entrée et une sortie côte à côte.

#    #

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

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

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

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

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

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

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

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

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

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

VBA Excel, 150 octets 146 octets

Instruction:

Créez un classeur avec deux feuilles de calcul vierges: feuille1 et feuille2. Définissez l'entrée dans Sheet1, puis placez le code suivant dans le module de code 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

Déverrouillé le code:

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

Explication:

1. Parcourez chaque cellule de la plage utilisée Sheet1
2. Définissez l'instruction conditionnelle pour copier chaque cellule contient un hashtag de caractère (#) dans la plage utilisée Sheet1 et collez- le dans la cellule dans Sheet2 avec la même adresse que Sheet1.
3. Parcourez à nouveau chaque cellule de la plage utilisée Sheet2 pour copier chaque adresse de cellule, puis utilisez-la pour attribuer le hashtag de caractère (#) à la cellule de Sheet1 avec la même adresse que la plage utilisée Sheet2.

Exemple d'E / S:

Avertissement: assurez-vous que chaque cellule de la feuille Sheet2 est toujours vide à chaque exécution du programme.

05AB1E , 70 68 69 61 58 60 40 octets

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

Explication

€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

Essayez-le en ligne

Mathematica, 91 70 octets

^{21 octets enregistrés grâce à @MartinEnder .}

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

Fonction anonyme. Prend une matrice de caractères en entrée et renvoie une matrice de caractères en sortie. Le caractère Unicode est U + F3C7 pour \[Transpose].

C #, 262 251 octets

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

Va jouer au golf plus loin quand j'aurai plus de temps.

Il se compile en un Func<string[], string[]>.

Version formatée:

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ée , 21 19 18 17 octets

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

Ceci est un programme complet. L'entrée et la sortie sont des chaînes de 0 et de 1 , délimitées par des sauts de ligne.

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

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

Rétine , 87 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Utilise Apour .et Zpour #.

Essayez-le en ligne!

Scala, 317 caractères

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)

Une version plus lisible, aurait probablement pu jouer plus:

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 octets

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

Prend l'entrée comme une chaîne multiligne. Fonctionne en supprimant récursivement les .s de début et de fin de toutes les lignes jusqu'à ce qu'au moins une ligne commence et se termine par un #, puis sélectionne autant de lignes que possible mais en commençant et en terminant sur les lignes contenant #et en changeant tous les .s en #. Probablement facilement golfable.

R, 158 155 octets

Ce programme accepte les points d'entrée .et les hashtags #, ligne par ligne.

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

Non golfé:

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

Voici les détails de la troisième ligne:

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 139 octets

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

Prend l'entrée comme un tableau de chaînes $n, avec 0au lieu de .et 1au lieu de #. Ensuite, nous effectuons une boucle $n, chaque itération testant si la chaîne actuelle est plus petite que 0(c'est-à-dire, il y a un 1), et si c'est le cas, sortons une chaîne. Utilise un pseudo-ternaire à la place d'une opération if/ else.

La chaîne est construite à partir de boucles sur toute la largeur de la chaîne d'entrée. À chaque itération, nous clouons sur un 0ou un 1selon que 1se trouve quelque part dans la colonne verticale correspondante. Pour le dernier cas de test, par exemple, cela se traduira par une chaîne comme 0011001001. Nécessite v3 + pour l' -inopérateur. Cette chaîne est associée à un regex fantaisie-fantaisie pour remplacer tout "intérieur" 0par 1s. Un grand merci à Business Cat dans le chat pour l'aide à ce sujet. Notre chaîne serait 0011111111à ce stade.

Sinon, affichez la chaîne actuelle (entièrement composée de zéros) $_.

Les chaînes résultantes sont laissées sur le pipeline et la sortie est implicite. Le défautWrite-Output par pour un tableau de chaînes est avec une nouvelle ligne entre chaque élément, c'est donc visuellement ce qui se passe.

Exemples

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 octets

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]

(Bien que je pense qu'une autre méthode pourrait être plus courte)

Prend et renvoie une liste de liste de caractères.

Testez-le sur ideoone

Perl 6 , 62 octets

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

Une routine anonyme qui peut être passée un tableau de tableaux de caractères (représentant la matrice) comme argument, et le modifie en place afin que la portée appelante ait le tableau modifié par la suite.

Utilise aau lieu de #comme le caractère "on". Le caractère "off" peut être n'importe quoi, il s'en fiche.

Python 3, 153 octets

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

L'entrée et la sortie sont une liste de chaînes.

non golfé

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

théorie du fonctionnement

L'idée principale est de supprimer les lignes et les colonnes autour de l'extérieur du tableau si elles n'ont pas de «#». Tout ce qui reste doit être rempli avec des «#».

Il est implémenté à l'aide d'une fonction récursive.

Cas 1: la ligne 0 ne contient pas de '#'. Le résultat est la ligne 0 + appel récursif sur les lignes restantes.

Cas 2: la ligne 0 contient un «#». Plus aucune ligne ne peut être supprimée. Faites pivoter le tableau cw de sorte que la colonne 0 soit maintenant la ligne 0. Traitez ensuite récursivement le tableau pivoté. Le résultat est tourné ccw.

Cas de base: le tableau a été tourné 4 fois, ce qui signifie que toutes les lignes / colonnes externes ont été supprimées si possible. Tout ce qui reste doit être rempli avec des «#»

Perl, 51 octets

Comprend +2 pour -0p

Donnez une entrée sur STDIN, le caractère est désactivé A, le caractère est a, par exemple:

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

Même longueur:

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

Python 2, 184 octets

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

L'entrée et la sortie sont une liste de chaînes.

Essayez-le sur Ideone (fork de la page de test de Jonathan Allan)

Pyth , 50 octets

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

Essayez-le en ligne!