Vous organisez une chasse au trésor pour vos amis. Pour mener les choses plus facilement, vous voulez dessiner une carte de tous les endroits où vous avez caché les objets précieux.

Contribution

Toute forme d'entrée indiquant une liste de points composée de coordonnées x et y (non négatives), 0 0étant le coin supérieur gauche est autorisée (Remarque: vous pouvez également utiliser l'indexation basée sur 1 dans votre réponse, veuillez commenter si vous le faites ). Exemple:

1 2
3 0
0 1

Défi

Votre fonction ou programme devrait être en mesure de construire une carte indiquant chaque emplacement donné avec un xoù la marque se trouve dans la ligne y + 1 et la colonne x + 1 dans la sortie. Les emplacements non marqués sont représentés par un . La carte se compose également d'un cadre où les coins sont +s, les lignes verticales sont |s et les lignes horizontales sont -s. Votre solution doit produire le plus petit cadre possible. Carte pour l'exemple d'entrée donné ci-dessus:

+----+
|   x|
|x   |
| x  |
+----+

Cas de test possibles

"0 0"
=>
+-+
|x|
+-+

"0 10
 5 5
 10 0"
=>
+-----------+
|          x|
|           |
|           |
|           |
|           |
|     x     |
|           |
|           |
|           |
|           |
|x          |
+-----------+

""
=>
++
++

"0 0
 0 2
 2 0"
=>
+---+
|x x|
|   |
|x  |
+---+

Bien sûr, c'est le code-golf , ce qui signifie que la solution avec le nombre d'octets le plus bas gagne! Des explications sur votre solution sont encouragées.

J , 37 34 octets

0<@|:' x'{~((i.@]e.#.~)1+>./) ::#:

Essayez-le en ligne!

                       1+>./          maximum for each coordinate + 1
             i.@]                     make an array with these dimensions filled with 0..x*y
                                      /* if the input is empty, 
                                         1+>./ is negative infinity
                                         and i.@] throws an error  */
                   #.~                mixed base conversion of input
                 e.                   replace the elements of i.@]
                                        with 1 if it's present in the
                                        converted input, 0 otherwise
           (                ) ::      if there's an error do the other thing instead
                                #:    "to binary", for empty input this returns a 0x0 matrix
0<@|:' x'{~                           index into character string, transpose and put in a box

JavaScript (ES6), 150 octets

Prend l'entrée sous la forme d'une liste de coordonnées indexées au [x,y]format 1. Renvoie une chaîne.

a=>(g=w=>y<h?' |-+x'[4*a.some(a=>a+''==[x,y])|2*(-~y%h<2)|++x%w<2]+[`
`[x=x<w?x:+!++y]]+g(w):'')((M=i=>Math.max(2,...a.map(a=>a[i]+2)))(x=y=0),h=M(1))

Essayez-le en ligne!

Haskell , 127 123 octets

Ceci définit l'opérateur (!)qui prend une liste de coordonnées x et une liste de coordonnées y correspondantes :

x!y|l<-'+':('-'<$m x)++"+"=unlines$l:['|':[last$' ':['x'|(i,j)`elem`zip x y]|i<-m x]++"|"|j<-m y]++[l];m x=[1..maximum$0:x]

Essayez-le en ligne!

Non golfé / Explication

La fonction d'assistance mattend une liste et retourne les indices (basés sur 1) jusqu'au maximum, si la liste est vide, elle retourne []:

m x | null x    = []
    | otherwise = [1 .. maximum x]

L'opérateur réel (!)n'est qu'une compréhension de liste, parcourant toutes les coordonnées et choisissant un caractère ou x, qui est joint à des sauts de ligne:

x ! y
  -- construct the top and bottom line
  | l <- "+" ++ replicate (maximum (0:x)) '-' ++ "+"
  -- join the list-comprehension with new-lines
  = unlines $ 
  -- prepend the top line
      [l]
  -- the actual map:
    -- begin the line with | and add the correct chars for each coordinate
      ++ [ "|" ++ [ if (i,j) `elem` zip x y then 'x' else ' '
    -- "loop" over all x-coordinates
                 | i <- m x
                 ]
    -- end the line with a |
           ++ "|"
    -- "loop" over all y-coordinates
         | j <- m y
         ]
  -- append the bottom line
      ++ [l]

Toile , 22 octets

ø╶｛X；┤╋｝ｌ|＊ｅＬ┤-×+ｅ：└∔∔

Essayez-le ici!

Prend des entrées indexées 1.

J'ai finalement décidé de corriger un bogue qui m'ennuyait depuis des lustres et j'ai réglé ce problème à 21 octets .

Explication (semi-ASCII pour monospace):

ø╶{X;┤╋}l|*eL┤-×+e:└++  full program, implicitly outputting ToS at the end
ø                       push an empty Canvas - the map
 ╶{    }                for each array in the input array
   X                      push "X"
    ;┤                    and push the two coordinates separately on the stack
      ╋                   and overlap the "X" there in the map
        l               get the vertical length of the map
         |*             repeat "|" vertically that many times
           e            encase the map in two of those vertical bars
            L           get the horizontal length of the map
             ┤          subtract 2 (leave place for the "+"es)
              -×        repeat "-" that many times
                +e      encase that line in "+"es
                  :└    push a copy of that below the map
                    ++  and join the 3 items vertically

Python 2 , 151 140 138 octets

-2 octets grâce à Jo King.

L'entrée est indexée sur 1.

m=input()
w,h=map(max,zip((0,0),*m))
b=['+'+'-'*w+'+']
M=b+['|'+' '*w+'|']*h+b
for x,y in m:M[y]=M[y][:x]+'x'+M[y][x+1:]
print'\n'.join(M)

Essayez-le en ligne!

Fusain , 37 octets

≔Ｅ²⁺²⌈Ｅθ§λιηＢ⊟⮌η⊟ηＦθ«Ｊ⊟⮌ι⊟ιx

Essayez-le en ligne! Le lien est vers la version détaillée du code. 1 indexé. Explication:

¿¬ＬθＵＲ²+«

Entrée vide dans un cas spécial en dessinant un rectangle 2x2 de +s.

≔Ｅ²⁺²⌈Ｅθ§λιη

Transposez l'entrée, prenez le maximum de chaque colonne (maintenant la ligne) et ajoutez 2 pour obtenir la taille de la boîte en coordonnées charbon.

Ｂ⊟⮌η⊟η

Dessinez la boîte.

Ｆθ«

Faites une boucle sur chaque coordonnée.

Ｊ⊟⮌ι⊟ι

Sautez à sa position.

x

Marquez avec une croix.

Stax , 32 31 24 octets

╩╠ee%╙æM■↓^⌐╧ΩΓ¡c¥èf¢○ [

Exécuter et déboguer

Prend des indices basés sur 0 comme tableau de [y, x] paires.

Explication:

zs'X&|<cM%'-*'+|S]s{'||Smn++m Unpacked program, implicit input
zs                            Tuck empty array under input
  'X                          Push "X"
    &                         Assign element at all indices (create map)
                                As the indexing arrays are an array of arrays, treat them as a path to navigate a multidimensional array.
                                Extend array if needed.
     |<                       Left-align all to the length of the longest.
       cM%                    Copy, transpose, length (width)
          '-*                 Repeat "-"
             '+|S             Surround with "+"
                 ]s           Make a singleton and tuck it below the map
                   {    m     Map:
                    '||S        Surround with "|"
                         n++  Surround with the above/below border (built above)
                            m Map:
                                Implicit output

R , 133 125 122 octets

function(m)cat(z<-c("+",rep("-",u<-max(m[,1])),"+","
"),rbind("|",`[<-`(matrix(" ",u,max(m[,2])),m,"x"),"|","
"),z,sep="")

Essayez-le en ligne!

1 indexé. Prend une matrice comme argument. 8 octets enregistrés grâce à digEmAll, 3 grâce à Giuseppe! Explication (version antérieure du code):

function(m){                           #x and y are the 1st and 2nd col of m
s=matrix(32,u<-max(m[,1]),max(m[,2]))  #s (treasure map) has dim max(x), max(y) 
s[m]=120                               #place the X's on the map
cat(                                   #print:
    z<-c("+",rep("-",u),"+","\n"),     #the top line
    intToUtf8(rbind(124,s,124,13)),    #the map
    z,                                 #the bottom line.
    sep="")
}

coordonnées prises au format [y, x]

JavaScript (Node.js) , 191 184 octets

c=f=a=>{a.map(([y,x])=>(c[M<++y?M=y:y]=c[y]||[])[m<++x?m=x:x]="x",M=m=0)
m++
M++
s=""
for(i=0;i<=M;s+=`
`,i++)for(j=0;j<=m;j++)s+=(c[i]||0)[j]||(j%m?i%M?" ":"-":i%M?"|":"+") 
return s}

Essayez-le en ligne!

JavaScript, 180 octets

F = 

s=>s.map(([x,y])=>(t[y]=t[Y<y?Y=y:y]||[])[X<x?X=x:x]='x',t=[X=Y=0])&&[...t,0].map((_,y)=>[...Array(X+2)].map((_,x)=>[(t[y]||0)[x]||' ',...'-|+'][!(y%~Y)+2*!(x%~X)]).join``).join`
`


console.log(F([[1,11],[6,6],[11,1]]))

Java 10, 238 223 octets

c->{var r="";int w=0,h=0,x,y;for(var l:c){w=(x=l.get(0))>w?x:w;h=(y=l.get(1))>h?y:h;}for(w++,h++,x=-1;++x<=w;r+="\n")for(y=-1;++y<=h;)r+=x%w+y%h<1?"+":x%w<1?"-":y%h<1?"|":(c+"").contains("["+x+", "+y+"]")?"x":" ";return r;}

Coordonnées indexées 1.

Essayez-le en ligne.

Explication:

c->{                      // Method with 2D Lists as parameter and String return-type
  var r="";               //  Result-String, starting empty
  int w=0,h=0,            //  Width and height, starting at 0
      x,y;                //  Temp x,y coordinates
  for(var l:c){           //  Loop over the Inner Lists containing the coordinates
    w=(x=l.get(0))>w?x:w; //   Determine width based on max x-coordinate
    h=(y=l.get(1))>h?y:h;}//   Determine height based on max y-coordinate
  for(w++,h++,            //  Increase both the width and height by 1
      x=-1;++x<=w;        //  Loop `x` in the range [0, width]
      r+="\n")            //    After every iteration: append a new-line to the result
    for(y=-1;++y<=h;)     //   Inner loop `y` in the range [0, height]
      r+=                 //    Append the following character to the result-String:
        x%w+y%h<1?        //    If it's one of the corners:
          "+"             //     Append "+"
        :x%w<1?           //    Else-if it's the top or bottom row:
          "-"             //     Append "-"
        :y%h<1?           //    Else-if it's the right or left column:
          "|"             //     Append "|"
        :(c+"").contains("["+x+", "+y+"]")? 
                          //    Else-if the current `x,y` is part of the input-coordinates
          "x"             //     Append "x"
        :                 //    Else:
          " ";            //     Append " "
  return r;}              //  Return the result-String

C (gcc) , 246 234 octets

Merci à plafondcat pour la suggestion.

Zéro indexé. La fonction prend une liste de coordonnées et de tampon, trouve les valeurs maximales x et y, remplit le tampon d'espaces, génère le cadre, puis trace les «x».

f(int*a,char*c){int*b=a,x,y=x=-1,i=0;for(;~*b;*++b>y?y=*b:0,++b)*b>x?x=*b:0;for(x+=4,y+=3,memset(c,32,x*y);++i<x;c[i]=c[y*x-i]=45);for(i=0;i<y;c[x*++i-1]=10*(i<=y))c[x*i]=c[x*i+x-2]=i&&y/i?124:43;for(b=a;~*b;b+=2)c[*b+1-~b[1]*x]='x';}

Essayez-le en ligne!

05AB1E , 44 42 octets

ζεZ}>`UX'-×'+.ø©,F'|NVXF¹YN‚.å„ xè}'|J,}®,

Essayez-le en ligne!

 ζεZ}>`                                     # Push the max of X and Y to the stack +1.
       UX                                   # Store the max X.
         '-×'+.ø©,                          # Print the top border.
                  F                     }   # From 0 to Y...
                   '|                       # Push left border.
                     NV                     # Store current Y in Y.
                       XF          }        # From 0 to X...
                         ¹                  # Push input.
                          YN‚               # Group current X and Y.
                             .å             # Exists in original input ? 1 : 0
                               „ xè         # Exists ? 'X' : ' '
                                    '|J,    # Right border, join, print.
                                         ®, # Print bottom border.

X et Y peuvent être inversés, je ne savais pas si cela importait du tout.

Je pense que je l'ai en moins d'octets, mais nous verrons ... Non.

ζεZ}>`D'-×'+.øUð×'|.øs.D)X.ø©svy>`s®sUXès'xsǝXǝ}

C (gcc) , 229 220 216 octets

-9 octets grâce au plafond .

Zéro indexé. Prend les coordonnées comme liste de nombres, où les nombres pairs sont X et les nombres impairs sont Y.

X,Y,i,j,k,x,z;f(l,n)int*l;{for(X=Y=0,i=n*=2;i--;X=fmax(l[i],X))Y=fmax(l[i--],Y);n&&X++-Y++;for(--i;i++<Y;puts(""))for(j=-1;j<=X;z=i<0|i==Y,putchar(j++<0|j>X?z?43:'|':x?z?45:32:'x'))for(x=k=n;k--;)x*=l[k--]-i|l[k]-j;}

Essayez-le en ligne!