इंटरमीडिएट स्ट्रिंग ऐरे प्रतिबिंब

16

चलो चरित्रों के 2-डी सरणी में एक चरित्र के प्रतिबिंब को फिर से परिभाषित करके शुरू करें :

अलग-अलग लोअरकेस वर्णमाला वाले वर्णों के वर्ग 2-डी सरणी को देखते हुए, मैट्रिक्स में एक पत्र के प्रतिबिंब को वर्ग के केंद्र के माध्यम से इसे सीधे उस पार से चरित्र के साथ स्वैप करते हुए परिभाषित करें।

इस प्रकार, पत्र का एक प्रतिबिंब cमें

abcde
fghij
klmno
pqrst
uvwxy

विन्यास में परिणाम होगा

abwde
fghij
klmno
pqrst
uvcxy

क्योंकि cऔर wस्विच किया गया है।

कुछ और उदाहरण (उपरोक्त मूल विन्यास के साथ):

चरित्र eको दर्शाते हुए बनेगी

 abcdu
 fghij
 klmno
 pqrst
 evwxy

चरित्र mको प्रतिबिंबित करना होगा

 abcde
 fghij
 klmno
 pqrst
 uvwxy

चरित्र bको दर्शाते हुए बनेगी

 axcde
 fghij
 klmno
 pqrst
 uvwby

चुनौती

अलग-अलग लोअरकेस अक्षरों वाले वर्णों के 2-डी सरणी को देखते हुए, दिए गए स्ट्रिंग में प्रत्येक वर्ण के माध्यम से जाएं और मैट्रिक्स में इसे "प्रतिबिंबित" करें।

स्पष्टता: स्ट्रिंग a-zमें अक्षर हैं, अक्षर अद्वितीय हैं, और सरणी कम से कम 1x1 है और अधिकतम 5x5 (जाहिर है, क्योंकि अंग्रेजी वर्णमाला में केवल 26 वर्ण हैं।) स्ट्रिंग में वर्णों की गारंटी दी जाती है। 2-डी सरणी में। स्ट्रिंग अधिकतम 100 वर्णों पर है।

इनपुट

एक स्ट्रिंग s, एक पूर्णांक N, और फिर NxNवर्णों की एक सरणी।

उदाहरण

इनपुट: 

ac
2
ab
cd

आउटपुट:

dc
ba

* कारण: सबसे पहले, के aसाथ प्रतिबिंबित करें d। फिर, प्रतिबिंबित cके साथ bक्योंकि cइनपुट स्ट्रिंग में दूसरा पत्र है।

स्कोरिंग

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

वर्तमान विजेता

कोड स्निपेट दिखाएं

code-golf  string 
— NL628
स्रोत
9
सैंडबॉक्स से किसी भी सार्थक उपयोग को प्राप्त करने के लिए आधा घंटा वास्तव में पर्याप्त समय नहीं है।
— पोस्ट रॉक गार्फ हंटर
3
कोई बात नहीं, अच्छा लग रहा है।
— user202729
1
(हमारे पास एक स्टैक स्निपेट लीडरबोर्ड भी है)
— user202729
6
एक विजेता को स्वीकार करने के लिए 50 घंटे का समय बहुत कम है; आमतौर पर आप एक या एक सप्ताह इंतजार करना चाहते हैं। हालांकि, PPCG पर, किसी भी उत्तर को स्वीकार नहीं करने के लिए यह आम बात है क्योंकि यह भविष्य के उत्तरों को हतोत्साहित करता है, और हम चुनौतियों को हमेशा के लिए खुला रखना चाहते हैं।
— हाइपरनेत्रिनो
2
आपके सभी उदाहरणों में वर्णमाला क्रम में वर्ण हैं। मुझे लगता है कि हम एक धारणा नहीं बना सकते हैं? इसके अलावा, हम कर राशि लेने के लिए Nएक इनपुट के रूप में अगर हम इसे की जरूरत नहीं है?
— स्टीवी ग्रिफिन

जवाबों:

3

ऑक्टेव , 85 68 66 बाइट्स

का उपयोग करते हुए eval, इसके अंदर एक लूप के साथ बहुत सारे बाइट्स बचाए गए! मैं से प्रेरणा मिल गया इस जवाब से लुइस Mendo !

@(c,N,A)eval"for C=c,A(flip(k))=A(k=[x=find(A==C),N^2+1-x]);end,A"

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

स्पष्टीकरण:

f=@(c,N,A)          % Anonymous function that takes the three input variables
eval"...          % Evaluate the string and run it:
 for C=c,          % Loop over the character list 'c'
  .. x=find(A==C)   % Find the index where the character C is in A, and store it as 'x'
  .. k=[x,N^2+1-x]  % Create a vector with the index of C, and the index of its reflection
   A(flip(k))=A(k)  % Swap the elements in these positions
  end               % End loop
  A"                % Display the new 'A'
— स्टीवी ग्रिफिन
स्रोत
2

पायथन 2 , 76 बाइट्स

lambda s,a:[a[[i,~i][(s.count(c)+s.count(a[~i]))%2]]for i,c in enumerate(a)]

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

इनपुट लेता है:

  • s: स्ट्रिंग
  • N: अवहेलना करना
  • a: तार के तार जुड़े

चट की एक फ्लैट सूची देता है

मैं तो है एक सूची के रूप सरणी लेने के लिए:

पायथन 2 , 111 108 107 104 बाइट्स

lambda s,n,a:[[x[sum(map(s.count,x))%2]for i in range(n)for x in[[a[j][i],a[~j][~i]]]]for j in range(n)]

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

इनपुट लेता है:

  • s: स्ट्रिंग
  • n: इंट
  • a: वर्णों की 2 डी सूची

चार्ट की 2 डी सूची लौटाता है

— TFeld
स्रोत
1

जावा 10, 126 123 116 बाइट्स

(s,n,m)->{for(var c:s)for(int N=n*n,i,j;N-->0;)if(m[i=N/n][j=N%n]==c){m[i][j]=m[n+~i][n+~j];m[n+~i][n+~j]=c;break;}}

बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट चरित्र-मैट्रिक्स को संशोधित करता है।

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

स्पष्टीकरण:

(s,n,m)->{        // Method with the three parameters and no return-type
  for(var c:s)    //  Loop over the characters given
    for(int N=n*n,i,j;N-->0;)
                  //   Inner loop over the matrix
      if(m[i=N/n][j=N%n]==c){
                  //    If the current character and matrix-value are equals:
        m[i][j]=m[n+~i][n+~j];m[n+~i][n+~j]=c;
                  //     Swap the values in the matrix at indices [i, j] and [n-i-1, n-j-1]
        break;}}  //     Stop the inner loop (go to next iteration of the outer loop)
— केविन क्रूज़सेन
स्रोत
डांग, जावा में कोडिंग! ??!?! +1 डिफ
— NL628
1

पायथन 3 , 122 111 बाइट्स

lambda l,n,A:[[[A[a][b],A[~b][~a]][sum(map(l.count,[A[a][b],A[~b][~a]]))%2]for b in range(n)]for a in range(n)]

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

2 डी सरणी का रिटर्न देता है।

— मजाक कर रहा है
स्रोत
आपको इसे आगे बढ़ाने में सक्षम होना चाहिए .. पाइथन की तुलना में जावा में इनपुट मैट्रिक्स को संशोधित करने का कोई तरीका नहीं है .. पी; आपको आरंभ करने के लिए (और इसे 1 बाइट के बजाय 1 बाइट से कम कर देगा मेरे जावा उत्तर से): हटाना aऔर bऔर का उपयोग कर n+~xऔर n+~yसीधे 2 बाइट्स की बचत होती है: a,b=n+~x,n+~y;A[x][y],A[a][b]=A[a][b],A[x][y]करने के लिएA[x][y],A[n+~x][n+~y]=A[n+~x][n+~y],A[x][y]
— केविन Cruijssen
1

आर , 74 61 बाइट्स

-13 बाइट्स ग्यूसेप के लिए धन्यवाद।

function(s,n,m){for(x in s)m[v]=rev(m[v<-(i=x==m)|rev(i)]);m}

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

के रूप में s, मैट्रिक्स के आकार nऔर मैट्रिक्स के रूप में ही खोज करने के लिए वर्णों का एक वेक्टर इनपुट करता है m। यदि स्ट्रिंग के रूप में पहला तर्क लेना नितांत आवश्यक है , तो यह बहुत मज़ा को बिगाड़ देगा।

— किरिल एल।
स्रोत
सांख्यिक सूचकांकों के बजाय तार्किक का उपयोग करते हुए, मैंने 61 बाइट्स
— Giuseppe
वाह, यह एक भारी सुधार है, बहुत बहुत धन्यवाद।
— किरिल एल।
0

जेली , 15 14 बाइट्स

FW;Ṛi,C$¥¦/ṁḷY

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

पूरा कार्यक्रम।

स्पष्टीकरण:

परिवार कल्याण; ¦i, C $ ¥ Ṛ / linkY मुख्य लिंक। इनपुट: ['अब', 'सीडी'] (बाएं), 'एसी' (दाएं)।
एफडब्ल्यू                    एफ लैटर्न और डब्ल्यू ने इसे एक सूची में रैप किया। वर्तमान मान = ['abcd']।
  ; इसे सही तर्क के साथ समझें। [ 'एबीसीडी', 'एक', 'ग']
          / बाईं ओर से कम करें:
   R | लागू आर पर everse ...
    मैं सूचकांक (बाएं तर्क में दाएं तर्क का) ...
     , सी $ और इसके पूरक सूचकांक।

अंतिम ऑपरेशन के लिए अधिक स्पष्टीकरण की आवश्यकता है। F = का उल्लेख करें Ṛi,C$¥¦, फिर मूल्य के लिए ['abcd','a','c']यह गणना करता है ('abcd' f 'a') f 'c', जिसका विस्तार इस प्रकार है:

Ṛi, C $ $ $ फ़ंक्शन च । बाएं तर्क = 'abcd' और दायाँ तर्क = 'a' मान लें
Ute सबसे पहले, रिवर्स की गणना करें। 'Dcba' प्राप्त करें।
 i ¥ लागू करने के लिए सूचकांकों की गणना करने के लिए, 'abcd' में 'a' का पहला सूचकांक
             ('abcd' i 'a') = 1. (पहला इंडेक्स)
  , C $ फिर जोड़ी (1 C) = 0. (अंतिम सूचकांक)
      0 0 और 1 सूचकांकों पर 'abcd' में 'dcba' लागू करें:

              a bc d
               d cb a
              ^ 1 ^ 0
              ====
              dbca
— user202729
स्रोत
0

रेटिना 0.8.2 , 96 बाइट्स

+`^(.)(.*¶(.|¶)*)((.)((.|¶)*))?\1(?(4)|(((.|¶)*)(.))?)((?<-3>.|¶)*$(?(3).))
$2$11$9$1$6$5$12
1A`

इसे ऑनलाइन आज़माएं! sपूर्णांक के बिना एक नईलाइन-सीमांकित स्ट्रिंग के रूप में स्ट्रिंग और वर्णों की सरणी लेता है N। स्पष्टीकरण: प्रत्येक चरित्र cके sबदले में संसाधित किया जाता है। रेगेक्स, सरणी के सिरों से दो पदों के बराबर होता है, जिनमें से एक है cऔर दूसरा उसका दर्पण है m। इन पात्रों की अदला-बदली की जाती है और उन्हें cहटा दिया जाता है s।

+`

sबदले में प्रत्येक वर्ण को संसाधित करता है ।

^(.)

$1पकड़ लेता है c।

(.*¶(.|¶)*)

$3सरणी में से एक लगाकर में पात्रों के ढेर कब्जा cया m। इन सभी वर्णों $2के बाकी हिस्सों पर कब्जा करता है s।

((.)((.|¶)*))?

यदि mपूर्वता है c, तो $4एक मूल्य है, $5कैद करता है mऔर $6बीच के अक्षर पकड़ता है mऔर c। स्टैक के रूप में $7कैप्चर $6करता है, लेकिन इसके मूल्य का उपयोग नहीं किया जाता है।

\1

c अब सरणी में ही मिलान किया गया है।

(?(4)|(((.|¶)*)(.))?)

यदि mपहले से ही मेल नहीं खाती थी, तो $8वैकल्पिक रूप से एक मूल्य है, जिसमें मामले कब्जा $9से पात्रों कब्जा cकरने के लिए m, $10कैप्चर $9ढेर जो अप्रयुक्त और है के रूप में $11कैप्चर m। मामले में मूल्य वैकल्पिक है cऔर mएक ही चरित्र हैं।

((?<-3>.|¶)*$(?(3).))

$12के अक्षर प्रत्यय को पकड़ता है cऔर m। एक संतुलन समूह का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि $12जब तक $3गहराई थी, यानी उपसर्ग और प्रत्यय समान लंबाई के होते हैं।

$2$11$9$1$6$5$12

पहले के बाकी - टुकड़े फिर वापस एक साथ रखा जाता है sऔर सरणी के उपसर्ग, तो अगर cpreceeded mतो mफिर बीच है, तो c, तो अगर mpreceeded cतो बीच तो mप्रत्यय, तो।

1A`

अब sयह खाली है इसे हटा दिया गया है।

— नील
स्रोत
0

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

स्ट्रिंग Sऔर एक सरणी लेता है Aजैसा कि स्ट्रिंग में शामिल हो गया।

([...S],[...A])=>S.map(c=>[A[j],A[i]]=[A[i=A.indexOf(c)],A[j=A.length+~i]])&&A.join``

कोड स्निपेट दिखाएं

— darrylyeo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.