Honestamente, não acredito que isso ainda não tenha sido solicitado, mas aqui está

fundo

Dado um gráfico simples planar sem direção (o gráfico pode ser desenhado no plano sem interseções), é um teorema comprovado que o gráfico é de 4 cores, um termo que exploraremos um pouco. No entanto, é muito mais fácil colorir um gráfico com 5 cores, que é o foco do nosso desafio hoje.

Uma coloração k válida de um gráfico é uma atribuição de "cores" aos nós do gráfico com as seguintes propriedades

1. Se dois nós estiverem conectados por uma aresta, os nós serão coloridos com cores diferentes.
2. No gráfico, existem no máximo 5 cores.

Diante disso, apresentarei a você um algoritmo bastante básico para colocar em 5 cores qualquer gráfico planar não direcionado simples. Este algoritmo requer as seguintes definições

Acessibilidade : se o nó 1 é alcançável a partir do nó 2, isso significa que há uma sequência de nós, cada um conectado ao próximo por uma borda, de modo que o primeiro nó seja o nó 2 e o último o nó 1. Observe que, desde gráficos não direcionados são simétricos, se o nó 1 estiver acessível a partir do nó 2, o nó 2 estiver acessível a partir do nó 1.

Subgráfico : Um subgráfico de um gráfico de um determinado conjunto de nós N é um gráfico em que os nós do subgrafo estão todos em N, e uma aresta do gráfico original está no subgrafo se e somente se os dois nós estiverem conectados pela aresta estão em N.

Seja Cor (N) uma função para colorir gráficos planares com N nós com 5 cores. Definimos a função abaixo

1. Encontre o nó com o menor número de nós conectado a ele. Este nó terá no máximo 5 nós conectados a ele.
2. Remova este nó do gráfico.
3. Ligue para Cor (N-1) neste novo gráfico para colori-lo.
4. Adicione o nó excluído de volta ao gráfico.
5. Se possível, pinte o nó adicionado de uma cor que nenhum dos nós conectados tenha.
6. Se não for possível, todos os 5 nós vizinhos do nó adicionado terão 5 cores diferentes; portanto, devemos tentar o seguinte processo.
7. Numere os nós que cercam o nó adicionado n1 ... n5
8. Considere o subgráfico de todos os nós no gráfico original com a mesma cor que n1 ou n3.
9. Se neste subgrafo, n3 não estiver acessível a partir de n1, no conjunto de nós acessível a partir de n1 (incluindo n1), substitua todas as ocorrências da cor de n1 por n3 e vice-versa. Agora pinte a cor original do nó n1 adicionado.
10. Se n3 estiver acessível a partir de n1 neste novo gráfico, execute o processo da etapa 9 nos nós n2 e n4, em vez de n1 e n3.

Desafio

Dada a entrada de uma lista de edição (representando um gráfico), pinte o gráfico, atribuindo um valor a cada nó.

Entrada : uma lista de arestas no gráfico (ou seja, [('a','b'),('b','c')...])

Observe que o edgelist de entrada será tal que se (a, b) estiver na lista, (b, a) NÃO estiver na lista.

Saída : um objeto contendo pares de valores, em que o primeiro elemento de cada par é um nó e o segundo sua cor, ou seja, [('a',1),('b',2)...]ou{'a':1,'b':2,...}

Você pode usar qualquer coisa para representar cores, de números, caracteres e qualquer outra coisa.

A entrada e a saída são bastante flexíveis, desde que seja bastante claro quais são as entradas e saídas.

Regras

• Este é um desafio do código-golfe
• Você não precisa usar o algoritmo que descrevi acima. É simplesmente lá para referência.
• Para qualquer gráfico, geralmente existem muitos métodos válidos para colori-los. Desde que a coloração produzida pelo seu algoritmo seja válida, isso é aceitável.
• Lembre-se de que o gráfico deve ser de 5 cores.

Casos de teste

Use o código a seguir para testar a validade dos resultados da coloração. Como existem muitas cores válidas por gráfico, esse algoritmo simplesmente verifica a validade da cor. Veja a documentação para ver como usar o código.

Alguns casos de teste aleatórios (e bastante tolos) :

Caso de teste 2: Gráfico de Krackhardt Kite [(0, 1), (0, 2), (0, 3), (0, 5), (1, 3), (1, 4), (1, 6), (2, 3), (2, 5), (3, 4), (3, 5), (3, 6), (4, 6), (5, 6), (5, 7), (6, 7), (7, 8), (8, 9)]

Uma saída válida: {0: 4, 1: 3, 2: 3, 3: 2, 4: 4, 5: 1, 6: 0, 7: 4, 8: 3, 9: 4}

Nota : Esses casos de teste são muito pequenos para testar o comportamento mais matizado do algoritmo de coloração; portanto, construir seus próprios gráficos é provavelmente um bom teste da validade do seu trabalho.

Nota 2 : adicionarei outro código que representará graficamente sua solução de coloração em breve.

Nota 3 : Não prevejo os algoritmos de coloração aleatória apresentados, o que é tão legal no PPCG! No entanto, se alguém pudesse jogar com um algoritmo mais determinístico, isso seria muito legal também.

Python 2 , 96 bytes

i=0
g=input()
while 1:i+=1;c={k:i/4**k%4for k in sum(g,())};all(c[s]^c[t]for s,t in g)>0<exit(c)

Experimente online!

$g$$i$$c$$c$$c$

A entrada é plana, portanto, sempre é possível encontrar uma cor 4.

(Assim: isso encontra a coloração lexicograficamente mais antiga em um sentido, e o faz de maneira muito ineficiente.)

$k$$\Big\lfloor \frac{i}{4^k} \Big\rfloor \bmod 4$$k$$i$

JavaScript (ES7), 80 76 74 bytes

Guardado 2 bytes graças a @Neil

A mesma abordagem que Lynn . Resolve em 4 cores, numeradas de 0 a 3 .

a=>{for(x=0;a.some(a=>a.map(n=>z=c[n]=x>>n*2&3)[0]==z,c={});x++);return c}

Experimente online!

Braquilog , 38 bytes

cd{∧4>ℕ}ᶻ.g;?z{tT&h⊇ĊzZhpT∧Zt≠}ᵐ∧.tᵐ≜∧

Experimente online!

Explicação

Example input: [["a","b"],["c","b"]]

cd                                       Concatenate and remove duplicates: ["a","b","c"]
  {∧4>ℕ}ᶻ.                               The output is this list zipped zith integers that
                                           are in [0..4]: [["a",I],["b",J],["c",K]]
         .g;?z                           Zip the output with the input:
                                           [[[["a",I],["b",J],["c",K]],["a","b"]],[["a",I],["b",J],["c",K]],["c","b"]]
              {               }ᵐ∧        Map for each element
               tT                        Call T the couple of nodes denoting an edge
                 &h⊇Ċ                    Take a subset of 2 elements in the head
                     zZ                  Zip and call it Z
                      ZhpT               The nodes in Z are T up to a permutation
                          ∧Zt≠           The integers in Z are all different color
                                 .tᵐ≜∧   Label the integers (i.e. colors) in the output so that
                                           it matches the set constraints

Python 2 , 211 bytes

def f(g):
 g={k:[(a,b)[a==k]for a,b in g if k in(a,b)]for k in sum(g,())};c={k:0 for k in g}
 for a,b in sorted(g.iteritems(),key=lambda a:len(a[1])):c={k:(c[k],c[k]+1)[c[a]==c[k]and k in b]for k in c}
 return c

Experimente online!

Determinístico! Provavelmente falharia em casos de teste mais complicados, mas estou muito cansada para encontrar um gráfico pelo qual ele falha. Mais casos de teste e / ou críticas são bem-vindos!

Limpo , 139 bytes

import StdEnv,Data.List
$l#(a,b)=unzip l
#e=nub(a++b)
=hd[zip2 e c\\c<- ?e|all(\(a,b)=c!!a<>c!!b)l]
?[h:t]=[[n:m]\\n<-[0..4],m<- ?t]
?e=[e]

Experimente online!

Gera todos os corantes e retorna o primeiro válido.

Gelatina , 23 bytes

®iⱮⱮ³¤ịE€S
FQ©L4ṗÇÐḟḢ®ż

Experimente online!

Força bruta. Assume que os nós são rotulados por números inteiros.