00001: HW10
bytecount: {'code': 844, 'const': 800, 'code+const': 1644}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    valid_words = []
    invalid_words = []
    def find_word(y, x, word):
        ch = "" if y == 15 or x == 15 else board[y][x]
        if ch:
            return word + ch
        else:
            if is_valid(word):
                valid_words.append(word)
            elif len(word) > 1:
                invalid_words.append(word)
            return ""
    for a in (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15):
        word1, word2 = "", ""
        for b in (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15):
            word1 = find_word(a, b, word1)
            word2 = find_word(b, a, word2)
    return [sorted(valid_words), sorted(invalid_words)]
def get_play(board, new_board):
    x,y = None, None
    word = ""
    down = 0
    for a in (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14):
        for b in (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14):
            ch = new_board[a][b]
            if ch != board[a][b]:
                if x is None:
                    x = b
                    y = a
                elif x==b:
                    down = 1
                word += ch
    return [y, x, down, word]
def play(row, col, down, tiles, board):
    valid, new_board = place_tiles(row, col, down, tiles, board)
    the_tiles = tiles
    if not valid:
        return -1
    def get_ch(y, x, down, i, board=new_board):
        if i in [15, -1]:
            return ""
        elif down:
            return board[i][x]
        else:
            return board[y][i]
    def find_word(y, x, down, first_order):
        nonlocal tiles
        ite = y if down else x
        side_effect_word = ""
        total_score = 0
        for i in range(ite - 1, -1, -1):
            ch = get_ch(y, x, down, i)
            if not ch:
                break
            side_effect_word = ch + side_effect_word
        for i in range(ite, 16):
            ch = get_ch(y, x, down, i)
            if not ch:
                break
            if first_order and not get_ch(y, x, down, i, board):
                score = find_word(i if down else y, x if down else i, not down, False)
                if score == -1:
                    return -1
                total_score += score
            side_effect_word += ch
        if is_valid(side_effect_word):
            return sum(map(get_value, side_effect_word)) + total_score
        elif len(side_effect_word) > 1:
            return -1
        return 0
    total_score = find_word(row, col, down, True)
    return -1 if total_score == -1 else 50 * (len(the_tiles) > 6) + total_score
def best_play(tiles, board):
    res = [-1] * 4
    for row in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14):
        for col in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14):
            for is_down in (0, 1):
                score = play(row, col, is_down, tiles, board)
                if score > res[0]:
                    res = [score, row, col, is_down]
    return res

00002: HW10
bytecount: {'code': 930, 'const': 619, 'code+const': 1549}
check_import({'allowable': ['math']}): none
def w(b,i,j):
  if b[i][j] != '': return b[i][j]
  return '0'
def c(s,m):
  p=0
  for e in s.split('0'):
      if e not in m :
        if is_valid(e):
          for c in e:
            p+=get_value(c)
      else:m.remove(e)
  return p
def get_all_words(board):
  nv,v,s,s2 = [],[],'',''
  for i in range(15):
    for j in range(15):
      s += w(board,i,j)
      s2 += w(board,j,i)
    for e in (s+'0'+s2).upper().split('0'):
      if is_valid(e):v.append(e)
      elif len(e)>1:nv.append(e)
    s,s2 = '',''
  return [sorted(v),sorted(nv)]
def get_play(board, new_board):
  ii,jj,s,d = 0,0,'',0
  for i in range(15):
    for j in range(15):
      if new_board[i][j] != board[i][j]:
        if s == '': ii,jj = i,j
        s+=new_board[i][j]
        if i != ii:d=1
  return [ii,jj,d,s]
def play(row,col,down,tiles,board):
  boo,nb = place_tiles(row,col,down,tiles,board)
  vi,nvi = get_all_words(board)
  v,nv = get_all_words(nb)
  if not boo or nv != nvi:
    return -1
  s,l,l2,ln,ln2 = 0,'','','',''
  if len(tiles) >6:s=50
  for i in range(15):
    for j in range(15):
      l += w(board,i,j)
      ln += w(nb,i,j)
      l2 += w(board,j,i)
      ln2 += w(nb,j,i)
    m,k = l.split('0'),l2.split('0')
    s+= c(ln,m)+c(ln2,k)
    l,l2,ln,ln2 = '','','',''
  return s
def best_play(tiles,board):
  s = []
  for i in range(15):
    for j in range(15):
      for k in range(2):
        s.append([play(i,j,k,tiles,board),-i,-j,-k])
  s.sort()
  if s[-1][0] !=-1:
    return [s[-1][0],-s[-1][1],-s[-1][2],-s[-1][3]]
  return [-1,-1,-1,-1]

00003: HW10
bytecount: {'code': 932, 'const': 719, 'code+const': 1651}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  a=[]
  b=[]
  for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
    s=''
    for w in board[i]+['']:
      s+=w
      if w=='':
        if len(s)>1:
          if is_valid(s): a.append(s)
          else: b.append(s)
        s=''
    for i2 in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      w=board[i2][i]
      s+=w
      if w=='' or i2==14:
        if len(s)>1:
          if is_valid(s): a.append(s)
          else: b.append(s)
        s=''
  return [sorted(a),sorted(b)]
def get_all_wordspos(board):
  a=[]
  b=[]
  for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
    s=''
    for i2 in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      w=board[i][i2]
      s+=w
      if w=='' or i2==14:
        if len(s)>1:
          if is_valid(s): a.append([s,0,i,i2])
          else: b.append([s,0,i,i2])
        s=''
    for i2 in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      w=board[i2][i]
      s+=w
      if w=='' or i2==14:
        if len(s)>1:
          if is_valid(s): a.append([s,1,i2,i])
          else: b.append([s,1,i2,i])
        s=''
  return [sorted(a),sorted(b)]
def get_play(board, new_board):
  d=[]
  for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
    for e in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      if board[i][e]!=new_board[i][e]:
        if d==[]: d=[i,e,1,'']
        d2=i
        d[3]+=new_board[i][e]
  if d[0]==d2: d[2]=0
  return d
def play(row,col,down,tiles,board):
  a,b=place_tiles(row,col,down,tiles,board)
  c=get_all_wordspos(board)[0]
  d,d1=get_all_wordspos(b)
  if d1!=[] or not a: return -1
  for i in c:
   if i in d: 
     d.remove(i)
  a=0
  for i in d:
    for e in i[0]:
      a+=get_value(e)
  if len(tiles)>6: a+=50
  return a
def best_play(tiles,board):
  f=[-1,-1,-1,-1]
  for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
    for e in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      for w in [0,1]:
        s=play(i,e,w,tiles,board)
        if s>f[0]: f=[s,i,e,w]
  return f

00004: HW10
bytecount: {'code': 984, 'const': 826, 'code+const': 1810}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  result = [[], []]
  for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
    h = ''
    v = ' '
    for j in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
      h += board[i][j] if board[i][j] else ' ' 
      v += board[j][i] if board[j][i] else ' '
    h += v
    for word in h.split():
      if  len(word) >= 2:
        result[not is_valid(word)].append(word)
  return [*map(sorted, result)]
def get_play(board, new_board):
  first_meet = []
  down = 0
  diff = ''
  for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
    for j in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
      c = new_board[i][j]
      if board[i][j] != c:
        if first_meet != []:
          if first_meet[1] == j:
            down = 1
        else:
          first_meet = [i, j]
        diff += c
  return [*first_meet, down, diff]
def get_all_word_position(board):
  result = [[], []]
  for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
    h = ''
    v = ' '
    for j in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
      h += board[i][j] if board[i][j] else ' ' 
      v += board[j][i] if board[j][i] else ' '
    h += v
    word = ''
    pos = [0, 0]
    for k in range(len(h)):
      if h[k] != ' ':
        if sum(pos) == 0:
          pos = [i, k%17] if k // 17 == 0 else [k%17 + 1, i]
        word += h[k]
        if (k == 14 or k == 30) and len(word) >= 2:
          result[not is_valid(word)].append([*pos, k // 17, word])
          word = ''
          pos = [0, 0]
      else:
        if len(word) >= 2:
          result[not is_valid(word)].append([*pos, k // 17, word])
        word = ''
        pos = [0, 0]
  return result
def play(row,col,down,tiles,board):
  result = place_tiles(row,col,down,tiles,board)
  valid_word, invalid_word = get_all_word_position(result[1])
  if not result[0] or invalid_word > []:
    return -1
  for word in get_all_word_position(board)[0]:
    if word in valid_word:
      valid_word.remove(word)
  score = 50 * ( len(tiles) >= 7) + sum(map(get_value, ''.join([x[3] for x in valid_word])))
  return score
def best_play(tiles,board):
  scoreboard = [-1,-1,-1,-1]
  for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
    for j in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]:
      for k in [0, 1]:
        score_h = play(i, j, k, tiles, board)
        if scoreboard[0] < score_h:
          scoreboard = [score_h, i, j, k]
  return scoreboard

00005: HW10
bytecount: {'code': 1038, 'const': 453, 'code+const': 1491}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  valid=[]
  invalid=[]
  backup=''
  for i in range(15):
    for j in range(15):
      if board[i][j]=='':
        if len(backup)>=2:
          if is_valid(backup):
            valid.append(backup)
          else:
            invalid.append(backup)
        backup=''
      else:
        backup+=board[i][j]
    if len(backup)>=2:
      if is_valid(backup):
        valid.append(backup)
      else:
        invalid.append(backup)
    backup=''
  backup=''
  for j in range(15):
    for i in range(15):
      if board[i][j]=='':
        if len(backup)>=2:
          if is_valid(backup):
            valid.append(backup)
          else:
            invalid.append(backup)
        backup=''
      else:
        backup+=board[i][j]
    if len(backup)>=2:
      if is_valid(backup):
        valid.append(backup)
      else:
        invalid.append(backup)
    backup=''
  return [sorted(valid),sorted(invalid)]
def get_play(board, new_board):
  check1,check2=True,True
  direc=0
  posi=[]
  word=''
  for i in range(15):
    for j in range(15):
      if board[i][j]!=new_board[i][j]:
        word+=new_board[i][j]
        if check1:
          check1=False
          st=i
          nd=j
          posi+=[i,j]
        elif check2:
          check2=False
          posi+=[i,j]
          if posi[0]-posi[2]!=0:
            direc=1
  return [st,nd,direc,word]
def play(row,col,down,tiles,board):
  word=[]
  bool_,board_=place_tiles(row,col,down,tiles,board)
  if bool_:
    _board_=board_.copy()
    for i in range(15):
      for j in range(15):
        if board[i][j]!=board_[i][j]:
          board_[i][j]+='-'
    for k in get_all_words(board_)[1]:
      if '-' in k:
        out=[i for i in k if i!='-']
        if len(out)>=2:
          word.append(''.join(out))
      else:
        return -1
    score=0
    for ro in word:
      if is_valid(ro):
        for se in ro:
          score+=get_value(se)
      else:
        return -1
    if len(tiles)>=7:
      score+=50
    board=_board_
    return score
  else:
    return -1
def best_play(tiles,board):
  out=[-1,-1,-1,-1]
  for i in range(15):
    for j in range(15):
      for k in range(2):
        if place_tiles(i,j,k,tiles,board)[0]:
          check=play(i,j,k,tiles,board)
          if check>out[0]:
            out=[check,i,j,k]
  return out

00006: HW10
bytecount: {'code': 1064, 'const': 484, 'code+const': 1548}
check_import({'allowable': ['math']}): none
def k(board):
    b = copy_board(board)
    b2 = make_board()
    for i in range(15):
        for j in range(15):
            b2[i][j] = b[j][i]
    return b2
def j(board):
    v = []
    iv = []
    for i in board:
        w = "|".join(i)
        w = w.strip("|")
        b = w.split("||")
        for c in b:
            c = c.strip("|")
            c = c[::2]
            if c == "" or len(c) == 1 :
                continue
            if is_valid(c):
                v.append(c)
            else:
                iv.append(c)
    return [v,iv]
def get_all_words(board):
    b = board.copy()
    v = []
    iv = []
    v1 , iv1 = j(b)
    v2 , iv2 = j(k(b))
    v.extend(v1)
    v.extend(v2)
    iv.extend(iv1)
    iv.extend(iv2)
    v.sort()
    iv.sort()
    return [v,iv]
def get_play(board, new_board):
    po = []
    d = 0
    w = ""
    for i in range(15):
        for j in range(15):
            if board[i][j] != new_board[i][j]:
                w += str(new_board[i][j])
                if po == []:
                    po = [i,j]
                else:
                    if i == po[0]:
                        d =0
                    else:
                        d =1
    return [po[0],po[1],d,w]
def g(board,b,c):
    s = 0
    for i in range(15):
        if b[i] != board[i]:
            a = b[i]
            l = -1
            g = [15]
            for i in range(15):
                if a[i] == "":
                    if i < c:
                        l = i
                    if i > c:
                        g.append(i)
            g.sort()
            h = g[0]
            if h== l +2:
                continue 
            for i in range(l+1,h):
                s+=get_value(a[i])
    return s
def play(row,col,down,tiles,board):
    v,b = place_tiles(row,col,down,tiles,board)
    if get_all_words(b)[1] == [] and v:
        s = 0
        s += g(board,b,col)
        s += g(k(board),k(b),row)
        if len(tiles) >= 7:
            s+=50
        return s
    return -1
def best_play(tiles,board):
    an = []
    for i in range(15):
        for j in range(15):
            for d in range(2):
                v,b = place_tiles(i,j,d,tiles,board)
                if get_all_words(b)[1] == [] and v:
                    s = play(i,j,d,tiles,board)
                    an.append([-s,i,j,d])
    an.sort()
    if len(an) ==0:
        return [-1,-1,-1,-1]
    an[0][0] = -1*an[0][0]
    return an[0]

00007: HW10
bytecount: {'code': 1170, 'const': 445, 'code+const': 1615}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    words = ["".join([board[r][c] for r, c in x]).upper() for x in get_words_pos(board)]
    words.sort()
    valid, invalid = [], []
    for w in words:
        if is_valid(w):
            valid.append(w)
        else:
            invalid.append(w)
    return [valid, invalid]
def get_board_changes(old, new):
    changes = []
    for row in range(15):
        for col in range(15):
            if old[row][col] != new[row][col]:
                changes.append((row, col))
    return changes
def get_play(board, new_board):
    changes = get_board_changes(board, new_board)
    tiles = "".join([new_board[r][c] for r, c in changes]).upper()
    if all([x[0] == changes[0][0] for x in changes]):  
        return [changes[0][0], changes[0][1], 0, tiles]
    else:
        return [changes[0][0], changes[0][1], 1, tiles]
def get_words_pos(board):
    pos = []
    for col in range(15):
        row = 0
        while row < 15:
            tmp = []
            if board[row][col] == "":
                row += 1
                continue
            while row < 15 and board[row][col] != "":
                tmp.append((row, col))
                row += 1
            if len(tmp) >= 2:
                pos.append(tmp)
    for row in range(15):
        col = 0
        while col < 15:
            tmp = []
            if board[row][col] == "":
                col += 1
                continue
            while col < 15 and board[row][col] != "":
                tmp.append((row, col))
                col += 1
            if len(tmp) >= 2:
                pos.append(tmp)
    return pos
def play(row,col,down,tiles,board):
    v, new_board = place_tiles(row, col, down, tiles, board)
    if not v:
        return -1
    _, invalid_new_words = get_all_words(new_board)
    if len(invalid_new_words):
        return -1
    pos = [set(x) for x in get_words_pos(new_board)]
    tiles_pos = set(get_board_changes(board, new_board))
    score = 0
    for p in pos:
        if len(p & tiles_pos):
            score += sum([get_value(new_board[r][c]) for r, c in p])
    if len(tiles) >= 7:
        score += 50
    return score
def best_play(tiles,board):
    scores = []
    for row in range(15):
        for col in range(15):
            for down in range(2):
                scores.append([play(row, col, down, tiles, board), row, col, down])
    scores.sort(key=lambda x: (-x[0], x[1], x[2], x[3]))
    if scores[0][0] != -1:
        return scores[0]
    return [-1, -1, -1, -1]

00008: HW10
bytecount: {'code': 1182, 'const': 365, 'code+const': 1547}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  valid=[]
  invalid=[]
  a=''
  b=''
  word=[]
  for i in range(15):
      for j in range(15):
          if board[i][j] != "":
              a+=board[i][j]
          else:
              if len(a)>1:
                  word.append(a)
              a=''
          if board[j][i] !="":
              b+=board[j][i]
          else:
              if len(b)>1:
                  word.append(b)
              b=''
      if len(a)>1:
          word.append(a)
      a=''
      if len(b)>1:
          word.append(b)
      b=''
  word.sort()
  for e in word:
      if is_valid(e):
          valid.append(e)
      else:
          invalid.append(e)
  return [valid,invalid]
def get_play(board, new_board):
  r=-1
  c=-1
  j=-1
  t=''
  d=0
  for i in range(15):
    for j in range(15):
      if board[i][j]!=new_board[i][j]:
        if r==-1 and c==-1:
          r=i
          c=j
        t+=new_board[i][j]
        if r!=i:
          d=1
  a=[r,c,d,t]
  return a
def play(row,col,down,tiles,board):
  ans=[]
  score=0
  x,y=place_tiles(row,col,down,tiles,board)
  if not x:
      return -1
  for i in range(15):
      a1=""
      a2=""
      b1=""
      b2=""
      for j in range(15):
          if not board[i][j]:
              a1+=" "
          if not y[i][j]:
              a2+=" "
          if not board[j][i]:
              b1+=" "
          if not y[j][i]:
              b2+=" "
          a1+=board[i][j]
          a2+=y[i][j]
          b1+=board[j][i]
          b2+=y[j][i]
      a2=a2.split()
      b2=b2.split()
      for w in a1.split():
          if is_valid(w) and w in a2:
              a2.remove(w)
      for w in b1.split():
          if len(w)>=2 and is_valid(w) and w in b2:
              b2.remove(w)
      for w in a2:
        if len(w)>=2 and not is_valid(w):
            return -1
        elif len(w)>=2:
            ans.append(w)
      for w in b2:
        if len(w)>=2 and not is_valid(w):
            return -1
        elif len(w)>=2:
            ans.append(w)
  for w in ans:
      for k in w:
          score+=get_value(k)
  if len(tiles)>=7:
      score+=50
  return score
def best_play(tiles,board):
  ans = [-1,-1,-1,-1]
  for i in range(15):
      for j in range(15):
          x = play(i ,j ,0 ,tiles ,board)
          y = play(i ,j ,1 ,tiles ,board)
          if x > ans[0]:
              ans = [x, i ,j ,0]
          if y > ans[0]:
              ans = [y, i ,j ,1]
  return ans

00009: HW10
bytecount: {'code': 1230, 'const': 439, 'code+const': 1669}
check_import({'allowable': ['math']}): none
def get_all_word_and_position(board):
    valid_words = []
    invalid_words = []
    pos = [[0,1],[1,0]]
    for i in range(15):
      for j in range(15):
        if board[i][j] != '':
          for k in range(len(pos)):
            newI = i-pos[k][0]
            newJ = j-pos[k][1]
            if newI < 0 or newJ < 0 or board[newI][newJ] == '':
              word = ''
              firstInd = [i,j]
              while firstInd[0] < 15 and firstInd[1] < 15 and board[firstInd[0]][firstInd[1]] != '':
                word += board[firstInd[0]][firstInd[1]]
                firstInd = [firstInd[0]+pos[k][0], firstInd[1]+pos[k][1]]
              if len(word) >= 2 :
                if is_valid(word):
                  valid_words.append([word,i,j,k])
                else:
                  invalid_words.append([word,i,j,k])
    return [sorted(valid_words),sorted(invalid_words) ]
def get_all_words(board):
    full=sum(board,[])
    valid=[]; invalid=[]
    for j in range(15):
      stR=''; stC=''
      for i in full[j*15:j*15+15]:
        if i=='':
          stR+=' '
        stR+=i
      for i in stR.split():
        if is_valid(i):
            valid.append(i)
        elif len(i)>=2:
            invalid.append(i)
      for i in full[j::15]:
        if i=='':
          stC+=' '
        stC+=i
      for i in stC.split():
        if is_valid(i):
            valid.append(i)
        elif len(i)>=2:
            invalid.append(i)
    return [sorted(valid),sorted(invalid)]
def get_play(board, new_board):
    s=''
    i,j,down=-1,-1,0
    for row in range(15):
        for co in range(15):
          if board[row][co]!=new_board[row][co] and i==-1 and j==-1:
              s+=new_board[row][co]
              i=row
              j=co
          elif board[row][co]!=new_board[row][co]:
              s+=new_board[row][co]
              if row==i: down=0
              elif co ==j: down=1
    return [i,j,down,s]
def play(row,col,down,tiles,board):
    can_do,new_board = place_tiles(row,col,down,tiles,board)
    word,inword = get_all_word_and_position(new_board)
    old_word,old_inword = get_all_word_and_position(board)
    getPlay = get_play(board, new_board)
    if not can_do: return -1
    elif inword != old_inword and len(inword)-len(old_inword)>=0 : return -1
    else:
      if len(tiles)>=7: c=50
      else: c=0
      for i in word:
        if i in old_word:
          old_word.remove(i)
        else:
          for l in i[0]:
            c+=get_value(l)
      if c!=0:return c
      else:return -1
def best_play(tiles,board):
    ans = [-1,-1,-1,-1]
    for row in range(15):
      for co in range(15):
        for d in range(2):
          score = play(row,co,d,tiles,board)
          if score > ans[0]:
            ans = [score, row, co, d]
    return ans

00010: HW10
bytecount: {'code': 1252, 'const': 587, 'code+const': 1839}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    x = '' ; y = ''
    for i in range(15):
        x += ' '
        y += ' '
        for j in range(15):
            if board[i][j] != '':
                x += board[i][j].upper()
            else:
                x += ' '
            if board[j][i] != '':
                y += board[j][i].upper()
            else:
                y += ' '
    z = (x+' '+y).split()
    l0 = [e for e in z if is_valid(e)]
    l0.sort()
    l1 = [e for e in z if not is_valid(e) and len(e) > 1]
    l1.sort()
    return [l0,l1]
def get_play(board, new_board):
    w = '' ; l = []
    for i in range(15):
        for j in range(15):
            if board[i][j].upper() != new_board[i][j].upper() :
                w += new_board[i][j].upper()
                l.append([i,j])
    l3 = 0
    if l[-1][0] > l[0][0]:
        l3 = 1
    return [l[0][0],l[0][1],l3,w]
def bonus(board):
    x = '' ; y = ''
    for i in range(15):
        x += ' '
        y += ' '
        for j in range(15):
            if board[i][j] != '':
                if x[-1] == ' ':
                    x+= str(i)+','+str(j)+','
                x += board[i][j].upper()
            else:
                x += ' '
            if board[j][i] != '':
                if y[-1] == ' ':
                    y+= str(j)+','+str(i)+','
                y += board[j][i].upper()
            else:
                y += ' '
    z = (x+' '+y).split()
    l0 = [[e.split(',')[0],e.split(',')[1],e.split(',')[2]] for e in z if is_valid(e.split(',')[2])]
    l0.sort()
    l1 = [e for e in z if not is_valid(e.split(',')[2]) and len(e.split(',')[2]) > 1]
    l1.sort()
    return [l0,l1]
def play(row,col,down,tiles,board):
    v,new_board = place_tiles(row,col,down,tiles,board)
    w,n = bonus(board) ; new_w,n2 = bonus(new_board)
    p = 0
    if not v or n2 != []:
        return -1
    else:
        for e in new_w:
            if e in w:
                w.remove(e)
            else:
                for f in e[2]:
                    p += get_value(f)
        if len(tiles) >= 7:
            p += 50
        return p
def best_play(tiles,board):
    l = []
    for i in range(15):
        for j in range(15):
            for k in range(2):
                l.append([-1*play(i,j,k,tiles,board),i,j,k])
    l.sort()
    b = l[0]
    if b[0] != 1:
        return [-1*b[0],b[1],b[2],b[3]]
    else:
        return [-1,-1,-1,-1]

00011: HW10
bytecount: {'code': 1276, 'const': 431, 'code+const': 1707}
check_import({'allowable': ['math']}): none
def get_all_words_forplay(board) :
  word = ''
  A = []
  B = []
  for i in range(15):
    m = 0
    n = 0
    for j in range(15):
      if board[i][j] != '' :
        if j < 14 and j >= m  and board[i][j+1] != '' :
          m = j 
          while m < 15  and board[i][m] != '' :
            word += board[i][m]
            m += 1
          if is_valid(word) :
            A.append([word,i,j,0])
          else :
            B.append([word])
          word = ''
      if board[j][i] != '' :
        if j < 14 and j >= n and board[j+1][i] != '' :
          n = j 
          while n < 15 and board[n][i] != '' :
            word += board[n][i]
            n += 1
          if is_valid(word) :
            A.append([word,j,i,1])
          else :
            B.append([word])
          word = ''
  return A,B
def get_all_words(board):
  word = ''
  A = []
  B = []
  for i in range(15):
    m = 0
    n = 0
    for j in range(15):
      if board[i][j] != '' :
        if j < 14 and j >= m  and board[i][j+1] != '' :
          m = j 
          while m < 15  and board[i][m] != '' :
            word += board[i][m]
            m += 1
          if is_valid(word) :
            A.append(word)
          else :
            B.append(word)
          word = ''
      if board[j][i] != '' :
        if j < 14 and j >= n and board[j+1][i] != '' :
          n = j 
          while n < 15 and board[n][i] != '' :
            word += board[n][i]
            n += 1
          if is_valid(word) :
            A.append(word)
          else :
            B.append(word)
          word = ''
  return [sorted(e for e in A), sorted(e for e in B)]
def get_play(board, new_board):
  checking_1 = True
  checking_2 = True
  word = ''
  d = 0
  for i in range(15):
    for j in range(15):
      if new_board[i][j] != board[i][j] :
        if checking_1 :
          m = i
          n = j
          checking_1 = False
        elif checking_2 :
          if m != i :
            d = 1 
          else :
            d = 0 
          checking_2 = False
        word += new_board[i][j]
  if len(word) == 1 :
    d = 0 
  return [m,n,d,word]
def play(row,col,down,tiles,board):
  count = 0
  X,nb = place_tiles(row,col,down,tiles,board)
  A,C = get_all_words_forplay(board)
  B,D = get_all_words_forplay(nb)
  if len(D) != 0 or X == False :
    return -1
  for e in B :
    if e not in A :
      for f in e[0] :
        count += get_value(f)
  if len(tiles) >= 7:
    count += 50
  return count
def best_play(tiles,board):
  ans = [-1,-1,-1,-1]
  for i in range(15):
    for j in range(15):
        for k in range(2):
          คะแนน = play(i,j,k,tiles,board)
          if คะแนน > ans[0] :
            ans = [คะแนน,i,j,k]
  return ans

00012: HW10
bytecount: {'code': 1400, 'const': 377, 'code+const': 1777}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  ans=[[],[]]
  for i in range(15):
    col=''
    for j in range(15):
      if(board[i][j]!=''):col+=board[i][j]
      else:col+=' '
    words=col.split()
    for k in words:
      if(is_valid(k)):
        ans[0].append(k)
      elif(len(k)>1):
        ans[1].append(k)
  for j in range(15):
    col=''
    for i in range(15):
      if(board[i][j]!=''):col+=board[i][j]
      else:col+=' '
    words=col.split()
    for k in words:
      if(is_valid(k)):
        ans[0].append(k)
      elif(len(k)>1):
        ans[1].append(k)
  ans[0].sort()
  ans[1].sort()
  return ans
def get_play(board, new_board):
  consi=[]
  for i in range(15):
    for j in range(15):
      if(board[i][j]!=new_board[i][j]):
        consi.append([i,j])
  consi.sort()
  if(len(consi)>1 and consi[0][0]==consi[1][0]):d=0
  elif(len(consi)>1 and consi[0][1]==consi[1][1]):d=1
  else:d=0
  word=''
  for i in consi:
    word+=new_board[i[0]][i[1]]
  return [consi[0][0],consi[0][1],d,word]
def play(row,col,down,tiles,board):
    i=row
    j=col
    di=dj=0
    if(down==0):dj=1
    else:di=1
    odi=(di+1)%2
    odj=(dj+1)%2
    b,nb=place_tiles(row,col,down,tiles,board)
    if(b==False):
      return -1
    while(i-di>-1 and j-dj>-1 and board[i-di][j-dj].isalpha()):
        i-=di
        j-=dj
    word=''
    l=0
    cnt=0
    while(i<15 and j<15):
        if(board[i][j].isalpha()):
            word+=board[i][j]
        elif(l-1 and jj-odj>-1 and board[ii-odi][jj-odj].isalpha()):
                consiw=board[ii-odi][jj-odj]+consiw
                ii-=odi
                jj-=odj
            ii=i
            jj=j
            while(ii+odi<15 and jj+odj<15 and board[ii+odi][jj+odj].isalpha()):
                consiw+=board[ii+odi][jj+odj]
                ii+=odi
                jj+=odj
            if(is_valid(consiw)):
                for k in consiw:
                    cnt+=get_value(k)
            elif(len(consiw)>1):
              return -1
            l+=1
        else:
          break
        i+=di
        j+=dj
    if(is_valid(word)):
        for k in word:
            cnt+=get_value(k)
        if(len(tiles)>6):cnt+=50
        return cnt
    else:
      return -1
def best_play(tiles,board):
  mx=r=c=d=-1
  for i in range(15):
    for j in range(15):
      for k in range(2):
        sc= play(i,j,k,tiles,board)
        if(mx

00013: HW10
bytecount: {'code': 1404, 'const': 440, 'code+const': 1844}
check_import({'allowable': ['math']}): none
def ex(b,d,x,c):
    r=""
    if d==0:
        p=c
        q=c+1
        while p>=0:
            if b[x][p]=="":
                break
            r=b[x][p]+r
            p-=1
        while q<15:
            if b[x][q]=="":
                break
            r+=b[x][q]
            q+=1
    else:
        p=x
        q=x+1
        while p>=0:
            if b[p][c]=="":
                break
            r=b[p][c]+r
            p-=1
        while q<15:
            if b[q][c]=="":
                break
            r+=b[q][c]
            q+=1
    return r
def get_all_words(board):
    b=copy_board(board)
    p=[[],[]]
    for f in "rr":
        r = range(15)
        for i in b:
            s=""
            for j in i:
                s+=j.strip()
                if j=="":
                    if len(s)>1:
                        p[int(is_valid(s))].append(s)
                    s=""
            if s!="" and len(s)>1:
                p[int(is_valid(s))].append(s)
        for i in r:
            for j in range(i):
                b[i][j],b[j][i]=b[j][i],b[i][j]
    p[1].sort()
    p[0].sort()
    return [p[1],p[0]]
def get_play(board, new_board):
    m=15
    s=15
    p=[]
    q=""
    r=range(15)
    for i in r:
        for j in r:
            if board[i][j]!=new_board[i][j]:
                p.append([i,j])
                q+=new_board[i][j]
    u=0
    if len(p)>1:
        if p[1][1]==p[0][1]:
            u=1
    return [p[0][0],p[0][1],u,q]
def play(row,col,down,tiles,board):
    n=place_tiles(row,col,down,tiles,board)
    s=get_all_words(n[1])
    c=0 if n[0] and len(s[1])==0 else -1
    if c==0:
        c+=sum([get_value(i) for i in ex(n[1],down,row,col)])
        rows=row
        cols=col
        tb = copy_board(board)
        if down==1:
            for i in range(15):
                for j in range(i):
                    n[1][i][j],n[1][j][i]=n[1][j][i],n[1][i][j]
                    tb[i][j],tb[j][i]=tb[j][i],tb[i][j]
            rows,cols=cols,rows
        for cs in range(cols,15):
            if n[1][rows][cs]!=tb[rows][cs] and len(ex(n[1],1,rows,cs))>1:
                c+=sum([get_value(i) for i in ex(n[1],1,rows,cs)])
        if len(tiles)>6:
            c+=50
    return c
def best_play(tiles,board):
    li = [-1,-1,-1,-1]
    for i in range(15):
        for j in range(15):
            for d in range(2):
                if len(tiles)==1 and d==1:
                    break
                tmp=copy_board(board)
                ss=play(i,j,d,tiles,tmp)
                if li[0]

00014: HW10
bytecount: {'code': 1516, 'const': 455, 'code+const': 1971}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    boardY = []
    val = []
    inval = []
    for No in range(15) :
      listY = []
      for lineY in board :
        listY.append(lineY[No])
      boardY.append(listY)
    for lineY in boardY :
      word = ''
      for ch in lineY :
        if 'A' <= ch.upper() <= 'Z' :
          word += ch.upper()
        else : 
          word += ','
      for wordi in word.split(",") :
        if len(wordi) >= 2 :
          if is_valid(wordi) :  
            val.append(wordi)
          else :
            inval.append(wordi) 
    for lineX in board :
      word = ''
      for ch in lineX :
        if 'A' <= ch <= 'Z' :
          word += ch
        else : 
          word += ','
      for wordi in word.split(',') :
        if len(wordi) >= 2 :
          if is_valid(wordi) :
            val.append(wordi)
          else:
            inval.append(wordi) 
    return [sorted(val),sorted(inval)]
def get_play(board, new_board):
    word = ''
    c = 0
    for i in range(15):
      d = 0
      for j in range(15) :
        if new_board[i][j] != board[i][j]:
          c += 1
          d += 1
          word += new_board[i][j]
          if c == 1 :
            row = i
            col = j
          if d == 1 :
            down = 1
          elif d >= 2 :
            down = 0
    if len(word) == 1 :
      down = 0      
    return [row,col,down,word]
def play(row,col,down,tiles,board):
    boardY = []
    logic, new_board = place_tiles(row,col,down,tiles,board)
    new_boardY = []
    Ans = []
    Score = 0
    for No in range(15) :
      listY = []
      NewY = []
      for lineY in board :
        listY.append(lineY[No])
      for NewLineY in new_board:
        NewY.append(NewLineY[No])
      boardY.append(listY)
      new_boardY.append(NewY)
    for i in range(15):
      TempX = ""
      TempY = ""
      TempNewX = ""
      TempNewY = ""
      for j in range(15) :
        if board[i][j] == "":
          TempX += " "
        TempX += board[i][j]
        if boardY[i][j] == "":
          TempY += " "
        TempY += boardY[i][j]
        if new_board[i][j] == "":
          TempNewX += " "
        TempNewX += new_board[i][j]
        if new_boardY[i][j] == "":
          TempNewY += " "
        TempNewY += new_boardY[i][j]
      TempX = TempX.split()
      TempY = TempY.split()
      TempNewX = TempNewX.split()
      TempNewY = TempNewY.split()
      for word in TempX:
        if is_valid(word) and word in TempNewX:
          TempNewX.remove(word)
      for word in TempY:
        if is_valid(word) and word in TempNewY:
          TempNewY.remove(word)
      for word in TempNewX:
        if is_valid(word):
          Ans.append(word)
        elif len(word) >= 2 and not is_valid(word):
          logic = False
      for word in TempNewY:
        if is_valid(word):
          Ans.append(word)
        elif len(word) >= 2 and not is_valid(word):
          logic = False
    for word in Ans:
      for ch in word:
        Score += get_value(ch)
    if len(tiles) >= 7:
        Score += 50
    if not logic:
        Score = -1
    return Score
def best_play(tiles,board):
    oupscore = {}
    towant = []
    for i in range(15):
      for j in range(15):
        score0 = play(j,i,0,tiles,board)
        score1 = play(j,i,1,tiles,board)
        if score0 > 0 :
          oupscore[j,i,0] = score0
        if score1 > 0 :
          oupscore[j,i,1] = score1
    if oupscore == {} :
      return[-1,-1,-1,-1]
    else :
      maxwant = max(list(oupscore.values()))
      for item in oupscore :
        if oupscore[item] ==  maxwant :
          towant.append(list(item))
      point = min(towant)
      r,c,d = point
      return [maxwant,r,c,d]

00015: HW10
bytecount: {'code': 1548, 'const': 501, 'code+const': 2049}
check_import({'allowable': ['math']}): none
def get_horizontal_words(i,board,start, end, p):
  hword = ""
  for j in range(start,end,p) :
    if board[i][j] != "" :
      hword += board[i][j]
    else:
      return hword
  return hword
def get_vertical_words(j,board,start, end, p):
  vword = ""
  for i in range(start,end,p) :
    if board[i][j] != "" :
        vword += board[i][j]
    else:
        return vword
  return vword
def get_all_words(board):
    words = []
    valid_words = []
    invalid_words = []
    for i in range(15) :
      hword = ""
      for j in range(15) :
        if board[i][j] != "" :
          hword += board[i][j]
        else:
          if len(hword) > 1:
            words.append(hword)
          hword = ""
      if len(hword) > 1:
        words.append(hword)
    for j in range(15):
      vword = ""
      for i in range(15) :
        if board[i][j] != "" :
          vword += board[i][j]
        else:
          if len(vword) > 1:
            words.append(vword)
          vword = ""
      if len(vword) > 1:
        words.append(vword)    
    for w in words :
      if is_valid(w) :
        valid_words.append(w)
      else :
        invalid_words.append(w)
    valid_words.sort()
    invalid_words.sort()
    return [valid_words,invalid_words]
def get_play(board, new_board):
    isVertical = 0
    row,column = 0,0
    add_word   = ""
    found = False
    for i in range(len(board)) :
      for j in range(len(board[i])) :
        if board[i][j] != new_board[i][j] :
          row,column = i,j
          for iv in range(i+1,15) :
            if board[iv][j].upper() != new_board[iv][j].upper() :
              isVertical = 1
          found = True
          break
      if found :
        break
    if isVertical:
      for i in range(row,15):
        if board[i][column] != new_board[i][column] :
          add_word += new_board[i][column]
    else:
      for j in range(column,15):
        if board[row][j] != new_board[row][j] :
          add_word += new_board[row][j]
    return [row,column,isVertical,add_word]
def play(row,col,down,tiles,board):
    score = 0
    words = []
    valid,new_board = place_tiles(row,col,down,tiles,board)
    if down and valid:  
      for i in range(row,15):
        if board[i][col] !=  new_board[i][col]:
          word = get_horizontal_words(i,new_board,col-1, -1, -1)[::-1] + get_horizontal_words(i,new_board,col, 15, 1)
          if len(word) > 1:
            words.append(word)
      word = get_vertical_words(col,new_board,row-1,-1,-1)[::-1] + get_vertical_words(col,new_board,row,15,1)
      if len(word) > 1:
          words.append(word)
    elif valid :
      for j in range(col,15):
        if board[row][j] !=  new_board[row][j]:
          word = "".join(get_vertical_words(j,new_board,row-1,-1,-1))[::-1] + get_vertical_words(j,new_board,row,15,1)
          if len(word) > 1:
            words.append(word)
      word = get_horizontal_words(row,new_board,col-1,-1,-1)[::-1] + get_horizontal_words(row,new_board,col,15,1)
      if len(word) > 1:
          words.append(word)
    else:
      return -1
    for ws in words:
      if is_valid(ws) :
        for w in ws:
          score += get_value(w)
      else:
        return -1
    if len(tiles) >= 7:
      score += 50
    if score > 0:
      return score
    else:
      return -1
def best_play(tiles,board):
    maxscore,maxi,maxj,maxdown = -1,-1,-1,-1
    for i in range(15):
      for j in range(15):
        valid,new_board = place_tiles(i,j,0,tiles,board)
        if valid :
          score_horizon = play(i,j,0,tiles,board)
          if score_horizon > maxscore:
            maxscore = score_horizon
            maxi = i
            maxj = j
            maxdown = 0
        valid,new_board = place_tiles(i,j,-1,tiles,board)
        if valid : 
          score_vertical = play(i,j,1,tiles,board)
          if score_vertical > maxscore:
            maxscore = score_vertical
            maxi = i
            maxj = j
            maxdown = 1
    return [maxscore,maxi,maxj,maxdown]

00016: HW10
bytecount: {'code': 1678, 'const': 505, 'code+const': 2183}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  out = [[],[]]
  for i in range(15):
    word = ''
    for j in range(15):
      if board[i][j] != '':
        word += board[i][j].upper()
      if j == 14 or board[i][j] == '':
        if word != '' and len(word) >= 2:
          valid = is_valid(word)
          if valid == True:
            out[0].append(word)
          if valid == False:
            out[1].append(word)
        word = ''
  for j in range(0,15):
    word = ''
    for i in range(0,15):
      if board[i][j] != '':
        word += board[i][j].upper()
      if i == 14 or board[i][j] == '':
        if word != '' and len(word) >= 2:
          valid = is_valid(word)
          if valid == True:
            out[0].append(word)
          if valid == False:
            out[1].append(word)
        word = ''
  out[0].sort()
  out[1].sort()
  return out
def get_play(board, new_board):
  listoftiles = []
  tiles = ''
  counti = 0
  countj = 0
  for i in range(15):
    for j in range(15):
      if board[i][j] != new_board[i][j]:
        tiles += new_board[i][j]
        listoftiles.append([new_board[i][j],i,j])
  for t in range(len(listoftiles)-1):
    if listoftiles[t][1] == listoftiles[t+1][1]:
      counti += 1
    if listoftiles[t][2] == listoftiles[t+1][2]:
      countj += 1
  row = listoftiles[0][1]
  col = listoftiles[0][2]
  for [t,i,j] in listoftiles:
    if row>i:
      row = i
    if col>j:
      col = j
  if len(tiles) == 1:
    down = 0
  elif counti>countj :
    down = 0
  elif counti= 7:
    score += 50
  return score
def best_play(tiles,board):
  listofchoice = []
  for i in range(15):
    for j in range(15):
      for t in range(2):
        a = play(i,j,t,tiles,board)
        if a > 0:
          listofchoice.append([a,i,j,t])
  listofchoice.sort()
  if len(listofchoice) == 0:
    return [-1,-1,-1,-1]
  else:
    bestscore = listofchoice[-1][0]
    for i in range(len(listofchoice)):
      if listofchoice[i][0] == bestscore:
        return listofchoice[i]
def get_all_words_withij(board):
  out = [[],[]]
  for i in range(15):
    word = ''
    for j in range(15):
      if board[i][j] != '':
        word += board[i][j].upper()
      if j == 14 or board[i][j] == '':
        if word != '' and len(word) >= 2:
          valid = is_valid(word)
          if valid == True:
            out[0].append([word,i,j-len(word)])
          if valid == False:
            out[1].append([word,i,j-len(word)])
        word = ''
  for j in range(0,15):
    word = ''
    for i in range(0,15):
      if board[i][j] != '':
        word += board[i][j].upper()
      if i == 14 or board[i][j] == '':
        if word != '' and len(word) >= 2:
          valid = is_valid(word)
          if valid == True:
            out[0].append([word,i-len(word),j])
          if valid == False:
            out[1].append([word,i-len(word),j])
        word = ''
  out[0].sort()
  out[1].sort()
  return out

00017: HW10
bytecount: {'code': 1682, 'const': 420, 'code+const': 2102}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    gaw = [[], []]
    word = ''
    gaw = [[], []]
    word = ''
    for i in board:
        for w in i:
            if w != '':
                word += w
            if w == '' and len(word) != 0:
                if is_valid(word):
                    gaw[0] += [word]
                elif len(word) > 1:
                    gaw[1] += [word]
                word = ''
        if word != '' :
                if is_valid(word):
                    gaw[0] += [word]
                elif len(word) > 1:
                    gaw[1] += [word]
                word = ''
    for r in range(15):
        for c in range(15):
            if board[c][r] != '':
                word += board[c][r]
            if board[c][r] == '' and len(word) != 0:
                if is_valid(word):
                    gaw[0] += [word.upper()]
                elif len(word) > 1:
                    gaw[1] += [word.upper()]
                word = ''
        if word != '' :
                if is_valid(word):
                    gaw[0] += [word.upper()]
                elif len(word) > 1:
                    gaw[1] += [word.upper()]
                word = ''
    gaw[0].sort()
    gaw[1].sort()
    return gaw
def get_play(board, new_board):
    gp = []
    tiles = ''
    first = True
    check_r = 0
    l = []
    for i in range(15):
        for j in range(15):
            if board[i][j] != new_board[i][j]:
                tiles += new_board[i][j]
                l.append([i, j])
    if len(tiles) == 1:
                down = 0
    elif l[0][0] == l[1][0]:
                down = 0
    else:
                down = 1
    row = l[0][0]
    col = l[0][1]
    tiles.upper()
    return [row, col, down, tiles]
def valid(v, iv, loc, word):
    if is_valid(word):
        v.append([word, loc])
    elif len(word) > 1:
        iv.append([word, loc])
    return v, iv, [], ""
def get_all_words_location(board):
    word1 = ""
    word2 = ""
    v = []
    iv = []
    List_1 = []
    List_2 = []
    for i in range(len(board)):
        for j in range(len(board)):
            if board[i][j] != "":
                word1 += board[i][j]
                List_1.append([i, j])
            if board[j][i] != "":
                word2 += board[j][i]
                List_2.append([j, i])
            if board[i][j] == "" and len(word1) + len(List_1) != 0:
                v, iv, List_1, word1 = valid(v, iv, List_1, word1)
            if board[j][i] == "" and len(word2) + len(List_2) != 0:
                v, iv, List_2, word2 = valid(v, iv, List_2, word2)
        if len(word1) + len(List_1) != 0:
            v, iv, List_1, word1 = valid(v, iv, List_1, word1)
        if len(word2) + len(List_2) != 0:
            v, iv, List_2, word2 = valid(v, iv, List_2, word2)
    v.sort()
    iv.sort()
    return [v, iv]
def play(row,col,down,tiles,board):
    new_board = place_tiles(row, col, down, tiles, board)[1]
    aw = get_all_words_location(board)
    aw2 = get_all_words_location(new_board)
    score = 0
    all_word = []
    pos = []
    for k in aw[0]:
        pos.append(k[1])
    if aw == aw2 or len(aw2[1]) != 0:
        return -1
    for i in aw2[0]:
        if i[1] not in pos:
            all_word.append(i)
    for j in all_word:
        for k in j[0]:
            score += get_value(k)            
    if len(tiles) >= 7:
        score += 50
    return score
def best_play(tiles,board):
    all_score = []
    cond = False
    for i in range(15):
        for j in range(15):
            for d in range(2):
                all_score.append(play(i, j, d, tiles, board))
    all_score.sort()
    for i in range(15):
        if cond:
            break
        for j in range(15):
            if cond:
                break
            for d in range(2):
                if play(i, j, d, tiles, board) == all_score[-1]:
                    row = i
                    col = j
                    down = d
                    cond = True
                    break
    score = all_score[-1]
    if score == -1:
        return [-1,-1,-1,-1]
    return [score, row, col, down]

00018: HW10
bytecount: {'code': 1710, 'const': 371, 'code+const': 2081}
check_import({'allowable': ['math']}): none
def  li_word_in_line (line):
      li = []
      for e in line:
        if e != "":
          li += e
        else :
          li += [" "]
      li = "".join(li).strip().split()
      return li
def get_all_words(board):
    valid = [] ; invalid = []
    for i in range (15):
      li = li_word_in_line (board[i])
      for f in li:
        if li != [] and len(f) > 1:
          if is_valid(f):
            valid.append(f.upper())
          else:
            invalid.append(f.upper())
      li = []
      column = [ e[i] for e in board ] 
      li = li_word_in_line (column)
      for f in li:
        if li != [] and len(f) > 1:
          if is_valid(f):
            valid.append(f.upper())
          else:
            invalid.append(f.upper())
    valid.sort() ; invalid.sort()
    return [valid , invalid]
def get_play(board, new_board):
    word = []; pos = []
    for i in range (15):
      a = board[i] ; b = new_board[i]
      if a != b:
        for j in range (15):
          if a[j] != b[j]:
            word += b[j]
            pos.append([i,j])
    i,j = pos[0]
    if len(pos) == 1:
      down = 0
    elif i == pos[1][0]:
      down = 0
    else:
      down = 1
    word = "".join(word)
    return [i , j , down , word.upper()]
def play(row,col,down,tiles,board):
    if place_tiles(row,col,down,tiles,board)[0] == False:
      return -1
    new_board = place_tiles(row,col,down,tiles,board)[1]
    new_word = []; pos = []
    if down == 0:
      n = len(tiles) ; j = 0
      while j < n:
        if board[row][col+j] == "" :
          pos.append([row,col+j])
        else:
          n += 1
        j += 1
    if down == 1:
      n = len(tiles) ; i = 0
      while i < n:
        if board[row+i][col] == "" :
          pos.append([row+i,col])
        else:
          n += 1
        i += 1
    for r in range (15):
      line_pos = [] ; li_line_pos = []
      for c in range (15):
        if new_board[r][c] != "":
          line_pos.append([r , c])
        else: 
          li_line_pos.append(line_pos)
          line_pos = [] 
      li_line_pos.append(line_pos)
      new_pos = []
      for e in li_line_pos:
        if len(e) != 1 and e != []:
          new_pos.append(e)        
      line = new_board[r]
      li_word = li_word_in_line (line)
      line_word = []
      for word in li_word:
        if len(word) > 1 :
          line_word.append(word)
      for li_pos in new_pos:
        check = 0
        for e in li_pos:
          if e in pos:
            check += 1
        if check > 0:
          i = new_pos.index(li_pos)
          new_word.append(line_word[i]) 
    for c in range (15):
      line_pos = [] ; li_line_pos = []
      for r in range (15):
        if new_board[r][c] != "":
          line_pos.append([r , c])
        else: 
          li_line_pos.append(line_pos)
          line_pos = []
      li_line_pos.append(line_pos)
      new_pos = []
      for e in li_line_pos:
        if len(e) != 1 and e != []:
          new_pos.append(e)
      line = [e[c] for e in new_board ]
      li_word = li_word_in_line (line)
      line_word = []
      for word in li_word:
        if len(word) > 1 :
          line_word.append(word)
      for li_pos in new_pos:
        check = 0
        for e in li_pos:
          if e in pos:
            check += 1        
        if check > 0:
          i = new_pos.index(li_pos)
          new_word.append(line_word[i])
    score = 0
    for word in new_word:
      if is_valid(word):
        for char in word:
          score += get_value(char)
      else:
        return -1
    if len(tiles) >= 7 :
      score += 50
    return score
def best_play(tiles,board):
  li = []
  for down in range (2):
    for i in range (15):
      for j in range (15):
        score = play(i,j,down,tiles,board)
        li.append([-score , i ,j , down])
  li.sort()
  li[0][0] = -li[0][0]
  if li[0][0] == -1:
    return [-1,-1,-1,-1]
  return li[0]

00019: HW10
bytecount: {'code': 1778, 'const': 855, 'code+const': 2633}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    x=[]
    for i in range(15):
        y=[]
        for e in f(board[i]):
            x.append(e)
        for j in range(15):
            y.append(board[j][i])
        for e in f(y):
            x.append(e)
    return [sorted([e for e in x if is_valid(e)]),sorted([e for e in x if not is_valid(e)])]
def get_play(board, new_board):
    b=False
    for i in range(15):
        for j in range(15):
            if board[i][j]!=new_board[i][j]:
                b=True
                break
        if b:
            break
    k=0
    text=''
    for z in range(i+1,15):
        if board[z][j]!=new_board[z][j]:
            k=1
            break
    if k:
        for z in range(15):
            if board[z][j]!=new_board[z][j]:
                text+=new_board[z][j]
    else:
        for z in range(15):
            if board[i][z]!=new_board[i][z]:
                text+=new_board[i][z]
    return [i,j,k,text]
def play(row,col,down,tiles,board):
    x=get_all_words_and_index(place_tiles(row,col,down,tiles,board)[1])
    y=get_all_words_and_index(board)
    if not place_tiles(row,col,down,tiles,board)[0] or x[1]!=[]:
        return -1
    for e in y[0]:
        if e in x[0]:
            x[0].remove(e)
    if len(tiles)>=7:
        s=50
    else:
        s=0
    ss=0
    for e in x[0]:
        ss+=sum([get_value(u) for u in e[0]])
    return ss+s
def best_play(tiles,board):
    b=False
    x={}
    for i in range(15):
        for j in range(15):
            for k in range(2):
                s=play(i,j,k,tiles,board)
                if s!=-1:
                    b=True
                    if not s in x:
                        x[s]=[[i,j,k]]
                    else:
                        x[s].append([i,j,k])
    if not b:
        return [-1,-1,-1,-1]
    i=sorted(x)[::-1][0]
    return [i]+sorted(x[i])[0]
def f(x):
    t=''
    for e in x:
        if 'A'<=e<='Z':
          t+=e
        else:
          t+=' '
    return [e for e in t.strip().split() if len(e)>=2]
def ff(x):
    t=''
    for e in x:
        if 'A'<=e<='Z':
          t+=e
        else:
          t+=' '
    return [e for e in t.strip().split()]
def g(i,x):
    t=''
    for z in range(len(x)):
        if 'A'<=x[z]<='Z':
            t+=str(i)+str(z)
        else:
            t+=' '
    return [e for e in t.strip().split()]
def h(i,x):
    t=''
    for z in range(len(x)):
        if 'A'<=x[z]<='Z':
            t+=str(z)+str(i)
        else:
            t+=' '
    return [e for e in t.strip().split()]
def z(x,y):
    z=[]
    for i in range(len(x)):
        z.append([x[i],y[i]])
    return z
def get_all_words_and_index(board):
    x=[]
    for i in range(15):
        y=[]
        x+=(z(ff(board[i]),g(i,board[i])))
        for j in range(15):
            y.append(board[j][i])
        x+=(z(ff(y),h(i,y)))
    x=[e for e in x if len(e)>0]
    return [sorted([e for e in x if is_valid(e[0]) and len(e[0])>=2]),sorted([e for e in x if not is_valid(e[0]) and len(e[0])>=2])]

00020: HW10
bytecount: {'code': 1894, 'const': 453, 'code+const': 2347}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    all_result=[]
    for i in range(0,15) : 
      word=''
      for j in range(0,15) : 
        if(board[i][j]!='') :
          word=word+board[i][j]
          if(j==14) :
            if(len(word)>=2) :
              all_result.append(word)
            break
          if(board[i][j+1]=='') :
            if(len(word)>=2) :
              all_result.append(word)
            word=''
    for i in range(0,15) : 
      word=''
      for j in range(0,15) : 
        if(board[j][i]!='') :
          word=word+board[j][i]
          if(j==14) :
            if(len(word)>=2) :
              all_result.append(word)
            break
          if(board[j+1][i]=='') :
            if(len(word)>=2) :
              all_result.append(word)
            word=''
    valid_result = []
    invalid_result=[]
    for i in all_result :
      if(is_valid(i)) :
        valid_result.append(i)
      else :
        invalid_result.append(i)
    valid_result.sort()
    invalid_result.sort()
    return [valid_result,invalid_result]
def get_play(board, new_board):
    check=1
    for i in range(0,15) :
      for j in range(0,15) :
        if(new_board[i][j]!='' and board[i][j]=='') : 
          start_i=i
          start_j=j
          check=0
          break
      if(check==0) : 
        break
    word=''
    for j in range(start_j,15) :
      if(new_board[start_i][j]!=board[start_i][j]) :
        word=word+new_board[start_i][j]
    if(len(word)>=2) :
      return [start_i,start_j,0,word]
    word=''
    for i in range(start_i,15) :
      if(new_board[i][start_j]!=board[i][start_j]) :
        word=word+new_board[i][start_j]
    if(len(word)>=2) :
      return [start_i,start_j,1,word]
    return [start_i,start_j,0,new_board[start_i][start_j]]
def get_word_score(x) :
  summary=0
  for i in x :
    summary+=get_value(i)
  return summary
def play(row,col,down,tiles,board):
  if(place_tiles(row,col,down,tiles,board)[0]==False) :
    return -1
  length_of_tiles=len(tiles)
  new_board=place_tiles(row,col,down,tiles,board)
  list_of_position=[]
  if(len(tiles)==1) :
    list_of_position.append([row,col])
  else :
    if(down==0) :
      for j in range(col,15) :
        if(len(tiles)>0) :
          if(board[row][j]=='') :
            list_of_position.append([row,j])
            if(len(tiles)==1) :
              tiles=''
              break
            tiles=tiles[1:]
    else :
      for i in range(row,15) :
        if(len(tiles)>0) :
          if(board[i][col]=='') :
            list_of_position.append([i,col])
            if(len(tiles)==1) :
              tiles=''
              break
            tiles=tiles[1:]
  """
  all_result=[]
  # check by each row เช็คตามแนวนอน
  for i in range(0,15) : #each row แต่ละแนวนอน --------------
    word=''
    is_in_position=0
    for j in range(0,15) : #แต่ละคำใน row นั้นๆ
      #if [i,j] in list_of_position :
        #is_in_position=1
      if(board[i][j]!='') :
        word=word+board[i][j]
        if(j==14) :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          break
        if(board[i][j+1]=='') :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          word=''
          is_in_position=0
  # check by each column
  for i in range(0,15) : #each column แต่ละแนวตั้ง
    word=''
    is_in_position=0
    for j in range(0,15) : #แต่ละคำใน column นั้นๆ
      if [j,i] in list_of_position :
        is_in_position=1
      if board[j][i]!='' :
        word=word+board[j][i]
        if(j==14) :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          break
        if(board[j+1][i]=='') :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          word=''
          is_in_position=0
  #return all_result"""
  all_result=[]
  board=new_board[1]
  for i in range(0,15) : 
    word=''
    is_in_position=0
    for j in range(0,15) : 
      if([i,j] in list_of_position) :
        is_in_position=1
      if(board[i][j]!='') :
        word=word+board[i][j]
        if(j==14) :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          break
        if(board[i][j+1]=='') :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          word=''
          is_in_position=0
  for i in range(0,15) : 
    word=''
    is_in_position=0
    for j in range(0,15) : 
      if([j,i] in list_of_position) :
        is_in_position=1
      if(board[j][i]!='') :
        word=word+board[j][i]
        if(j==14) :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          break
        if(board[j+1][i]=='') :
          if(len(word)>=2 and is_in_position==1) :
            all_result.append(word)
          word=''
          is_in_position=0
  scores=0
  for i in all_result :
    scores+=get_word_score(i)
    if(is_valid(i)==False) :
      return -1
  if(length_of_tiles>=7) :
    scores+=50
  return scores
def best_play(tiles,board):
  list_of_scores=[]
  for i in range(0,15) :
    for j in range(0,15) :
      if(place_tiles(i,j,0,tiles,board)[0]==True) :
        list_of_scores.append(play(i,j,0,tiles,board))
      if(place_tiles(i,j,1,tiles,board)[0]==True) :
        list_of_scores.append(play(i,j,1,tiles,board))
  maximum=max(list_of_scores)
  if(maximum==-1) :
    return [-1,-1,-1,-1]
  for i in range(0,15) :
    for j in range(0,15) :
      if(place_tiles(i,j,0,tiles,board)[0]==True and maximum==play(i,j,0,tiles,board)) :
        return[maximum,i,j,0]
      if(place_tiles(i,j,1,tiles,board)[0]==True and maximum==play(i,j,1,tiles,board)) :
        return [maximum,i,j,1]

00021: HW10
bytecount: {'code': 1976, 'const': 369, 'code+const': 2345}
check_import({'allowable': ['math']}): none
def get_pos(board):
  allword = []
  valid_words = []
  book = ''
  allpos = []
  c = 0
  allthing = []
  for i in range(len(board)):
    c = 0
    book = ''
    allpos = []
    for j in range(len(board[0])):
      if get_value(board[i][j])>0:
          c = c+1
          book = book+str(board[i][j])
          allpos.append(str(i)+str(j))
          cc = int(c)
          if (cc>=2) and (j==len(board[0])-1):
            allword.append(book)
            allthing.append([book,allpos])
      else:
          if c>=2:
            allword.append(book)
            allthing.append([book,allpos])
          c=0
          book = ''
          allpos = []
  c = 0
  allpos = []
  for x in range(len(board[0])):
    c = 0
    book = ''
    allpos = []
    for y in range(len(board)):
      if get_value(board[y][x])>0:
          c = c+1
          cc = int(c)
          book = book + str(board[y][x])
          allpos.append(str(y)+str(x))
          if (cc>=2) and (y==len(board[0])-1):
            allword.append(book)
            allthing.append([book,allpos])
      else:
          if c>=2:
            allword.append(book)
            allthing.append([book,allpos])
          book = ''
          c= 0
          allpos = []
  for i in allword:
    if is_valid(i):
      valid_words.append([i])
  return allthing
def get_all_words(board):
  allword = []
  valid_words = []
  invalid_words = []
  book = ''
  c = 0
  for i in range(len(board)): 
    c = 0
    book = ''
    for j in range(len(board[0])):
      if get_value(board[i][j])>0:
          c = c+1
          book = book+str(board[i][j])
          cc = int(c)
          if (cc>=2) and (j==len(board[0])-1):
            allword.append(book)
      else:
          if c>=2:
            allword.append(book)
          c=0
          book = ''
  c = 0
  for x in range(len(board[0])):
    c = 0
    book = ''
    for y in range(len(board)):
      if get_value(board[y][x])>0:
          c = c+1
          cc = int(c)
          book = book + str(board[y][x])
          if (cc>=2) and (y==len(board[0])-1):
            allword.append(book)
      else:
          if c>=2:
            allword.append(book)
          book = ''
          c= 0
  for i in allword:
    if is_valid(i):
      valid_words.append(i)
    else:
      invalid_words.append(i)
  valid_words.sort()
  invalid_words.sort()
  return [valid_words,invalid_words]
def get_play(board, new_board):
  allchar = []
  tryrow = []
  trycol = []
  down = 0
  for y in range(len(board)):
    for x in range(len(board[0])):
      if board[y][x] != new_board[y][x]:
        allchar.append(new_board[y][x])
        tryrow.append(y)
        trycol.append(x)
  tiles = ''.join(allchar)
  row = min(tryrow)
  col = min(trycol)
  if len(allchar) >1:
    if tryrow[0] == tryrow[1]:
      down = 0
    elif trycol[0] == trycol[1]:
      down = 1
  elif len(allchar) == 1:
    down = 0
  return [row,col,down,tiles]
def play(row,col,down,tiles,board):
  score = 0
  oldword = get_all_words(board)
  board1 = copy_board(board)
  new_board = place_tiles(row,col,down,tiles,board1)[1]
  old = get_all_words(board1)
  new = get_all_words(new_board)
  pold = get_pos(board1)
  pnew = get_pos(new_board)
  listans = []
  if old[1] != new[1] or new_board == board:
    score = -1
  elif old[1] == new[1]:
    for i in pnew:
      if i in pold:
        pos = pold.index(i)
        pold = pold[:pos:]+pold[pos+1::]
      else:
        listans.append(i[0])
    for i in listans:
      for j in i:
        score = score+get_value(j)
    if len(tiles) >= 7 :
      score = score+50
  return score
def best_play(tiles,board):
  allscore=  []
  for y in range(len(board)):
    for x in range(len(board[0])):
      if place_tiles(y,x,0,tiles,board)[0] == False:
        allscore.append([-1,-1,-1,-1])
      elif place_tiles(y,x,0,tiles,board)[0] == True:
        allscore.append([play(y,x,0,tiles,board),y,x,0])
  for x in range(len(board[0])):
    for y in range(len(board)):
      if place_tiles(y,x,1,tiles,board)[0] == False:
        allscore.append([-1,-1,-1,-1])
      elif place_tiles(y,x,1,tiles,board)[0] == True:
        allscore.append([play(y,x,1,tiles,board),y,x,1])
  allscore.sort()
  scoreonly = []
  for i in allscore:
    scoreonly.append(i[0])
  m = max(scoreonly)
  for i in allscore:
    if i[0] == m:
      [score,row,col,down] = i
      break
  return [score,row,col,down]

00022: HW10
bytecount: {'code': 2126, 'const': 369, 'code+const': 2495}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  listOfWords = [[],[]]
  validWords = []
  invalidWords = []
  word = ''
  for i in range(len(board)):
    if len(word) > 1:
      if is_valid(word):
        validWords += [word]
      else:
        invalidWords += [word]
    word = ''
    for j in range(len(board[0])):
      if len(board[i][j]) == 1:
        word += board[i][j]
      elif len(board[i][j]) == 0 and len(word) > 1:
        if is_valid(word):
          validWords += [word]
        else:
          invalidWords += [word]
        word = ''
      else:
        word = ''
  if len(word) > 1:
    if is_valid(word):
      validWords += [word]
    else:
      invalidWords += [word]
  word = ''
  for j in range(len(board[0])):
    if len(word) > 1:
      if is_valid(word):
        validWords += [word]
      else:
        invalidWords += [word]
    word = ''
    for i in range(len(board)):
      if len(board[i][j]) == 1:
        word += board[i][j]
      elif len(board[i][j]) == 0 and len(word) > 1:
        if is_valid(word):
          validWords += [word]
        else:
          invalidWords += [word]
        word = ''
      else:
        word = ''
  if len(word) > 1:
    if is_valid(word):
      validWords += [word]
    else:
      invalidWords += [word]
  validWords.sort()
  invalidWords.sort()
  listOfWords[0] = validWords
  listOfWords[1] = invalidWords
  return listOfWords
def get_play(board, new_board):
  tiles = ''
  listOfWords = []
  for i in range(len(board[0])):
    tiles = ''
    for j in range(len(board)):
      if new_board[j][i] != board[j][i]:
        if tiles == '':
          row = j
          col = i
        tiles += new_board[j][i]
    if tiles != '':
      listOfWords.append(tiles)
  if len(listOfWords) > 1:
    for j in range(len(board[0])):
      tiles = ''
      for i in range(len(board)):
        if new_board[j][i] != board[j][i]:
          if tiles == '':
            row = j
            col = i
          tiles += new_board[j][i]
      if tiles != '':
        down = 0
        return [row,col,down,tiles] 
  else:
    down = 1
    tiles = listOfWords[0]
    if len(tiles) == 1:
      down = 0
    return [row,col,down,tiles]
def play(row,col,down,tiles,board):
  if place_tiles(row,col,down,tiles,board)[0] == False:
    return -1
  newBoard = place_tiles(row,col,down,tiles,board)[1]
  totalScores = 0
  wordBoard = get_all_words_v2(board)[0]
  wordNewBoard = get_all_words_v2(newBoard)[0]
  invalidNewWord = get_all_words_v2(newBoard)[1]
  if invalidNewWord != []:
    return -1
  for e in wordNewBoard:
    if e not in wordBoard:
      for s in e[0]:
        totalScores += get_value(s)
    else:
      wordBoard.remove(e)
  if len(get_play(board, newBoard)[3]) >= 7:
    totalScores += 50
  return totalScores
def get_all_words_v2(board):
  listOfWords = [[],[]]
  validWords = []
  invalidWords = []
  word = ''
  for i in range(len(board)):
    if len(word) > 1:
      if is_valid(word):
        validWords += [[word,row,col,0]]
      else:
        invalidWords += [word]
    word = ''
    for j in range(len(board[0])):
      if len(board[i][j]) == 1:
        if len(word) == 0:
          row = j;col = i
        word += board[i][j]
      elif len(board[i][j]) == 0 and len(word) > 1:
        if is_valid(word):
          validWords += [[word,row,col,0]]
        else:
          invalidWords += [word]
        word = ''
      else:
        word = ''
  if len(word) > 1:
    if is_valid(word):
      validWords += [[word,row,col,0]]
    else:
      invalidWords += [word]
  word = ''
  for j in range(len(board[0])):
    if len(word) > 1:
      if is_valid(word):
        validWords += [[word,row,col,1]]
      else:
        invalidWords += [word]
    word = ''
    for i in range(len(board)):
      if len(board[i][j]) == 1:
        if len(word) == 0:
          row = i;col = j
        word += board[i][j]
      elif len(board[i][j]) == 0 and len(word) > 1:
        if is_valid(word):
          validWords += [[word,row,col,1]]
        else:
          invalidWords += [word]
        word = ''
      else:
        word = ''
  if len(word) > 1:
    if is_valid(word):
      validWords += [[word,row,col,1]]
    else:
      invalidWords += [word]
  validWords.sort()
  invalidWords.sort()
  listOfWords[0] = validWords
  listOfWords[1] = invalidWords
  return listOfWords
def best_play(tiles,board):
  listOfScore = []
  for i in range(len(board)):
    for j in range(len(board[0])):
      if play(i,j,0,tiles,board) != -1:
        listOfScore += [[i,j,0,play(i,j,0,tiles,board)]]
      if play(i,j,1,tiles,board) != -1:
        listOfScore += [[i,j,1,play(i,j,1,tiles,board)]]
  if len(listOfScore) == 0:
    return [-1,-1,-1,-1]
  bestScore = -1
  for l in listOfScore:
    if l[3] > bestScore:
      bestScore = l[3]
  listOfBestScore = []
  for l in listOfScore:
    if l[3] == bestScore:
      listOfBestScore += [l]
  listOfBestScore.sort()
  best = listOfBestScore[0]
  bestPlay = [best[3],best[0],best[1],best[2]]
  return bestPlay

00023: HW10
bytecount: {'code': 2162, 'const': 393, 'code+const': 2555}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    val = []
    inval = []
    uou = 15
    tung = 15
    for i in range(tung):
      kum = ''
      for j in range(uou):
        if board[i][j] != '':
          kum += board[i][j]
        if board[i][j] == '':
          if len(kum) > 1:
            if is_valid(kum):
              val.append(kum)
            else:
              inval.append(kum)
          kum = ''
        if j == 14:
          if len(kum) > 1:
            if is_valid(kum):
              val.append(kum)
            else:
              inval.append(kum)
    for i in range(uou):
      kum = ''
      for j in range(tung):
        if board[j][i] != '':
          kum += board[j][i]
        if board[j][i] == '':
          if len(kum) > 1:
            if is_valid(kum):
              val.append(kum)
            else:
              inval.append(kum)
          kum = ''
        if j == 14:
          if len(kum) > 1:
            if is_valid(kum):
              val.append(kum)
            else:
              inval.append(kum)
    val.sort()
    inval.sort()
    return [val, inval]
def get_play(board, new_board):
    tung = 15
    uou = 15
    letter = ''
    check = False
    for i in range(uou):
      for j in range(tung):
        if board[i][j] != new_board[i][j]:
          if letter == '':
            row = i
            col = j
          elif not check:
            if i == row:
              down = 0
              check = True
            elif j == col:
              down = 1
              check = True
          letter += new_board[i][j]
    if len(letter) == 1:
      down = 0
    return [row, col, down, letter]
def play(row,col,down,tiles,board):
    score = 0
    if place_tiles(row,col,down,tiles,board)[0]:
      kum = get_all_words(place_tiles(row,col,down,tiles,board)[1])[0]
      if len(get_all_words(place_tiles(row,col,down,tiles,board)[1])[1]) > 0:
        return -1
      else:
        oldkum = get_all_words(board)[0]
        while len(oldkum) > 0:
          if oldkum[0] in kum:
            kum.remove(oldkum[0])
          oldkum.remove(oldkum[0])
    else:
      return -1
    count = 0
    if down == 1:
      putkum = ''
      for i in range(row, row+len(tiles)+count):
        if board[i][col] == '':
          putkum += tiles[i-row-count]
        else:
          count += 1
          putkum += board[i][col]
        check = tiles[i-row-count]
        if board[i][col] == '':
          for j in range(col-1, -1, -1):
            if board[i][j] != '':
              check = board[i][j]+check
            else:
              break
          for k in range(col+1, 15):
            if board[i][k] != '':
              check += board[i][k]
            else:
              break
          if len(check) > 1:
            if check.upper() in kum:
              kum.remove(check.upper())
            kum.append(check)
    else:
      putkum = ''
      for i in range(col, col+len(tiles)+count):
        if board[row][i] == '':
          putkum += tiles[i-col-count]
        else:
          count += 1
          putkum += board[row][i]
        check = tiles[i-col-count]
        if board[row][i] == '':
          for j in range(row-1, -1, -1):
            if board[j][i] != '':
              check = board[j][i]+check
            else:
              break
          for k in range(row+1, 15):
            if board[k][i] != '':
              check += board[k][i]
            else:
              break
          if len(check) > 1:
            if check.upper() in kum:
              kum.remove(check.upper())
            kum.append(check)
    if down == 1:
      for a in range(row-1, -1, -1):
        if board[a][col] != '':
          putkum = board[a][col]+putkum
        else:
          break
      for b in range(len(tiles)+row, 15):
        if board[b][col] != '':
          putkum += board[b][col]
        else:
          break
    else:
      for j in range(col-1, -1, -1):
        if board[row][j] != '':
          putkum = board[row][j]+putkum
        else:
          break
      for k in range(len(tiles)+col, 15):
        if board[row][k] != '':
          putkum += board[row][k]
        else:
          break
    if count > 0:
      putkum += tiles[-count:]
    if putkum.upper() in kum:
      kum.remove(putkum.upper())
    kum.append(putkum)
    for i in range(len(kum)):
      for j in range(len(kum[i])):
        score += get_value(kum[i][j])
    if len(tiles) >= 7:
      score += 50
    return score
def best_play(tiles,board):
    uou = 15
    tung = 15
    down = 2
    tam = []
    for uou1 in range(uou):
      for tung1 in range(tung):
        for down1 in range(down):
          score = play(uou1, tung1, down1, tiles, board)
          if score != -1:
            tam.append([score, uou1, tung1, down1])
    tam.sort()
    if len(tam) > 0:
      max = tam[-1][0]
      for i in range(len(tam)):
        if len(tiles) == 1:
          if tam[i][0] == max and tam[i][3] == 0:
            return tam[i]
        elif tam[i][0] == max:
          return tam[i]
    return [-1,-1,-1,-1]

00024: HW10
bytecount: {'code': 2618, 'const': 597, 'code+const': 3215}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    valid_words = []
    invalid_words = []
    for row in range(len(board)):
      word_horizontal = ""
      for index_in_row in range(15):
        if "A" <= board[row][index_in_row].upper() <="Z":
          word_horizontal += board[row][index_in_row].upper()
        else:
          word_horizontal += " "
      list_of_word_horizontal = word_horizontal.split()
      for word in list_of_word_horizontal:
        if len(word) >= 2:
          if is_valid(word) == True:
            valid_words.append(word)
          else:
            invalid_words.append(word)
    for index_in_row in range(len(board)):
      word_vertical = ""
      for line in range(15):
        if "A" <= board[line][index_in_row].upper() <= "Z":
          word_vertical += board[line][index_in_row].upper()
        else:
          word_vertical += " "
      list_of_word_vertical = word_vertical.split()
      for word in list_of_word_vertical:
        if len(word) >= 2:
          if is_valid(word) == True:
            valid_words.append(word)
          else:
            invalid_words.append(word)
    valid_words.sort()
    invalid_words.sort()
    return [valid_words,invalid_words]
def get_all_words_with_index(board):
  valid_words_horizontal_with_index = []
  list_of_index_each_ch_in_horizontal = []
  valid_words_vertical_with_index = []
  list_of_index_each_ch_in_vertical = []
  for row in range(15):
    word_horizontal = ""
    if "A" <= board[row][0] <= "Z" and "A" <= board[row][1] <= "Z":
      word_horizontal += board[row][0]
      list_of_index_each_ch_in_horizontal.append([row,0,0])
    for index_in_row in range(1,14):
      if board[row][index_in_row-1] == "" and "A" <= board[row][index_in_row] <= "Z" and "A" <= board[row][index_in_row+1] <= "Z":
        word_horizontal += board[row][index_in_row]
        list_of_index_each_ch_in_horizontal.append([row,index_in_row,0])
      elif "A" <= board[row][index_in_row-1] <= "Z" and "A" <= board[row][index_in_row] <= "Z" and "A" <= board[row][index_in_row+1] <= "Z":
        word_horizontal += board[row][index_in_row]
        list_of_index_each_ch_in_horizontal.append([row,index_in_row,0])
      elif "A" <= board[row][index_in_row-1] <= "Z" and "A" <= board[row][index_in_row] <= "Z" and board[row][index_in_row+1] == "":
        word_horizontal += board[row][index_in_row]
        list_of_index_each_ch_in_horizontal.append([row,index_in_row,0])
      else:
        word_horizontal += " "
    if "A" <= board[row][13] <= "Z" and "A" <= board[row][14] <= "Z":
      word_horizontal += board[row][14]
      list_of_index_each_ch_in_horizontal.append([row,14,0])
    list_of_word_horizontal = word_horizontal.split()
    for word in list_of_word_horizontal:
      if len(word) >= 2:
          valid_words_horizontal_with_index.append([word,list_of_index_each_ch_in_horizontal[0]])
          list_of_index_each_ch_in_horizontal = list_of_index_each_ch_in_horizontal[len(word):]
  for index_in_row in range(15):
    word_vertical = ""
    if "A" <= board[0][index_in_row] <= "Z" and "A" <= board[1][index_in_row] <= "Z":
      word_vertical += board[0][index_in_row]
      list_of_index_each_ch_in_vertical.append([0,index_in_row,1])
    for row in range(1,14):
      if board[row-1][index_in_row] == "" and "A" <= board[row][index_in_row] <= "Z" and "A" <= board[row+1][index_in_row] <= "Z":
        word_vertical += board[row][index_in_row]
        list_of_index_each_ch_in_vertical.append([row,index_in_row,1])
      elif "A" <= board[row-1][index_in_row] <= "Z" and "A" <= board[row][index_in_row] <= "Z" and "A" <= board[row+1][index_in_row] <= "Z":
        word_vertical += board[row][index_in_row]
        list_of_index_each_ch_in_vertical.append([row,index_in_row,1])
      elif "A" <= board[row-1][index_in_row] <= "Z" and "A" <= board[row][index_in_row] <= "Z" and board[row+1][index_in_row] == "":
        word_vertical += board[row][index_in_row]
        list_of_index_each_ch_in_vertical.append([row,index_in_row,1])
      else:
        word_vertical += " "
    if "A" <= board[13][index_in_row] <= "Z" and "A" <= board[14][index_in_row] <= "Z":
      word_vertical += board[14][index_in_row]
      list_of_index_each_ch_in_vertical.append([row,14,1])
    list_of_word_vertical = word_vertical.split()
    for word in list_of_word_vertical:
      if len(word) >= 2:
          valid_words_vertical_with_index.append([word,list_of_index_each_ch_in_vertical[0]])
          list_of_index_each_ch_in_vertical = list_of_index_each_ch_in_vertical[len(word):]
  list_of_words_horizontal = valid_words_horizontal_with_index
  list_of_words_vertical = valid_words_vertical_with_index
  list_of_all_words_valid = []
  for word in list_of_words_horizontal:
    if is_valid(word[0]) == True:
      list_of_all_words_valid.append(word)
  for word in list_of_words_vertical:
    if is_valid(word[0]) == True:
      list_of_all_words_valid.append(word)
  return list_of_all_words_valid
def get_play(board, new_board):
  word_not_same = ""
  index_not_found = []
  for row in range(len(board)):
    for index_in_row in range(15):
      if board[row][index_in_row].upper() != new_board[row][index_in_row].upper():
        word_not_same += new_board[row][index_in_row].upper()
        index_not_found.append([row,index_in_row])
  down = 0
  if index_not_found[0][0] < index_not_found[-1][0]:
    down = 1
  return [index_not_found[0][0],index_not_found[0][1],down,word_not_same,]
def play(row,col,down,tiles,board):
  before_out = []
  point = 0
  valid_word_old_board = get_all_words_with_index(board)
  valid,new_board = place_tiles(row,col,down,tiles,board)
  valid_word_new_board,invalid_word_new_board = get_all_words(new_board)
  if len(invalid_word_new_board) >= 1 or valid == False:
    return -1
  valid_word_new_board = get_all_words_with_index(new_board)
  for word in valid_word_new_board:
    if word in valid_word_old_board:
      valid_word_old_board.remove(word)
    else:
      before_out.append(word[0])
  for word in before_out:
    for ch in word:
      point += get_value(ch)
  if len(tiles) >= 7:
    point += 50
  return point
def best_play(tiles,board):
  list_of_point_etc = []
  for row in range(len(board)):
    for index_in_row in range(len(board)):
      for down in range(2):
          list_of_point_etc.append([play(row,index_in_row,down,tiles,board),row,index_in_row,down])
  list_of_point_etc.sort()
  maxs_point = max(list_of_point_etc)[0]
  if maxs_point == -1:
    return [-1,-1,-1,-1]
  for point,row,index_in_row,down in list_of_point_etc:
    if point == maxs_point:
      return [point,row,index_in_row,down]

00025: HW10
bytecount: {'code': 2876, 'const': 500, 'code+const': 3376}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    p = []
    i = 0
    while i < 15:
        j = 0
        while j < 15:
            word = ""
            while j<15 and board[i][j] != '':
                word += board[i][j]
                j += 1
            if word != "" and len(word) >= 2:
                p.append(word)
            j += 1
        i += 1
    j = 0
    while j < 15:
        i = 0
        while i < 15:
            word = ""
            while i<15 and board[i][j] != '':
                word += board[i][j]
                i += 1
            if word != "" and len(word) >= 2:
                p.append(word)
            i += 1
        j += 1
    p.sort()
    valid = []
    invalid = []
    for x in p:
        check = is_valid(x)
        if check == True:
            valid.append(x)
        elif check == False:
            invalid.append(x)
    ans = []
    ans.append(valid)
    ans.append(invalid)
    return ans
def get_play(board, new_board):
    s = []
    for i in range (15):
        p = []
        for j in range (15):
            if board[i][j] == "" and new_board[i][j] == "":
                p.append("")
            elif board[i][j] == new_board[i][j] :
                p.append("")
            else :
                p.append(new_board[i][j])
        s.append(p)
    for i in range (15):
        x = -1
        y = -1
        word = ""
        for j in range (15):
            if s[j][i] != "":
                if x == -1 and y == -1 :
                    x = j
                    y = i
                    word += s[j][i]
                else:
                    word += s[j][i]
        if len(word) >= 2:
            return [x,y,1,word]
    for i in range (15):
        x = -1
        y = -1
        word = ""
        for j in range (15):
            if s[i][j] != "":
                if x == -1 and y == -1:
                    x = i
                    y = j
                    word += s[i][j]
                else:
                    word += s[i][j]
        if len(word) >= 1:
            return [x,y,0,word]
def play(row,col,down,tiles,board):
    check = place_tiles(row,col,down,tiles,board)
    if check[0] == False:
        return -1
    else:
        new_board = check[1]
        add_board = []
        for i in range(15):
            p = []
            for j in range(15):
                if board[i][j] != new_board[i][j]:
                    p.append(new_board[i][j])
                else:
                    p.append("")
            add_board.append(p)
        all_word = []
        if down == 0:
            i = 0
            while i < 15:
                j = 0
                while j < 15:
                    if add_board[i][j] != "":
                        x = i
                        y = j
                        while j>0 and new_board[i][j-1] != "":
                            j -= 1
                        word = ""
                        while j<15 and new_board[i][j] != "":
                            word += new_board[i][j]
                            j += 1
                        all_word.append(word)
                        while y<15:
                            if add_board[x][y] != "":
                                while x>0 and new_board[x-1][y] != "":
                                    x -= 1
                                word = ""
                                while x<15 and new_board[x][y] != "":
                                    word += new_board[x][y]
                                    x += 1
                                if len(word) >=2:
                                    all_word.append(word)
                                x = i
                            y+=1
                    else:
                        j += 1
                i += 1
        elif down == 1:
            j = 0
            while j < 15:
                i = 0
                while i < 15:
                    if add_board[i][j] != "":
                        x = i
                        y = j
                        while i>0 and new_board[i-1][j] != "":
                            i -= 1
                        word = ""
                        while i<15 and new_board[i][j] != "":
                            word += new_board[i][j]
                            i += 1
                        all_word.append(word)
                        while x<15:
                            if add_board[x][y] != "":
                                while y>0 and new_board[x][y-1] != "":
                                    y -= 1
                                word = ""
                                while y<15 and new_board[x][y] != "":
                                    word += new_board[x][y]
                                    y += 1
                                if len(word) >=2:
                                    all_word.append(word)
                                y = j
                            x += 1
                    else:
                        i += 1
                j += 1        
        for x in all_word:
            checklist = is_valid(x)
            if checklist == False:
                return -1
        score = 0
        for i in range (len(all_word)):
            for j in range (len(all_word[i])):
                score += get_value(all_word[i][j])
        if len(tiles) >= 7 :
            score += 50
        return score
def best_play(tiles,board):
    answer = []
    board_play = copy_board(board)
    for i in range(15):
        for j in range(15):
            a = 0
            x = i
            y = j
            word = ""
            while j>0 and board[i][j-1] != "":
                j -= 1
            while j<15:
                if board[i][j] != "":
                    word += board[i][j]
                elif a=len(tiles) and board[i][j] == "":
                    break
                j += 1
            check_tiles = place_tiles(x,y,0,tiles,board)
            check_word = is_valid(word)
            if check_tiles[0] == True and check_word == True:
                score = play(x,y,0,tiles,board)
                if score != -1:
                    answer.append([score,x,y,0])
    for j in range(15):
        for i in range(15):
            a = 0
            x = i
            y = j
            word = ""
            while i>0 and board[i-1][j] != "":
                i -= 1
            while i<15:
                if board[i][j] != "":
                    word += board[i][j]
                elif a=len(tiles) and board[i][j] == "":
                    break
                i += 1
            check_tiles = place_tiles(x,y,1,tiles,board)
            check_word = is_valid(word)
            if check_tiles[0] == True and check_word == True:
                score = play(x,y,1,tiles,board)
                if score != -1:
                    answer.append([score,x,y,1])
    if answer == []:
        return [-1,-1,-1,-1]
    else:
        answer2 = []
        for d in answer:
            answer2.append([d[0],-d[1],-d[2],-d[3]])
        ans3 = max(answer2)
        ans3 = [ans3[0],-ans3[1],-ans3[2],-ans3[3]]
        return ans3