J, 37 34 bytes

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

Try it 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

Takes input as a list of 1-indexed coordinates in [x,y] format. Returns a 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)) 

Try it online!

Haskell, 127 123 bytes

This defines the operator (!) which takes a list of x-coordinates and a list of the corresponding y-coordinates:

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] 

Try it online!

Ungolfed/Explanation

The helper function m expects a list and returns indices (1-based) up to the maximum, if the list is empty it returns []:

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

The actual operator (!) is just a list-comprehension, traversing all the coordinates and choosing a or x character, which gets joined with newlines:

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] 

Canvas, 22 bytes

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

Try it here!

Takes 1-indexed inputs.

Finally decided to fix a bug that's been annoying me for ages and golfed this down to 21 bytes.

Explanation (half-ASCII-fied for 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 bytes

-2 bytes thanks to Jo King.

Input is 1-indexed.

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) 

Try it online!

Charcoal, 37 bytes

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

Try it online! Link is to verbose version of code. 1-indexed. Explanation:

¿¬ＬθＵＲ²+« 

Special-case empty input by drawing a 2x2 rectangle of +s.

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

Transpose the input, take the maximum of each column (now row) and add 2 to get the box size in Charcoal co-ordinates.

Ｂ⊟⮌η⊟η 

Draw the box.

Ｆθ« 

Loop over each co-ordinate.

Ｊ⊟⮌ι⊟ι 

Jump to its position.

x 

Mark with a cross.

Stax, 32 31 24 bytes

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

Run and debug it

Takes 0-based indices as array of [y, x] pairs.

Explanation:

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

Try it online!

1-indexed. Takes a matrix as argument. Saved 8 bytes thanks to digEmAll, 3 thanks to Giuseppe! Explanation (earlier version of 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="") } 

coords taken of the format [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} 

Try it 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]]))

C (gcc), 246 234 bytes

Thanks to ceilingcat for the suggestion.

Zero-indexed. The function takes a list of co-ordinates and buffer, finds the maximum x and y values, fills the buffer with spaces, generates the frame, and then plots the 'x's.

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

Try it online!

05AB1E, 44 42 bytes

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

Try it 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 and Y may be reversed, didn't know if that mattered at all.

I think I have this in less bytes, but we'll see... Nope.

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

Java 10, 238 223 220 219 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+r).contains("["+x+", "+y+"]")?"x":" ";return r;} 

-3 bytes thanks to @ceilingcat.

1-indexed coordinates.

Try it online.

Explanation:

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+r).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), 229 220 216 bytes

-9 bytes thanks to ceilingcat.

Zero-indexed. Takes coordinates as list of numbers, where even numbers are X and odd numbers are 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;} 

Try it online!