Introdução

Dado um gráfico não direcionado G, podemos construir um gráfico L (G) (chamado gráfico de linhas ou gráfico conjugado) que representa as conexões entre as arestas em G. Isso é feito criando um novo vértice em L (G) para cada aresta em G e conectando esses vértices se as arestas que eles representam têm um vértice em comum.

Aqui está um exemplo da Wikipedia mostrando a construção de um gráfico de linhas (em verde).

Como outro exemplo, considere este gráfico G com os vértices A, B, C e D.

    A
    |
    |
B---C---D---E

Criamos um novo vértice para cada aresta em G. Nesse caso, a aresta entre A e C é representada por um novo vértice chamado AC.

   AC

 BC  CD  DE

E conecte os vértices quando as arestas que eles representam têm um vértice em comum. Nesse caso, as arestas de A a C e de B a C têm o vértice C em comum; portanto, os vértices AC e BC são conectados.

   AC
  /  \
 BC--CD--DE

Este novo gráfico é o gráfico de linhas do G!

Veja a Wikipedia para mais informações.

Desafio

Dada a lista de adjacência para um gráfico G, seu programa deve imprimir ou retornar a lista de adjacência para o gráfico de linha L (G). Isso é código-golfe, então a resposta com o menor número de bytes vence!

Entrada

Uma lista de pares de strings representando as arestas de G. Cada par descreve os vértices conectados por essa aresta.

• Cada par (X, Y) é garantido como único, o que significa que a lista não conterá (Y, X) ou um segundo (X, Y).

Por exemplo:

[("1","2"),("1","3"),("1","4"),("2","5"),("3","4"),("4","5")]
[("D","E"),("C","D"),("B","C"),("A","C")]

Resultado

Uma lista de pares de cadeias representando as arestas de L (G). Cada par descreve os vértices conectados por essa borda.

• Cada par (X, Y) deve ser único, o que significa que a lista não conterá (Y, X) ou um segundo (X, Y).

• Para qualquer aresta (X, Y) em G, o vértice criado em L (G) deve ser nomeado XY (os nomes são concatenados juntos na mesma ordem em que foram especificados na entrada).

Por exemplo:

[("12","13"),("12","14"),("12","25"),("13","14"),("13","34"),("14","34"),("14","45"),("25","45"),("34","45")]
[("DE","CD"),("CD","CB"),("CD","CA"),("BC","AB")]

Casos de teste

[] -> []

[("0","1")] -> []

[("0","1"),("1","2")] -> [("01","12")]

[("a","b"),("b","c"),("c","a")] -> [("ab","bc"),("bc","ca"),("ca","ab")]

[("1","2"),("1","3"),("1","4"),("2","5"),("3","4"),("4","5")] -> [("12","13"),("12","14"),("12","25"),("13","14"),("13","34"),("14","34"),("14","45"),("25","45"),("34","45")]

Ruby, 51 bytes

->a{a.combination(2){|x,y|p [x*'',y*'']if(x&y)[0]}}

Experimente online!

Para cada combinação de duas arestas, se elas tiverem um vértice em comum (por exemplo, se o primeiro elemento de sua interseção for não- nil), imprima uma matriz contendo as duas arestas em STDOUT.

JavaScript (Firefox 30-57), 77 bytes

a=>[for(x of a=a.map(x=>x.join``))for(y of a)if(x<y&&x.match(`[${y}]`))[x,y]]

Assume que todas as entradas são letras únicas (bem, qualquer caractere único que não seja ^e ]).

Braquilog , 13 bytes

{⊇Ċ.c¬≠∧}ᶠcᵐ²

Experimente online!

Com todos os casos de teste

(-1 byte substituindo l₂por Ċ, graças a @Fatalize.)

{⊇Ċ.c¬≠∧}ᶠcᵐ²   Full code
{       }ᶠ      Find all outputs of this predicate:
 ⊇Ċ.             A two-element subset of the input
    c            which when its subarrays are concatenated
     ­          does not have all different elements
                 (i.e. some element is repeated)
       ∧         (no further constraint on output)
          cᵐ²   Join vertex names in each subsubarray in that result

K (ngn / k) , 45 39 33 29 30 bytes

(*>:)#(3=#?,/)#,/{x,/:\:x}@,:'

Experimente online!

,:' agrupar cada aresta em uma lista de 1 elemento

{ }@ aplicar uma função com argumento implícito x

x,/:\:xconcatene cada esquerda xe direita x, obtenha uma matriz de resultados - todos os pares de arestas

,/ achatar a matriz

( )# filtro

(3=#?,/)#filtre apenas os pares cuja concatenação ( ,/) tenha uma contagem ( #) de exatamente 3 ?elementos únicos ( )

Isso remove as arestas como ("ab";"ab")e ("ab";"cd")da lista.

(*>)#filtre apenas os pares cuja permutação decrescente de classificação ( >) começa com ( *) a 1 (não 0 é booleano verdadeiro)

No nosso caso, a permutação de ordenação descendente pode ser 0 1ou 1 0.

Gelatina , 5 bytes

Œcf/Ƈ

Experimente online!

MATL , 13 bytes

2XN!"@Y:X&n?@

Experimente online!

Não é tão ruim quanto eu esperava, dada a entrada da matriz de células. Basicamente, a mesma ideia da resposta Ruby da @ Doorknob .

2XN   % Get all combinations of 2 elements from the input
!     % Transpose
"     % Iterate over the columns (combinations)
@     % Push the current combination of edges
Y:    % Split it out as two separate vectors
X&n   % Get the number of intersecting elements between them
?@    % If that's non-zero, push the current combination on stack
      % Implicit loop end, valid combinations collect on the stack 
      %  and are implicitly output at the end

C (gcc) , 173 bytes

Entrada ie saída osão matrizes simples e terminadas em nulo. Os nomes de saída podem ter até 998 caracteres antes que isso ocorra.

#define M(x)o[n]=malloc(999),sprintf(o[n++],"%s%s",x[0],x[1])
f(i,o,j,n,m)char**i,**j,**o;{for(n=0;*i;i+=2)for(j=i;*(j+=2);)for(m=4;m--;)strcmp(i[m/2],j[m%2])||(M(i),M(j));}

Experimente online!

Mathematica 23 bytes

EdgeList[LineGraph[#]]&

Exemplo: g = Graph[{1 <-> 2, 2 <-> 3, 3 <-> 4, 2 <-> 4 }]

EdgeList@LineGraph[g]

(*

{2 <-> 1, 3 <-> 2, 4 <-> 1, 4 <-> 2, 4 <-> 3}

*)

Pitão , 7 bytes

@F#.cQ2

Experimente aqui!

Se a junção for necessária, 10 bytes

sMM@F#.cQ2

Experimente aqui!

Wolfram Language 64 53 bytes

""<>#&/@#&/@Select[#~Subsets~{2},IntersectingQ@@#&]&

Localiza todos os Subsets de comprimento 2 da lista de entrada , Selectaqueles em que os nós de um par se cruzam com os nós de outro par (indicando que os pares compartilham um nó) eStringJoin os nós de todos os pares selecionados.

O código é especialmente difícil de ler porque emprega 4 aninhados puros ( também conhecido como funções "anônimas").

O código usa chaves, "{}", como delimitadores de lista, como é habitual no Wolfram Language.

1 byte economizado graças ao Sr. Xcoder.

Exemplo

""<>#&/@#&/@Select[#~Subsets~{2},IntersectingQ@@#&]&[{{"1","2"},{"1","3"},{"1","4"},{"2","5"},{"3","4"},{"4","5"}}]

(*{{"12", "13"}, {"12", "14"}, {"12", "25"}, {"13", "14"}, {"13", "34"}, {"14", "34"}, {"14", "45"}, {"25", "45"}, {"34", "45"}}*)

Python 2 , 109 bytes

lambda a:[(s,t)for Q in[[''.join(p)for p in a if x in p]for x in set(sum(a,()))]for s in Q for t in Q if s<t]

Experimente online!

Para cada nó x(descoberto fazendo um conjunto da lista achatada de arestas), faça uma lista dos pares pque têm xcomo membro; em seguida, para cada uma dessas listas Q, encontre os pares únicos e distintos em Q(exclusividade / distinção é imposta via if s<t).

Bytes em C # 233

static void c(List<(string a,string b)>i,List<(string,string)>o){for(int m=0;m<i.Count;m++){for(int n=m+1;n<i.Count;n++){if((i[n].a+i[n].b).Contains(i[m].a)||(i[n].a+i[n].b).Contains(i[m].b)){o.Add((i[m].a+i[m].b,i[n].a+i[n].b));}}}}

Exemplo

using System;
using System.Collections.Generic;

namespace conjugateGraphGolf
{
    class Program
    {
        static void Main()
        {
            List<(string a, string b)>[] inputs = new List<(string, string)>[]
            {
                new List<(string, string)>(),
                new List<(string, string)>() {("0", "1")},
                new List<(string, string)>() {("0", "1"),("1", "2")},
                new List<(string, string)>() {("a","b"),("b","c"),("c","a")},
                new List<(string, string)>() {("1","2"),("1","3"),("1","4"),("2","5"),("3","4"),("4","5")}
            };

            List<(string, string)> output = new List<(string, string)>();

            for(int i = 0; i < inputs.Length; i++)
            {
                output.Clear();
                c(inputs[i], output);

                WriteList(inputs[i]);
                Console.Write(" -> ");
                WriteList(output);
                Console.Write("\r\n\r\n");
            }

            Console.ReadKey(true);
        }

        static void c(List<(string a,string b)>i,List<(string,string)>o){for(int m=0;m<i.Count;m++){for(int n=m+1;n<i.Count;n++){if((i[n].a+i[n].b).Contains(i[m].a)||(i[n].a+i[n].b).Contains(i[m].b)){o.Add((i[m].a+i[m].b,i[n].a+i[n].b));}}}}

        public static void WriteList(List<(string a, string b)> list)
        {
            Console.Write("[");
            for(int i = 0; i < list.Count; i++)
            {
                Console.Write($"(\"{list[i].a}\",\"{list[i].b}\"){(i == list.Count - 1 ? "" : ",")}");
            }
            Console.Write("]");
        }
    }
}