Estás organizando una búsqueda del tesoro para tus amigos. Para realizar las cosas con mayor facilidad, desea dibujar un mapa de todos los lugares donde escondió los objetos preciosos.

Entrada

Se 0 0permite cualquier forma de entrada que denote una lista de puntos que consista en las coordenadas x e y (no negativas), siendo la esquina superior izquierda (Nota: también puede usar indexación basada en 1 en su respuesta, por favor comente eso si lo hace ) Ejemplo:

1 2
3 0
0 1

Desafío

Su función o programa debería ser capaz de construir un mapa que denote cada ubicación dada con un lugar xdonde la marca se encuentre en la fila y + 1 y la columna x + 1 en la salida. Las ubicaciones sin marcar se representan con un . El mapa también consiste en un marco donde las esquinas son +s, las líneas verticales son |sy las líneas horizontales son -s. Su solución debe generar el marco más pequeño posible. Mapa para el ejemplo de entrada dado anteriormente:

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

Posibles casos de prueba

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

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

""
=>
++
++

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

Por supuesto, este es el código de golf , lo que significa que gana la solución con el conteo de bytes más bajo. Se alientan las explicaciones de su solución.

J , 37 34 bytes

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

Pruébalo en línea!

                       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 bytes

Toma la entrada como una lista de coordenadas indexadas 1 en [x,y]formato. Devuelve una cadena.

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

Pruébalo en línea!

Haskell , 127 123 bytes

Esto define el operador (!)que toma una lista de x coordenadas y una lista de las coordenadas y correspondientes :

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]

Pruébalo en línea!

Ungolfed / Explicación

La función auxiliar mespera una lista y devuelve índices (basados ​​en 1) hasta el máximo, si la lista está vacía, devuelve[] :

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

El operador real (!)es solo una lista de comprensión, que atraviesa todas las coordenadas y elige un carácter o x, que se une con nuevas líneas:

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]

Lienzo , 22 bytes.

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

Pruébalo aquí!

Toma entradas indexadas 1.

Finalmente decidí arreglar un error que me ha estado molestando durante años y lo reduje a 21 bytes .

Explicación (medio ASCII-fied para monoespacio):

ø╶{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

Pitón 2 , 151 140 138 bytes

-2 bytes gracias a Jo King.

La entrada está indexada en 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)

Pruébalo en línea!

Carbón , 37 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. 1 indexado. Explicación:

¿¬ＬθＵＲ²+«

Entrada vacía de casos especiales dibujando un rectángulo de 2x2 de +s.

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

Transponga la entrada, tome el máximo de cada columna (ahora fila) y agregue 2 para obtener el tamaño de la caja en coordenadas de carbón.

Ｂ⊟⮌η⊟η

Dibuja la caja.

Ｆθ«

Pase sobre cada coordenada.

Ｊ⊟⮌ι⊟ι

Salta a su posición.

x

Marcar con una cruz.

Stax , 32 31 24 bytes

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

Ejecutar y depurarlo

Toma índices basados ​​en 0 como una matriz de [y, x] pares.

Explicación:

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 , 133125122 bytes

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

Pruébalo en línea!

1 indexado. Toma una matriz como argumento. ¡Ahorré 8 bytes gracias a digEmAll, 3 gracias a Giuseppe! Explicación (versión anterior del código):

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="")
}

coordenadas tomadas del formato [y, x]

JavaScript (Node.js) , 191 184 bytes

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}

Pruébalo en línea!

JavaScript, 180 bytes

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 bytes

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

Coordenadas indexadas en 1.

Pruébalo en línea.

Explicación:

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 bytes

Gracias a ceilingcat por la sugerencia.

Indexado a cero. La función toma una lista de coordenadas y búfer, encuentra los valores máximos de x e y, llena el búfer con espacios, genera el marco y luego traza las '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';}

Pruébalo en línea!

05AB1E , 44 42 bytes

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

Pruébalo en línea!

 ζε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 e Y pueden revertirse, no sabía si eso importaba en absoluto.

Creo que tengo esto en menos bytes, pero ya veremos ... No.

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

C (gcc) , 229 220 216 bytes

-9 bytes gracias a ceilingcat .

Indexado a cero. Toma las coordenadas como una lista de números, donde los números pares son X y los impares son 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;}

Pruébalo en línea!