Quando si utilizza uno strumento come git per unire due file, è possibile rilevare un conflitto e aggiungerlo al risultato dell'unione.

Una fusione di questi due file:

il mio file:

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

il loro file:

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

comporterebbe:

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

Vedi Linee di segnalazione dei conflitti

Risolvere questo conflitto con il mio creerebbe questo file:

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

Risolvere questo conflitto con Theirs creerebbe questo file:

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

L'obiettivo di questa sfida è quello di scrivere un file sorgente che contenga un conflitto e compili / esegua ancora.

Scrivi un file sorgente che:

1. contiene una valida, a due vie, il conflitto segnata dalle appropriate marcatori delle patch di conflitto ( <<<<<<<, =======, >>>>>>>) La mia e la loro descrittori di file dopo i marcatori sono opzionali.
2. compila / esegue senza errori / avvisi se i marker rimangono parte della sorgente
3. compila / esegue senza errori / avvisi se il conflitto viene risolto utilizzando il mio
4. compila / esegue senza errori / avvisi se il conflitto viene risolto usando il loro
5. genera "Hello Conflict" durante la compilazione / esecuzione del file in conflitto
6. genera "Hello Mine" durante la compilazione / esecuzione della versione miniera
7. genera "Hello Theirs" durante la compilazione / esecuzione della loro versione

I marker dovrebbero trovarsi nel file sorgente in modo tale che kdiff3 riconosca il conflitto.

Sono vietate le scappatoie standard .

Vince il codice più corto.

Il punteggio è la lunghezza della fonte in conflitto

Gelatina , 51 byte

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

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

Provalo online!

Spiegazione

I marker di conflitto qui sono posizionati in modo che una delle tre righe diventi la seconda riga del programma dopo che il conflitto è stato risolto; questa sarà una costante, chiamata 2£. La seconda riga del programma originale codifica la stringa " Conflict"(nella notazione compressa di Jelly); la terza riga codifica la stringa " Mine"(questa diventerà la seconda riga se il conflitto viene risolto come mio); la sesta riga codifica la stringa " Theirs"(e diventerà la seconda riga se il conflitto viene risolto come loro).

Il programma principale è sempre l'ultima riga, indipendentemente dal numero di righe prima che vengano eliminate. Prende la codifica compressa di "Hello"e ne aggiunge ( ;) il valore 2£, producendo così l'output desiderato.

JavaScript (ES6), 102 94 93 90 byte

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

Se il conflitto è stato risolto, allora non c'è la sesta riga, quindi stampa invece la prima riga. Modifica: salvato 3 byte grazie a @nderscore.

Brachylog , 68 67 66 byte

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

Provalo online!

Prova "Hello Mine"qui la versione

Prova "Hello Theirs"qui la versione

Spiegazione

Per fortuna, <<<<<<<, =======e >>>>>>>sono tutte le definizioni normativa vigente in Brachylog. Significano rispettivamente:

• L'input è inferiore a una variabile implicita, è di per sé inferiore a ..., ecc., Di per sé inferiore all'output.
• Tutti gli elementi dell'input sono uguali e tutti gli elementi dell'input sono uguali e ... e Input = Output
• Come il primo ma maggiore di invece.

Se rimuoviamo i conflitti, finiamo con "Mine"o "Theirs"sulla seconda riga, il che significa che diventano numero predicato 1. Chiamare quel predicato con ↰₁sulla prima riga unificherà il suo input e output con Mine/ Theirs, con cui poi stamperemo w.

Se chiamiamo ↰₁il file in conflitto, finiamo per chiamare <<<<<<<. Quindi chiamiamo quel predicato con una stringa come input (usando ċ₂- coerce to string). <fallirà con una stringa come input. Quindi inseriamo una disgiunzione ∨"Conflict"wnel predicato principale che afferma che se il predicato 1 fallisce, stampiamo Conflictinvece. ↰₁con una stringa come input non avrà esito negativo per le righe "Mine"o "Theirs"perché sono stringhe.

PHP, 74 65 byte

Nota: utilizza la codifica IBM-850

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

Archivia in un file ed eseguilo in questo modo:

php -nf conflict.php

Spiegazione

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

Il XOR binario risulta in uno dei seguenti 3:

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

Ritocchi

• Salvato 9 byte usando la logica binaria sulle stringhe

Pip , 61 byte

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

Provalo online!

Tutto in mezzo ""è una stringa. Dividiamo la stringa grande su newline ( "..."^n) e prendiamo il 7 ° elemento con l'indicizzazione ciclica ( (___7)). Per la versione in conflitto, ci sono sette righe, quindi l'indice 7 è equivalente all'indice 0 e otteniamo Conflict. Per le versioni risolte, ci sono tre righe, quindi l'indice 7 è equivalente all'indice 1 e otteniamo Mine/ Theirs. Quindi concatenare "Hello "sul davanti e stampare automaticamente.

Lotto, 133 129 byte

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

Spiegazione: L' gotoistruzione passa all'etichetta successiva che può trovare. Nel caso del conflitto, questo finisce per saltare gli indicatori di conflitto e sottiene il suo valore finale. Nel caso di risolvere con il mio, i goto non hanno alcun effetto, ma l'ultimo setnon esiste più, quindi il risultato è il mio. Nel caso di risolvere con Theirs l'inital gotoignora il rimanente, setquindi il risultato è il suo valore iniziale. Modifica: salvato 4 byte grazie a @DLosc.

Python 2, 88 87 byte

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

Stampa la sesta o (ora) prima riga come appropriato.

.COM opcode, 77 byte

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$'

Se è <<<<<<<consentito uno spazio dopo , 75 byte

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 '>>>>>>>'     

Retina , 57 byte

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

Provalo online!

Prova la versione "Miniera"

Prova la versione "Loro"

Spiegazione del programma Conflict

Come spesso accade con Retina, questo programma contiene molte fasi di sostituzione.

Hello 

Sostituire l'ingresso vuoto / inesistente con Hello .

$
<<<<<<<

Sostituisci la fine della stringa di lavoro con <<<<<<<

Mine
=======

Sostituisci Minecon =======. Dal momento Mineche non appare da nessuna parte nella stringa di lavoro, questo non fa nulla.

Theirs
>>>>>>>

Sostituisci Theirscon >>>>>>>. Stesso accordo con Mine; Theirsnon appare, quindi la sostituzione non fa nulla.

<+
Conflict

Sostituisci una sequenza di <con Conflict. Abbiamo aggiunto <<<<<<<alla fine della stringa la prima sostituzione, così diventa la stringa di lavoro Hello Conflict, che viene implicitamente emessa alla fine del programma.

Spiegazione dei programmi Mine / Theirs

Quando il conflitto viene risolto, il codice sarà simile al seguente:

Hello 
$
Mine
<+
Conflict

Hello 

Come prima, a partire dalla stringa Hello.

$
Mine

Ora invece di aggiungere <<<<<<<a Hello , aggiungiamo Mine.

<+
Conflict

Successivamente, sostituiamo una sequenza di <con Conflict. Ma non ci sono <s nella stringa, quindi non succede nulla.

La stringa di lavoro Hello Mine, viene implicitamente emessa. Il programma "Theirs" funziona allo stesso modo.

OLIO , 88 80 77 byte

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

4 2sta stampando la riga 2 ( Hello), 10verifica se la riga 0 ( 4) è identica alla riga 16 (quella che contiene a 4quando esiste il conflitto) e passa alla riga 16 o alla riga 8 in base al risultato. Se esisteva, 4 4stampa la riga 4 ( Conflict). In caso contrario, 4 11stampa o Mineo Theirs, a seconda di ciò che è stato unito, ed 3esce.

Java 145 byte

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

Java non ha stringhe multilinea quindi era necessario qualche trucco per i commenti

Bash, 76 byte

golfed

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

Come funziona

Utilizza qui doc , per alimentare il testo sorgente su sed .

Sed antepone la prima riga che legge con "Hello", sostituisce la <<<<<<<stringa con "Conflict" e quindi esce (q ).

Provalo online!

ES6 (Javascript), 83, 82 byte

golfed

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

Provalo

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

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

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

Java 8, 108 byte

Questo è un lambda che accetta input vuoti e non restituisce nulla.

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

Provalo online

Approccio ispirato alla soluzione Java di masterX244 .

C (GCC), 110 byte

Invio di funzioni.

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

Approccio ispirato alla soluzione Java di masterX244 .

TIOS

• il mio
• il loro
• conflitto

Perl 5 , 68 byte

Aggiornato dopo aver realizzato che la versione con 6 di ogni delimitatore funziona come previsto, ma con gli attuali 7 delimitatori, non ... Oops ...

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

Prova il conflitto online!

Prova il mio online!

Provalo online!