सीमाहीन मेज

Question

इस चुनौती में आप कार्टेशियन प्लेन में वर्णमाला के अक्षर रखने जा रहे हैं और परिणाम को टेक्स्ट के रूप में आउटपुट करते हैं।

आपका इनपुट 3 मापदंडों के साथ सूची की सूची में शामिल होगा:

• एक्स समन्वय
• Y समन्वय करते हैं
• तार

कैसे?

हम जानते हैं कि कार्टेशियन प्लेन में 2 एक्सिस $(X, Y)$ और 4 क्वाड्रेंट होते हैं, जहां $(X,Y)$ निर्देशांक होते हैं $(+,+)$ , $(−,+)$ , $(−,−)$ , और$(+,−)$ । उदाहरण के लिए

कार्टेशियन प्लेन के रूप में निम्नलिखित 3 बाय 3 मैट्रिक्स पर विचार करें

$$\begin{matrix} (-1,1) & (0,1) & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}$$

यदि हमें इनपुट में कुछ दिया जाता है जैसे कि [[-1,1,L],[0,1,F]]हमारा मैट्रिक्स कुछ इसी तरह दिखेगा

$$\begin{matrix} L & F & (1,1) \\ (-1,0) & (0,0) & (1,0) \\ (-1,-1) & (0,-1) & (1,-1) \end{matrix}$$

और अंतिम उत्पादन LF

इसके अलावा कुछ बिंदु हैं जिनका हमें सही आउटपुट प्राप्त करने के लिए अनुसरण करने की आवश्यकता है:

• जब एक एक्स, वाई समन्वय दोहराया जाता है, तो आपको तारों को समतल करना होगा। उदाहरण: मान लें (-1,1) स्ट्रिंग Fरखी गई है और आपको स्ट्रिंग aको उसी बिंदु पर रखने की आवश्यकता है। आप परिणामस्वरूप दोनों तार को समेटते हैं Faऔर यह वह मान है जो (-1,1) में जाएगा।
• आपका आउटपुट मैट्रिक्स के अनुरूप होना चाहिए। उदाहरण अपने अंतिम परिणाम के रूप में कल्पना करें:

$$\begin{matrix} Ma & r & ie \\ i & s & (1,0) \\ cute & (0,-1) & (1,-1) \end{matrix}$$

आपको आउटपुट चाहिए

Ma  rie 
i   s       
cute

क्यों?

आप इसे एक तालिका के रूप में देख सकते हैं जहां स्तंभ x- अक्ष और y- अक्ष की पंक्तियों के मान हैं।

        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma"     |      "r"      |     "ie" 
Row 2   |  "i"      |      "s"      |
Row 3   |  "cute"   |               |

सभी कॉलम मानों की लंबाई समान होनी चाहिए

        Column 1    |   Column 2    |   Column 3
        ----------------------------------------
Row 1   |  "Ma  "   |      "r"      |     "ie" 
Row 2   |  "i   "   |      "s"      |
Row 3   |  "cute"   |               |

Finnaly हम परिणाम का उत्पादन करते हैं

Ma  rie
i   s
cute

---

परीक्षण के मामलों

Input
------------
[[3, 3, "c"]
[4, 1, "un"]
[5, 3, "e"]
[4, 3, "od"]
[4, 2, "lf"]
[1, 2, "go"]
[2, 1, "i"]
[2, 1, "s f"]]

Output
--------------
      code
go     lf 
  is f un

---

Input
--------------
[[0, 0, 's'],
[-1,1, 'M'],
[0, 1, 'r'],
[-1,1, 'a'],
[1, 1, 'i'],
[-1, 0, 'i'],
[1, 1, 'e'],
[-1,- 1, 'c'],
[-1,- 1, 'u'],
[-1, -1, 'te']]

Output.
----------------
Ma  rie
i   s
cute

---

टिप्पणियाँ

• यह कोड-गोल्फ माना जाता है
• आप निर्देशांक को एक सूची में लपेट सकते हैं उदा [[3, 3], "c"]
• आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं
• आप मान सकते हैं कि इनपुट में कोई भी संख्या या रिक्त स्थान नहीं होगा। जैसे की तरह कुछ नहीं हो सकता है a aकभी नहीं लेकिन 1या " "या 1aया1 1

Comments

सैंडबॉक्स

— लुइस फेलिप डी जीसस मुनोज़

@ केविनक्रूजसेन आप मान सकते हैं कि केवल इनपुट में कोई संख्या या रिक्त स्थान नहीं होगा। ऐसा कुछ हो सकता है a aलेकिन कभी नहीं 1या `` 1aया1 1

— लुइस फेलिप डी जीसस मुनोज़

@LuisfelipeDejesusMunoz धन्यवाद। ओह, और एक और सवाल मुझे यकीन है कि यहाँ और लोग जानना चाहेंगे: मैरी कौन है? ; पी

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

@KevinCruijssen मेरा क्रश 5 साल पहले: c

— लुइस फेलिप डी

क्या हम नामित ट्यूल की सूची के रूप में इनपुट ले सकते हैं? कुछ इस तरह (int a,int b,string c):?

— अज्ञानता का अवतार

Answer 1

जावास्क्रिप्ट (ईएस 8),  186 180  179 बाइट्स

@ बग्घी को 1 बाइट धन्यवाद दिया

a=>(g=d=>a.some(([x,y,s])=>(w[x+=d]>(l=((r=o[y=d-y]=o[y]||[])[x]=[r[x]]+s).length)||(w[x]=l),x|y)<0,w=[o=[]])?g(-~d):o.map(r=>w.map((w,x)=>(r[x]||'').padEnd(w)).join``).join`
`)``

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

जेएस में नकारात्मक संकेत (या उनकी कमी)

एक सरणी को देखते हुए A[], जेएस में ऐसा करने के लिए यह पूरी तरह से कानूनी है A[-1] = 5। हालाँकि, यह सरणी में मान को नहीं बचाएगा। इसके बजाय, यह इस नकारात्मक इंडेक्स को एक स्ट्रिंग ( "-1") तक ले जाएगा और सरणी के आसपास के ऑब्जेक्ट में संबंधित गुण सेट करेगा ।

बुरी खबर यह है कि इस तरह के गुणों के साथ गुण चलने योग्य नहीं हैं map():

a = [];
a[1] = 3;
a[-1] = 5;
a.map((v, i) => console.log(v + ' is stored at index ' + i))

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

उपरोक्त कोड केवल प्रदर्शित करेगा 3 is stored at index 1।

एक संभावित समाधान होगा:

a = [];
a[1] = 3;
a[-1] = 5;
Object.keys(a).map(k => console.log(a[k] + ' is stored with key ' + k))

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

परंतु:

• यह बहुत गोल्फ के अनुकूल नहीं है।
• संख्यात्मक क्रम में कुंजियों को क्रमबद्ध नहीं किया जाता है।

हम यहां क्या करते हैं

$x$$y$

हम डेटा पर पहला पास कर सकते हैं, के न्यूनतम मूल्य की तलाश कर रहे हैं $x$ और का न्यूनतम मूल्य $y$। लेकिन यह काफी लंबा होगा।

यहां हम इसके बजाय क्या करते हैं:

• हम शुरू करते हैं $d=0$
• हम एक पुनरावृत्ति प्रक्रिया करते हैं $x$ के साथ बदल दिया गया है $x+d$ तथा $y$ के साथ बदल दिया गया है $d-y$
• अगर हमारे पास भी है $x<0$ या $y<0$ किसी भी प्रविष्टि के लिए, हम गर्भपात और पुनरावृत्ति के साथ एक और प्रयास शुरू करते हैं $d+1$

Comments

मुझे लगता है कि आप की घोषणा के द्वारा एक बाइट बचा सकता है oके भीतर w: w=[o=[]]।

— झबरा

@ शैगी मुझे लगता है कि वास्तव में सुरक्षित है। धन्यवाद। :)

— अर्नुलद

Answer 2

पायथन 2 , 188 185 181 बाइट्स

s=sorted;d={};k={}
for x,y,c in input():d[x]=d.get(x,{});k[~y]=d[x][y]=d[x].get(y,'')+c
for y in s(k):print''.join('%*s'%(-max(map(len,d[x].values())),d[x].get(~y,''))for x in s(d))

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

Answer 3

एपीएल (Dyalog यूनिकोड) , 39 बाइट्स ^SBCS

अनाम infix lambda ले रही है * निर्देशांक और तार की सूची के रूप में बाएँ और दाएँ तर्क।

{⊃,/↑¨↓⌽m⊣m[c],←⍵⊣m←(⊃⌈/c←1+⍺-⌊/⍺)⍴⊂''}

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

{... } "डीएफएन"; बाएं (निर्देशांक) और दाएं (तार) तर्क हैं ⍺और⍵ :

 ⊂'' खाली स्ट्रिंग संलग्न है, इसलिए एक सरणी के लिए भरण के रूप में उपयोग करें

 (… निम्न आयामों के एक सरणी में )⍴ चक्रीय रूप से r eshape:

  ⌊/⍺ निर्देशांक के प्रत्येक अक्ष के साथ सबसे कम मूल्य

  ⍺- सभी निर्देशांक से घटाएँ

  1+ इसे एक में जोड़ें (क्योंकि हम समावेशी रेंज चाहते हैं)

  c← दुकान में c( ग oordinates के लिए)

  ⌈/ उनमें से प्रत्येक अक्ष के साथ उच्चतम मूल्य

  ⊃ आयामों के रूप में उपयोग करने के लिए अनपैक

 m← स्टोर में m( मी एट्रीक्स के लिए)

 ⍵⊣ तार के पक्ष में है कि त्यागें

 m[c],←mनिर्देशांक में  उन लोगों को जोड़ेंc

 m⊣ संशोधित के पक्ष में उन लोगों को त्यागें m

 ⌽ आईना

 ↓ तार की सूची की सूची में विभाजित

 ↑¨ एक वर्ण मैट्रिक्स में स्ट्रिंग्स की प्रत्येक सूची को मिलाएं, रिक्त स्थान के साथ पैडिंग

 ,/ क्षैतिज संघनन द्वारा कम करें

 ⊃ अनपैक (चूंकि कमी 1 से 0 तक रैंक कम करती है)

---

^{* यदि इंटरवॉवन निर्देशांक और तार का एक भी तर्क लेना आवश्यक है, तो यह 5 बाइट्स लंबा होगा।}

Answer 4

05AB1E , 45 44 बाइट्स

WsàŸãεUõIvyнXQiyθ«]IZsß->ôεíDéθgjí}øRJʒðKĀ}»

एक आंतरिक सूची के रूप में इनपुट-निर्देशांक लेता है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Wsà           # Get the minimum and maximum of the (implicit) input-list
   Ÿ          # Create a list in the range [min, max]
    ã         # Create each possible pair by taking the cartesian product with itself
ε             # Map each coordinate to:
 U            #  Pop and store the coordinate in variable `X`
 õ            #  Push an empty string ""
  Iv          #  Loop `y` over the input-items:
    yн        #   Get the coordinates of item `y`
      XQi     #   If it's equal to variable `X`:
         yθ   #    Get the string of item `y`
           «  #    Concat it to the (non-)empty string
]             # Close the if-statement, loop, and map
 IZsß         # Get the maximum and minimum of the input-list
     -        # Subtract them from each other
      >       # And increase it by 1
       ô      # Split the list into parts of this size
ε             # Map each part to:
 í            #  Reverse each inner string
  Déθg        #  Get the length of the longest inner string
      j       #  Prepend spaces to each item up to that length
       í      #  And reverse every item back again
              #  (so the spaces are trailing instead of leading)
}ø            # After the map: zip/transpose; swapping rows/columns
  R           # Reverse the entire list
   J          # Join each inner list together to a single string
ʒðKĀ}         # Remove all strings consisting only of spaces
     »        # Join the strings by newlines (and output implicitly)

Answer 5

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

≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζＦ…·⌊ζ⌈ζ«≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε⮌εＭ⌈ＥεＬκ±Ｌε

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

≔Ｅθ§ι¹η≔Ｅθ§ι⁰ζ

इनपुट से निर्देशांक निकालें।

Ｆ…·⌊ζ⌈ζ«

एक्स-निर्देशांक पर लूप करें।

≔Ｅ…·⌊η⌈η⭆θ⎇∧⁼ι§μ⁰⁼κ§μ¹§μ²ωε

Y- निर्देशांक पर लूप, दिए गए निर्देशांक में तार के सभी को निकालने और समेटना।

⮌ε

तार को उल्टे क्रम में प्रिंट करें क्योंकि चारकोल की समन्वय प्रणाली की तुलना में वाई-निर्देशांक उलट हैं।

Ｍ⌈ＥεＬκ±Ｌε

अगले कॉलम की शुरुआत में जाएं।

Answer 6

पर्ल 5 -p00 -MList::Util=max, 148 बाइट्स

s/(\S+) (\S+) (.*)
/$a{$1}=max$a{$1},length($h{$2}{$1}.=$3);''/ge;for$y(sort{$b-$a}keys%h){map{printf"%-$a{$_}s",$h{$y}{$_}}sort{$a-$b}keys%a;say""}

TIO

किस तरह

• s/(\S+) (\S+) (.*) /... ;''/ge;, प्रतिस्थापन झंडे /gलूप /eeval, प्रतिस्थापन खाली समाशोधन लाइन इनपुट / डिफ़ॉल्ट चर का मूल्यांकन करता है
• $a{$1}=max$a{$1},length($h{$2}{$1}.=$3), मानचित्र का एक%% h को निर्दिष्ट करता है जिसका प्रथम स्तर की कुंजी yदूसरा स्तर xऔर $3मान को स्ट्रिंग को समतल करता है, लंबाई प्राप्त करता है और दूसरे मानचित्र% को स्वत: निर्दिष्ट करता है जिसकी कुंजियाँ xऔर स्तंभ पर लंबाई की अधिकतम मान ( x)
• for$y(sort{$b-$a}keys%h){... ;say""}, न्यूलाइन को प्रिंट करने के लिए अंत $yमें %hक्रमबद्ध उल्टे की कुंजियों में पंक्ति सूचकांकों के लिएsay""
• map{... }sort{$a-$b}keys%a, $_कुंजी में कॉलम इंडेक्स के लिए संख्यात्मक रूप से सॉर्ट किया गया
• printf"%-$a{$_}s",$h{$y}{$_}, कॉलम की चौड़ाई के साथ बाईं ओर संरेखित स्ट्रिंग

Answer 7

क्लीन , 212 206 बाइट्स

import StdEnv,StdLib
? =minList
m=maxList
c=flatten
$a#(x,y,z)=unzip3 a
=flatlines(map c(transpose[[ljustify(m(map length l))k\\l<-[reverse[c[s\\(u,v,s)<-a|u==i&&v==j]\\j<-[?y..m y]]],k<-l]\\i<-[?x..m x]]))

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