Ufdjrw

This is the code to represent a set of distinct numbers from 0 to 15 in 12 space such that the differences between some adjacent numbers are also distinct.

import itertools

list = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

for i in itertools.permutations(list,12):
 a1 = abs(i[0] - i[1])
 b1 = abs(i[0] - i[2])
 a = abs(i[0] - i[3])
 b = abs(i[0] - i[4])
 c = abs(i[0] - i[5])
 d = abs(i[1] - i[6])
 e = abs(i[2] - i[7])
 f = abs(i[3] - i[8])
 g = abs(i[4] - i[9])
 h = abs(i[5] - i[10])
 g1 = abs(i[6] - i[11])
 h1 = abs(i[7] - i[11])
 c1 = abs(i[8] - i[11])
 d1 = abs(i[9] - i[11])
 e1 = abs(i[10] - i[11])
 L= [a1, b1, a, b, c, d, e, f, g, h, g1, h1, c1, d1, e1]
 if (len(set(L))==15):
 print(i)
 print(L)

There seems to be no output for this code but I can't figure out why.

Here is an approach which generates random solutions. It moves all the variable checks into a loop and short-circuits the loop when there is a clash:

import itertools, random

labels = list(range(16))
edges = ((0,1),(0,2),(0,3),(0,4),(0,5),(1,6),(2,7),(3,8),(4,9),(5,10),(6,11),(7,11),(8,11),(9,11),(10,11))
num_vertices = 12

def solve(labels,edges,num_vertices):
 shuffled_labels = labels[:] #make a copy
 random.shuffle(shuffled_labels)
 for p in itertools.permutations(shuffled_labels,num_vertices):
 differences = [0]*16
 solved = True #innocent until proven guilty
 for i,j in edges:
 difference = abs(p[i]-p[j])
 differences[difference] += 1
 if differences[difference] == 2:
 solved = False
 break #no need to check more edges
 if solved:
 return p

One run (of about 1 minute):

>>> solve(labels,edges,num_vertices)
(6, 5, 1, 14, 3, 2, 11, 15, 12, 13, 9, 0)

This is easily verified to satisfy your constraints.

Here is a generator solution which will yield all possible solutions:

def solutions(labels,edges,num_vertices):
 for p in itertools.permutations(labels,num_vertices):
 differences = [0]*16
 solved = True #innocent until proven guilty
 for i,j in edges:
 difference = abs(p[i]-p[j])
 differences[difference] += 1
 if differences[difference] == 2:
 solved = False
 break #no need to check more edges
 if solved:
 yield p

Used like e.g.:

for p in solutions(labels,edges,num_vertices): print(p)

Unlike the random approach which usually returns in less than a minute, the generator churns away for a very long time before it starts yielding results. This suggests that the identity permutation (where this generator starts) is far from being a solution. Still, it does eventually yield permutations (after about 10-15 minutes), with the first one being:

(0, 1, 3, 13, 14, 15, 10, 7, 6, 2, 4, 12)

(agreeing with the result of @jasonharper).