Ejecutar conflicto de fusión


24

Cuando se utiliza una herramienta como git para fusionar dos archivos, se puede detectar un conflicto y agregarlo al resultado de la fusión.

Una fusión de estos dos archivos:

mi archivo:

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

su archivo:

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

daría como resultado:

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

Ver líneas de marcador de conflicto

Resolver este conflicto con Mine crearía este archivo:

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

Resolver este conflicto con Theirs crearía este archivo:

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

El objetivo de este desafío es escribir un archivo fuente que contenga un conflicto y que aún se compile / ejecute.

Escriba un archivo fuente que:

  1. contiene una válida, de dos vías, el conflicto marcado por los marcadores adecuados conflicto parche ( <<<<<<<, =======, >>>>>>>) Mina y la de ellos descriptores de archivos después de que los marcadores son opcionales.
  2. compila / ejecuta sin errores / advertencias si los marcadores siguen siendo parte de la fuente
  3. compila / ejecuta sin errores / advertencias si el conflicto se resuelve usando el mío
  4. compila / ejecuta sin errores / advertencias si el conflicto se resuelve usando los suyos
  5. genera "Hello Conflict" al compilar / ejecutar el archivo en conflicto
  6. genera "Hello Mine" al compilar / ejecutar la versión minera
  7. genera "Hello Theirs" al compilar / ejecutar la versión de ellos

Los marcadores deben ubicarse en el archivo fuente de manera que kdiff3 reconozca el conflicto.

Las lagunas estándar están prohibidas.

El código más corto gana.

La puntuación es la longitud de la fuente en conflicto


¿Se permiten los envíos de funciones o solo programas completos?
Jakob

@Jakob: debe ser posible ejecutarlo / ejecutarlo. Entonces, si hay un REPL que puede ejecutar la función (o solo la expresión), seguro.
Erno

Respuestas:


2

Jalea , 51 bytes

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

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

Pruébalo en línea!

Explicación

Los marcadores de conflicto aquí se colocan de modo que una de tres líneas se convierta en la segunda línea del programa después de que se resuelva el conflicto; Esta será una constante, llamada . La segunda línea del programa original codifica la cadena " Conflict"(en la notación comprimida de Jelly); la tercera línea codifica la cadena " Mine"(esta se convertirá en la segunda línea si el conflicto se resuelve como mío); la sexta línea codifica la cadena " Theirs"(y se convertirá en la segunda línea si el conflicto se resuelve como suyo).

El programa principal siempre es la última línea, sin importar cuántas líneas se eliminen antes. Toma la codificación comprimida de "Hello", y le agrega ( ;) el valor de , produciendo así la salida deseada.


13

JavaScript (ES6), 102 94 93 90 bytes

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

Si el conflicto se ha resuelto, entonces no hay una sexta línea, por lo que imprime la ahora primera línea. Editar: Guardado 3 bytes gracias a @nderscore.


¡Uso creativo de expresiones regulares!
Erno

@ErnodeWeerd Vaya, lo acabo de cambiar ...
Neil

:) no te preocupes, me alegró verlo
Erno

-3 bytes:console.log('Hello',(a=`...`)[6]||a[1])
nderscore

10

Brachylog , 68 67 66 bytes

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

Pruébalo en línea!

Prueba la "Hello Mine"versión aquí

Prueba la "Hello Theirs"versión aquí

Explicación

Afortunadamente, <<<<<<<, =======y >>>>>>>son todas las definiciones de reglas válidas en Brachylog. Significan respectivamente:

  • La entrada es menor que una variable implícita, en sí misma menor que ..., etc., en sí misma menor que la salida.
  • Todos los elementos de la entrada son iguales, y todos los elementos de la entrada son iguales, y ..., y Entrada = Salida
  • Igual que el primero pero mayor que en su lugar.

Si eliminamos conflictos, terminamos con "Mine"o "Theirs"en la segunda línea, lo que significa que se convierten en el predicado número 1. Llamar a ese predicado con ↰₁en la primera línea unificará su entrada y salida con Mine/ Theirs, que luego imprimiremos con w.

Si llamamos ↰₁ al archivo en conflicto, terminamos llamando <<<<<<<. Por lo tanto, llamamos a ese predicado con una cadena como entrada (usando ċ₂- coerce a cadena). <fallará con una cadena como entrada. Luego colocamos una disyunción ∨"Conflict"wen el predicado principal que establece que si el predicado 1 falla, imprimimos en su Conflictlugar. ↰₁con una cadena como entrada no fallará para las líneas "Mine"o "Theirs"porque son cadenas.


9

PHP, 74 65 bytes

Nota: utiliza la codificación IBM-850

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

Almacenar en un archivo y ejecutar así:

php -nf conflict.php

Explicación

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

El XOR binario da como resultado cualquiera de los siguientes 3:

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

Ajustes

  • Guardado 9 bytes utilizando lógica binaria en cadenas

Algún día PHP tendrá un =======operador, y esto será un poco más fácil.
Jakob

7

Pip , 61 bytes

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

Pruébalo en línea!

Todo entre ""es una cadena. Dividimos la cadena grande en las nuevas líneas ( "..."^n) y tomamos el séptimo elemento con indexación cíclica ( (___7)). Para la versión en conflicto, hay siete líneas, por lo que el índice 7 es equivalente al índice 0 y obtenemos Conflict. Para las versiones resueltas, hay tres líneas, por lo que el índice 7 es equivalente al índice 1 y obtenemos Mine/ Theirs. Luego se concatena "Hello "al frente y se imprime automáticamente.


Muy creativo, me gusta la indexación cíclica.
Erno

6

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%

Explicación: La gotodeclaración va a la siguiente etiqueta que puede encontrar. En el caso del conflicto, esto simplemente termina omitiendo los marcadores de conflicto y sobtiene su valor final. En el caso de resolver con Mine, los gotos no tienen efecto, pero el último setya no existe, por lo que el resultado es Mine. En el caso de resolver con Theirs, el inicio gotoomite el resto, setpor lo que el resultado es su valor inicial. Editar: Guardado 4 bytes gracias a @DLosc.


¡Agradable! ¿Se puede quitar :cy hacer en su @goto tlugar?
DLosc

@DLosc Oh, ¿entonces Batch pasa a la siguiente etiqueta, en lugar de la primera? ¡Ordenado!
Neil

No lo sé, no lo he probado. Podría estar completamente equivocado.
DLosc

4

Python 2, 88 87 bytes

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

Imprime la sexta o (ahora) primera línea según corresponda.


1
No imprime la parte "Hola" ...
Erno

@ErnodeWeerd Lo siento, también cometí ese error en mi otra respuesta y olvidé corregir esta.
Neil

¿Hay un espacio entre Hello y lo que sigue?
Erno

@ErnodeWeerd La instrucción Python 2 printsiempre usa un espacio como separador (y una nueva línea final; la printfunción de Python 3 le permite elegir el separador y el terminador).
Neil

3

.COM código de operación, 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$'

Si un espacio después de <<<<<<<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 '>>>>>>>'     

¡Buena esa! ¿Podría agregar las versiones de ensamblaje? Me gustaría poder leer las instrucciones :). Sí, el espacio parece estar permitido (las especificaciones no son tan claras como me gustaría que fueran)
Erno

2

Retina , 57 bytes


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

Pruébalo en línea!

Prueba la versión "Mine"

Prueba la versión "Theirs"

Programa de explicación de conflictos

Como suele ser el caso con Retina, este programa contiene muchas etapas de reemplazo.


Hello 

Reemplace la entrada vacía / inexistente con Hello .

$
<<<<<<<

Reemplace el final de la cadena de trabajo con <<<<<<<

Mine
=======

Reemplazar Minecon =======. Como Mineno aparece en ninguna parte de la cadena de trabajo, esto no hace nada.

Theirs
>>>>>>>

Reemplazar Theirscon >>>>>>>. El mismo trato que con Mine; Theirsno aparece, por lo que el reemplazo no hace nada.

<+
Conflict

Reemplace una secuencia de <con Conflict. Añadimos <<<<<<<al final de la cadena en el primer reemplazo, por lo que la cadena de trabajo se convierte enHello Conflict , que se emite implícitamente al final del programa.

Explicación de los programas de Mine / Theirs

Cuando se resuelva el conflicto, el código se verá así:


Hello 
$
Mine
<+
Conflict

Hello 

Igual que antes, comenzando con la cadena Hello.

$
Mine

Ahora, en lugar de agregar <<<<<<<a Hello , agregamos Mine.

<+
Conflict

A continuación, reemplazamos una secuencia de <con Conflict. Pero no hay <s en la cadena, por lo que no pasa nada.

La cadena de trabajo,, Hello Minese emite implícitamente. El programa "suyo" funciona de la misma manera.


1

ACEITE , 88 80 77 bytes

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

4 2está imprimiendo la línea 2 ( Hello), 10prueba si la línea 0 ( 4) es idéntica a la línea 16 (la que contiene un 4cuando existe el conflicto) y salta a la línea 16 o la línea 8 según el resultado. Si existiera, 4 4imprime la línea 4 ( Conflict). Si no fuera así4 11 imprime cualquiera Mineo Theirs, según lo que se fusionó, y 3sale.


1

Java 145 Bytes

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

Java no tiene cadenas multilínea, por lo que se necesita algún truco de comentarios


¿Cuál es la razón del extra *en la tercera línea? Creo que eso solo */s+="Mine";/*funcionaría.
CAD97

restos de cuando las líneas de comentarios eran líneas separadas para evitar líneas idénticas (refactorizadas antes de publicar y olvidadas), gracias por esa pista y 3 bytes
masterX244

1

Bash, 76 bytes

Golfed

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

Cómo funciona

Utiliza aquí doc , para alimentar el texto fuente a sed .

Sed antepondrá la primera línea que lee con "Hola", reemplazará la <<<<<<<cadena por "Conflicto" y luego saldrá (q ).

¡Pruébelo en línea!


1

ES6 (Javascript), 8382 bytes

Golfed

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

Intentalo

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

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

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



1

C (GCC), 110 bytes

Presentación de funciones.

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

Enfoque inspirado en la solución Java de masterX244 .

TIO


¡Buena esa! Uso inteligente de los comentarios de varias líneas.
Erno

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.