शब्दों को पार करते हुए


21

इनपुट:

दो तार (नोट: इनपुट का क्रम महत्वपूर्ण है)।

आउटपुट:

दोनों शब्द / वाक्य उनके बीच में एक खाली रेखा के साथ लाइनों पर शुरू होते हैं। वे 'क्षैतिज रूप से' एक-दूसरे के बगल में चलते हैं। लेकिन जब वे एक ही स्थिति में एक ही चरित्र होते हैं, तो वे एक-दूसरे को पार करते हैं, और फिर 'एक-दूसरे के बगल में' चलते रहते हैं।

कंफ्यूज़िंग बोले? आइए एक उदाहरण दें:

इनपुट: Words crossing overऔर Ducks quacking:

Word  quack n 
    s      i g
Duck  cross n  over

जैसा कि आप देख सकते हैं, ये रास्ते हैं:
बहोत बुरा MS पेंट ।।

चुनौती नियम:

  • जब हम फिर से पार कर सकते हैं, तो हम हमेशा सबसे पहले एक सीधी रेखा पर चलते हुए पीछे जाते हैं, इससे पहले कि हम फिर से पार कर सकें (ऊपर परीक्षण केस देखें {1} - जहां ingबराबर है, लेकिन जब हम पार कर चुके हैं i, तो हमें पहले वापस जाना होगा सीधे चलना (इस प्रकार अनदेखा करना n), इससे पहले कि हम फिर से पार कर सकें g)।
  • इनपुट अलग-अलग लंबाई के हो सकते हैं, जिस स्थिति में लंबे समय तक एक सीधी रेखा में चलना जारी रहता है (देखें परीक्षण के मामले 1, 2, 4 और 6)।
  • दोनों इनपुट समान हो सकते हैं (परीक्षण केस 3 देखें)।
  • इनपुट में कोई टैब नहीं होगा और न ही नई लाइनें होंगी।
  • रिक्त स्थान को उन वर्णों के रूप में नजरअंदाज कर दिया जाता है जो समान (एक किनारे के मामले के रूप में) होते हैं , जिस स्थिति में उसके बाद अगला (गैर-स्थान) चरित्र होता है - यदि कोई है - तो इसके बजाय पार हो रहा है (परीक्षण मामलों 3, 5 और 6 देखें)।
  • इनपुट में एक ही स्थिति में कोई भी समीपस्थ (गैर-स्थान) वर्ण नहीं हो सकता है, इस स्थिति में दोनों बस एक सीधी रेखा में क्षैतिज रूप से चलते हैं (परीक्षण मामलों को देखें 2)।
  • यहां तक ​​कि अगर पहला चरित्र बराबर है, तो हम हमेशा दो लाइनों को अलग करते हैं (परीक्षण के मामले 3 और 6 देखें)।
  • अनुगामी रिक्त स्थान और एकल अनुगामी नई-लाइन वैकल्पिक हैं।
  • आप मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII वर्ण (नई-लाइनें और बहिष्कृत टैब) होंगे।
  • आदानों केस-संवेदी होते हैं, इसलिए Aऔर aबराबर नहीं हैं, और (परीक्षण का मामला 7 देखें) पार नहीं होंगे।
  • दोनों इनपुट लंबाई हमेशा कम से कम 2 होगी।
  • इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं। नई लाइनों के साथ एक एकल स्ट्रिंग हो सकता है; एक स्ट्रिंग-सरणी / सूची; STDOUT पर मुद्रित; पात्रों की 2 डी सरणी; आदि।

सामान्य नियम:

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

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

1. Input: "Words crossing over" & "Ducks quacking"

1. Output:
Word  quack n 
    s      i g
Duck  cross n  over

2. Input: "bananas" & "ananas"

2. Output:
bananas

ananas

3. Input: "I see my twin!" & "I see my twin!"

3. Output:
I  e   y  w n 
  s e m  t i !
I  e   y  w n 

4. Input: "Is the weather nice?" & "Not really, no.."

4. Output:
Is th ally, no..
     e
Not r  weather nice?

5. Input: "Codegolf & Programming Puzzles" & "The golfer might solve puzzles"

5. Output:
Code o f & Programming P z l s
    g l                 u z e
The  o fer might solve p z l s

6. Input: "Can you turn the lights off?" & "Can you try to solve this?"

6. Output:
C n  o   urn the  ve  s off?
 a  y u t        l   t 
C n  o   ry to so igh his?

7. Input: "one Ampere" & "two apples"

7. Output:
one Am les
      p
two ap ere

8. Input: "Words crossing" & "Words Quacking"

8. Output:
W r s cross n 
 o d       i g
W r s Quack n 

जवाबों:


4

जाप , 56 47 33 बाइट्स

y ®m+S éBv ©ZꬩZx ?°B:B=c2)¯3÷y

इसे ऑनलाइन टेस्ट करें!दो तारों के एक सरणी के रूप में इनपुट लेता है।

मैं एक कुल मूर्ख हूँ ... y ® एक लाख गुना आसान दो अलग-अलग लंबाई के स्ट्रिंग्स पर उपयोग करना है U¬íV¬@...

व्याख्या

y ®   m+S éBv © Zê¬ © Zx ?° B:B= c2)¯  3à ·  y
y mZ{Zm+S éBv &&Zêq &&Zx ?++B:B=Bc2)s0,3} qR y

              Implicit: U = array of two strings
y             Transpose U, padding the shorter string with spaces in the process.
mZ{        }  Map each pair of chars Z by this function: (we'll call the chars X and Y)
  Zm+S          Append a space to each char, giving X + " " + Y + " ".
  Bv            If B is divisible by 2
  &&Zêq           and Z is a palindrome (X and Y are the same)
  &&Zx ?          and Z.trim() is not empty (X and Y are not spaces):
    ++B           Increment B. B is now odd; the top and bottom strings are swapping.
  :             Otherwise:
    B=Bc2         Ceiling B to a multiple of 2. (0 -> 0, 1 -> 2, 2 -> 2, etc.)
  é       )     Rotate the string generated earlier this many chars to the right.
  s0,3          Take only the first 3 chars of the result.
qR            Join the resulting array of strings with newlines.
y             Transpose rows with columns.
              Implicit: output result of last expression

B वह चर है जो हम किस अवस्था में देखते हैं:

  • B % 4 == 0 शीर्ष पर पहले शब्द का मतलब है, लेकिन स्विच करने के लिए तैयार;
  • B % 4 == 1 इसका मतलब है कि हमने अभी-अभी स्विच किया है;
  • B % 4 == 2 शीर्ष पर दूसरा शब्द का अर्थ है, लेकिन स्विच करने के लिए तैयार;
  • B % 4 == 3 इसका मतलब है कि हमने अभी वापस स्विच किया है।

Bपूर्व निर्धारित होना होता है 11; चूंकि 11 % 4 == 3, पहले कॉलम में हमेशा शीर्ष पर पहला शब्द होता है। हम Bकिसी भी समय शब्दों की स्थिति को बढ़ाते हैं , या किसी भी समय यह विषम (साथ B=c2) है।


6

APL (Dyalog) , 64 बाइट्स

{C←⎕UCS1e' '1 0 1⍀⍵⊖⍨≠\eC(2/⊃l)⎕R(lC⌽⍳2)C(0@0=⌿⍵)∧' '1⌷⍵}

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


यदि तार 3 समान अक्षरों से शुरू होते हैं, तो यह तीसरे अक्षरों को काटता है, दूसरे को नहीं । मैं अनिश्चित हूं कि अगर यह सही परिणाम है, तो मैंने ओपी से पूछा है।
श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद। अब तय होना चाहिए।
आदम

ठीक है, अच्छा समाधान तो। यदि आपके पास समय है, तो शायद आप एक स्पष्टीकरण जोड़ सकते हैं: पी
श्री एक्सकोडर

@ Mr.Xcoder हाँ, मैं हमेशा करता हूँ। (यदि आप मेरा कोई अस्पष्ट उत्तर देखते हैं तो मुझे पिंग करें!)
आदम


4

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

AE⮌θιθAE⮌ηιηW∧θη«A⊟θεA⊟ηδA∧¬∨φ⁼ε ⁼εδφ¿φ«εAθδAηθAδη»«↑↓ε↓↗δ»»¿θ↑↓↑⮌⁺θη

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

AE⮌θιθAE⮌ηιη        Turn the input strings into arrays and reverse them
W∧θη«               While both valus still have characters left
     A⊟θεA⊟ηδ       Extract the next pair of characters
     A∧¬∨φ⁼ε ⁼εδφ   Determine whether this is a crossing point
     ¿φ«εAθδAηθAδη  If so then print the character and switch the value
      »«↑↓ε↓↗δ»»     Otherwise print the two characters apart
¿θ↑↓                Move to print any remaining characters accordingly
↑⮌⁺θη               Print any remaining characters

3

अजगर २ , 217 210 बाइट्स

आधिकारिक बाइट के लिए धन्यवाद

a,b=map(list,input())
n=max(len(a),len(b))
c=[' ']*n
a=(a+c)[:n]
b=(b+c)[:n]
for i in range(1,n):
 if a[i]==b[i]!=' '==c[i-1]:c[i]=a[i];a[i]=b[i]=' ';a[i:],b[i:]=b[i:],a[i:]
print'\n'.join(map(''.join,[a,c,b]))

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


1
1 बाइट पूर्वनिर्धारित करकेs=' '
officialaimm

1
@officialaimm मैंने कुछ बदलाव किए, अब इसकी बाइट काउंट = /
रॉड

2

हास्केल, 142 138 बाइट्स

g(a:b)f(c:d)|f>0,a==c,a>' '=[' ',a,' ']:g d 0b|1<2=[a,' ',c]:g b 1d
g[]_[]=[]
g b f d=g(max" "b)f$max" "d
a&b=[[j!!i|j<-g a 0b]|i<-[0..2]]

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

यह काम किस प्रकार करता है:

g                    -- function g constructs a list of lists of three characters
                     --   the 1st char belongs to the upper line,
                     --   the 2nd char to the middle line and
                     --   the 3rd char to the lower line
      f              -- flag f indicates if crossing is allowed or not
 (a:b) (c:d)         -- strings to cross
  |f>0               -- if crossing is allowed
      ,a==c          -- and both strings start with the same char
           ,a>' '    --   that is not a space
   =[' ',a,' ']      -- return space for upper/lower line and char a for the middle line
      :g d 0b        -- and go on with crossing disabled and strings swapped
 |1<2=               -- else
   [a,' ',c]         -- keep chars in their lines and
      :g b 1d        --  go on with crossing enabled

g[]_[]=[]            -- base case: stop when both strings are empty

g b f d=             -- if exactly one string runs out of characters
 g(max" "b)f$max" "d --   replace it with a single space and retry

a&b=                 -- main function
          i<-[0..2]  -- for each line i from [0,1,2]    
       j<-g a 0b     -- walk through the result of a call to g with crossing disabled
    j!!i             -- and pick the char for the current line  

+1 अच्छा जवाब। ऐसा लगता है कि यह एक छोटा सा बग है, क्योंकि यह अब पार करना शुरू कर देता है जब पहले दो अक्षर समान होते हैं, जैसे परीक्षण 3, 6 और 8 ( टीआईओ )। इसके अलावा, मुझे लगता है कि आप अपने स्पष्टीकरण वाक्य में एक शब्द भूल गए "ऊपरी / निचली रेखा के लिए वापसी स्थान और मध्य रेखा के लिए एक for for for "।
केविन क्रूज़सेन

1
@ केविनक्रूजसेन: बग को खोजने के लिए धन्यवाद। सौभाग्य से इसे ठीक करना आसान है: बस इसके साथ शुरू करें g 0। लापता शब्द के बारे में: "a" जैसा कि "वैरिएबल" नामक एक है, लेकिन यह वास्तव में भ्रामक है, इसलिए मैंने इसे पुन: प्रकाशित किया।
nimi

आह, वह a। :) मैं aचर का संकेत देते समय व्यक्तिगत रूप से अपने स्पष्टीकरण में उपयोग करता हूं, हालांकि आमतौर पर यह बिना पर्याप्त स्पष्ट है। स्पष्टीकरण के लिए धन्यवाद, और मैं वास्तव में इसके लिए एक बहुत आसान बग-फिक्स की उम्मीद कर रहा था।
केविन क्रूज़सेन

यह सुनिश्चित नहीं करना है कि 'a' कैसे करें ( 'बैक-टिक के साथ प्रतिस्थापित किया जा रहा है) अब एक टिप्पणी में, जो कि मैं कहना चाहता था .. (इसलिए मैं अपने कोड-ब्लॉकों के अंदर, चर के चारों ओर बैक-टिक का उपयोग करता हूं।)
केविन क्रूज़सेन

2

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

(a,b,c='',g=([a,...A],[b,...B],w)=>a?w&a==b&a>' '?' '+g(B,A,c+=a):a+g(A,B,1,c+=' '):'')=>g(a,b)+`
`+c+`
`+g(b,a)

Ungolfed:

f=
(a,b,                                    //the inputs
 c='',                                   //c will hold the middle sentence
 g=([a,...A],[b,...B],w)=>               //define a function to walk through the strings
                                         //w will be false if we're at the beginning,
                                         //... or if we've just done a swap
     a?                                  //are there any letters left?
       w&a==b&a>' '?' '+g(B,A,c+=a):     //if we haven't just swapped and the letters match,
                                         //... add the current letter to c 
                                         //... and recurse swapping the strings
                    a+g(A,B,1,c+=' '):   //else add a space to c and continue processing
                    ''
)=>
g(a,b)+'\n'+                             //call g with a, b
c+'\n'+                                  //output c
g(b,a)                                   //call g with b, a

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


1

एपीएल (डायलॉग) , 50 बाइट्स

{3↑(0,+\2∨/2|{⍵⌈a×1+11↓⍵}⍣≡a←>⌿2=⌿3↑⍵)⊖⍵⍀⍨¯1*⍳4}

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

⍵⍀⍨¯1*⍳4 मैट्रिक्स देता है:

Words.crossing.over
...................
Ducks.quacking.....
...................

(डॉट्स रिक्त स्थान का प्रतिनिधित्व करते हैं)। इसके स्तंभों को विभिन्न राशियों से घुमाया जाएगा ताकि पहली तीन पंक्तियाँ वांछित परिणाम की तरह दिखें - इसलिए3↑ शुरुआत करीब। बाकी एल्गोरिथ्म रोटेशन की मात्रा की गणना करता है।

Parens के भीतर: 3↑⍵जैसे एक मैट्रिक्स बनाता है

Words.crossing.over
Ducks.quacking.....
...................

और 2=⌿इसकी पंक्तियों की तुलना जोड़ीदार, यानी पहली स्ट्रिंग बनाम दूसरी स्ट्रिंग और दूसरी स्ट्रिंग बनाम ऑल-स्पेस पंक्ति।

0 0 0 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 1 1 1

हम इसमें रुचि रखते हैं जहां पूर्व सच है (1) और बाद वाला झूठा (0), इसलिए हम >⌿नाम के साथ एक बूलियन वेक्टर प्राप्त करने के लिए कम करते हैं a

0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0

अब, 1-एस के प्रत्येक खिंचाव में हमें समवर्ती घटनाओं को शून्य करने की आवश्यकता है क्योंकि कोई भी दो मोड़ एक दूसरे के बगल में नहीं हो सकते हैं। पहले हम एक नंबरिंग प्राप्त करते हैं जैसे:

0 0 0 0 1 0 0 0 0 0 0 1 2 3 0 0 0 0 0

, जब तक परिणाम स्थिर नहीं हो जाता, तब तक a[i]साथ a[i]*max(a[i-1]+1, a[i])रहना {⍵⌈a×1+1,¯1↓⍵}⍣≡, और हम उस मोड 2 को लेते हैं:2|

0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0

अब हम जानते हैं कि ट्विस्ट कहां होगा। हम प्रत्येक 1को बाईं ओर कॉपी करते हैं - 2∨/ (जोड़ीदार "या"):

0 0 0 0 1 1 0 0 0 0 0 1 1 1 1 0 0 0 0

और आंशिक रकम की गणना करें - +\

0 0 0 0 1 2 2 2 2 2 2 3 4 5 6 6 6 6 6

वह हमें स्तंभ रोटेशन की मात्रा देता है जिसकी हमें शुरुआत में आवश्यकता थी। मोडुलो 4 निहित है।


अच्छा! यहां तक ​​कि 14 बाइट्स भी आदम से छोटी हैं । क्या आप एक स्पष्टीकरण जोड़ सकते हैं (मुझे यकीन है कि आप इसे वैसे ही बना रहे हैं जैसा कि हम बोलते हैं, लेकिन अगर आप नहीं हैं ..?)
केविन क्रूज़सेन

स्पष्टीकरण केवल यह पता लगाने का आनंद लेता है कि यह आपके दम पर कैसे काम करता है ... :)
ngn

1

पर्ल 5 , 211 बाइट्स

@a=map[/./g],<>;$b=1;($f,@{$r[$i]})=$a[0][$i]eq$a[1][$i]&&$f&&$a[0][$i]ne$"?(0,$",$a[0][$i],$",$t=$b++):(1,$a[$t%2][$i],$",$a[$b%2][$i]),$i++while$a[0][$i]||$a[1][$i];for$i(0..2){print$r[$_][$i]for 0..$#r;say''}

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

# पर्ल 5 , 234 बाइट्स

बग केविन ने बताया

@a=map[/./g],<>;$l=@{$a[0]}>@{$a[1]}?@{$a[0]}:@{$a[1]};$b=1;@{$r[$_]}=$a[0][$_]eq$a[1][$_]&&$_&&$r[$_-1][1]eq$"&&$a[0][$_]ne$"?($",$a[0][$_],$",$t=$b++):($a[$t%2][$_],$",$a[$b%2][$_])for 0..$l;for$i(0..2){print$r[$_][$i]for 0..$l;say}

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


नमस्ते, जब मैं परीक्षण के मामले का परीक्षण करने की कोशिश करता हूं तो मुझे "Can you turn the lights off?" & "Can you try to solve this?"एक त्रुटि मिल रही है: Modification of non-creatable array value attempted, subscript -1 at .code.tio line 1, <> line 2.क्या यह एक बग है, या क्या मैं कुछ गलत कर रहा हूं? यहाँ TIO है।
केविन क्रूज़सेन

1
बग। जब पहले दो अक्षर समान थे, तो एक सरणी सबस्क्रिप्ट -1 था, जो कि सरणी में डेटा होने पर ही मान्य होता है। इसे 4 और बाइट्स के साथ तय किया।
Xcali

0

05AB1E , 31 बाइट्स

ζεËNĀ¾Èyðå_Pi¼ë¾É½}yð«S¾._¨}øJ»

पोर्ट ऑफ @ETHproductions के Japt उत्तर , लेकिन दो छोटे अंतरों के साथ:
1) मैं स्ट्रिंग्स की सूची के बजाय वर्णों की 2 डी सूची के रूप में इनपुट लेता हूं।
2) counter_variable05AB1E में 0, डिफ़ॉल्ट रूप से, Japt में 11 (या 3) के बजाय है B, इसलिए इसे मैप के अंदर अतिरिक्त चेक के रूप में जोड़ा गया है (और मैं बाएं के बजाय दाईं ओर घुमाता हूं)।

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

स्पष्टीकरण:

ζ                  # Zip/transpose (swapping rows/columns) the (implicit) input-list
                   # with space filler by default to create pairs
 ε          }      # Map each pair `y` to:
  Ë                #  Check if both values in the pair are equal
  NĀ               #  Check if the map-index is not 0
  ¾È               #  Check if the counter_variable is even
  yðå_             #  Check if the pair contains no spaces " "
  Pi               #  If all checks are truthy:
    ¼              #   Increase the counter_variable by 1:
   ë               #  Else:
    ¾É             #   Check if the counter_variable is odd
      ½            #   And if it is: increase the counter_variable by 1
   }               #  Close the if-else
    yð«            #  Add a space after both characters in the pair
       S           #  Convert it to a list of characters (implicitly flattens)
        ¾._        #  Rotate this list the counter_variable amount of times towards the right
           ¨       #  And then remove the last character
             ø     # Zip/transpose; swapping rows/columns
              J    # Join each inner character-list to a single string
               »   # Join everything by newlines (and output implicitly)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.