def get_ssb2(n):
if n == 1:
return [[1, ], ]
elif n == 2:
return [[[1], [2, 3]], ]
else:
prev_list = [[[1], [2, 3]], [[1,], [2,], [3,]] ]
new_list = []
for i in range(4, get_sbb_size(n)+1):
new_list = []
for prev in prev_list:
for row_idx in range(len(prev)):
prev_len = len(prev[row_idx])
if prev_len < row_idx+1:
if prev_len == row_idx or len(prev[row_idx-1]) > prev_len:
new_array = util.clone_array(prev)
new_array[row_idx].append(i)
new_list.append(new_array)
if len(prev) < n:
new_array = util.clone_array(prev)
new_array.append([i,])
new_list.append(new_array)
prev_list = new_list
return new_list
def comb(tss, debug=False):
size = len(tss)
triangle = util.clone_array(tss)
if debug:
prev = util.clone_array(tss)
print("COMBING")
util.print_array(triangle)
for i in range(1, size):
if debug:
print('dealing with row ', i)
for j in reversed(range(1, i + 1)):
if debug:
print('\thandling row ', j)
triangle = handle_row_with_col_max_v4(triangle, j, size - i)
if debug and not prev == triangle:
print('>>>>> i,j', i, j)
util.print_array(triangle)
prev = util.clone_array(triangle)
return triangle
def comb(tss, debug=False):
size = len(tss)
triangle = util.clone_array(tss)
if debug:
prev = util.clone_array(tss)
print("COMBING")
util.print_array(triangle)
for i in reversed(range(1,size)):
print('dealing with row ', i)
for j in range(i,size):
print('\thandling row ', j)
triangle = handle_row_swap(triangle, j)
if debug and not prev == triangle:
print('>>>>> i,j', i, j)
util.print_array(triangle)
prev = util.clone_array(triangle)
# for i in range(1,size):
# handle_row_swap(triangle, i)
#
# if debug and not prev == triangle:
# print('>>>>> i', i)
# util.print_array(triangle)
# prev = util.clone_array(triangle)
#
return triangle
def comb_with_col_max(tss, debug=False):
size = len(tss)
triangle = util.clone_array(tss)
if debug:
prev = util.clone_array(tss)
print("COMBING with col max")
util.print_array(triangle)
for col_max in range(1,size+1):
if debug:
print('dealing with col_max ', col_max)
for j in range(1,size):
if debug:
print('\thandling row ', j)
triangle = handle_row_with_col_max(triangle, j, col_max)
if debug and not prev == triangle:
print('>>>>> col_max,j', col_max, j)
util.print_array(triangle)
prev = util.clone_array(triangle)
# for i in range(1,size):
# handle_row_swap(triangle, i)
#
# if debug and not prev == triangle:
# print('>>>>> i', i)
# util.print_array(triangle)
# prev = util.clone_array(triangle)
#
# final time needed?
if debug:
print('one more time')
for j in reversed(range(1,size)):
if debug:
print('\thandling row ', j)
triangle = handle_row_with_col_max(triangle, j, col_max)
if debug and not prev == triangle:
print('>>>>> col_max,j', col_max, j)
util.print_array(triangle)
prev = util.clone_array(triangle)
return triangle
def get_boosted_tss_trapezoid(max_row_size, num_rows):
trap_list = [[ [ x for x in row],] for row in get_boosted_tss_rows(max_row_size)]
for idx in range(num_rows-1):
old_trap_list = util.clone_array(trap_list)
trap_list = []
row_list = get_boosted_tss_rows(max_row_size-1 - idx)
for trap in old_trap_list:
for row in row_list:
trap_list.append( trap + [row,])
return trap_list
def comb(triangle_in, debug=False):
triangle = util.clone_array(triangle_in)
size = len(triangle)
for i in range(size - 1):
max_idx = len(triangle[i + 1])
for j in reversed(range(i + 1)):
if debug:
print('handle', i, j)
new_big, new_small = handle_rows(triangle[j], triangle[j + 1],
max_idx)
triangle[j] = new_big
triangle[j + 1] = new_small
if debug:
util.print_array(triangle)
return triangle
def get_boosted_fbt_trapezoid(max_row_size, num_rows):
trap_list = [[ row,] for row in get_boosted_fbt_rows(max_row_size)]
for idx in range(num_rows-1):
old_trap_list = util.clone_array(trap_list)
trap_list = []
row_list = get_boosted_fbt_rows(max_row_size-1 - idx)
for trap in old_trap_list:
for row in row_list:
is_valid = True
for k in range(max_row_size-1 - idx):
if row[k] > trap[-1][k] or row[k] > trap[-1][k+1]:
is_valid = False
if is_valid:
trap_list.append( trap + [row,])
return trap_list
def jt_move(triangle, row_idx, col_idx):
print('\t\tjt_move', row_idx, col_idx, triangle)
if not col_idx < len(triangle[row_idx]) - 1:
raise IndexError("Called jt_move for ({0},{1}) on {2})".format(
str(row_idx), str(col_idx), str(triangle)))
s = triangle[row_idx][col_idx]
x = triangle[row_idx][col_idx + 1]
y = triangle[row_idx + 1][col_idx]
if s <= x and s <= y:
# all is good
new_triangle = triangle
new_row_idx = row_idx
new_col_idx = col_idx
else:
new_triangle = util.clone_array(triangle)
if x < s:
#if not y <= x:
# raise ValueError("Programming error y>x for ({0},{1}) on {2})".format(str(row_idx), str(col_idx), str(triangle)))
new_triangle[row_idx][col_idx] = x
new_triangle[row_idx][col_idx + 1] = s
new_row_idx = row_idx
new_col_idx = col_idx + 1
else:
new_triangle[row_idx][col_idx] = y + 1
new_triangle[row_idx][col_idx + 1] = x - 1
new_triangle[row_idx + 1][col_idx] = s
new_row_idx = row_idx + 1
new_col_idx = col_idx
if new_row_idx == row_idx and new_col_idx == col_idx:
return new_triangle
elif new_col_idx == len(triangle[new_row_idx]) - 1:
return new_triangle
else:
return jt_move(new_triangle, new_row_idx, new_col_idx)
def compare_two_rows(size, col_sums=()):
# tss_list = get_boosted_tss(size)
# fbt_list = get_boosted_fbt(size)
#
#
#
# tss_row_list = []
#
# for tss in tss_list:
# temp = [tss[0], tss[1]]
#
# if not temp in tss_row_list:
# tss_row_list.append(temp)
#
# fbt_row_list = []
#
# for fbt in fbt_list:
# temp = [fbt[0], fbt[1]]
#
# if not temp in fbt_row_list:
# fbt_row_list.append(temp)
###########
# tss_row_list = [ [x[0], x[1]] for x in tss_list]
# fbt_row_list = [ [x[0], x[1]] for x in fbt_list]
#combed_row_list = [handle_row_with_col_max_v4(tss_rows, 1, size-1) for tss_rows in tss_row_list]
#print(len(tss_row_list), len(fbt_row_list), len(combed_row_list))
###########
tss_row_list2 = get_boosted_tss_trapezoid(size, 2)
fbt_row_list2 = get_boosted_fbt_trapezoid(size, 2)
tss_row_list = tss_row_list2
fbt_row_list = fbt_row_list2
fbt_match_list = [f for f in fbt_row_list if get_col_sums(f) == col_sums]
combed_map = dict()
error_list = []
comb_match_list = []
for k, t in enumerate(tss_row_list):
print(k, 'before')
util.print_array(t)
tt = util.clone_array(t)
if k % 1000 == 0:
print('processed', k)
#print("HANDLING ROW WITH COL MAX")
#b = handle_row_with_col_max_v4(tt, 1, size-1)
b = untangle(tt, 1, size - 1)
key = str(b)
if not key in combed_map:
combed_map[key] = [
t,
]
else:
print('REPEAT!!!!', k)
combed_map[key].append(t)
print(key, 'mapped from', combed_map[key])
print('after')
util.print_array(b)
if not b in fbt_row_list:
print('ERROR NOT IN FBT LIST!', k)
error_list.append([t, b])
print(t, 'mapped to', b)
else:
if get_col_sums(b) == col_sums:
comb_match_list.append(b)
#print('======================')
print('num errors', len(error_list))
for x in error_list:
print(x[0], x[1], util.get_column_sums(x[0]))
missing_count = 0
print('missing')
for b in fbt_row_list:
if not str(b) in combed_map:
missing_count += 1
#print(b, util.get_column_sums(b))
print(missing_count)
rep_count = 0
print('repeated')
for k in combed_map:
x = combed_map[k]
if len(x) > 1:
print(k)
rep_count += 1
for y in x:
print('\t', y, util.get_column_sums(y))
print('summary')
print('tss=', len(tss_row_list), 'combed=', len(combed_map), 'fbt=',
len(fbt_row_list), 'repeated=', rep_count, 'error=', len(error_list))
# print('only tss 1')
# for t in tss_row_list:
# if not t in tss_row_list2:
# print('\t', t)
# print('only tss 2')
# for t in tss_row_list2:
# if not t in tss_row_list:
# print('\t', t)
#
# print('only fbt 1')
# for t in fbt_row_list:
# if not t in fbt_row_list2:
# print('\t', t)
# print('only fbt 2')
# for t in fbt_row_list2:
# if not t in fbt_row_list:
# print('\t', t)
if not col_sums == ():
print('missing fbt with col_sums', col_sums)
for f in fbt_match_list:
if not f in comb_match_list:
print(f)
r4j = [[3, 2, 2, 2], [3, 3, 2]] # [4,4,4,2],[2,1,0]
r4k = [[3, 2, 1, 0], [3, 2, 1]]
r4l = [[3, 3, 2, 2], [3, 3, 2]] # [4,4,4,2], [2,2,0]
r4m = [[4, 3, 2, 2], [3, 3, 2]] # [4,4,4,2], [3,3,1]
r5a = [[4, 3, 2, 1, 0], [3, 2, 2, 2]]
r5b = [[4, 3, 2, 2, 2], [4, 3, 3, 2]]
r5c = [[4, 3, 3, 3, 2], [4, 4, 3, 2]]
r5d = [[4, 3, 3, 3, 3], [4, 4, 3, 2]]
rlong = [[3, 3, 2, 2, 2, 1, 1], [3, 3, 2, 2, 2, 1]]
r = r5c
#r = r3a
rr = util.clone_array(r)
s = len(r[0])
util.print_array(r)
print('handle')
c_before = handle_row_with_col_max_v4(rr, 1, s - 1, True)
#c = comb(r)
#util.print_array(c_before)
print('untangle')
c = untangle(r, 1, s - 1, True)
util.print_array(c)
r5d = [[4, 3, 3, 3, 3], [4, 4, 3, 2]]
r5e = [[4, 3, 3, 3, 3], [4, 4, 3, 3]]
r5f = [[4, 3, 3, 3, 3], [4, 4, 4, 3]]
r5g = [[4, 4, 3, 3, 3], [4, 4, 3, 3]]
r5h = [[5, 4, 3, 3, 3], [4, 4, 3, 3]]
r5i = [[4, 3, 3, 2, 2], [4, 3, 3, 2]]
r5j = [[4, 3, 2, 1, 0], [4, 3, 2, 1]]
r5k = [[4, 3, 2, 1, 1], [4, 3, 2, 1]]
r6a = [[5, 4, 3, 2, 2, 2], [5, 4, 3, 3, 2]]
rlong = [[3,3,2,2,2,1,1],[3,3,2,2,2,1]]
r = r4a
r_orig = util.clone_array(r)
#r = r3a
rr = util.clone_array(r)
s = len(r[0])
r_col_sum = get_col_sums(r)
util.print_array(r)
print('handle')
#c = comb(r)
