from machine import I2S, Pin
import array, math
N = 100                                   # 44100/100 = exactly 441 Hz
cyc = array.array('h')                    # array append is amortised O(1)
for i in range(N):
   v = int(18000 * math.sin(2*math.pi*i/N))
   cyc.append(v); cyc.append(v)          # L, R
mv = memoryview(cyc)
i2s = I2S(0, sck=Pin(10), ws=Pin(11), sd=Pin(22),
         mode=I2S.TX, bits=16, format=I2S.STEREO, rate=44100, ibuf=8192)
for _ in range(441):                      # ~1 s, starts instantly
   i2s.write(mv)

# Graphical Sudoku solver for the Pico Computer 3 (MicroPython, HDMI output).
# Iterative back-tracking (no deep recursion) so it never overflows the stack.
# Uses hdmi.text (8x12 font) if the firmware has it, else a scaled framebuf font.
# Run:  run("sudoku.py")   — Ctrl-C stops and restores the console.
import hdmi, framebuf, time

PUZZLE = (
   (5, 3, 0, 0, 7, 0, 0, 0, 0),
   (6, 0, 0, 1, 9, 5, 0, 0, 0),
   (0, 9, 8, 0, 0, 0, 0, 6, 0),
   (8, 0, 0, 0, 6, 0, 0, 0, 3),
   (4, 0, 0, 8, 0, 3, 0, 0, 1),
   (7, 0, 0, 0, 2, 0, 0, 0, 6),
   (0, 6, 0, 0, 0, 0, 2, 8, 0),
   (0, 0, 0, 4, 1, 9, 0, 0, 5),
   (0, 0, 0, 0, 8, 0, 0, 7, 9),
)
STEP_MS = 4  # animation delay per placement; 0 = instant, higher = slower

disp = hdmi.fb()
W, H = hdmi.width(), hdmi.height()
HAVE_HTEXT = hasattr(hdmi, "text")   # 8x12 console font available?
FH = 12 if HAVE_HTEXT else 8

PANEL = 150 if W >= 560 else 0
MARGIN = 16
avail = min(H - 2 * MARGIN, W - PANEL - 2 * MARGIN)
CELL = avail // 9
GRID = CELL * 9
OX = MARGIN + ((W - PANEL - 2 * MARGIN) - GRID) // 2
OY = MARGIN + ((H - 2 * MARGIN) - GRID) // 2
SCALE = max(1, (CELL - 6) // FH)
GOX = (CELL - 8 * SCALE) // 2
GOY = (CELL - FH * SCALE) // 2

C_BG = disp.colour(0xFFFFFF)
C_LINE = disp.colour(0x000000)
C_CLUE = disp.colour(0x000000)
C_TRY = disp.colour(0xFF8000)
C_OK = disp.colour(0x0000FF)
C_HILITE = disp.colour(0xFFF0C0)
C_DONE = disp.colour(0x00A000)
C_TXT = disp.colour(0x000000)
PX = OX + GRID + 20

_glyph = bytearray(8)
_gfb = framebuf.FrameBuffer(_glyph, 8, 8, framebuf.MONO_HLSB)

def put(s, x, y, col, scale=1):
   if HAVE_HTEXT:
       hdmi.text(s, x, y, col, -1, scale)
       return
   for ch in s:
       _gfb.fill(0)
       _gfb.text(ch, 0, 0, 1)
       for gy in range(8):
           row = _glyph[gy]
           if row:
               yy = y + gy * scale
               bit = 0x80
               for gx in range(8):
                   if row & bit:
                       disp.fill_rect(x + gx * scale, yy, scale, scale, col)
                   bit >>= 1
       x += 8 * scale

def cell_xy(r, c):
   return OX + c * CELL, OY + r * CELL

def draw_cell(r, c, val, col, bg=None):
   x, y = cell_xy(r, c)
   disp.fill_rect(x + 1, y + 1, CELL - 1, CELL - 1, bg if bg is not None else C_BG)
   if val:
       put(str(val), x + GOX, y + GOY, col, SCALE)

def draw_grid():
   disp.fill(C_BG)
   for i in range(10):
       disp.vline(OX + i * CELL, OY, GRID + 1, C_LINE)
       disp.hline(OX, OY + i * CELL, GRID + 1, C_LINE)
   for i in range(0, 10, 3):
       gx, gy = OX + i * CELL, OY + i * CELL
       disp.vline(gx - 1, OY, GRID + 1, C_LINE)
       disp.vline(gx + 1, OY, GRID + 1, C_LINE)
       disp.hline(OX, gy - 1, GRID + 1, C_LINE)
       disp.hline(OX, gy + 1, GRID + 1, C_LINE)

board = [list(row) for row in PUZZLE]

def valid(r, c, n):
   for i in range(9):
       if board[r][i] == n or board[i][c] == n:
           return False
   br, bc = (r // 3) * 3, (c // 3) * 3
   for i in range(br, br + 3):
       for j in range(bc, bc + 3):
           if board[i][j] == n:
               return False
   return True

def status(msg, col):
   if PANEL:
       disp.fill_rect(PX, OY + 70, PANEL - 20, 16 * SCALE, C_BG)
       put(msg, PX, OY + 70, col, 2)

def solve():
   empties = [(r, c) for r in range(9) for c in range(9) if board[r][c] == 0]
   n_empty = len(empties)
   i = 0
   steps = 0
   while 0 <= i < n_empty:
       r, c = empties[i]
       n = board[r][c] + 1        # resume just above the last value tried here
       board[r][c] = 0            # clear so valid() ignores our own cell
       while n <= 9 and not valid(r, c, n):
           n += 1
       if n <= 9:
           steps += 1
           board[r][c] = n
           draw_cell(r, c, n, C_TRY, C_HILITE)
           if STEP_MS:
               time.sleep_ms(STEP_MS)
           if PANEL and steps % 32 == 0:
               disp.fill_rect(PX, OY + 104, PANEL - 20, 12, C_BG)
               put("steps: %d" % steps, PX, OY + 104, C_TXT)
           i += 1
       else:
           draw_cell(r, c, 0, C_TXT)   # un-fill on backtrack
           i -= 1
   return i == n_empty, steps

def main():
   try:
       console(False)
   except NameError:
       pass
   draw_grid()
   for r in range(9):
       for c in range(9):
           if board[r][c]:
               draw_cell(r, c, board[r][c], C_CLUE)
   if PANEL:
       put("SUDOKU", PX, OY, C_OK, 3 if HAVE_HTEXT else 2)
       put("SOLVER", PX, OY + (36 if HAVE_HTEXT else 20), C_OK, 3 if HAVE_HTEXT else 2)
   t0 = time.ticks_ms()
   ok, steps = solve()
   dt = time.ticks_diff(time.ticks_ms(), t0)
   if ok:  # repaint the solved-in digits blue
       for r in range(9):
           for c in range(9):
               if not PUZZLE[r][c]:
                   draw_cell(r, c, board[r][c], C_OK)
   if PANEL:
       status("SOLVED!" if ok else "no soln", C_DONE if ok else C_TRY)
       put("steps: %d" % steps, PX, OY + 104, C_TXT)
       put("%d ms" % dt, PX, OY + 124, C_TXT)
   print("solved" if ok else "no solution", "in", steps, "steps,", dt, "ms")

try:
   main()
except KeyboardInterrupt:
   print("\nstopped")