Ao usar uma ferramenta como o git para mesclar dois arquivos, um conflito pode ser detectado e adicionado ao resultado da mesclagem.

Uma mesclagem desses dois arquivos:

meu arquivo:

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

o arquivo deles:

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

resultaria em:

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

Consulte Linhas de Marcador de Conflito

Resolver esse conflito com o Mine criaria este arquivo:

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

Resolver esse conflito com os deles criaria este arquivo:

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

O objetivo deste desafio é escrever um arquivo de origem que contenha um conflito e ainda compile / execute.

Escreva um arquivo de origem que:

1. contém um válido, nos dois sentidos, o conflito marcado pelos marcadores remendo de conflito adequadas ( <<<<<<<, =======, >>>>>>>) Meu e Deles descritores de arquivos após os marcadores são opcionais.
2. compila / executa sem erros / avisos se os marcadores permanecerem parte da fonte
3. compila / executa sem erros / avisos se o conflito for resolvido usando o meu
4. compila / executa sem erros / avisos se o conflito for resolvido usando o deles
5. gera "Hello Conflict" ao compilar / executar o arquivo em conflito
6. produz "Hello Mine" ao compilar / executar a versão mine
7. produz "Olá!" ao compilar / executar a versão deles

Os marcadores devem estar localizados no arquivo de origem de forma que o kdiff3 reconheça o conflito.

As brechas padrão são proibidas.

O código mais curto vence.

Pontuação é o comprimento da fonte em conflito

Geléia , 51 bytes

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

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

Experimente online!

Explicação

Os marcadores de conflito aqui são posicionados para que uma das três linhas se torne a segunda linha do programa após a resolução do conflito; isso será uma constante, nomeado 2£. A segunda linha do programa original codifica a string " Conflict"(na notação compactada de Jelly); a terceira linha codifica a string " Mine"(esta se tornará a segunda linha se o conflito for resolvido como meu); a sexta linha codifica a string " Theirs"(e se tornará a segunda linha se o conflito for resolvido como deles).

O programa principal é sempre a última linha, não importa quantas linhas sejam excluídas. Ele pega a codificação compactada "Hello"e acrescenta ( ;) o valor 2£dela, produzindo assim a saída desejada.

JavaScript (ES6), 102 94 93 90 bytes

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

Se o conflito tiver sido resolvido, não haverá sexta linha; portanto, a primeira linha será impressa. Editar: salvou 3 bytes graças a @nderscore.

Braquilog , 68 67 66 bytes

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

Experimente online!

Experimente a "Hello Mine"versão aqui

Experimente a "Hello Theirs"versão aqui

Explicação

Felizmente, <<<<<<<, =======e >>>>>>>são todas as definições de regras válidas em Brachylog. Eles significam respectivamente:

• A entrada é menor que uma variável implícita, é menor que ..., etc., é menor que a saída.
• Todos os elementos da entrada são iguais, e todos os elementos da entrada são iguais, e ..., e Input = Output
• Igual ao primeiro, mas maior que o contrário.

Se removermos conflitos, terminamos com "Mine"ou "Theirs"na segunda linha, o que significa que eles se tornam o predicado número 1. Chamar esse predicado com ↰₁na primeira linha unificará sua entrada e saída com Mine/ Theirs, com a qual imprimiremos w.

Se chamarmos ↰₁o arquivo em conflito, acabamos ligando <<<<<<<. Portanto, chamamos esse predicado com uma string como entrada (usando ċ₂- coerce to string). <falhará com uma string como entrada. Em seguida, colocamos uma disjunção ∨"Conflict"wno predicado principal, que afirma que, se o predicado 1 falhar, imprimiremos Conflict. ↰₁com uma string como input não falhará nas linhas "Mine"ou "Theirs"porque são strings.

PHP, 74 65 bytes

Nota: usa codificação IBM-850

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

Armazene em um arquivo e execute assim:

php -nf conflict.php

Explicação

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

O XOR binário resulta em um dos seguintes 3:

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

Tweaks

• Salvou 9 bytes usando lógica binária em cadeias

Pip , 61 bytes

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

Experimente online!

Tudo entre ""é uma corda. Dividimos a string grande em novas linhas ( "..."^n) e pegamos o sétimo elemento com indexação cíclica ( (___7)). Para a versão em conflito, existem sete linhas, portanto o índice 7 é equivalente ao índice 0 e obtemos Conflict. Para as versões resolvidas, existem três linhas; portanto, o índice 7 é equivalente ao índice 1 e obtemos Mine/ Theirs. Em seguida, concatene "Hello "para a frente e imprima automaticamente.

Lote, 133 129 bytes

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

Explicação: A gotoinstrução vai para o próximo rótulo que pode encontrar. No caso do conflito, isso acaba pulando os marcadores de conflito e sobtendo seu valor final. No caso de resolver com o Mine, os gotos não têm efeito, mas o último setnão existe mais, então o resultado é Mine. No caso de resolver com eles, o inicial gotoignora o restante, de setmodo que o resultado é seu valor inicial. Editar: salvou 4 bytes graças ao @DLosc.

Python 2, 88 87 bytes

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

Imprime a sexta ou (agora) primeira linha, conforme apropriado.

.COM opcode, 77 bytes

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 um espaço depois do <<<<<<<permitido, 75 bytes

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 bytes

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

Experimente online!

Experimente a versão "Mine"

Experimente a versão "Deles"

Explicação do programa Conflito

Como geralmente ocorre com o Retina, este programa contém muitos estágios de substituição.

Hello 

Substitua a entrada vazia / inexistente por Hello .

$
<<<<<<<

Substitua o final da cadeia de trabalho por <<<<<<<

Mine
=======

Substitua Minepor =======. Como Minenão aparece em nenhum lugar da string de trabalho, isso não faz nada.

Theirs
>>>>>>>

Substitua Theirspor >>>>>>>. O mesmo negócio que com Mine; Theirsnão aparece, então a substituição não faz nada.

<+
Conflict

Substitua uma sequência de <por Conflict. Nós adicionamos <<<<<<<o final da string na primeira substituição, para que a string de trabalho se torne Hello Conflict, o que é implicitamente produzido no final do programa.

Explicação dos meus / seus programas

Quando o conflito for resolvido, o código ficará assim:

Hello 
$
Mine
<+
Conflict

Hello 

O mesmo de antes, começando com a sequência Hello.

$
Mine

Agora, em vez de anexar <<<<<<<aHello  , anexamos Mine.

<+
Conflict

Em seguida, substituímos uma sequência de < por Conflict. Mas não há <s na string, então nada acontece.

A sequência de trabalho,, Hello Mineé implicitamente emitida. O programa "Deles" funciona da mesma maneira.

ÓLEO , 88 80 77 bytes

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

4 2está imprimindo a linha 2 ( Hello), 10testa se a linha 0 ( 4) é idêntica à linha 16 (a que contém a 4quando o conflito existe) e salta para a linha 16 ou 8, dependendo do resultado. Se existir, 4 4imprime a linha 4 ( Conflict). Se não,4 11 imprime um Mineou Theirs, dependendo do que foi mesclado, e 3sai.

Java 145 bytes

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

O Java não possui seqüências de linhas múltiplas, portanto, foram necessários alguns truques para comentários

Bash, 76 bytes

Golfe

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

Como funciona

Usa aqui doc , para alimentar o texto fonte para sed .

O Sed irá anexar a primeira linha lida com "Hello", substituir a <<<<<<<string por "Conflict" e sair (q ).

Experimente Online!

ES6 (Javascript), 83, 82 bytes

Golfe

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

Tente

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 bytes

Este é um lambda que aceita entrada vazia e não retorna nada.

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

Experimente Online

Abordagem inspirada na solução Java da masterX244 .

C (GCC), 110 bytes

Envio de função.

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

Abordagem inspirada na solução Java da masterX244 .

TIOs

• meu
• deles
• conflito

Perl 5 , 68 bytes

Atualizado depois de perceber que a versão com 6 de cada delimitador funciona conforme o esperado, mas com os 7 delimitadores reais, não funciona ... Opa ...

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

Experimente o conflito online!

Experimente o meu online!

Experimente online!