python: nono.py comparison

comparison nono.py @ 74:0245bc07f16c simple

try to simplify Rows/Cols (do without?) by hiving off the run-counts copletely

author	Henry Thompson <ht@markup.co.uk>
date	Sat, 09 Aug 2025 15:59:19 -0400
parents	63e87db2bc31
children

comparison

equal deleted inserted replaced

-:63e87db2bc31
+:0245bc07f16c
 #  sum(len(rn) for rn in rows U cols)
 # My own strategy seems to be FIFO for pass 0, then LIFO, for the queue of new/changed runs
 # By cases, wrt types of change of a cell in its runs
 # Change at the margin:
 #  New fill: complete the run and discard it, kill the other end and queue it
-#      dead: advance margin and add fill to any internal sequences of fills (always?), queue the new fill(s)
+#      dead: advance margin and append a new fill to any internal sequences of fills (always?), queue the new fill(s)
 # Change in the middle
 #  New dead: If deterministic, split the run in two and requeue the cell (now in two runs)
 #      fill: If deterministic single gap at any end, kill, split, and requeue the cell (now in two runs)
 # ----------
 # Doesn't yet cover everything, e.g. killing gaps that are too small to be filled
 # Do we need to actually represent run-internal segments, e.g. skips and bars?
+# Hypothesis: we only need Columns and Rows for printing
 import sys
 Red = "[31m"
 eRed = "[39m"
 RedFmt = Red + "%s" + eRed
 class Run:
-'''What we're looking for, converted eventually into what
+'''What we're looking for, converted eventually into what we've found.
-we've found.
 "left" and "right" make sense for Rows, for Columns read "above" and "below"'''
 def __init__(self, n, i, j):
 # A run of length n, starting within [i,j]
 self.n = n
 return ""
 class Vector(list):
 # reads top-to-bottom or left-to-right
-def __init__(self, n, m):
+def __init__(self, m, left, right):
+self.n = n = (left.x - right.x) + 1 # size
 list.__init__(self, list(range(n)))
-self.n = n  # size
 self.m = m  # parent NoNo
 self.margin0 = 0  # a run can start here, so if >0 then self[m0-1].val must be False
 self.marginN = n - 1  # a run can end here, so if <n-1 then self[mN+1].val ditto
 def initRuns(self, runs):
 class Row(Vector):
 cLet = "R"
-def __init__(self, n, m, pos):
+def __init__(self, m, left, right):
-Vector.__init__(self, n, m)
+Vector.__init__(self, left, right, m)
-self.y = pos
+self.y = left.y
 def __repr__(self):
 return "R@%s%s:%s" % (self.y, self.runs, list.__repr__(self))
 def initDisp(self):
 class Column(Vector):
 cLet = "C"
-def __init__(self, n, m, pos):
+def __init__(self, m, top, bottom):
-Vector.__init__(self, n, m)
+Vector.__init__(self, top, bottom, m)
-self.x = pos
+self.x = top.x
 def __repr__(self):
 return "C@%s%s:%s" % (self.x, self.runs, list.__repr__(self))
 def initDisp(self):
 self.header = self.fmt % header
 dprint(self.header)
 class Cell:
-def __init__(self, row, y, column, x):
+def __init__(self, x, y):
-# At the intersection of row and column Vectors
-self.row = row
-self.column = column
 self.x = x
 self.y = y
 self.val = None  # three valued: None(unknown), True(filled), False(empty)
-self.row[x] = self
-self.column[y] = self
 def __repr__(self):
 return "c@(%s,%s):%s" % (self.x, self.y, self.val)
 def __str__(self):
 global SOLVER
 self.loop = 0
 self.dp = ""  # old depth hack
 self.debug = debug
 self.dstate = []
+self.pending = [] # newly filled/dead cells whose runs need to be checkedo
 SOLVER = self
 n = self.n = len(runsPerCol)
 if n != len(runsPerRow):
 print("losing r:%s x c:%s" % (len(runsPerRow), n), sys.stderr)
 exit(1)
+list.__init__(self,list(list(list(range(n)) for _ in range(n))))
 self.rc = runsPerRow
 self.cc = runsPerCol
 # print col nums>9 vertically :-(
-self.columns = cc = [Column(n, self, i) for i in range(n)]
+self.rows = [[(self[x,y] := Cell(x,y)) for y in range(n)] for x in range(n)]
-self.rows = rr = [Row(n, self, i) for i in range(n)]
-for x in range(n):
-for y in range(n):
-self[x, y] = Cell(rr[y], y, cc[x], x)
 # Need cells in place for the following
-for row, runs in zip(rr, runsPerRow):
+maxCRheight = 0
-row.initRuns(runs)
+for i in range(n):
-for col, runs in zip(cc, runsPerCol):
+self.initRuns([Cell[i,y] for y in range(n)], runsPerRow[i])
-col.initRuns(runs)
+self.initRuns([Cell[x,i] for x in range(n)], runsPerCol[i])
-self.maxCRheight = maxCRheight = max(col.height for col in cc)
+maxCRheight = max(maxCRheight = max(col.height for col in cc)
+self.maxCRheight = maxCRheight
 for c in cc:
 c.updateHeader(maxHeight=maxCRheight)
 maxRRwidth = max(row.width for row in rr)
 for r in rr:
 r.updateHeader(maxWidth=maxRRwidth)

Mercurial > hg > python

comparison nono.py @ 74:0245bc07f16c simple