python, практика, матрицы, крестики-нолики

#[derive(Debug)]
struct InvalidInput;

fn foo(field: &[&str]) -> Result<char, InvalidInput> {
    let field_size = field.len();
    let valid_input = field.iter().all(|i|
        i.len() == field_size &&
        i.chars().all(|c| "XO.".chars().any(|x| x == c))
    );
    if !valid_input {
        return Err(InvalidInput);
    }
    
    let diagonals = [(0, field_size + 1), (field_size - 1, field_size - 1)];
    let isns = (0..field_size).map(|x| (x, field_size)).chain(
        (0..field_size).map(|x| (x * field_size, 1))
    ).chain(
        diagonals.iter().map(|x| x.clone())
    );
    
    for (init_skip, step_skip) in isns {
        let iter = (0..3).map(|x|
            field.iter()
                 .flat_map(|x| x.chars())
                 .nth(init_skip + x * step_skip)
                 .unwrap()
        );
        let folded = iter.fold('U', |acc, x| match (acc, x) {
            ('U', 'X') => 'X',
            ('U', 'O') => 'O',
            ('U', '.') => '.',
            ('X', 'X') => 'X',
            ('O', 'O') => 'O',
            _ => 'N'
        });
        println!();
        match folded {
            'X' => return Ok('X'),
            'O' => return Ok('O'),
            _ => continue
        }
    }
    Ok('D')
}

fn main() {
    println!("{:?}", foo(&["X.O", "XX.", "OOO"]));
}

if row[0] == row[1] == row[2] and row[0] != ".":

def check(result):

    # horizontal
    h = filter(lambda x: x.count(x[0]) == len(x), result)
    if len(h):
        return(h[0][0] if h[0][0] != '.' else 'D')

    # vertical
    v = filter(lambda x: x.count(x[0]) == len(x),
               [map(lambda x: x[i], result) for i in range(len(result))])
    if len(v):
        return(v[0][0] if v[0][0] != '.' else 'D')

    # diagonal
    c = len(result[0]) // 2
    if result[c][c] in 'X0':
        d = filter(lambda x: x.count(result[c][c]) == len(x),
                   [''.join([x[i] for i, x in enumerate(result)]),
                    ''.join([x[i] for i, x in enumerate(reversed(result))])])
        if len(d):
            return(result[c][c])

    return('D')

        if row.count(row[0]) == length and row[0] != ".":
            return row[0]

def who_win(s):
    if row[0] != '.' and row.strip(row[0]) == '':
        return row[0]

def checkio(result):
    length       = len(result)
    temp         = ""
    result_col   = []

    #check rows
    for row in result:
        won = who_win(row)
        if won:
            return won

    #check diagonal
    won = who_win(''.join(result[i][i] for i in range(length)))
    if won:
        return won

    #check diagonal reverse
    won = who_win(''.join(result[length - 1 - i][i]
                  for i in range(length - 1, -1, -1)))
    if won:
        return won

    #check columns
    for i in range(length):
        for j in range(length):
            temp += (result[j][i])
        result_col.append(temp)
        temp = ""

    for col in result_col:
        won = who_win(col)
        if won:
            return won

    #anyway, draw
    return "D"

def who_win(s):
    if s[0] != '.' and s.strip(s[0]) == '':
        return s[0]

def checkio(result):
    length = len(result)
    temp = ""

    # check rows
    to_check = result  # rows
    to_check.append(''.join(result[i][i] for i in range(length)))  # diagonal
    to_check.append(''.join(result[length - 1 - i][i]
                            for i in range(length - 1, -1, -1)))  # reverse diag
    # check columns
    for i in range(length):
        for j in range(length):
            temp += (result[j][i])
        to_check.append(temp)
        temp = ""

    for res in to_check:
        won = who_win(res)
        if won:
            return won

    # anyway, draw
    return "D"

def who_win(s):
    if s[0] != '.' and s.strip(s[0]) == '':
        return s[0]

def checkio(result):
    length = len(result)

    # rows:
    to_check = result
    # diagonal:
    to_check.append(''.join(result[i][i] for i in range(length)))
    # reverse diagonal:
    to_check.append(''.join(result[i][-i-1] for i in range(length)))
    # collumns:
    to_check += [''.join(result[i][j] for i in range(length))
                         for j in range(length)]

    for res in to_check:
        won = who_win(res)
        if won:
            return won

    # anyway, draw
    return "D"

"".join(result[i][j] for i in range(3)) for j in range(3))

"".join(result[i][j] for i in (0,1,2)) for j in (0,1,2))

"".join(result[i][0] for i in (0,1,2),
"".join(result[i][2] for i in (0,1,2),
"".join(result[i][3] for i in (0,1,2)

"".join((result[0][0], result[1][0] result[2][0])),
"".join((result[0][1], result[1][1] result[2][1])),
"".join((result[0][2], result[1][2] result[2][2]))

    to_check += [''.join(result[i][j] for i in range(length))
                 for j in range(length)]

    def collumn(j):
        return ''.join(result[i][j] for i in range(length))
    to_check += [collumn(j) for j in range(length)]