आप अपने दोस्तों के लिए एक खजाने की खोज का आयोजन कर रहे हैं। चीजों को अधिक आसानी से संचालित करने के लिए, आप उन सभी स्थानों का नक्शा बनाना चाहते हैं, जहां आपने कीमती वस्तुओं को छिपाया था।

इनपुट

इनपुट के किसी भी रूप में (nonnegative) x- और y- समन्वित बिंदुओं की एक सूची दर्शाती है, 0 0ऊपरी बाएँ कोने की अनुमति दी जा रही है (नोट: आप अपने उत्तर में 1-आधारित अनुक्रमण का उपयोग भी कर सकते हैं, कृपया टिप्पणी करें कि यदि आप )। उदाहरण:

1 2
3 0
0 1

चुनौती

आपका फ़ंक्शन या प्रोग्राम हर दिए गए स्थान को दर्शाते हुए एक मानचित्र का निर्माण करने में सक्षम होना चाहिए xजहाँ आउटपुट में पंक्ति y + 1 और स्तंभ x + 1 में चिह्न पाया जाता है। चिह्नित स्थानों को एक के साथ दर्शाया गया है । नक्शे में एक फ्रेम भी होता है, जहाँ कोने +s होते हैं , ऊर्ध्वाधर रेखाएँ होती हैं |और क्षैतिज रेखाएँ होती हैं -। आपके समाधान को सबसे छोटे संभव फ्रेम का उत्पादन करना चाहिए। ऊपर दिए गए इनपुट उदाहरण के लिए मानचित्र:

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

संभावित परीक्षण मामले

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

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

""
=>
++
++

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

बेशक, यह कोड-गोल्फ है , जिसका अर्थ है कि सबसे कम बाइट गिनती के साथ समाधान जीतता है! आपके समाधान की व्याख्या को प्रोत्साहित किया जाता है।

code-golf ascii-art

— racer290
स्रोत

वास्तव में नहीं, लेकिन मैं वास्तव में एक और इनपुट प्रारूप के बारे में नहीं सोच सकता था। लेकिन मैं इसे बदलने के लिए तैयार हूं, अगर यह चुनौती का लाभ देता है।

— racer290

क्या नॉन स्क्वायर मैप हो सकते हैं?

— फ्रॉन्फ्रॉग

4

@ racer290 मैं बस कुछ कहना चाहूँगाthe input is a list of locations (e.g. nested list, list of tuples, space & newline separated, separate inputs, ect.)

— dzaima

1

क्या आउटपुट वर्णों का 2d सरणी हो सकता है?

— OVS

2

क्या मैं x- और y- निर्देशांक लेते हुए एक फ़ंक्शन दो अलग-अलग तर्कों के रूप में प्रस्तुत कर सकता हूं?

— ბიმო

7

जे , 37 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

                       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

— FrownyFrog
स्रोत

1

मुझे लगता है कि आउटपुट स्वरूपण मेरे द्वारा प्रस्तावित की तुलना में बेहतर है;)

— रेसर 2

::emptyइतनी क्रिया क्यों है ? यह क्या है? इसे 1 बाइट या तो सरलीकृत क्यों नहीं किया जा सकता है? (मुझे जे का कोई ज्ञान नहीं है)

— मैजिक ऑक्टोपस यूरिन

मैं इसे बिना TIO पर भाग गया :: खाली और यह काम करने के लिए लग रहा था (न तो जम्मू को पता था)

— क्विंटेक

असल में :: खाली लगता है "" इनपुट मामले को संभालने के लिए

— Quintec

@MagicOctopusUrn मुझे सही मायने में खाली बॉक्स का उत्पादन करने का एक छोटा तरीका नहीं पता है, वे डिफ़ॉल्ट रूप से 1 पंक्ति उच्च हैं।

— फ्रॉन्फ्रॉग

4

जावास्क्रिप्ट (ईएस 6), 150 बाइट्स

[x,y]प्रारूप में 1-अनुक्रमित निर्देशांक की सूची के रूप में इनपुट लेता है । एक स्ट्रिंग लौटाता है।

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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत

4

हास्केल , 127 123 बाइट्स

यह उस ऑपरेटर को परिभाषित करता है (!)जो x -ordordinates की सूची और संबंधित 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]

इसे ऑनलाइन आज़माएं!

Ungolfed / स्पष्टीकरण

सहायक फ़ंक्शन mकिसी सूची की अपेक्षा करता है और सूचक (1-आधारित) को अधिकतम तक लौटाता है, यदि सूची खाली है तो वह वापस आ जाती है []:

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

वास्तविक ऑपरेटर (!)सिर्फ एक सूची-समझ है, सभी निर्देशांक को ट्रेस करके या एक xचरित्र का चयन करता है , जो नई सुर्खियों में शामिल हो जाता है:

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]

— ბიმო
स्रोत

3

कैनवस , 22 बाइट्स

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

यहाँ यह कोशिश करो!

1-अनुक्रमित इनपुट लेता है।

अंत में एक बग को ठीक करने का फैसला किया गया जो मुझे उम्र के लिए परेशान कर रहा था और इसे 21 बाइट्स तक नीचे पहुंचा दिया ।

स्पष्टीकरण (मोनोसेपस के लिए आधा-एएससीआईआई-फिट):

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

— dzaima
स्रोत

3

पायथन 2 , 151 140 138 बाइट्स

-2 बाइट्स जो किंग की बदौलत।

इनपुट 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)

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

मुझे संदेह है कि आप 1-आधारित अनुक्रमणिका का उपयोग कर रहे हैं, कृपया अपने उत्तर में उस नोट को छोड़ दें जैसा कि चुनौती में कहा गया है।

— racer290

2

चारकोल , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 1 अनुक्रमित। स्पष्टीकरण:

¿¬ＬθＵＲ²+«

+S का 2x2 आयत बनाकर विशेष-केस खाली इनपुट ।

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

इनपुट को स्थानांतरित करें, प्रत्येक कॉलम (अब पंक्ति) का अधिकतम लें और चारकोल को-ऑर्डिनेट्स में बॉक्स का आकार प्राप्त करने के लिए 2 जोड़ें।

Ｂ⊟⮌η⊟η

बॉक्स ड्रा करें।

Ｆθ«

प्रत्येक समन्वय पर लूप करें।

Ｊ⊟⮌ι⊟ι

कूदो अपनी स्थिति पर।

एक क्रॉस के साथ चिह्नित करें।

— नील
स्रोत

खाली इनपुट के लिए असफल होने लगता है: tio.run/…

— wastl

@wastl धन्यवाद, मैं वर्कअराउंड लेकर आया हूं।

— नील

2

स्टैक्स , 32 31 24 बाइट्स

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

इसे चलाएं और डीबग करें

[y, x]जोड़े के सरणी के रूप में 0-आधारित सूचकांकों को लेता है ।

स्पष्टीकरण:

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

— wastl
स्रोत

1

अच्छी तरह से किया। आप |Sघेरने के निर्देश से थोड़ा और अधिक लाभ प्राप्त कर सकते हैं , और एक संक्षिप्त शॉर्टहैंड मानचित्र। ( m) सराउंड लेता है aऔर bस्टैक से और उत्पादन करता है b+a+b। और आप पंक्तियों पर पुनरावृति करने और आउटपुट के उत्पादन mके लिए अंतिम के बजाय उपयोग कर सकते हैं |J। उदाहरण के लिए

— पुनरावर्ती

1

एक और बात: आप की जगह ले सकता z]n+H%साथ cM%। यह वह टुकड़ा है जो नक्शे की चौड़ाई प्राप्त करता है, लेकिन खाली नक्शे के लिए एक विशेष मामला है। यदि आप इसे मापने से पहले नक्शे को स्थानांतरित करते हैं, तो विशेष मामला दूर हो जाता है।

— पुनरावर्ती

@recursive मैं आसपास की तरह कुछ की तलाश में था, लेकिन मैंने गलत कीवर्ड

— खोजे

आप स्वाभाविक रूप से उस ऑपरेशन को क्या कहेंगे? मैं इसे डॉक्स में जोड़ सकता हूं ताकि अगला व्यक्ति उसे ढूंढ सके।

— पुनरावर्ती

@recursive मुझे याद नहीं है कि यह क्या था, और मैं स्वाभाविक रूप से इसे अब चारों ओर से

— बुलाऊंगा

2

आर , 133 125 122 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित। एक मैट्रिक्स को तर्क के रूप में लेता है। सहेजे गए 8 बाइट्स digEmAll के लिए धन्यवाद, 3 Giuseppe के लिए धन्यवाद! स्पष्टीकरण (कोड का पूर्व संस्करण):

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

— Jayce
स्रोत

यदि आप utf8 कोड के बजाय सामान्य वर्णों का उपयोग करते हैं तो आप 8 वर्णों को सहेजते हैं: tio.run/##ZU7NDoIwDL7zFEu9tKEzDONF4UkMhzmGchgYN_KC@uwIaozRpG36/…

— digEmAll

[<-ब्रेसिज़ को हटाने के लिए सीधे उपयोग करके 122 बाइट्स ।

— ग्यूसेप

@Giuseppe वास्तव में! मुझे पता था कि एक रास्ता बनना होगा।

— JayCe

1

प्रारूप के कोर्ड्स [y, x]

जावास्क्रिप्ट (Node.js) , 191 184 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

— DanielIndie
स्रोत

मुझे लगता है कि आपने गलती से कहीं x- और y- निर्देशांक की अदला-बदली कर

— ली

@ racer290 क्या आप अधिक विशिष्ट हो सकते हैं?

— डैनियलइंडी

आपके समाधान की कोशिश करते हुए, मैंने पाया कि परीक्षण मामलों में x निर्देशांक को बदलने से समन्वय की ऊर्ध्वाधर दिशा में परिवर्तन हुआ। मुझे लगता है कि बग पहली पंक्ति में है ( a.map(([y,x]))

— racer290

लेकिन x सही

— पैरामटर है जैसा

2

तो अपने समाधान में आप पहले y समन्वय लेते हैं? मुझे लगता है कि आपके उत्तर में उस पर एक नोट छोड़ना बेहतर होगा।

— racer290

1

जावास्क्रिप्ट, 180 बाइट्स

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

स्निपेट का विस्तार करें

— l4m2
स्रोत

1

जावा 10, 238 223 बाइट्स

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-अनुक्रमित निर्देशांक।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

— केविन क्रूज़सेन
स्रोत

rwhxy; lcwxlgetw? xw; hylgeth? yh; forwhxxwr। foryyhrxwyh? xwyhcxy? XR।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn क्या आप सभी चर और get/ के forलिए नामकरण कर रहे हैं ? : एस एक्सडी

— केविन क्रूज़सेन

1

सी (जीसीसी) , 246 234 बाइट्स

सुझाव के लिए सीलिंग के लिए धन्यवाद।

शून्य अनुक्रमित। फ़ंक्शन को-ऑर्डिनेट्स और बफर की सूची लेता है, अधिकतम x और y मान पाता है, रिक्त स्थान के साथ बफर को भरता है, फ्रेम उत्पन्न करता है, और फिर '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';}

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत

235 बाइट्स के

— छत

1

05AB1E , 44 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

 ζε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.

एक्स और वाई उलट हो सकते हैं, पता नहीं है कि अगर बिल्कुल भी मायने रखता है।

~~मुझे लगता है कि मेरे पास यह कम बाइट्स में है, लेकिन हम देखेंगे ...~~ नहींं।

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

— जादू ऑक्टोपस Urn
स्रोत

1

यह काफी नहीं है, लेकिन आप पहली बार बदलकर 1 बाइट बचा सकता है Fके लिए Lv, निकालें NVऔर परिवर्तन Yकरने के लिए y। 41 बाइट्स

— केविन क्रूज़सेन

1

जैसा कि चैट में @Eignign द्वारा बताया गया है , εZ}हो सकता है €à।

— केविन क्रूज़सेन

मोबाइल पर नफरत का संपादन पीसी के पास तक इंतजार करेगा।

— मैजिक ऑक्टोपस यूरिन

1

@ केविनक्रूजसेन Ývनहीं Lv, लेकिन फिर भी एक अच्छा संपादन :)।

— मैजिक ऑक्टोपस Urn

आह, तुम सही हो। Ývके बजाय Lv। मेरी गलती।

— केविन क्रूज़सेन

0

सी (जीसीसी) , 229 220 216 बाइट्स

-9 बाइट्स सीलिंगकैट के लिए धन्यवाद ।

शून्य अनुक्रमित। संख्याओं की सूची के रूप में निर्देशांक लेता है, जहाँ संख्याएँ X भी हैं और विषम संख्याएँ 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;}

इसे ऑनलाइन आज़माएं!

— gastropner
स्रोत

@ceilingcat चीयर्स!

— गैस्ट्रोपनर

के for(n&&X++-Y++;i<=Y;i+=puts(""))बजाय सुझावn&&X++-Y++;for(--i;i++<Y;puts(""))

— छत 21

खजाना नक्शा ड्राइंग बॉट

इनपुट

चुनौती

संभावित परीक्षण मामले

जे , 37 34 बाइट्स

जावास्क्रिप्ट (ईएस 6), 150 बाइट्स

हास्केल , 127 123 बाइट्स

Ungolfed / स्पष्टीकरण

कैनवस , 22 बाइट्स

पायथन 2 , 151 140 138 बाइट्स

चारकोल , 37 बाइट्स

स्टैक्स , 32 31 24 बाइट्स

आर , 133 125 122 बाइट्स

जावास्क्रिप्ट (Node.js) , 191 184 बाइट्स

जावास्क्रिप्ट, 180 बाइट्स

जावा 10, 238 223 बाइट्स

सी (जीसीसी) , 246 234 बाइट्स

05AB1E , 44 42 बाइट्स

सी (जीसीसी) , 229 220 216 बाइट्स