python: nono.py comparison

comparison nono.py @ 72:15e540c190d5 simple

derive Nono from list, not dict, and get [x,y] working

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

comparison

equal deleted inserted replaced

-:eea4bcb657bc
+:15e540c190d5
 #!/usr/bin/python3
 # New version, input taken from Nonograms Outer HTML plus
 #  > fgrep 'task = ' nono10.xhtml|tr ';' '\n' | fgrep task\ = | sed 's/^.*= //'| tr -d \'
 #  E.g. 8/5.1/2.3/2.1/4.3/3.4/2/1.1/3/5.2/2.2/2.2/1.3.2/5.1/3.1.1/2/2.3.1/7.1/1.1.2/3.2
+#######  New Plan #######
+# All that matters is runs of incomplete cells.  We begin with n+n runs, the maximum number is
+#  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)
+# 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?
 import sys
 Red='[31m'
 eRed='[39m'
 if self.val is not None:
 eprint("Reset not allowed: %s -> %s at %s,%s"%(self.val, v, self.x,self.y),err=103)
 self.val=v
 return True
-class Nono(dict):
+class Nono(list):
 # 0,0 is upper left, so increasing y goes _downwards_, to match the standard layout
-def __init__(self,runsPerRow,runsPerCol,debug):
+def __getitem__(self,xy):
+return list.__getitem__(self,xy[1])[xy[0]]
+def __setitem__(self,xy,v):
+list.__getitem__(self,xy[1])[xy[0]] = v
+def __init__(self,runsPerRow: list[int],
+runsPerCol: list[int],
+debug: bool) -> list[list[Cell]]:
 global SOLVER
 self.loop=0
 self.dp='' # old depth hack
 self.debug = debug
 self.dstate=[]
 SOLVER=self
 n=self.n=len(runsPerCol)
+list.__init__(self,list(list(list(range(n)) for _ in range(n))))
 if n!=len(runsPerRow):
 print("losing r:%s x c:%s"%(len(runsPerRow),n),sys.stderr)
 exit(1)
 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=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)
+self[x,y]=Cell(rr[y],y,cc[x],x)
 # Need cells in place for the following
 for row,runs in zip(rr,runsPerRow):
 row.initRuns(runs)
 for col,runs in zip(cc,runsPerCol):
 col.initRuns(runs)

Mercurial > hg > python

comparison nono.py @ 72:15e540c190d5 simple