00001: HW10
bytecount: {'code': 562, 'const': 339, 'code+const': 901}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    w_valid = []
    w_invalid = []
    t_word = ''
    for j, c in enumerate(sum([*map(list, zip(*board)), *board], []), 1):
        t_word += c
        if not (c and j % 15):
            if is_valid(t_word):
                w_valid += [t_word]
            elif len(t_word) > 1:
                w_invalid += [t_word]
            t_word = ''
    return [sorted(w_valid), sorted(w_invalid)]
def get_play(board, new_board):
    coord1 = []
    out_str = ''
    down = 0
    for j, (c, c_new) in enumerate(zip(sum(board, []), sum(new_board, []))):
        if c != c_new:
            out_str += c_new
            _j = j % 15
            if coord1:
                if _j == coord1[1]:
                    down = 1
            else:
                coord1 = [j // 15, _j]
    return coord1 + [down, out_str]
def play(row, col, down, tiles, board):
    new_words, new_invalid = get_all_words(
        place_tiles(row, col, down, tiles, board)[1]
    )
    score = 0
    for w1 in get_all_words(board)[0]:
        if w1 in new_words:
            new_words.remove(w1)
    for c in ''.join(new_words):
        score += get_value(c)
    if not score or new_invalid:
        return -1
    if len(tiles) >= 7:
        return score + 50
    return score
def best_play(tiles, board):
    best_set = [1, -1, -1, -1]
    for j in range(450):
        _i = (j // 15) % 15
        _j = j % 15
        _k = j // 225
        q = [-play(_i, _j, _k, tiles, board), _i, _j, _k]
        if q < best_set:
            best_set = q
    return [-best_set.pop(0), *best_set]

00002: HW10
bytecount: {'code': 578, 'const': 620, 'code+const': 1198}
check_import({'allowable': ['math']}): none
def get_all_words(b):
    o = [[],[]]
    for i in [*b,[*sum([*zip(*b,['']*15)],())]]:
      for j in map(lambda x: x.replace(' ',''),[*filter(lambda x: len(x.strip()) > 2,' '.join(i).split('  '))]):
        o[is_valid(j)].append(j)
    return [*reversed([*map(sorted,o)])]
def get_play(board, new_board):
    d = []
    t = 0
    x = ''
    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]:
        s = new_board[i][j]
        if board[i][j] != s:
          if len(d) > 0:
            if d[1] == j:
              t = 1
          else:
            d = [i,j]
          x += s
    return [*d,t,x]
def play(*a):
    ac,aw = get_all_words(a[4])
    i,b = place_tiles(*a)
    ac2,aw2 = get_all_words(b)
    if not i or aw2 != aw:
      return -1
    o = 50*(len(a[3]) > 6)
    for i in ac:
      if i in ac2:
        ac2.remove(i)
    for i in ac2:
      o+=sum(map(get_value,i))
    return o
def best_play(*a):
    o = [-1]*4
    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]:
          p = play(i,j,k,*a)
          if p > o[0]:
            o = [p,i,j,k]
    return o

00003: HW10
bytecount: {'code': 704, 'const': 550, 'code+const': 1254}
check_import({'allowable': ['math']}): none
def split_word(row):
    word = ""
    list_word = []
    for letter in row:
      if letter:
        word += letter
      else:
        if len(word) > 1:
          list_word.append(word)
        word = ""
    if len(word) > 1:
      list_word.append(word)
    return list_word
def get_all_words(board):
    valid = []
    invalid = []
    for row in board:
      for word in split_word(row):
        if is_valid(word):
          valid.append(word)
        else:
          invalid.append(word)
    for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]:
      for word in split_word(sum(board, [])[i::15]):
        if is_valid(word):
          valid.append(word)
        else:
          invalid.append(word)
    return [sorted(valid),sorted(invalid)]
def get_play(board, new_board):
    tiles = ""
    down = 0
    location = []
    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]:
        letter = new_board[row][col]
        if letter != board[row][col]:
          tiles += letter
          location.append([row,col])
    if len(location) > 1:
      if location[0][1] == location[1][1]:
        down = 1
    return location[0] + [down, tiles]
def play(row,col,down,tiles,board):
    scores = 0
    word_in_board = get_all_words(board)[0]
    word_in_new_board, invalid_words = get_all_words(place_tiles(row, col, down, tiles, board)[1])
    if invalid_words:
      return -1
    for word in word_in_new_board:
      if word not in word_in_board:
        for letter in word:
          scores += get_value(letter)
      else:
        word_in_board.remove(word)
    if scores > 0:
      if len(tiles) >= 7:
        scores += 50
      return scores
    return -1
def best_play(tiles,board):
    top_score = 0
    location = [-1,-1,-1,-1]
    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 down in [0,1]:
          score = play(row,col,down,tiles,board)
          if score > top_score:
            top_score = score
            location = [score, row, col, down]
    return location

00004: HW10
bytecount: {'code': 730, 'const': 326, 'code+const': 1056}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  row = ''
  col = ''
  for i in range(15):
    row += ' '
    col += ' '
    for j in range(15):
      x = board[i][j]
      if get_value(x) != -1:
        row += x
      else:
        row += ' '
      y = board[j][i]
      if get_value(y) != -1:
        col += y
      else:
        col += ' '
  valid = []
  invalid = []
  for i in sorted(row.split() + col.split()):
    if len(i) > 1:
      if is_valid(i):
        valid.append(i)
      else:
        invalid.append(i)
  return [valid, invalid]
def get_play(board, new_board):
  tiles = ''
  row = []
  col = []
  for i in range(15):
    for j in range(15):
      t = new_board[i][j]
      if board[i][j] != t:
        row.append(i)
        col.append(j)
        tiles += t
  down = 0
  frow = row[0]
  fcol = col[0]
  if frow != row[-1]:
    down = 1
  return [frow, fcol, down, tiles]
def play(row,col,down,tiles,board):
  w_board,z = get_all_words(board)
  x, n_board = place_tiles(row,col,down,tiles,board)
  w_n_board,y = get_all_words(n_board)
  score = 0
  if y != [] or not x:
    return -1
  for w in w_n_board:
    if w in w_board:
      w_board.pop(w_board.index(w))
    else:
      if is_valid(w):
        for l in w:
          score += get_value(l)
  if len(tiles) > 6:
    score += 50
  return score
def best_play(tiles,board):
  score = []
  for row in range(15):
    for col in range(15):
      for down in range(2):
        score.append([-play(row,col,down,tiles,board), row, col, down])
  m, row, col, down = min(score)
  if m == 1:
    return [-1,-1,-1,-1]
  return [-m, row, col, down]

00005: HW10
bytecount: {'code': 736, 'const': 350, 'code+const': 1086}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  all_words = []
  for x in range(2):
    for n in range(15):
      i,j,word = 0,0,''
      valid_words = []
      invalid_words = []
      while i < 16 and j < 16:
        if x == 0:
            i = n
        else: j = n
        if i < 15 and 15 > j and board[i][j] != '':
          word += board[i][j]
        else:
            if word != '' and len(word) > 1:
              all_words.append(word)
            word = ''
        j += 1
        i += 1
      all_words.sort()
      for w in all_words:
        if is_valid(w):
          valid_words.append(w)
        else:
          invalid_words.append(w)
  return [valid_words,invalid_words]
def get_play(board, new_board):
    row = []
    col = []
    tiles = []
    d = 0
    for i in range(15) :
        for j in range(15) :
            x = new_board[i][j]
            if board[i][j] != x:
              row.append(i)
              if j in col: d = 1
              col.append(j)
              tiles.append(x)
    return [row[0],col[0],d,''.join(tiles)]
def play(row,col,down,tiles,board):
    a,b = place_tiles(row,col,down,tiles,board)
    valid1,invalid1 = get_all_words(board)
    valid2,invalid2 = get_all_words(b)
    if not a or invalid2 != invalid1:
        return -1
    score = 0
    if len(tiles) >= 7:
        score = 50
    for vl in valid2:
        if not vl in valid1:
            for w in vl:
                score += get_value(w)
        else: valid1.remove(vl)
    return score
def best_play(tiles,board):
    sum_score = [-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)
            a = sum_score[0]
            if a < x and x >= y: sum_score = [x,i,j,0]
            elif a < y: sum_score = [y,i,j,1]
    return sum_score

00006: HW10
bytecount: {'code': 742, 'const': 362, 'code+const': 1104}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  A=[]
  B=[]
  c=''
  x=0
  for i in range(15):
    c+=' '
    for j in board[i]:
      if j == '':
        c+=' '
      else:
        c+=j
  while x<15:
    y=0
    c+=' '
    while y<15:
      if board[y][x]=='':
        c+=' '
      else:
        c+=board[y][x]
      y+=1
    x+=1
  for z in c.strip().split():
    if len(z)>1:
      if is_valid(z):
        A.append(z)
      else:
        B.append(z)
  return [sorted(A),sorted(B)]
def get_play(board, new_board):
  w,I,d='','',0
  for i in range(15):
    for j in range(15):
      if board[i][j]!=new_board[i][j]:
        w+=new_board[i][j]
        if I=='':
          I,J=i,j
        elif j==J:
          d=1
  return [I,J,d,w]
def play(row,col,down,tiles,board):
  s=0
  a,b=get_all_words(board)
  x,y=place_tiles(row,col,down,tiles,board)
  A,B=get_all_words(y)
  if B!=[] or x==False:
    s=-1
  else:
    if len(tiles)>6:
      s+=50
    for i in A:
      if i in a:
        a.remove(i)
      else:
        for j in i:
          s+=get_value(j)
  return s
def best_play(tiles,board):
  V=[[1,-1,-1,-1]]
  for d in range(2):
    for i in range(15):
      for j in range(15):
        n=play(i,j,d,tiles,board)
        if n!=-1:
          V.append([n*-1,i,j,d])
  V.sort()
  V[0][0]*=-1
  return V[0]

00007: HW10
bytecount: {'code': 746, 'const': 312, 'code+const': 1058}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  v = [[],[]]
  for i in range(15):
    a = ''
    for j in range(15):
      cur = board[i][j]
      if cur != '':
        a += cur
      if len(a) >= 2 and (cur == '' or j == 14):
        v[is_valid(a)].append(a)
        a = ''
      elif cur == '' :
        a = ''
    a = ''
    for j in range(15):
      cur = board[j][i]
      if cur != '':
        a += cur
      if len(a) >= 2 and (cur == '' or j == 14):
        v[is_valid(a)].append(a)
        a = ''
      elif cur == '' :
        a = ''
  return list(reversed(list(map(sorted,v))))
def get_play(board, new_board):
  d = 0
  _i = 0
  _j = 0
  t = ''
  for i in range(15):
    for j in range(15):
      if board[i][j] != new_board[i][j]:
        if _i != 0 or _j != 0:
          if _j == j:
            d = 1
        else:
          _i = i
          _j = j
        t += new_board[i][j]
  return [_i,_j,d,t]
def play(row,col,down,tiles,board):
  correct,wrong = get_all_words(board)
  i,board2 = place_tiles(row,col,down,tiles,board)
  correct2,wrong2 = get_all_words(board2)
  if not i:
    return -1
  if wrong2 != wrong:
    return -1
  output = 50 if len(tiles) > 6 else 0
  for i in correct:
    if i in correct2:
      correct2.remove(i)
  for i in correct2:
    for j in i:
      output += get_value(j)
  return output
def best_play(tiles,board):
  max_score = -1
  row, col, dow = -1, -1, -1
  for a in range(15):
    for b in range(15):
      for c in range(2):
        score = play(a, b, c, tiles, board)
        if score > max_score:
          max_score = score
          row = a
          col = b
          dow = c
  out = [max_score, row, col, dow]
  return out

00008: HW10
bytecount: {'code': 748, 'const': 310, 'code+const': 1058}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    words = []
    for i in range(15) :
        w1 = '' ; w2 = ''
        for j in range(15) :
            H = board[i][j] ; V = board[j][i]
            if H == '' : H = ' '
            if V == '' : V = ' '
            w1 += H ; w2 += V
        words += w1.strip().split() + w2.strip().split()
    correct = [] ; wrong = []
    for w in words :
        if len(w) != 1 :
            if is_valid(w) : correct.append(w.upper())
            else : wrong.append(w.upper())
    return [sorted(correct), sorted(wrong)]
def get_play(board, new_board):
    word = ''
    I = []
    J = []
    for i in range(15) :
        for j in range(15) :
            if board[i][j] != new_board[i][j] :
                word += new_board[i][j]
                I.append(i)
                J.append(j)
    d = 0
    if I[0] != I[-1] : d = 1
    return [I[0],J[0],d,word]
def play(row,col,down,tiles,board):
    valid, new_board = place_tiles(row,col,down,tiles,board)
    if valid :
        new_words, new_wrongs = get_all_words(new_board)
        if new_wrongs != [] :
            score = -1
        else :
            if len(tiles) >= 7 : score = 50
            else : score = 0
            words = get_all_words(board)
            for w in words[0] :
                if w in new_words :
                    new_words.remove(w)
            for w in new_words :
                for c in w :
                    score += get_value(c)
    else : score = -1
    return score
def best_play(tiles,board):
    bp = []
    for i in range(15) :
        for j in range(15) :
            bp.append([-play(i,j,0,tiles,board), i, j, 0])
            bp.append([-play(i,j,1,tiles,board), i, j, 1])
    score, row, col, down = sorted(bp)[0]
    if score == 1 : return [-1, -1, -1, -1]
    return [-score, row, col, down]

00009: HW10
bytecount: {'code': 756, 'const': 352, 'code+const': 1108}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  val=[]
  inval=[]
  row=copy_board(board)
  col=''
  for i in range(15):
    for j in range(15):
      if row[j][i]=='': row[j][i]=' '
      col+=row[j][i]
    col+=' '
  for i in row+[col]:
    x=''.join(i).strip().split()
    for j in x:
      if is_valid(j): val.append(j)
      elif len(j)>1: inval.append(j)
  val.sort()
  inval.sort()
  return [val,inval]
def get_play(board, new_board):
  tiles=''
  for i in range(15):
    for j in range(15): 
      if board[i][j]!=new_board[i][j]: 
        if tiles=='': row=i; col=j
        tiles+=new_board[i][j]
  return [row,col,(col==14 or board[row][col+1:]==new_board[row][col+1:])*(len(tiles)!=1),tiles]
def play(row,col,down,tiles,board):
  val,newboard=place_tiles(row,col,down,tiles,board)
  count=0
  b=get_all_words(board)[0]
  for i in get_all_words(newboard)[0]:
    if i not in b:
      for e in i: count+=get_value(e)
    else: b.remove(i)
  if val==False or count==0 or get_all_words(newboard)[1]!=[]: return -1
  else: return count+(50*(len(tiles)>=7))
def best_play(tiles,board):
  allplay=[-1]*4
  for k in range(2):
    for i in range(15):
      for j in range(15):
        a=[play(i,j,k,tiles,board),i,j,k]
        if allplay[0]<a[0] or (allplay[0]==a[0] and allplay[1:]>a[1:]): allplay,a=a,allplay
  return allplay

00010: HW10
bytecount: {'code': 762, 'const': 314, 'code+const': 1076}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    v,n = [],[]
    for i in range(15):
        s,p = '',''
        for j in range(15):
            if board[j][i] != '':
                s += board[j][i]
            else:
                c_v(s,v,n)
                s = ''
            if board[i][j] != '':
                p += board[i][j]
            else:
                c_v(p,v,n)
                p = ''
        c_v(s,v,n)
        c_v(p,v,n)
    return [sorted(v),sorted(n)]
def c_v(x,v,n):
    if len(x) >= 2:
        if is_valid(x): v.append(x)
        else: n.append(x)
def get_play(board, new_board):
    t = ''
    l = []
    for i in range(15):
        for j in range(15):
            if board[i][j] != new_board[i][j]:
                t += new_board[i][j]
                l.append([i,j])
    r,c = l[0]
    if len(t) == 1:
        d = 0
    else:
        if l[0][0] == l[1][0]: d = 0
        else: d = 1
    return [r,c,d,t]
def play(row,col,down,tiles,board):
    v,n_b = place_tiles(row,col,down,tiles,board)
    s = 0 if len(tiles) < 7 else 50
    if v :
        use,n_use = get_all_words(n_b)
        cuse,cnuse = get_all_words(board)
        if len(n_use) > 0:
             return -1
        for e in use:
            if e not in cuse:
              for k in e:
                  s += get_value(k)
            else: cuse.remove(e)
        return s
    else:
        return -1
def best_play(tiles,board):
    l = [-1,-1,-1,-1]
    m = 0
    for i in range(15):
        for j in range(15):
            a = play(i,j,0,tiles,board)
            b = play(i,j,1,tiles,board)
            if a > m:
                m = a
                l = [a,i,j,0]
            if b > m:
                m = b
                l = [b,i,j,1]
    return l

00011: HW10
bytecount: {'code': 776, 'const': 348, 'code+const': 1124}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    words = ''
    for i in range(15):
        words += ' '
        for j in range(15):
            if board[i][j] != '':
                words += board[i][j]
            else:
                words += ' '
    for j in range(15):
        words += ' '
        for i in range(15):
            if board[i][j] != '':
                words += board[i][j]
            else:
                words += ' '
    words = words.split()
    words.sort()
    Words=[[],[]]
    for e in words:
        if len(e) >= 2:
            if is_valid(e):
                Words[0].append(e)
            else:
                Words[1].append(e)  
    return Words
def get_play(board, new_board):
    word = ''
    coordinate = []
    for i in range(15):
        for j in range(15):
            if new_board[i][j] != board[i][j]:
                word += new_board[i][j]
                coordinate.append([j,i])
    x1,y1 = coordinate[0]
    x2,y2 = coordinate[-1]
    down = 0
    if y2>y1:
        down = 1
    return [y1,x1,down,word]
def play(row,col,down,tiles,board):
    valid,new_board = place_tiles(row,col,down,tiles,board)
    if valid == False:
        return -1
    valid_w,invalid_w = get_all_words(board)
    valid_nw,invalid_nw = get_all_words(new_board)
    if invalid_nw != []:
        return -1
    score = 0
    for w in valid_nw:
        if w in valid_w:
            valid_w.remove(w)
        else:
            for ch in w:
                score += get_value(ch)
    if len(tiles) >= 7:
        score += 50
    return score
def best_play(tiles,board):
    best = []
    for i in range(15):
        for j in range(15):
            for down in range(2):
                best.append([-play(i,j,down,tiles,board),i,j,down])
    best.sort()
    best[0][0] *= -1
    if best[0][0] == -1:
        return [-1,-1,-1,-1]
    else:
        return best[0]

00012: HW10
bytecount: {'code': 780, 'const': 405, 'code+const': 1185}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    b = board
    a = sorted(' '.join(''.join([e if e else ' ' for e in n]) for n in b).split() + ' '.join([''.join(b[j][i] if b[j][i] else ' ' for j in range(15)) for i in range(15)]).split())
    return [[e for e in a if is_valid(e)], [e for e in a if not is_valid(e) and len(e) >= 2]]
def get_play(board, new_board):
    x = board; z = new_board
    r = []; c = 0
    for i in range(15):
        for j in range(15):
            if x[i][j] != z[i][j]:
                if not r: a, b = i, j
                else: c = 0 if a == i else 1
                r.append(z[i][j])
    return [a, b, c, ''.join(r)]
def play(row, col, down, tiles, board):
    a = get_all_words(board)
    v, n = place_tiles(row, col, down, tiles, board)
    s, z = get_all_words(n)
    for e in a[0]:
        if e in s:
            s.remove(e)
    b = sum([sum([get_value(i) for i in e]) for e in s])
    if not b or z: b = -1
    return b + 50 if len(tiles) >= 7 and b > 0 else b
def best_play(tiles,board):
    s = [-1, -1, -1, -1]
    for r in range(15):
        for c in range(15):
            for d in range(2):
                a = play(r, c, d, tiles, board)
                if a > s[0]:
                    s = [a, r, c, d]
    return s

00013: HW10
bytecount: {'code': 780, 'const': 298, 'code+const': 1078}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  word=[]
  invalid=[]
  valid=[]
  add=""
  eat=""
  for i in range(15):
    for a in range(15):
      if board[i][a]=="":
        word.append(add)
        add=""
      else:
        add+=board[i][a]
      if board[a][i]=="":
        word.append(eat)
        eat=""
      else:
        eat+=board[a][i]
    if eat !="":
      word.append(eat)
      eat=""
    if add !="":
      word.append(add)
      add=""
  for i in word:
      if is_valid(i):
        valid.append(i)
      elif len(i)>=2:
        invalid.append(i)
  valid.sort()
  invalid.sort()
  return [valid,invalid]
def get_play(board, new_board):
  cat=""
  position=[]
  count=0
  for i in range(15):
    if board[i]!=new_board[i]:
      count+=1
      for a in range(15):
        if board[i][a]!=new_board[i][a]:
          cat+=new_board[i][a]
          if len(cat)==1:
            position+=[i,a]
  if count==1:
    down=0
  else:
    down=1
  return position+[down,cat]
def play(row,col,down,tiles,board):
  youth=place_tiles(row,col,down,tiles,board)
  diff=[]
  c=get_all_words(board)[0]
  b=0
  if youth[0]==True:
    a=get_all_words(youth[1])
    if a[1]==[]:
      for i in c:
        if i in a[0]:
          a[0].remove(i)
      for x in a[0]:
        for y in x:
          b+=get_value(y)
      if len(tiles)>=7:
        b+=50
      return b
  return -1
def best_play(tiles,board):
  score=[-1,-1,-1,-1]
  for i in range(15):
    for a in range(15):
      for x in range(2):
        hat=play(i,a,x,tiles,board)
        if hat>score[0]:
          score=[hat,i,a,x]
  return score

00014: HW10
bytecount: {'code': 786, 'const': 441, 'code+const': 1227}
check_import({'allowable': ['math']}): none
def get_all_words(board):
   Y = []
   N = []
   VH = [[[] for e in range(15)],[[] for e in range(15)]]
   for r in range(15):
      for cl in range (15):
         q = board[r][cl]
         if q == '':
            q = ' '
         VH[0][cl] += q
         VH[1][r] += q
   for e in [0,1]:
      for v in VH[e]:
         for t in ''.join(v).split():
            if is_valid(t):
               Y.append(t)
            elif len(t) >= 2:
               N.append(t)
   return [sorted(Y),sorted(N)]
def get_play(board, new_board):
   rcdt = [0,0,0,'']
   rs = 0
   for e in range (15):
      if board[e] != new_board[e]:
         rs += 1
         for j in range (15):
            if board[e][j] != new_board[e][j]:
               rcdt[3] += new_board[e][j].upper()
               if len(rcdt[3]) == 1:
                  rcdt[0] = e
                  rcdt[1] = j
   if rs > 1:
       rcdt[2] = 1
   return rcdt
def play(row,col,down,tiles,board):
    toBe = place_tiles(row,col,down,tiles,board)
    if not toBe[0]:
      return -1
    a = get_all_words(toBe[1])
    if a[1] != []:
      return -1
    score = 0
    b = get_all_words(board)
    for e in b[0]:
       if e in a[0]:
          a[0].remove(e)
    for letter in ''.join(a[0]):
             score += letter_value[letter.lower()]
    if len(tiles) >= 7:
       score += 50
    return score
def best_play(tiles,board):
    rcd = [-1]*4
    maxscore = 0
    for row in range (15):
      for col in range (15):
        for down in range (2):
          crscore = play(row,col,down,tiles,board)
          if crscore > maxscore:
            rcd = [crscore, row, col, down]
            maxscore = crscore
    return rcd

00015: HW10
bytecount: {'code': 792, 'const': 381, 'code+const': 1173}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    valid_words, invalid_words = [], []
    curr_word_h, curr_word_v = '', ''
    for i in range(15):
        for j in range(15):
            if board[i][j] != '':
                curr_word_h += board[i][j]
            if board[i][j] == '' or j == 14:
                if len(curr_word_h) >= 2:
                    if is_valid(curr_word_h):
                        valid_words.append(curr_word_h.upper())
                    else:
                        invalid_words.append(curr_word_h.upper())
                curr_word_h = ''
            if board[j][i] != '':
                curr_word_v += board[j][i]
            if board[j][i] == '' or j == 14:
                if len(curr_word_v) >= 2:
                    if is_valid(curr_word_v):
                        valid_words.append(curr_word_v.upper())
                    else:
                        invalid_words.append(curr_word_v.upper())
                curr_word_v = ''
    valid_words.sort()
    invalid_words.sort() 
    return [valid_words, invalid_words]
def get_play(board, new_board):
    i_idx, j_idx, down, new_word = 0, 0, 0, ''
    stop_i= 0
    for i in range(15):
        for j in range(15):
            if board[i][j] != new_board[i][j]:
                if not new_word:
                    i_idx, j_idx = i, j
                new_word += new_board[i][j]
                stop_i = i
    if stop_i != i_idx:
        down = 1
    return [i_idx, j_idx, down, new_word]
def play(row,col,down,tiles,board):
    score = -1
    first_con, new_board = place_tiles(row,col,down,tiles,board)
    old_words, new_words = get_all_words(board), get_all_words(new_board)
    if first_con and new_words[1] == old_words[1]:
        score = 0
        for word in new_words[0]:
            if word in old_words[0]:
                old_words[0].remove(word)
            else:
                for ch in word:
                    score += get_value(ch)
        if len(tiles) >= 7:
            score += 50
    return score
def best_play(tiles,board):
    max_score, i_idx, j_idx, down = -1, -1, -1, -1
    for i in range(15):
        for j in range(15):
            score = play(i, j, 0, tiles, board)
            if score > max_score:
                i_idx, j_idx, down = i, j, 0
                max_score = score
            score = play(i, j, 1, tiles, board)
            if score > max_score:
                i_idx, j_idx, down = i, j, 1
                max_score = score
    return [max_score, i_idx, j_idx, down]

00016: HW10
bytecount: {'code': 798, 'const': 298, 'code+const': 1096}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    valid = []
    invalid = []
    words = []
    for i in range(15):
        word_row = word_col = ''
        found_row = found_col = False
        for j in range(15):
            if board[i][j] != '':
                found_row = True
                word_row += board[i][j]
            if (board[i][j] == '' or j == 14) and found_row:
                if len(word_row) > 1:
                    words.append(word_row)
                found_row = False
                word_row = ''
            if board[j][i] != '':
                found_col = True
                word_col += board[j][i]
            if (board[j][i] == '' or j == 14) and found_col:
                if len(word_col) > 1:
                    words.append(word_col)
                found_col = False
                word_col = ''
    for word in words:
        if is_valid(word):
            valid.append(word)
        else:
            invalid.append(word)
    valid.sort()        
    invalid.sort()
    return [valid,invalid]
def get_play(board, new_board):
    row_index = []
    col_index = []
    tiles = ''
    for i in range(15):
        for j in range(15):
            if board[i][j] != new_board[i][j]:
                row_index.append(i)
                col_index.append(j)
                tiles += new_board[i][j]
    down = len(tiles) != 1 and col_index[0] == col_index[1]
    down = int(down)
    row = row_index[0]
    col = col_index[0]
    return [row,col,down,tiles]
def play(row,col,down,tiles,board):
    placeable, new_board = place_tiles(row,col,down,tiles,board)
    valid, invalid = get_all_words(new_board)   
    if not placeable or invalid:
        return -1
    old_valid = get_all_words(board)[0]
    score = 0
    for word in valid:
        if word in old_valid:
            old_valid.remove(word)
            continue
        for character in word:
            score += get_value(character)
    if len(tiles) >= 7:
        return score + 50
    return score
def best_play(tiles,board):
    result = [-1, -1, -1, -1]
    best_score = -1
    for i in range(15):
        for j in range(15):
            for k in range(2):
                score = play(i,j,k,tiles,board)
                if score > best_score:
                    best_score = score
                    result = [score, i, j, k]
    return result

00017: HW10
bytecount: {'code': 810, 'const': 400, 'code+const': 1210}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    a = [[], []]
    for n in range(2):
      for i in range(len(board)):
        b = ''
        for j in range(len(board[i])):
          if n == 0:
            x = board[i][j]
          if n == 1:
            x = board[j][i]
          if x != '':
            b += x
          else:
            b += ' '
        for word in b.strip().split():
          if len(word) >= 2:
            if is_valid(word):
              a[0].append(word)
            else:
              a[1].append(word)
    a[0].sort()
    a[1].sort()
    return a
def get_play(board, new_board):
    a = True
    t = ''
    d = 0
    for i in range(len(board)):
      for j in range(len(board[i])):
        x = new_board[i][j]
        if x != board[i][j]:
          if a: 
            row = i
            col = j
            a = False
          else:
            if j == col: 
              d = 1
          t += x
    return [row, col, d, t]
def play(row,col,down,tiles,board):
    board_words = get_all_words(board)
    played_board = place_tiles(row,col,down,tiles,board)
    new_board_words = get_all_words(played_board[1])
    if not played_board[0]:
      return -1
    a = []
    s = 0
    for n in range(2):
      for i in new_board_words[n]:
        if i not in board_words[n]:
          if n == 0:
            for j in i:
              s += get_value(j)
          else:
            a.append(i)
        else:
          board_words[n].remove(i)
    if len(a) != 0:
      return -1
    if len(tiles) >= 7:
      s += 50
    return s
def best_play(tiles,board):
    lst = []
    for row in range(len(board)):
      for col in range(len(board[row])):
        for down in range(2):
          s = play(row,col,down,tiles,board)
          if s != -1:
            lst.append([s, row, col, down])
    lst.sort(key= lambda x: (-x[0], x[1]))
    if len(lst) == 0:
      return [-1,-1,-1,-1]
    return lst[0]

00018: HW10
bytecount: {'code': 816, 'const': 348, 'code+const': 1164}
check_import({'allowable': ['math']}): none
def get_all_words(board):
    word = ''
    for i in range(15):
      word += ' '
      for j in range(15):
        if board[i][j] != '':
          word += board[i][j]
        else:
          word += ' '
    for j in range(15):
      word += ' '
      for i in range(15):
        if board[i][j] != '':
          word += board[i][j]
        else:
          word += ' '
    words = [[], []]
    word = word.strip().split()
    for word in word:
      if len(word) >= 2:
        if is_valid(word):
          words[0].append(word)
        else:
          words[1].append(word)
    words[0].sort()
    words[1].sort()
    return words
def get_play(board, new_board):
    tiles = ''
    coordinate = []
    for i in range(15):
      for j in range(15):
        if board[i][j] != new_board[i][j]:
          tiles += new_board[i][j]
          coordinate.append([j, i])
    col, row = coordinate[0]
    col1, row1 = coordinate[-1]
    down = 0
    if row < row1:
      down = 1
    return [row,col,down,tiles]
def play(row,col,down,tiles,board):
    valid, new_board = place_tiles(row,col,down,tiles,board)
    word1, word1_worng = get_all_words(board)
    word2, word2_wrong = get_all_words(new_board)
    if (valid == False) or len(word2_wrong) > 0:
      return -1
    score = 0
    for word in word2:
      if word not in word1:
        for each_word in word:
          score += get_value(each_word)
      else:
        word1.remove(word)
    if len(tiles) >= 7:
      score += 50
    return score
def best_play(tiles,board):
  every_play = []
  for row in range(15):
    for col in range(15):
      for down in range(2):
        score = play(row,col,down,tiles,board)
        if score != -1:
          every_play.append([score,row,col,down])
  every_play.sort()
  if len(every_play) == 0:
    return [-1,-1,-1,-1]
  highest_score = every_play[-1][0]
  for each_play in every_play:
      if each_play[0] == highest_score:
        return each_play

00019: HW10
bytecount: {'code': 824, 'const': 376, 'code+const': 1200}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  valid_word = []
  invalid_word = []
  for i in range(15):
    word_row = ''
    word_column = ''
    for k in range(15):
      if board[i][k] == '':
        word_row += ' '
      else:
        word_row += board[i][k]
      if board[k][i] == '':
        word_column += ' '
      else:
        word_column += board[k][i]
    word_in_row = word_row.split()
    word_in_column = word_column.split()
    for each_r in word_in_row:
      if is_valid(each_r):
        valid_word.append(each_r)
      else:
        if len(each_r) > 1:
          invalid_word.append(each_r)
    for each_c in word_in_column:
      if is_valid(each_c):
        valid_word.append(each_c)
      else:
        if len(each_c) > 1:
          invalid_word.append(each_c)
  valid_word.sort()
  invalid_word.sort()
  return [valid_word, invalid_word]
def get_play(board, new_board):
  missing_word = ''
  start_index = [0, 0]
  pos = 0
  start = True
  for i in range(15):
    for k in range(15):
      if board[i][k] != new_board[i][k]:
        missing_word += new_board[i][k]
        if start:
          start_index = [i, k]
          start = False
        if not start and start_index[0] == i:
          pos = 0
        elif not start and start_index[1] == k:
          pos = 1
  return start_index + [pos, missing_word]
def play(row,col,down,tiles,board):
  start_word = get_all_words(board)
  status, new_board = place_tiles(row, col, down, tiles, board)
  new_word = get_all_words(new_board)
  if not status or len(new_word[1]) != 0:
    return -1
  for word in start_word[0]:
    if word in new_word[0]:
      new_word[0].remove(word)
  added_word = new_word[0]
  score = 0
  for each in added_word:
    for ch in each:
      score += get_value(ch)
  if len(tiles) >= 7:
    score += 50
  return score
def best_play(tiles,board):
  max_score = -1
  max_row, max_col, max_down = -1, -1, -1
  for i in range(15):
    for j in range(15):
      for k in range(2):
        check = place_tiles(i, j, k, tiles, board)
        if check[0]:
          score = play(i, j, k, tiles, board)
          if score > max_score:
            max_score = score
            max_row = i
            max_col = j
            max_down = k
  return [max_score, max_row, max_col, max_down]

00020: HW10
bytecount: {'code': 836, 'const': 324, 'code+const': 1160}
check_import({'allowable': ['math']}): none
def get_all_words(board):
  s = ' '
  t = ' '
  for i in range(15):
    for j in range(15):
      if board[i][j] != '':
        s += board[i][j]
      else: 
        s += ' '
      if board[j][i] != '':
        t += board[j][i]
      else:
        t += ' '
    s += ' '
    t += ' '
  words = s.split() + t.split()
  true = []
  false = []
  for e in words:
    if len(e) > 1:
      if is_valid(e):
        true.append(e)
      else:
        false.append(e)
  return [sorted(true),sorted(false)]
def get_play(board, new_board):
  diff = ''
  l = []
  for i in range(15):
    for j in range(15):
      if board[i][j] != new_board[i][j]:
        diff += new_board[i][j]
        l.append([j,i])
  x1,y1 = l[0]
  x2,y2 = l[-1]
  down = 0
  if y1 < y2:
    down = 1
  return [y1,x1,down,diff.upper()]
def play(row,col,down,tiles,board):
  [valid, new_board] = place_tiles(row,col,down,tiles,board)
  wordb = get_all_words(board)
  wordn = get_all_words(new_board)
  if not valid or wordn[1] != []:
    return -1
  scores = 0
  for e in wordn[0]:
    if e not in wordb[0]:
      for k in e:
        scores += get_value(k)
    else:
      wordb[0].remove(e)
  if len(tiles) >= 7:
    scores += 50
  return scores
def best_play(tiles,board):
  l = []
  for i in range(15):
    for j in range(15):
      [valid1, new_board1] = place_tiles(i,j,0,tiles,board)
      if valid1:
        l.append([play(i,j,0,tiles,board),i,j,0])
      else:
        l.append([-1,-1,-1,-1])
      [valid2, new_board2] = place_tiles(i,j,1,tiles,board)
      if valid2:
        l.append([play(i,j,1,tiles,board),i,j,1])
      else:
        l.append([-1,-1,-1,-1])
  l = sorted(l)
  mx = l[-1][0]
  for e in l:
    if e[0] == mx:
      return e