def set_sequences(self, a1, a2, a3, a4, a5, a6, a7, a8, c1, c2, c3, c4, v1,
v2, v3, v4):
# create circular lists for each set with corresponding edges
self.all_edges_in_order = CircularList(
(a1, a2, a3, a4, a5, a6, a7, a8))
self.ceiling_edges_clockwise = CircularList((c1, c2, c3, c4))
self.vertical_edges_up = CircularList((v1, v2, v3, v4))
def get_basic_section(start, classified_pixels, start_back=None):
# 'gradient' vector
delta = np.array([0, 0])
last_gradients = CircularList()
section = []
section.append(start)
x, y = start
next, next_value = get_max_neighbor(classified_pixels, x, y, start_back)
delta = np.subtract(next, start)
while next_value == 2: # edge pixel
last_gradients.insert((delta[0], delta[1]))
section.append(next)
next = np.add(next, delta)
next_value = classified_pixels[next[0], next[1]]
if next_value < 2: # blank pixel or miscellaneous pixel
last = section[-1] # get last element added in section
x, y = last
back = np.subtract(last, delta)
# get max value in the neighborhood, unless the 'back'
next, next_value = get_max_neighbor(classified_pixels, x, y, back)
delta = np.subtract(next, last)
last_gradients.insert((delta[0], delta[1]))
section.append(next)
last_element = next
return section, last_gradients, last_element
def get_knot_hash(lengths):
lengths.extend(LENGTHS_SUFFIX)
skip_size = 0
current_position = 0
total_score = 0
total_in_garbage = 0
real_list = [x for x in range(256)]
cl = CircularList(real_list)
for length in lengths * NUM_ROUNDS:
cl.reverse_portion(current_position, length)
current_position += length
current_position += skip_size
skip_size += 1
sparse_hashes = []
for x in range(16):
offset = 16 * x
sh = 0
for i in range(16):
sh ^= cl[offset + i]
sparse_hashes.append(sh)
return "".join([format(sh, '02x') for sh in sparse_hashes])
def __init__(self, cache_size=None):
self.required_updates = []
# they are held here until it is synced with exchange candles timeframe
self.pending_updates = []
self.partial_candles = []
self.cache_size = CandleBuilder.DEFAULT_CACHE_SIZE if cache_size is None else cache_size
self.candles_list = CircularList(self.cache_size)
def christmas_animation(self, duration=3600):
startTime = datetime.now()
ceiling_led_list = CircularList()
for edge in self.ceiling_edges_clockwise:
for led_number in edge.leds:
ceiling_led_list.append(led_number)
# print(ceiling_led_list._data)
last_ceiling_stamp = datetime.now()
last_vertical_stamp = datetime.now()
update_necessary = False
while (datetime.now() - startTime).total_seconds() <= duration:
if (datetime.now() - last_ceiling_stamp).total_seconds() >= 1:
for i in ceiling_led_list:
color = (0, 0, 0)
color_pick = randint(1, 10)
if color_pick == 0:
color = (0, 0, 255)
elif 1 <= color_pick <= 6:
color = (255, 0, 0)
elif 7 <= color_pick <= 10:
color = (0, 255, 0)
self.set_led(i, color)
ceiling_led_list.shiftForward()
last_ceiling_stamp = datetime.now()
update_necessary = True
if (datetime.now() - last_vertical_stamp).total_seconds() >= 0.05:
for edge in self.vertical_edges_up:
for i in range(edge.length):
offset = 2 * i
self.set_led(
edge.leds[i],
(255, max(0, min(255,
offset + randint(-15, 15))), 0))
last_vertical_stamp = datetime.now()
update_necessary = True
if update_necessary:
update_necessary = False
self.update()
time.sleep(0.1)
def build_list_horizontal_circle(self, include_vertical=True):
list_of_leds = CircularList()
if include_vertical:
# iterate through all edges in order and add LED numbers of ceiling strips to list, add list of LEDs in
# vertical edges as list so they function as a single LED
for edge in self.all_edges_in_order:
if edge in self.ceiling_edges_clockwise:
for led in edge.leds:
list_of_leds.append([led])
else:
list_of_leds.append(edge.leds)
else:
# iterate through edges and add the led numbers to the circular list
for edge in self.ceiling_edges_clockwise:
for led in edge.leds:
list_of_leds.append([led])
return list_of_leds
def build_list_vertical_straight(self, include_horizontal=True):
list_of_leds = CircularList()
for i in range(0, self.vertical_edges_up[0].length):
list_of_leds.append([
self.vertical_edges_up[0].leds[i],
self.vertical_edges_up[1].leds[i],
self.vertical_edges_up[2].leds[i],
self.vertical_edges_up[3].leds[i]
])
if include_horizontal:
all_horizontal = []
for edge in self.ceiling_edges_clockwise:
for n in edge.leds:
all_horizontal.append(n)
list_of_leds.append(all_horizontal)
return list_of_leds
def get_crossing_section_direction(classified_pixels, crossing_pixel,
last_gradients, section):
# counter gradients frequency
cnt_gradient = Counter(last_gradients.get_list())
# count in list
grads = cnt_gradient.most_common()
crossing_section_direction = []
next = crossing_pixel
next_value = classified_pixels[next[0], next[1]]
# back is a edge pixel
back = section[-2][0], section[-2][1]
# avoid local minima
iterations = 0
loop_grads = CircularList(3)
excluded_grad = None
while next_value != 2: # edge pixel
aux_value = 0
i = 0
if iterations == 3:
list_loop_grads = loop_grads.get_list()
excluded_grad = list_loop_grads[1]
crossing_section_direction[:] = []
iterations = 0
# blank pixel or miscellaneous and i < len
while aux_value < 2 and i < len(grads):
if grads[i][0] == excluded_grad:
continue
delta = grads[i][0]
aux = np.add(next, delta)
if aux[0] == back[0] and aux[1] == back[
1]: # back[0] >= 0 and back[1] >= 0 and
aux_value = 0
else:
aux_value = classified_pixels[aux[0], aux[1]]
i += 1
if aux_value < 2 and i == len(grads):
delta = get_direction(classified_pixels, back, next, grads,
excluded_grad)
loop_grads.insert(delta)
back = next[0], next[1]
next = np.add(next, delta)
next_value = classified_pixels[next[0], next[1]]
else:
loop_grads.insert(delta)
back = next[0], next[1]
next = aux
next_value = aux_value
crossing_section_direction.append(next)
iterations += 1
return crossing_section_direction
from circular_list import CircularList
NUM_ROUNDS = 64
LENGTHS_SUFFIX = [17, 31, 73, 47, 23]
skip_size = 0
current_position = 0
total_score = 0
total_in_garbage = 0
real_list = [x for x in range(256)]
cl = CircularList(real_list)
with open("input.txt", "rb") as input_file:
line = input_file.read()[:-1]
lengths = [c for c in line]
lengths.extend(LENGTHS_SUFFIX)
for length in lengths * NUM_ROUNDS:
cl.reverse_portion(current_position, length)
current_position += length
current_position += skip_size
skip_size += 1
sparse_hashes = []
for x in range(16):
offset = 16 * x
sh = 0
for i in range(16):
def reset(self):
'''Resets position and skip to 0'''
self.circular_list = CircularList([i for i in range(256)])
self.pos = 0
self.skip = 0
def __init__(self):
self.circular_list = CircularList([i for i in range(256)])
self.pos = 0
self.skip = 0