Você está organizando uma caça ao tesouro para seus amigos. Para conduzir as coisas com mais facilidade, você deseja desenhar um mapa de todos os locais onde ocultou os objetos preciosos.

Entrada

0 0É permitida qualquer forma de entrada que denote uma lista de pontos que consistem nas coordenadas x e y (não-negativas), sendo o canto superior esquerdo (Nota: Você também pode usar a indexação baseada em 1 na sua resposta, por favor, comente se você fizer isso. ) Exemplo:

1 2
3 0
0 1

Desafio

Sua função ou programa deve ser capaz de construir um mapa indicando cada local determinado, xonde a marca é encontrada na linha y + 1 e na coluna x + 1 na saída. Locais não marcados são representados com um . O mapa também consiste em um quadro em que os cantos são +s, as linhas verticais são se |as linhas horizontais são -s. Sua solução deve gerar o menor quadro possível. Mapa para o exemplo de entrada fornecido acima:

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

Possíveis casos de teste

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

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

""
=>
++
++

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

Obviamente, isso é código-golfe , o que significa que a solução com a menor contagem de bytes vence! Explicações da sua solução são incentivadas.

J , 37 34 bytes

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

Experimente online!

                       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

Recebe a entrada como uma lista de coordenadas indexadas em 1 no [x,y]formato. Retorna uma string.

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

Experimente online!

Haskell , 127 123 bytes

Isso define o operador (!)que obtém uma lista de coordenadas xe uma lista das coordenadas y correspondentes :

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]

Experimente online!

Ungolfed / Explicação

A função auxiliar mespera uma lista e retorna índices (com base em 1) até o máximo, se a lista estiver vazia, ela retornará []:

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

O operador real (!)é apenas uma compreensão da lista, percorrendo todas as coordenadas e escolhendo um caractere ou x, que se junta às novas linhas:

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]

Tela , 22 bytes

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

Experimente aqui!

Recebe entradas indexadas em 1.

Finalmente decidi consertar um bug que me incomoda há muito tempo e reduziu isso para 21 bytes .

Explicação (semi-ASCII-fied para monoespaço):

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

-2 bytes graças a Jo King.

A entrada é indexada em 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)

Experimente online!

Carvão , 37 bytes

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

Experimente online! Link é a versão detalhada do código. 1 indexado. Explicação:

¿¬ＬθＵＲ²+«

Caso vazio de entrada especial, desenhando um retângulo 2x2 de +s.

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

Transponha a entrada, pegue o máximo de cada coluna (agora linha) e adicione 2 para obter o tamanho da caixa nas coordenadas de carvão.

Ｂ⊟⮌η⊟η

Desenhe a caixa.

Ｆθ«

Faça um loop sobre cada coordenada.

Ｊ⊟⮌ι⊟ι

Salte para sua posição.

x

Marque com uma cruz.

Stax , 32 31 24 bytes

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

Execute e depure

Toma índices baseados em 0 como matriz de [y, x] pares.

Explicação:

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 bytes

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

Experimente online!

1 indexado. Toma uma matriz como argumento. Economizou 8 bytes graças a digEmAll, 3 graças a Giuseppe! Explicação (versão anterior do 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="")
}

cordas tiradas do 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}

Experimente online!

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 em 1.

Experimente online.

Explicação:

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) , 246234 bytes

Agradecimentos a ceilingcat pela sugestão.

Indexado a zero. A função pega uma lista de coordenadas e buffer, encontra os valores máximos xey, preenche o buffer com espaços, gera o quadro e, em seguida, plota os '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';}

Experimente online!

05AB1E , 44 42 bytes

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

Experimente online!

 ζε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 podem ser revertidos, não sabiam se isso importava.

Eu acho que tenho isso em menos bytes, mas vamos ver ... Não.

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

C (GCC) , 229 220 216 bytes

-9 bytes graças ao ceilingcat .

Indexado a zero. Toma coordenadas como lista de números, onde números pares são X e números ímpares são 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;}

Experimente online!