रनिंग मर्ज कंफर्ट

Question

जब दो फाइल को मर्ज करने के लिए git जैसे टूल का उपयोग किया जाता है, तो एक संघर्ष का पता लगाया जा सकता है और मर्ज के परिणाम में जोड़ा जा सकता है।

इन दो फ़ाइलों का एक मर्ज:

मेरी फाइल:

Common line of code 1
Common line of code 2
my lines
Common line of code 3
Common line of code 4

उनकी फ़ाइल:

Common line of code 1
Common line of code 2
their lines
Common line of code 3
Common line of code 4

परिणाम होगा:

Common line of code 1
Common line of code 2
<<<<<<< Mine
my lines
=======
their lines
>>>>>>> Theirs
Common line of code 3
Common line of code 4

देखें संघर्ष मार्कर लाइन्स

मेरा इस संघर्ष को हल करने से यह फ़ाइल बन जाएगी:

Common line of code 1
Common line of code 2
my lines
Common line of code 3
Common line of code 4

उनके साथ इस संघर्ष को हल करने से यह फ़ाइल बन जाएगी:

Common line of code 1
Common line of code 2
their lines
Common line of code 3
Common line of code 4

इस चुनौती का उद्देश्य एक स्रोत फ़ाइल लिखना है जिसमें एक संघर्ष होता है और फिर भी संकलन / निष्पादित होता है।

एक स्रोत फ़ाइल लिखें जो:

1. एक वैध, दो तरह से, संघर्ष उचित पैच संघर्ष मार्कर द्वारा चिह्नित होता है ( <<<<<<<, =======, >>>>>>>) मेरा और मार्कर के बाद उनका फ़ाइल वर्णनकर्ता वैकल्पिक हैं।
2. यदि संकलक स्रोत का हिस्सा बने रहते हैं, तो वे त्रुटियों / चेतावनियों के बिना संकलित / निष्पादित करते हैं
3. यदि मेरा उपयोग करके संघर्ष को हल किया जाता है, तो त्रुटियों / चेतावनियों के बिना संकलन / क्रियान्वयन
4. संकलन / त्रुटियों या चेतावनियों के बिना निष्पादित करता है यदि संघर्ष उनका उपयोग करके हल किया जाता है
5. जब विवादित फ़ाइल को संकलित / निष्पादित करता है तो आउटपुट "हैलो संघर्ष"
6. "हैलो माइन" को आउटपुट करता है जब खदान संस्करण को संकलित / निष्पादित करता है
7. जब उनके संस्करण को संकलित / निष्पादित कर रहा है, तो "हेलो थिर" को आउटपुट करता है

मार्कर को स्रोत फ़ाइल में इस तरह से स्थित होना चाहिए कि kdiff3 संघर्ष को पहचानता है।

मानक खामियों को मना किया जाता है।

सबसे छोटा कोड जीतता है।

स्कोर परस्पर विरोधी स्रोत की लंबाई है

Comments

क्या फंक्शन सबमिशन की अनुमति है, या सिर्फ पूर्ण कार्यक्रम हैं?

— जैकब

@ जाकोब - इसे चलाना / चलाना संभव होना चाहिए। तो अगर कोई REPL है जो फ़ंक्शन (या सिर्फ अभिव्यक्ति) को निष्पादित कर सकता है, तो सुनिश्चित करें।

— एरनो

Answer 1

जेली , 51 बाइट्स

<<<<<<<
“½&;»
“£<Ø»
=======

“8ẉI»
>>>>>>>
“¢5Ṛ»;2£

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

व्याख्या

यहां संघर्ष मार्करों को तैनात किया जाता है ताकि तीन लाइनों में से एक कार्यक्रम हल होने के बाद कार्यक्रम की दूसरी पंक्ति बन जाए; यह एक स्थिर, नामित होगा 2£। मूल कार्यक्रम की दूसरी पंक्ति स्ट्रिंग " Conflict"(जेली के संकुचित संकेतन में) को एन्कोड करती है ; तीसरी पंक्ति स्ट्रिंग को एनकोड करती है " Mine"(यह दूसरी पंक्ति बन जाएगी यदि संघर्ष को मेरे रूप में हल किया जाए); छठी पंक्ति स्ट्रिंग को एन्कोड करती है " Theirs"(और यदि दूसरी समस्या उनके रूप में हल हो जाती है तो दूसरी पंक्ति बन जाएगी)।

मुख्य कार्यक्रम हमेशा अंतिम पंक्ति होता है, चाहे कितनी भी लाइनें हटाए जाने से पहले क्यों न हों। यह संपीड़ित एन्कोडिंग लेता है "Hello", और इस प्रकार वांछित उत्पादन का उत्पादन करता है, ( ;) इसके मूल्य को जोड़ता है 2£।

Answer 2

जावास्क्रिप्ट (ईएस 6), 102 94 93 90 बाइट्स

console.log('Hello',(a=`
<<<<<<<
Mine
=======
Theirs
>>>>>>>
Conflict`.split`
`)[6]||a[1])

यदि संघर्ष हल हो गया है, तो कोई छठी पंक्ति नहीं है, इसलिए यह अब पहली पंक्ति को प्रिंट करता है। संपादित करें: @nderscore के लिए 3 बाइट्स सहेजे गए।

Comments

नियमित अभिव्यक्ति का रचनात्मक उपयोग!

— एर्नो

@ErnodeWeerd ओह, मैंने अभी इसे बदल दिया ...

— नील

:) कोई चिंता नहीं, मुझे यह देखकर खुशी हुई

— Erno

-3 बाइट्स:console.log('Hello',(a=`...`)[6]||a[1])

— अंडरस्कोर

Answer 3

ब्रेकीलॉग , 68 67 66 बाइट्स

"Hello "wċ₂↰₁w∨"Conflict"w
<<<<<<<
"Mine"
=======
"Theirs"
>>>>>>>

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

"Hello Mine"यहाँ संस्करण की कोशिश करो

"Hello Theirs"यहाँ संस्करण की कोशिश करो

व्याख्या

शुक्र है, <<<<<<<, =======और >>>>>>>Brachylog में सभी वैध शासन परिभाषाएं दी गई हैं। वे क्रमशः मतलब:

• इनपुट एक निहित संस्करण से कम है, खुद से कम है ..., आदि, आउटपुट से कम है।
• इनपुट के सभी तत्व समान हैं, और इनपुट के सभी तत्व समान हैं, और ..., और इनपुट = आउटपुट
• पहले की तरह ही लेकिन इसके बजाय अधिक से अधिक।

यदि हम संघर्षों को दूर करते हैं, तो हम दूसरी पंक्ति के साथ "Mine"या उस "Theirs"पर समाप्त होते हैं , जिसका अर्थ है कि वे विधेय संख्या 1 हो जाते हैं ↰₁। पहली पंक्ति के साथ विधेय करना इसके इनपुट और आउटपुट को एकीकृत करेगा Mine/ Theirs, जिसके साथ हम तब प्रिंट करते हैंw ।

यदि हम ↰₁विवादित फ़ाइल पर कॉल करते हैं, तो हम कॉल करना समाप्त करते हैं <<<<<<<। इसलिए हम इनपुट के रूप में एक स्ट्रिंग के साथ विधेय को कहते हैं (उपयोग ċ₂- स्ट्रिंग के लिए मोटे)। <इनपुट के रूप में एक स्ट्रिंग के साथ विफल हो जाएगा। फिर हमने ∨"Conflict"wमुख्य विधेय में एक अव्यवस्था डाल दी जिसमें कहा गया है कि यदि 1 विधेय विफल हो जाता है, तो हम Conflictइसके बजाय प्रिंट करते हैं। ↰₁एक स्ट्रिंग के साथ इनपुट के रूप में "Mine"या "Theirs"लाइनों के लिए विफल नहीं होगा क्योंकि वे तार हैं।

Answer 4

PHP, 74 65 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है

Hello<?='
<<<<<<<
2:<?PU_~
=======
+;73"&_~
>>>>>>>
'^~ıǼ¡Ñ»¬áü;

एक फ़ाइल में स्टोर करें और इस तरह से चलाएं:

php -nf conflict.php

व्याख्या

Hello       # Print "Hello"
<?='        # Print result of expression
<<<<<<<     # String with merge conflict
2:<?PU_~
=======
+;73"&_~
>>>>>>>
'
^           # XOR that string with...
~ıǼ¡Ñ»¬áü; # ... this string, negated.

निम्नलिखित 3 में से किसी एक में बाइनरी XOR का परिणाम है:

'
<<<<<<<
' ^ ~'ıǼ¡Ñ»¬áü'
==> ' Conflict' 
--------------------------------------------------------------------------
'
2:<?PU_~' ^ ~'ıǼ¡Ñ»¬áü'
==> ' Mine' (right padded with nul bytes)
--------------------------------------------------------------------------
'
+;73"&_~' ^ ~'ıǼ¡Ñ»¬áü'
==> ' Theirs' (right padded with nul bytes)

बदलाव

• तार पर द्विआधारी तर्क का उपयोग करके 9 बाइट्स सहेजे गए

Comments

किसी दिन PHP में एक =======ऑपरेटर होगा, और फिर यह थोड़ा आसान हो जाएगा।

— जेकब

Answer 5

पिप , 61 बाइट्स

"Hello ".("Conflict
<<<<<<<
Mine
=======
Theirs
>>>>>>>
"^n7)

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

बीच सब कुछ ""एक स्ट्रिंग है। हम नए सिरे पर बड़ी स्ट्रिंग को विभाजित करते हैं ( "..."^n) और 7 वें तत्व को साइक्लिकल इंडेक्सिंग ( (___7)) के साथ लेते हैं । परस्पर विरोधी संस्करण के लिए, सात लाइनें हैं, इसलिए सूचकांक 7 सूचकांक 0 के बराबर है और हम प्राप्त करते हैं Conflict। हल किए गए संस्करणों के लिए, तीन लाइनें हैं, इसलिए सूचकांक 7 सूचकांक 1 के बराबर है और हमें मिलता है Mine/ Theirs। फिर "Hello "सामने और ऑटोप्रिंट को समतल करें।

Comments

बहुत रचनात्मक, मुझे चक्रीय अनुक्रमण पसंद है।

— एर्नो

Answer 6

बैच, 133 129 बाइट्स

@set s=Theirs
@goto t
<<<<<<<
:t
@set s=Mine
@goto m
=======
:m
@set s=Conflict
@goto t
>>>>>>>
:t
:m
echo Hello %s%

स्पष्टीकरण: यह gotoविवरण अगले लेबल पर जाता है। संघर्ष के मामले में, यह बस संघर्ष मार्करों को छोड़ देता है, और sइसका अंतिम मूल्य प्राप्त करता है। माइन के साथ हल करने के मामले में, गोटो का कोई प्रभाव नहीं होता है, लेकिन अंतिम setअब मौजूद नहीं है, इसलिए परिणाम मेरा है। थेरिस के साथ हल करने के मामले में इनबिल्ट gotoशेष को बायपास करता है setइसलिए परिणाम इसका प्रारंभिक मूल्य है। संपादित करें: @DLosc के लिए 4 बाइट्स सहेजे गए।

Comments

अच्छा! क्या आप इसके बजाय हटा सकते हैं :cऔर कर सकते हैं @goto t?

— 10

@ डोस ओह, इसलिए बैच पहले के बजाय अगले लेबल पर जाता है? साफ!

— नील

मुझे नहीं पता - मैंने इसका परीक्षण नहीं किया है। मैं पूरी तरह से गलत हो सकता हूं।

— DLosc

Answer 7

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

print 'Hello','''
<<<<<<<
Mine
=======
Theirs
>>>>>>>
Conflict'''.split('\n')[1::5][-1]

छठी या (अब) पहली पंक्ति को उपयुक्त के रूप में प्रिंट करता है।

Comments

यह "हैलो" भाग को प्रिंट नहीं करता है ...

— एर्नो

@ErnodeWeerd क्षमा करें, मैंने अपने दूसरे उत्तर में भी वह गलती की है, और इसे ठीक करना भूल गया।

— नील

क्या हैलो और जो कुछ भी है, उसके बीच एक स्थान है?

— एर्नो

@ErnodeWeerd पायथन 2 printकथन हमेशा विभाजक के रूप में एक स्थान का उपयोग करता है (और एक अनुगामी न्यूलाइन; पायथन 3 का printकार्य आपको विभाजक और टर्मिनेटर चुनने की अनुमति देता है)।

— नील

Answer 8

.COM opcode, 77 बाइट्स

0000h: B4 09 BA 17 01 CD 21 BA 1F 01 80 3E 1F 01 3C 75 ; ......!....>..<u
0010h: 03 BA 44 01 CD 21 C3 48 65 6C 6C 6F 20 24 0A 3C ; ..D..!.Hello $.<
0020h: 3C 3C 3C 3C 3C 3C 0A 4D 69 6E 65 24 0A 3D 3D 3D ; <<<<<<.Mine$.===
0030h: 3D 3D 3D 3D 0A 54 68 65 69 72 24 0A 3E 3E 3E 3E ; ====.Their$.>>>>
0040h: 3E 3E 3E 0A 43 6F 6E 66 6C 69 63 74 24          ; >>>.Conflict$

        org 100h
        mov ah, 9
        mov dx, str1
        int 21H
        mov dx, str2
        cmp [str2], byte '<'
        jne $+5
        mov dx, str3
        int 21H
        ret

str1    db 'Hello $', 10
str2    db '<<<<<<<', 10
        db 'Mine$', 10
        db '=======', 10
        db 'Their$', 10
        db '>>>>>>>', 10
str3    db 'Conflict$'

यदि <<<<<<<अनुमति के बाद एक स्थान , 75 बाइट्स

0000h: B4 09 BA 0D 01 CD 21 BA 1E 01 CD 21 C3 48 65 6C ; ......!....!.Hel
0010h: 6C 6F 20 24 0A 3C 3C 3C 3C 3C 3C 3C 20 0A 43 6F ; lo $.<<<<<<< .Co
0020h: 6E 66 6C 69 63 74 24 4D 69 6E 65 24 0A 3D 3D 3D ; nflict$Mine$.===
0030h: 3D 3D 3D 3D 0A 2A 2A 2A 2A 2A 2A 2A 2A 54 68 65 ; ====.********The
0040h: 69 72 24 0A 3E 3E 3E 3E 3E 3E 3E                ; ir$.>>>>>>>

        org 100h
        mov ah, 9
        mov dx, str1
        int 21H
        mov dx, str2
        int 21H
        ret

str1    db 'Hello $', 10
        db '<<<<<<< ', 10
str2    db 'Conflict$'
        db 'Mine$', 10
        db '=======', 10
        db '********Their$', 10
        db '>>>>>>>'     

Comments

अच्छा है! क्या आप असेंबली वर्जन को जोड़ पाएंगे, मुझे निर्देश पढ़ने में मज़ा आएगा :)। हां, स्पेस की अनुमति दी गई प्रतीत होती है (चश्मा उतना स्पष्ट नहीं है जितना मैं उन्हें पसंद करूंगा)

— एर्नो

Answer 9

रेटिना , 57 बाइट्स

Hello 
$
<<<<<<<
Mine
=======
Theirs
>>>>>>>
<+
Conflict

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

"मेरा" संस्करण का प्रयास करें

"उनके" संस्करण का प्रयास करें

संघर्ष कार्यक्रम की व्याख्या

जैसा कि अक्सर रेटिना के साथ होता है, इस कार्यक्रम में कई प्रतिस्थापित चरण होते हैं।

Hello 

खाली / गैर-मौजूद इनपुट से बदलें Hello ।

$
<<<<<<<

वर्किंग स्ट्रिंग के अंत को बदलें <<<<<<<

Mine
=======

बदलें Mineके साथ =======। चूंकि Mineकाम करने वाली स्ट्रिंग में कहीं भी दिखाई नहीं देता है, यह कुछ भी नहीं करता है।

Theirs
>>>>>>>

बदलें Theirsके साथ >>>>>>>। साथ ही सौदा Mine; Theirsप्रकट नहीं होता है, इसलिए प्रतिस्थापन कुछ नहीं करता है।

<+
Conflict

के एक दृश्य की जगह <के साथ Conflict। हमने <<<<<<<पहले प्रतिस्थापन पर स्ट्रिंग के अंत में जोड़ा , इसलिए काम करने वाला स्ट्रिंग बन जाता है Hello Conflict, जो कि कार्यक्रम के अंत में अनुमानित रूप से आउटपुट है।

मेरा / उनके कार्यक्रमों की व्याख्या

जब संघर्ष हल हो जाता है, तो कोड इस तरह दिखाई देगा:

Hello 
$
Mine
<+
Conflict

Hello 

पहले की तरह ही, स्ट्रिंग से शुरू Hello।

$
Mine

अब अपील <<<<<<<करने के बजाय Hello , हम अपील करते हैं Mine।

<+
Conflict

अगला, हम के <साथ एक क्रम को प्रतिस्थापित करते हैं Conflict। लेकिन <स्ट्रिंग में कोई एस नहीं हैं , इसलिए कुछ भी नहीं होता है।

कार्यशील स्ट्रिंग, Hello Mineअनुमानित रूप से आउटपुट है। "उनकी" कार्यक्रम उसी तरह से काम करता है।

Answer 10

OIL , 88 80 77 बाइट्स

4
2
Hello 
10
Conflict
16
16
8
4
11
3
<<<<<<<
Mine
=======
Theirs
>>>>>>>
4
4

4 2मुद्रण रेखा 2 ( Hello) है, 10परीक्षण करता है कि क्या लाइन 0 ( 4) लाइन 16 के साथ समान है (एक जिसमें 4संघर्ष मौजूद है) और परिणाम के आधार पर या तो लाइन 16 या लाइन 8 पर कूदता है। यदि यह अस्तित्व में है, तो 4 4प्रिंट्स लाइन 4 ( Conflict)। यदि यह नहीं था, 4 11तो क्या विलय किया गया था, और बाहर निकलता है , इसके आधार पर Mineया तो प्रिंट Theirsकरता 3है।

Answer 11

जावा 145 बाइट्स

()->{String s = "Hello ";/*
<<<<<<<
*/s+="Mine";/*
=======
*/s+="Theirs";/*
>>>>>>>
*/if(s.length()>15)s="Hello Conflict";System.out.println(s);}

जावा में कोई मल्टीलाइन स्ट्रिंग्स नहीं है इसलिए कुछ कमेंट ट्रिकरी की जरूरत थी

Comments

*तीसरी लाइन पर अतिरिक्त का क्या कारण है ? मुझे लगता है कि बस */s+="Mine";/*काम करेगा।

— 14:97 पर CAD97

जब टिप्पणी लाइनों से बचे हुए थे समान लाइनों से बचने के लिए अलग लाइनें थीं (पोस्ट करने से पहले और भूल गए), उस संकेत के लिए thx और 3 बाइट्स

— मास्टरएक्स 244

Answer 12

बैश, 76 बाइट्स

golfed

sed 's/^/Hello /;s/<\+/Conflict/;q'<<E
<<<<<<<
Mine
=======
Theirs
>>>>>>>
E

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

स्रोत पाठ को sed करने के लिए, यहाँ doc का उपयोग करता है ।

सेड "हेलो" के साथ पढ़ी जाने वाली पहली लाइन को प्रीपेन्ड करेगा, <<<<<<<स्ट्रिंग को "कंफ्लिक्ट" से बदल देगा और फिर छोड़ देगा ( q)।

यह ऑनलाइन की कोशिश करो!

Answer 13

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

golfed

alert("Hello "+((T=`\
<<<<<<<
Mine
=======
Theirs
>>>>>>>
`)[1]>"<"?T:"Conflict"))

कोशिश करो

alert("Hello "+((T=`\
<<<<<<<
Mine
=======
Theirs
>>>>>>>
`)[1]>"<"?T:"Conflict"))

alert("Hello "+((T=`\
Mine
`)[1]>"<"?T:"Conflict"))

alert("Hello "+((T=`\
Theirs
`)[1]>"<"?T:"Conflict"))

Answer 14

जावा 8, 108 बाइट्स

यह एक मेमना है जो खाली इनपुट स्वीकार करता है और कुछ भी नहीं लौटाता है।

n->System.out.print("Hello "+",Mine,Theirs,Conflict".split(",")[/*
<<<<<<<
*/1/*
=======
*/+2/*
>>>>>>>
*/])

यह ऑनलाइन की कोशिश करो

मास्टरएक्स 244 के जावा समाधान से प्रेरित दृष्टिकोण ।

Answer 15

सी (जीसीसी), 110 बाइट्स

कार्य प्रस्तुत करना।

f(){char*s[]={0,"Mine","Theirs","Conflict"};printf("Hello %s",s[/*
<<<<<<<
*/1/*
=======
*/+2/*
>>>>>>>
*/]);}

मास्टरएक्स 244 के जावा समाधान से प्रेरित दृष्टिकोण।

TIOs

• मेरी
• उन लोगों के
• संघर्ष

Comments

अच्छा है! मल्टी-लाइन टिप्पणियों का स्मार्ट उपयोग।

— एर्नो

Answer 16

पर्ल ५ , 68 बाइट्स

यह समझने के बाद कि प्रत्येक सीमांकक के 6 के साथ संस्करण इच्छित के रूप में काम करता है, लेकिन वास्तविक 7 सीमांकक के साथ, यह नहीं करता है ... O ...

say"Hello ",q
<<<<<<<
!Mine!;0
=======
!Theirs!;0
>>>>>>>
&&Conflict

संघर्ष ऑनलाइन कोशिश करो!

ऑनलाइन कोशिश करो!

ऑनलाइन itheirs की कोशिश करो!