def main(difficulty):
clock = pygame.time.Clock()
diff_gen(difficulty)
strs = utils.read_field('new_field.txt')
objects = []
cur = Cursor()
prev_sel = (0, 0)
screen_color = BLACK
for x in range(9):
row = []
for y in range(9):
elem = strs[x][y]
if '1' <= elem <= '9':
row.append(Number(int(elem), x, y, fixed=True))
else:
row.append(Number(None, x, y))
objects.append(row)
while True:
SCREEN.fill(screen_color)
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN
and event.key == pygame.K_ESCAPE):
exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
if utils.checker(strs):
screen_color = DARK_GREEN
else:
screen_color = DARK_RED
clock.tick(20)
cur.exist()
objects[prev_sel[0]][prev_sel[1]].selected = False
objects[cur.gx][cur.gy].selected = True
if not objects[cur.gx][
cur.gy].fixed and cur.number_pressed and cur.number:
if cur.number == 'd':
objects[cur.gx][cur.gy].number = None
strs[cur.gx][cur.gy] = 'X'
else:
objects[cur.gx][cur.gy].number = cur.number
strs[cur.gx][cur.gy] = cur.number
prev_sel = (cur.gx, cur.gy)
for row in objects:
for obj in row:
obj.exist()
pygame.display.flip()
pdf.add_font('BPmono', '', 'BPmonoItalics.ttf', uni=True)
pdf.add_page()
pdf.set_font('BPmono', size=16)
ln = 0
for row in new_rows:
ln += 1
pdf.cell(200, 10, txt=row + '\n', ln=1, align='L')
pdf.output('the_field.pdf')
if __name__ == '__main__':
print('''
1: Генератор расстановки для судоку + PDF
2: Генератор поля судоку по сложности
3: Решатель судоку по полю (автоматически генерируется поле, а затем решается)
4: Графическое судоку
''')
program = int(input('Выберите программу (1-4):'))
if program == 1:
sudoku_gen()
elif program == 2:
diff_gen(int(input('Введите сложность (1-3):')))
elif program == 3:
diff_gen(1)
sudoku_solver()
elif program == 4:
GA(1)
f = utils.read_field('new_field.txt')
gen_pdf(f)
def main(difficulty):
sudoku_gen.main()
field = utils.read_field()
new_field = set_difficulty(field, difficulty)
utils.write_to_txt(new_field, 'new_field.txt')
all_pole_elems.add(elem)
solved = len({'x', 'X', '0', 0} & all_pole_elems) == 0
something_marked = False
while not solved:
for x in range(9):
for y in range(9):
the_elem = new_strs[x][y]
neighbors = set(new_strs[x] + new_cols[y])
neighbors.update(utils.get_square_elements(x, y, new_strs))
neighbors -= {'x', 'X', '0', 0}
if len(neighbors) == 8 and not ('1' <= str(the_elem) <= '9'):
something_marked = True
mark = ({str(i) for i in range(1, 10)} ^ neighbors).pop()
new_strs[x][y] = mark
print(f'marked ad {mark}')
all_pole_elems = set()
for Str in new_strs:
for elem in Str:
all_pole_elems.add(elem)
solved = len({'x', 'X', '0', 0} & all_pole_elems) == 0
utils.write_to_txt(new_strs, 'thordo.txt')
new_cols = utils.adjust_cols_from_rows(new_strs)
if not something_marked:
break
if not something_marked:
print('unsolveable')
if __name__ == '__main__':
main(utils.read_field('new_field.txt'))
def build_field_time_series(local_time_indices, file_names, mesh_file, out_dir,
blocking, all_dim_vals, blockDimName,
variable_list, vertices, connectivity, offsets,
valid_mask, output_32bit, combine_output, append,
xtimeName): # {{{
if len(variable_list) == 0:
return
if output_32bit:
outType = 'float32'
else:
outType = 'float64'
# Get dimension info to allocate the size of Colors
time_series_file = utils.open_netcdf(file_names[0])
if mesh_file is not None:
# blockDim may not exist in time series file
blockDim = len(mesh_file.dimensions[blockDimName])
else:
blockDim = len(time_series_file.dimensions[blockDimName])
# Pre-compute the number of blocks
nBlocks = 1 + blockDim / blocking
nPolygons = len(offsets)
nPoints = len(vertices[0])
nTimes = len(local_time_indices)
nVars = len(variable_list)
var_has_time_dim = np.zeros(nVars, bool)
nHyperSlabs = 0
for iVar in range(nVars):
var_name = variable_list[iVar]
if xtimeName is not None:
if var_name in time_series_file.variables:
var_has_time_dim[iVar] = \
'Time' in time_series_file.variables[var_name].dimensions
else:
# we can't support time dependence in the mesh file
assert ('Time' not in mesh_file.variables[var_name].dimensions)
var_has_time_dim[iVar] = False
extra_dim_vals = all_dim_vals[var_name]
if (extra_dim_vals is None) or (len(extra_dim_vals) == 0):
nHyperSlabs += 1
else:
nHyperSlabs += len(extra_dim_vals)
time_series_file.close()
any_var_has_time_dim = np.any(var_has_time_dim)
try:
os.makedirs(out_dir)
except OSError:
pass
if any_var_has_time_dim:
try:
os.makedirs('{}/time_series'.format(out_dir))
except OSError:
pass
else:
# there is no point in combining output if no fields have Time dim
combine_output = False
nTimes = 1
# Output time series
if use_progress_bar:
widgets = [
'Writing time series: ',
Percentage(), ' ',
Bar(), ' ',
ETA()
]
field_bar = ProgressBar(widgets=widgets,
maxval=nTimes * nHyperSlabs).start()
else:
print "Writing time series...."
suffix = blockDimName[1:]
if any_var_has_time_dim:
if combine_output or np.all(var_has_time_dim):
out_prefix = "fieldsOn{}".format(suffix)
else:
out_prefix = "timeDependentFieldsOn{}".format(suffix)
# start the pvd file
pvd_file = utils.write_pvd_header(out_dir, out_prefix)
pvd_file.write('<Collection>\n')
if not combine_output and not np.all(var_has_time_dim):
static_prefix = "staticFieldsOn{}".format(suffix)
varIndices = np.arange(nVars)[np.logical_not(var_has_time_dim)]
timeIndependentFile = utils.write_vtp_header(out_dir,
static_prefix,
varIndices[0],
varIndices,
variable_list,
all_dim_vals,
vertices,
connectivity,
offsets,
nPoints,
nPolygons,
outType,
cellData=True,
pointData=False,
xtime=None)
prev_file = ""
for time_index in range(nTimes):
if prev_file != file_names[time_index]:
if prev_file != "":
time_series_file.close()
time_series_file = utils.open_netcdf(file_names[time_index])
prev_file = file_names[time_index]
if any_var_has_time_dim:
if xtimeName is None:
xtime = None
years = float(time_index)
else:
if xtimeName not in time_series_file.variables:
raise ValueError("xtime variable name {} not found in "
"{}".format(xtimeName, time_series_file))
var = time_series_file.variables[xtimeName]
if len(var.shape) == 2:
xtime = ''.join(
var[local_time_indices[time_index], :]).strip()
date = datetime(int(xtime[0:4]), int(xtime[5:7]),
int(xtime[8:10]), int(xtime[11:13]),
int(xtime[14:16]), int(xtime[17:19]))
years = date2num(date,
units='days since 0000-01-01',
calendar='noleap') / 365.
else:
xtime = var[local_time_indices[time_index]]
years = xtime / 365.
xtime = str(xtime)
# write the header for the vtp file
vtp_file_prefix = "time_series/{}.{:d}".format(
out_prefix, time_index)
file_name = '{}/{}.vtp'.format(out_dir, vtp_file_prefix)
if append and os.path.exists(file_name):
pvd_file.write('<DataSet timestep="{:.16f}" group="" '
'part="0"\n'.format(years))
pvd_file.write('\tfile="{}.vtp"/>\n'.format(vtp_file_prefix))
continue
if combine_output:
varIndices = np.arange(nVars)
else:
varIndices = np.arange(nVars)[var_has_time_dim]
timeDependentFile = utils.write_vtp_header(out_dir,
vtp_file_prefix,
varIndices[0],
varIndices,
variable_list,
all_dim_vals,
vertices,
connectivity,
offsets,
nPoints,
nPolygons,
outType,
cellData=True,
pointData=False,
xtime=xtime)
# add time step to pdv file
pvd_file.write('<DataSet timestep="{:.16f}" group="" '
'part="0"\n'.format(years))
pvd_file.write('\tfile="{}.vtp"/>\n'.format(vtp_file_prefix))
if time_index == 0 or combine_output:
varIndices = np.arange(nVars)
else:
# only the time-dependent variables
varIndices = np.arange(nVars)[var_has_time_dim]
iHyperSlabProgress = 0
for iVar in varIndices:
has_time = var_has_time_dim[iVar]
var_name = variable_list[iVar]
(out_var_names, dim_list) = \
utils.get_hyperslab_name_and_dims(var_name,
all_dim_vals[var_name])
if has_time or combine_output:
vtkFile = timeDependentFile
else:
vtkFile = timeIndependentFile
for iHyperSlab in range(len(out_var_names)):
if dim_list is not None:
dim_vals = dim_list[iHyperSlab]
else:
dim_vals = None
field = np.zeros(blockDim, dtype=outType)
for iBlock in np.arange(0, nBlocks):
blockStart = iBlock * blocking
blockEnd = min((iBlock + 1) * blocking, blockDim)
cellIndices = np.arange(blockStart, blockEnd)
field_block = \
utils.read_field(var_name, mesh_file,
time_series_file, dim_vals,
local_time_indices[time_index],
cellIndices, outType)
field[blockStart:blockEnd] = field_block
field = field[valid_mask]
vtkFile.appendData(field)
if use_progress_bar:
field_bar.update(time_index * nHyperSlabs +
iHyperSlabProgress)
iHyperSlabProgress += 1
del field
if any_var_has_time_dim:
timeDependentFile.save()
del timeDependentFile
if time_index == 0 and not combine_output and not \
np.all(var_has_time_dim):
timeIndependentFile.save()
del timeIndependentFile
time_series_file.close()
if use_progress_bar:
field_bar.finish()
if any_var_has_time_dim:
# finish the pdv file
pvd_file.write('</Collection>\n')
pvd_file.write('</VTKFile>\n') # }}}