दो वैक्टर का रैखिक संयोजन

Question

कार्यकारी सारांश

यह देखते हुए कि इनपुट दो वैक्टर और उनके संबंधित "वेट" का प्रतिनिधित्व करता है, उत्पादन करता है जो उन वैक्टरों के भारित योग का भी प्रतिनिधित्व करता है।

चुनौती

इनपुट में निम्नलिखित वर्णों की एक या अधिक पंक्तियाँ होंगी:

• अंक 0 की ठीक एक घटना, जो दो-आयामी विमान में उत्पत्ति का प्रतिनिधित्व करती है;
• वास्तव में दो अन्य अंक (1-9; एक ही अंक हो सकते हैं या नहीं भी हो सकते हैं), जिनकी उत्पत्ति के सापेक्ष स्थितियां वैक्टर का प्रतिनिधित्व करती हैं, और जिनके मूल्य थ्रेड वैक्टर से जुड़े भार का प्रतिनिधित्व करते हैं;
• "पृष्ठभूमि वर्ण" की कुछ संख्या। सॉल्वर एक विशिष्ट पृष्ठभूमि चरित्र चुन सकता है; उदाहरण के लिए, मैं "का चयन करूंगा।" (ज्यादातर मानव पठनीयता के लिए)। वैकल्पिक रूप से, पृष्ठभूमि वर्ण कुछ भी हो सकते हैं जो रिक्त स्थान की तरह दिखते हैं।

(सॉल्वर यह चुन सकता है कि इनपुट एकल मल्टी-लाइन स्ट्रिंग है या एक-लाइन स्ट्रिंग का एक सरणी है।)

उदाहरण के लिए, इनपुट

....2
.0...
...3.

वजन 2 के साथ निर्देशांक (3,1) पर एक वेक्टर का प्रतिनिधित्व करता है, और वजन 3 के साथ निर्देशांक (2, -1) पर एक वेक्टर।

आउटपुट निम्न परिवर्तनों के साथ इनपुट के समान होना चाहिए:

• एक "परिणाम चरित्र", जिसे सॉल्वर द्वारा चुना जाता है, इनपुट वैक्टर के भारित योग द्वारा निर्दिष्ट स्थिति में जोड़ा जाना चाहिए (समकक्ष, उस स्थिति में जो इनपुट वैक्टर का उपयुक्त रैखिक संयोजन है);
• मूल, दो इनपुट वैक्टर और एक ही चित्र में आउटपुट वेक्टर को फिट करने के लिए जितने पृष्ठभूमि के पात्रों की आवश्यकता होती है। यदि वांछित हो तो अतिरिक्त पृष्ठभूमि पात्रों को शामिल किया जा सकता है; एकमात्र बाधा यह है कि, यदि पृष्ठभूमि चरित्र एक दृश्यमान चरित्र है, तो पूरे आउटपुट को आकार में आयताकार होना चाहिए और वेक्टर का प्रतिनिधित्व नहीं करने वाले प्रत्येक चरित्र को पृष्ठभूमि चरित्र होना चाहिए। (यदि रिक्त स्थान को पृष्ठभूमि वर्णों के रूप में उपयोग किया जाता है, तो इन बाधाओं को लागू करने की आवश्यकता नहीं है।)

(सामान्य तौर पर, अगर वजन के साथ एक वेक्टर (v, w) है और वजन b के साथ दूसरा वेक्टर (x, y) है, तो उनका भारित योग a (v, w) + b (x, y) = (av +) है bx, द्वारा aw +)।)

पिछले उदाहरण में, उपयुक्त रैखिक संयोजन 2 * (3,1) + 3 * (2, -1) = (12, -1) है। यदि हम परिणाम के रूप में "X" का उपयोग करते हैं, तो आउटपुट जैसा दिख सकता है

....2.........
.0............
...3.........X

या

................
...2............
0...............
..3.........X...
................
................

सामान्य कोड-गोल्फ स्कोरिंग: सबसे छोटा जवाब, बाइट्स में, जीतता है।

उदाहरण इनपुट और आउटपुट

यदि रिक्त स्थान का उपयोग किया जाता है, तो उपरोक्त इनपुट जैसा दिखेगा

    2
 0
   3

और आउटपुट जैसा लगेगा

    2
 0
   3         X

व्हाट्सएप के पात्र / अनुगामी / रेखाएं अप्रासंगिक हैं; यदि वे पाठक के लिए अदृश्य हैं, तो यह ठीक है। (यह कहा जा रहा है, बाकी उदाहरणों के लिए मैं बैकग्राउंड कैरेक्टर के लिए "" का उपयोग करके वापस जाऊंगा, इसे पढ़ना आसान बनाने के लिए।)

यदि दोनों वैक्टर का वजन 1 है, तो परिणाम एक समांतर चतुर्भुज की तरह दिखेगा: इनपुट

.1.
...
1.0

उत्पादन की ओर जाता है

X.1.
....
.1.0

ध्यान दें कि इस समांतर चतुर्भुज को पतित किया जा सकता है यदि इनपुट वैक्टर के संपर्क में न हों: इनपुट

0.1..1

उत्पादन की ओर जाता है

0.1..1.X

परिणाम वेक्टर के लिए इनपुट वैक्टर या मूल में से एक के बराबर करना संभव है; इस मामले में, यह केवल इनपुट चरित्र को ओवरराइट करता है। उदाहरण के लिए, इनपुट

..2.0.1...

पैदावार देता है

..X.0.1...

(जहां इनपुट और / या आउटपुट में, अग्रणी और अनुगामी अवधि को हटाया जा सकता है)। इनपुट

.....3
......
...0..
......
......
2.....

पैदावार देता है

.....3
......
...X..
......
......
2.....

अंत में, इनपुट

90
.8

पैदावार देता है

........90
.........8
..........
..........
..........
..........
..........
..........
X.........

Comments

PPCG में आपका स्वागत है! अच्छी पहली चुनौती।

— AdmBorkBork

@TimmyD स्वागत और प्रोत्साहन के लिए धन्यवाद :)

— ग्रेग मार्टिन

अंत में, क्योंकि मुझे यकीन है कि अन्य लोग इसे लाएंगे, यह एक गिरगिट चुनौती के करीब है क्योंकि कोड का एक बड़ा हिस्सा बस इनपुट को पार्स करने वाला है, जब यह वास्तव में चुनौती का मुख्य जोर नहीं है।

— AdmBorkBork

क्या इनपुट या सही आउटपुट में पंक्तियों / स्तंभों की संख्या पर कोई सीमा है?

— श्वेत

@TimmyD मैंने भारित राशि के लिए सामान्य सूत्र जोड़ा है, और यह भी स्पष्ट किया है कि या तो इनपुट प्रारूप ठीक है। मैं मानता हूं कि यह एक गिरगिट चुनौती के करीब है (हालांकि मैं उम्मीद कर रहा था कि कुछ भाषा (ओं) में समस्या को हल करने के लिए बोर्ड पर सीधे "चलने" की क्षमता हो सकती है); हालांकि सैंडबॉक्स पर प्रतिक्रिया नकारात्मक से अधिक सकारात्मक थी, इसलिए मैंने इसके साथ जाने का फैसला किया।

— ग्रेग मार्टिन

Answer 1

MATL , 48 बाइट्स

tZyyX:UX>*Yat48-tt0>*3#fbbhb~2#fh-*s7M+'X'wZ}4$(

बैकग्राउंड कैरेक्टर स्पेस है। इनपुट एक 2 डी चार सरणी है जिसमें अर्धविराम द्वारा अलग की गई पंक्तियाँ हैं। इसलिए परीक्षण मामलों में संबंधित इनपुट हैं:

['    2'; ' 0   '; '   3 ']
[' 1 '; '   '; '1 0']
['0 1  1']
['  2 0 1   ']
['     3'; '      '; '   0  '; '      '; '      '; '2     ']
['90'; ' 8']

आउटपुट में महत्वपूर्ण मात्रा में पेडिंग व्हाट्सएप शामिल है।

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

Answer 2

पायथन 3, 374 355 बाइट्स

बहुत अधिक परिष्कृत अजगर समाधान नहीं है जो पैडिंग के साथ बहुत उदार है (अधिकतम शतरंज की दूरी का उपयोग करता है)। इनपुट एक एकल पंक्ति है जहाँ पंक्तियों को पाइपों से अलग किया जाता है (हालांकि एल्गोरिथ्म आसानी से अल्फ़ान्यूमेरिकल का उपयोग नहीं कर सकता है जो एक नई पंक्ति या ईओएफ नहीं है)। कुछ भी गैर अल्फ़ान्यूमेरिक या | इनपुट पैडिंग के लिए कार्य करता है, आउटपुट पैडिंग अवधियों का उपयोग करता है। अधिक अनुभवी अजगर गोल्फरों से प्रतिक्रिया और सुधार की सराहना की जाती है।

संपादित करें: कुछ सुधार @TheBikingViking के लिए धन्यवाद। इसके अलावा और भी अधिक मार्जिन जोड़ा गया क्योंकि मैं पैडिंग के साथ काफी उदार नहीं था।

s=input()
l=[len(s),1+s.find('|')]['|'in s]
P=sorted([int(c),i%l,i//l]for i,c in enumerate(s)if c.isalnum())
L=X=Y=0
P[0][0]=-sum(p[0]for p in P)
for w,x,y in P:L=max(abs(x),abs(y),L);X+=x*w;Y+=y*w
P+=[['X',P[0][1]+X,P[0][2]+Y]]
P[0][0]=0
L=2*max(abs(X),abs(Y),L)
S=[2*L*["."]for _ in[0]*2*L]
for w,x,y in P:S[L+y][L+x]=str(w)
for s in S:print(''.join(s))

Comments

अच्छा उत्तर! पायथन युक्तियों पर एक नज़र डालें । कुछ संकेत: 1. यह निर्दिष्ट करने के लिए एक अच्छा विचार है कि आपने पायथन 2/3 का उपयोग किया है, क्योंकि कुछ विशेषताएं भिन्न हैं। 2. आप ऑन लाइन के [a,b][condition]बजाय कर सकते हैं b if condition else c2. sortedजेनरेटर स्टेटमेंट सहित कोई भी पुनरावृत्ति लेता है, इसलिए आप बाहरी ब्रैकेट को चौकोर कोष्ठक में छोड़ सकते हैं। 3. के zip(p)बजाय काम करना चाहिए p[0] for p in P।

— बाइक चलाना

4. आप ऑन लाइन 7. के P+=[stuff]बजाय कर सकते हैं P.append([stuff])। 5. के ["."]बजाय करो list(".")। (3. होना चाहिए था zip(p)[0]।)

— TheBikingViking

क्षमा करें, राजधानी होना चाहिए Pमें zip।

— बाइक चलाना

5. आपको S=[stuff]*2*Lलाइन 10 पर करने में सक्षम होना चाहिए

— TheBikingViking

[१] अच्छा बिंदु, अजगर संस्करण जोड़ देगा। [२] अच्छा पैटर्न, लेकिन यह काम नहीं करेगा index(कुछ नहीं मिला पर त्रुटि)। findहालांकि साथ काम करेंगे । [पुन। सॉर्ट किया गया] धन्यवाद, जोड़ने पर उन्हें हटाने से चूक गए sorted। [३] जिप (* पी) [०] अजगर ३ में काम नहीं करता (ज़िप ऑब्जेक्ट इंडेक्सेबल नहीं है)। [४] पी + = [सामान] काम नहीं करेगा, हालांकि पी + = [[सामान]] होगा। [५] धन्यवाद। [अन्य 5] काम नहीं करता है। मुझे नई सूची चाहिए, संदर्भ नहीं।

— अल्गमीर

Answer 3

जावास्क्रिप्ट, 534 528 502 बाइट्स

n="indexOf"
J="join"
B=X=>X.split(O)
O='\n'
w=i[n](O)+1
h=B(i).length
Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}
C=[0,0,0]
G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""
o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w
x=y=0
j=i
for(z="1";z<="9";z++){while(p=~j[n](z)){j=j.replace(z," ")
x+=~p%w-l
y+=L(~p)-c}}
I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))
N=Z(I[0].length+1," ",2)
A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))
M=y+c+C[1]
O=""
m=B(A[M])
m[x+l+C[0]/h]="x"
A[M]=m[J]("")
A[J]("\n")

ध्यान दें कि पैडिंग इष्टतम है। यह प्रोग्राम मानता है कि मेरे पास कच्ची स्ट्रिंग है, जिसमें \nपात्रों द्वारा अलग-अलग लाइनें हैं । पैडिंग रिक्त स्थान के साथ किया जाता है, और परिणाम चरित्र एक लोअरकेस हैx ।

कोड-गोल्फिंग में यह मेरा पहला प्रयास है।

तकनीकी सामान: - कार्यक्रम का आकार लगभग दोगुना हो गया (और इसकी जटिलता नाटकीय रूप से बढ़ गई) परिणाम चरित्र को ध्यान में रखते हुए, ज्यादातर इसलिए क्योंकि जावास्क्रिप्ट तार अपरिवर्तनीय हैं।

---

लाइन द्वारा लाइन स्पष्टीकरण:

n="indexOf"
J="join"
B=X=>X.split(O)

मैं उन का बहुत उपयोग करता हूं, इसलिए उन्हें तार में संग्रहीत करने से मुझे कुछ जगह बच गई। आप नीचे देख सकते हैं कि splitफ़ंक्शन के लिए, मैंने बस एक उपनाम बनाया है; इसका कारण यह है कि मुझे केवल एक तर्क की आवश्यकता थी, दूसरे को निरंतर होने की। के लिए indexOfऔर join, यह फिर भी लंबे समय तक हो गया होता।

O='\n'
w=i[n](O)+1
h=B(i).length

यहां कुछ भी जटिल नहीं है, मैं प्रारंभिक सरणी की चौड़ाई और ऊंचाई पढ़ रहा हूं। i[n]पहुँच के उपयोग पर ध्यान दें indexOf, जबकि splitअलग तरीके से नियंत्रित किया जाता है।

Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}

यह दिलचस्प हो रहा है। यह फ़ंक्शन मूल रूप से स्ट्रिंग X के जे -1 बार कॉन्टेनेट बनाता है और इसे वापस करता है। इसका उपयोग पैडिंग के लिए रिक्त स्थान के तारों को उत्पन्न करने के लिए किया जाता है।

C=[0,0,0]

इस सरणी में पैडिंग द्वारा जोड़े गए लाइनों और स्तंभों की संख्या शामिल होगी (पहले मामले में एक कारक एच द्वारा)। अंतिम सेल एक रद्दी है, और मुझे नीचे दिए गए फ़ंक्शन में एक अतिरिक्त तर्क रखने से रोकता है।

G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""

यह फ़ंक्शन अकेले पैडिंग (दोनों लाइन और कॉलम) को संभालता है; यह निर्धारित करता है, परिणाम वेक्टर (एक्स) के एक समन्वय पर आधारित है, और उत्पन्न करने के लिए लाइनों (स्तंभों की संख्या) (ई), चाहे वह एक बनाने के लिए आवश्यक है। X+E+1+Tसिर्फ एक कुछ स्थान बचाने के लिए चाल, है Uभरने स्ट्रिंग (स्तंभों के लिए एक जगह है, और लाइनों के लिए एक पूरी लाइन) है, और हम करने के लिए वापस आऊँगा R। यह फ़ंक्शन मूल रूप से, एक पंक्ति के मामले में, उक्त पंक्ति के आरंभ या अंत में आवश्यक पैडिंग, और, एक कॉलम के मामले में, मूल लाइनों के पहले या बाद में आवश्यक पैडिंग लाइनों को लौटाता है।

o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w

यहां हम मूल की स्थिति को पढ़ते हैं, और हम इसके निर्देशांक प्राप्त करते हैं। L एक इंडेक्स को एक लाइन नंबर में बदलने के लिए एक फ़ंक्शन है।

x=y=0
j=i
for(z="1";z<="9";z++){
    while(p=~j[n](z)){
        j=j.replace(z," ")
        x+=~p%w-l
        y+=L(~p)-c
    }
}

मैंने इसे पढ़ने में आसान बनाने के लिए कुछ व्हाट्सएप को जोड़ा। यहां ऐसा होता है कि प्रत्येक संभावित संख्या के लिए, हम इसे मूल स्ट्रिंग में ढूंढते रहते हैं। ~चाल जावास्क्रिप्ट में अपेक्षाकृत आम है; यह बिटवाइज़ नहीं ऑपरेटर है, लेकिन यहाँ जो भी मायने रखता है, वह है ~-1==0, जो मुझे लूप के अंत के लिए परीक्षण करने की अनुमति देता है। मैं तब स्ट्रिंग में चरित्र को मिटा देता हूं (यही कारण है कि मैंने एक प्रतिलिपि बनाई है), इससे मुझे आवश्यकतानुसार खोज जारी रखने की अनुमति मिलती है। मैं फिर (x, y)एक साधारण विकल्प का उपयोग करते हुए वेक्टर के निर्देशांक जोड़ता हूं ।

I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))

मैंने यहां मूल स्ट्रिंग को लाइनों में विभाजित किया है, और प्रत्येक पंक्ति के लिए, मैं कॉल Gकरता हूं जो लाइनों के पहले और बाद में पैडिंग उत्पन्न करेगा। l-w+2और इतने पर एक सरल सूचकांक गणना जो मुझे परीक्षण करने की अनुमति देता है कि क्या मैं गद्दी जोड़ने के लिए या नहीं करने की आवश्यकता से आते हैं। उदाहरण के लिए, यदि x>0और x+l-w+1>0, तो (x+l-w+1)+1लाइन के बाद रिक्त स्थान जोड़ा जाना चाहिए। +xयह पहले पैरामीटर होने के कारण हटाया जा रहा है, और X+E+1+Tकी परिभाषा में इस्तेमाल कियाG ।

इसी तरह की बात पहले पात्रों के लिए की जाती है, और फिर स्तंभों के लिए। यहां बहुत सारे फैक्टराइजेशन हैं जो मुझे केवल एक फ़ंक्शन का उपयोग करने की अनुमति देते हैं। अंतिम पैरामीटर पर ध्यान दें; पहले मामले में, मैं C[0]बाद में यह जानना चाहता हूं कि प्रत्येक पंक्ति की शुरुआत में मैंने कितने कॉलम जोड़े हैं; यह मुझे परिणाम चरित्र की अंतिम स्थिति को पुनः प्राप्त करने की अनुमति देता है। मैं हालांकि मूल पंक्ति के बाद जोड़े गए कॉलम के बारे में परवाह नहीं करता हूं, यही वजह है कि Gरद्दी सेल को लिखने के लिए दूसरी कॉल C[2]जो अप्रयुक्त है।

N=Z(I[0].length+1," ",2)

यहाँ मैं बस लाइनों की नई लंबाई पढ़ता हूं, और इससे रिक्त स्थान बनाता हूं। इसका उपयोग ऊर्ध्वाधर गद्दी बनाने के लिए किया जाएगा।

A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))

यह ठीक दो पंक्तियों के समान है। केवल अंतर C[1]इस समय के लिए लिख रहा है , और विभाजकों का उपयोग कर रहा है N+Oऔर O+N। याद रखें कि Oएक नई Nरेखा है , और रिक्त स्थान की एक पंक्ति है। फिर मैं Bइसे फिर से विभाजित करने के लिए परिणाम पर लागू करता हूं (मुझे इसे संपादित करने के लिए परिणाम चरित्र वाले लाइन को पुनः प्राप्त करने की आवश्यकता है)।

M=y+c+C[1]

यह परिणामी चरित्र का ऊर्ध्वाधर सूचकांक है।

O=""
m=B(A[M])
m[x+l+C[0]/h]="x"

यहां मुझे Oउपयुक्त लाइन को वर्णों में विभाजित करने में सक्षम होने के लिए संशोधित करने के लिए मजबूर किया गया है । इसका कारण यह है कि जावास्क्रिप्ट तार अपरिवर्तनीय हैं; एक स्ट्रिंग को संपादित करने का एकमात्र तरीका इसे एक सरणी में बदलना है (जो कि मैं यहां कर रहा हूं), सही स्थिति पर संपादित करें और फिर से स्ट्रिंग में शामिल हों। उस hकारक पर भी ध्यान दें , जो इसलिए है क्योंकि Gफ़ंक्शन को एक बार प्रारंभिक पंक्ति में बुलाया गया था।

A[M]=m[J]("")
A[J]("\n")

मैं अंत में सरणी में नए स्ट्रिंग को प्रतिस्थापित करता हूं, और इसे फिर से एक स्ट्रिंग में शामिल करता हूं। वू हू!