The Spelling Bee bees are back...

# How many bees are in the beehive?

* bees can be facing UP, DOWN, LEFT, RIGHT, and now also _diagonally_ up/down/left/right
* bees can share parts of other bees



## Examples

Ex1
```
bee.bee     
.e..e..
.b..eeb
```
_Answer: 5_

Ex2
```
beee..     
eeb.e.
ebee.b
```
_Answer: 7_

Difficulty: introductory

Starter code:

def how_many_bees(hive):
	

Solutions:
def how_many_bees(h):
    if not h: return 0
    v = list(zip(*h))
    b = [None] * len(h)
    sf = (b[i:] + l + b[:i] for i,l in enumerate(h))
    sb = (b[:i] + l + b[i:] for i,l in enumerate(h))
    df = [[n for n in l if n is not None] for l in zip(*sf)]
    db = [[n for n in l if n is not None] for l in zip(*sb)]
    inline = '\n'.join(map(''.join, h+v+df+db))
    return (inline + inline[::-1]).count('bee')

def how_many_bees(hive):
    if not hive: return 0
    hive = [list(x) for x in hive]
    directions = [(0,1), (1,1), (1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1)]
    output = 0
    for row, _ in enumerate(hive):
        for col, val in enumerate(_):
            curr = 'b'
            if val == 'b':
                for direction in directions:
                    coord = (row+direction[0], col+direction[1])
                    if inBounds(hive, coord) and hive[coord[0]][coord[1]] == 'e':
                        output += traverse(hive, coord, direction, curr)
    return output                       

def traverse(hive, coord, direction, curr):

    curr += hive[coord[0]][coord[1]]
    new_c = (coord[0]+direction[0], coord[1]+direction[1])

    if curr == 'bee':
        return 1
    if(inBounds(hive, new_c)):
        return traverse(hive, new_c, direction, curr)   
    return 0
        
    
def inBounds(hive, coord):
    row, col = len(hive), len(hive[0])
    if 0 <= coord[0] < row and 0 <= coord[1] < col:
        return True
    return False

def find_bee_heads(hive):
    for i, row in enumerate(hive):
        for j, x in enumerate(row):
            if x == 'b':
                yield i, j

def count_ee(hive, r, c, i, j):
    return sum(
        0 <= i + di * 2 < r and 0 <= j + dj * 2 < c and hive[i+di][j+dj] == hive[i+di*2][j+dj*2] == 'e'
        for di, dj in [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1,1)]
    )
    
def how_many_bees(hive):
    hive = hive or []
    r = len(hive)
    c = r and len(hive[0])
    return sum(count_ee(hive, r, c, i, j) for i, j in find_bee_heads(hive))

def how_many_bees(hive):
    # Degenerate cases
    if not hive or len(hive) < 3 or len(hive[0]) < 3:
        return 0
    # rotate +90 degrees
    rn90 = lambda a: [list(x) for x in zip(*a[::-1])]
    # rotate -45 degrees
    r45 = lambda a: [[val for r, row in enumerate(a) for c, val in enumerate(row) if r + c == i][::-1] for i in range(len(a) + len(a[0]))]
    # Count bees
    bees = lambda a: sum("".join(r).count("bee") for r in a)
    # Count diagonal bees
    dbees = lambda a: bees(r45(a))
    # All cardinal bees
    result = bees(hive) + bees(rn90(hive)) + bees(rn90(rn90(hive))) + bees(rn90(rn90(rn90(hive))))
    # All diagonal bees
    result += dbees(hive) + dbees(rn90(hive)) + dbees(rn90(rn90(hive))) + dbees(rn90(rn90(rn90(hive))))
    return result

def how_many_bees(hive):
    if type(hive)!=list: return 0
    n=0
    l=[(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
    for x in range(len(hive)):
        for y in range(len(hive[x])):
            if hive[x][y]=='b':
                for i in l:
                    if 0<=x+i[0]*2<len(hive) and 0<=y+i[1]*2<len(hive[x]) and hive[x+i[0]][y+i[1]]=='e' and hive[x+i[0]*2][y+i[1]*2]=='e':
                        n+=1
    return n

def how_many_bees(hive):
    if not hive:
        return 0
    r=0
    for row in hive:
        r+=''.join(row).count('bee')
        r+=''.join(row[::-1]).count('bee')
    for column in zip(*hive):
        r+=''.join(column).count('bee')
        r+=''.join(column[::-1]).count('bee')
    m,n=len(hive),len(hive[0])
    for i in range(m):
        for j in range(n):
            if hive[i][j]=='b':
                if i<m-2 and j<n-2:
                    if hive[i+1][j+1]==hive[i+2][j+2]=='e':
                        r+=1
                if i<m-2 and j>=2:
                    if hive[i+1][j-1]==hive[i+2][j-2]=='e':
                        r+=1
                if i>=2 and j<n-2:
                    if hive[i-1][j+1]==hive[i-2][j+2]=='e':
                        r+=1
                if i>=2 and j>=2:
                    if hive[i-1][j-1]==hive[i-2][j-2]=='e':
                        r+=1
    return r

def how_many_bees(hive):
    if not hive:
        return 0
    def gather_bees(row,col):
        h = col<len(hive[row])-2 
        if h:
            yield hive[row][col]+hive[row][col+1]+hive[row][col+2]
        v = row<len(hive)-2
        if v:
            yield hive[row][col]+hive[row+1][col]+hive[row+2][col]
        if h and v:
            yield hive[row][col]+hive[row+1][col+1]+hive[row+2][col+2]
            yield hive[row+2][col]+hive[row+1][col+1]+hive[row][col+2]
    count = 0
    for row in range(len(hive)):
        for col in range(len(hive[row])):
            count += sum(1 for x in gather_bees(row,col) if x in ['bee','eeb'])
    return count

def how_many_bees(hive):
    if not hive:
        return 0
    new_hive = [[i for i in line] for line in hive]    
    result = 0
    for line in range(len(hive)):
        for i in range(len(hive[0])):
            if hive[line][i] == "b":
                if len(hive[0]) - i > 2 and hive[line][i+1] == "e" and hive[line][i+2] == "e":
                    result +=1
                if i > 1 and hive[line][i-1] == "e" and hive[line][i-2] == "e":
                    result +=1
                if len(hive) - line > 2 and hive[line+1][i] == "e" and hive[line+2][i] == "e":                    
                    result +=1
                if line > 1 and hive[line-1][i] == "e" and hive[line-2][i] == "e":
                    result +=1
                if len(hive[0]) - i > 2 and len(hive) - line > 2 and hive[line+1][i+1] == "e" and hive[line+2][i+2] == "e":
                    result +=1
                if i > 1 and line > 1 and hive[line-1][i-1] == "e" and hive[line-2][i-2] == "e":
                    result +=1
                if len(hive[0]) - i > 2 and line > 1 and hive[line-1][i+1] == "e" and hive[line-2][i+2] == "e":
                    result +=1
                if i > 1 and len(hive) - line > 2 and hive[line+1][i-1] == "e" and hive[line+2][i-2] == "e":
                    result +=1
                
    return result

def how_many_bees(hive):
    if not hive:
        return 0
    
    hive_matrix = [list(line) for line in hive]
    
    max_col = len(hive_matrix[0])
    max_row = len(hive_matrix)
    
    cols = [[] for _ in range(max_col)]
    rows = [[] for _ in range(max_row)]
    fdiag = [[] for _ in range(max_row + max_col - 1)]
    bdiag = [[] for _ in range(len(fdiag))]
    min_bdiag = -max_row + 1
    
    for x in range(max_col):
        for y in range(max_row):
            cols[x].append(hive_matrix[y][x])
            rows[y].append(hive_matrix[y][x])
            fdiag[x+y].append(hive_matrix[y][x])
            bdiag[x-y-min_bdiag].append(hive_matrix[y][x])
            
    h1 = '\n'.join([''.join(line) for line in cols])
    h11 = h1.count('bee') + h1.count('eeb')
    
    v1 = '\n'.join([''.join(line) for line in rows])
    v11 = v1.count('bee') + v1.count('eeb')
    
    d1 = '\n'.join(''.join(line) for line in fdiag)
    d11 = d1.count('bee') + d1.count('eeb')
    
    d2 = '\n'.join(''.join(line) for line in bdiag)
    d22 = d2.count('bee') + d2.count('eeb')
    return h11 + v11 + d11 + d22

def how_many_bees(hive):
    if not(hive) or not(len(hive)) or not(len(hive[0])):
        return 0
    class Model(object):
        def __init__(self):
            self.bees = 0
        def checker(self, row, col):
            if row > 1 and hive[row - 1][col] == 'e' and hive[row - 2][col] == 'e':
                self.bees += 1
            if row < len(hive) - 2 and hive[row + 1][col] == 'e' and hive[row + 2][col] == 'e':
                self.bees += 1
            if col > 1 and hive[row][col - 1] == 'e' and hive[row][col - 2] == 'e':
                self.bees += 1
            if col < len(hive[0]) - 2 and hive[row][col + 1] == 'e' and hive[row][col + 2] == 'e':
                self.bees += 1
            if row > 1 and col > 1 and hive[row - 1][col - 1] == 'e' and hive[row - 2][col - 2] == 'e':
                self.bees += 1
            if row < len(hive) - 2 and col > 1 and hive[row + 1][col - 1] == 'e' and hive[row + 2][col - 2] == 'e':
                self.bees += 1
            if row > 1 and col < len(hive[0]) - 2 and hive[row - 1][col + 1] == 'e' and hive[row - 2][col + 2] == 'e':
                self.bees += 1
            if row < len(hive) - 2 and col < len(hive[0]) - 2 and hive[row + 1][col + 1] == 'e' and hive[row + 2][col + 2] == 'e':
                self.bees += 1
    b = Model()
    for i in range(len(hive)):
        for j in range(len(hive[i])):
            if hive[i][j] == 'b':
                b.checker(i, j)
    return b.bees