Sie organisieren eine Schatzsuche für Ihre Freunde. Um die Arbeit zu vereinfachen, möchten Sie eine Karte aller Orte zeichnen, an denen Sie die wertvollen Objekte versteckt haben.

Eingang

Jede Form der Eingabe, die eine Liste von Punkten angibt, die aus (nichtnegativen) x- und y-Koordinaten besteht, 0 0wobei die obere linke Ecke zulässig ist (Hinweis: Sie können in Ihrer Antwort auch eine 1-basierte Indexierung verwenden ). Beispiel:

1 2
3 0
0 1

Herausforderung

Ihre Funktion oder Ihr Programm sollte in der Lage sein, eine Karte zu erstellen, die jede gegebene Stelle mit einer Stelle bezeichnet, xan der sich die Markierung in Zeile y + 1 und Spalte x + 1 in der Ausgabe befindet. Nicht markierte Stellen sind mit einem gekennzeichnet . Die Karte besteht auch aus einem Rahmen, in dem die Ecken +s, die vertikalen Linien |s und die horizontalen Linien -s sind. Ihre Lösung sollte den kleinstmöglichen Frame ausgeben. Karte für das oben angegebene Eingabebeispiel:

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

Mögliche Testfälle

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

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

""
=>
++
++

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

Natürlich ist dies Codegolf , was bedeutet, dass die Lösung mit der niedrigsten Byteanzahl gewinnt! Erklärungen zu Ihrer Lösung sind erwünscht.

J , 37-34 Bytes

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

Probieren Sie es 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 Byte

Nimmt die Eingabe als Liste mit 1-indizierten Koordinaten im [x,y]Format. Gibt eine Zeichenfolge zurück.

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

Probieren Sie es online!

Haskell , 127 123 Bytes

Dies definiert den Operator, (!)der eine Liste von x- Koordinaten und eine Liste der entsprechenden y- Koordinaten nimmt:

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]

Probieren Sie es online!

Ungolfed / Erklärung

Die Hilfsfunktion merwartet eine Liste und gibt Indizes (1-basiert) bis zum Maximum zurück. Wenn die Liste leer ist, gibt sie Folgendes zurück []:

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

Der eigentliche Operator (!)ist nur ein Listenverständnis, das alle Koordinaten durchläuft und ein oder ein xZeichen auswählt, das mit Zeilenumbrüchen verbunden wird:

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 Byte

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

Probieren Sie es hier aus!

Nimmt 1-indizierte Eingaben auf.

Schließlich entschied ich mich, einen Fehler zu beheben, der mich schon seit Ewigkeiten nervt, und spielte diesen auf 21 Bytes herunter .

Erklärung (halb-ASCII-fähig für 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 dank Jo King.

Die Eingabe ist 1-indiziert.

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)

Probieren Sie es online!

Kohle , 37 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. 1-indiziert. Erläuterung:

¿¬ＬθＵＲ²+«

Sonderfall Leereingabe durch Zeichnen eines 2x2 Rechtecks ​​von +s.

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

Transponieren Sie die Eingabe, nehmen Sie das Maximum jeder Spalte (jetzt Zeile) und addieren Sie 2, um die Boxgröße in Charcoal-Koordinaten zu erhalten.

Ｂ⊟⮌η⊟η

Zeichne die Schachtel.

Ｆθ«

Schleife über jede Koordinate.

Ｊ⊟⮌ι⊟ι

Springe zu seiner Position.

x

Markiere mit einem Kreuz.

Stax , 32 31 24 Bytes

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

Führen Sie es aus und debuggen Sie es

Nimmt 0-basierte Indizes als Array von [y, x]Paaren.

Erläuterung:

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

Probieren Sie es online!

1-indiziert. Nimmt eine Matrix als Argument. 8 Bytes dank digEmAll, 3 dank Giuseppe! Erklärung (frühere Version des Codes):

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

Koordinaten des Formats [y, x]

JavaScript (Node.js) , 191 184 Byte

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}

Probieren Sie es online!

JavaScript, 180 Byte

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

1-indizierte Koordinaten.

Probieren Sie es online aus.

Erläuterung:

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

Danke an ceilingcat für den Vorschlag.

Nullindexiert. Die Funktion erstellt eine Liste mit Koordinaten und Puffern, ermittelt die maximalen x- und y-Werte, füllt den Puffer mit Leerzeichen, generiert den Frame und zeichnet dann die X-Werte.

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

Probieren Sie es online!

05AB1E , 44 42 Bytes

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

Probieren Sie es 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 und Y können vertauscht sein, wussten nicht, ob das überhaupt von Bedeutung ist.

Ich glaube, ich habe das in weniger Bytes, aber wir werden sehen ... Nein.

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

C (gcc) , 229 220 216 Bytes

-9 bytes dank ceilingcat .

Nullindexiert. Nimmt Koordinaten als Liste von Zahlen, wobei gerade Zahlen X und ungerade Zahlen Y sind.

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

Probieren Sie es online!