BastterCode semana 5 - MATRIX - Check if Every Row and Column Contains All Numbers
comentada em 11/03/2023 23:40

postado por @Giovanni em 07/02/2023 08:10:54

Aproveitando para quem ta participando, o que vcs acham de resolver uma questão extra por mês, de dificuldade média ?

fica confuso?
teria 1 mês para resolver e discutir

Acho uma boa ideia! 

Essa semana vai ser apertada para mim, então fui de XGH:

Ver mais

Ver mais

@Giovanni,
Gostei do desafio mensal. Acho que não fica confuso. Se ainda achar que fica confuso, na semana que lança ele não lança outro, só fica mais prazo pra postagens....

Bruteforce em C pra responder rápido. Depois eu filosofo.

bool checkValid(int** matrix, int matrixSize, int* matrixColSize){
    int i,j,verifyDigit;
    bool incomplete = false;
    for(verifyDigit=1;verifyDigit<=matrixSize&&!incomplete;verifyDigit++){
// Rows
        for(i=0;i<matrixSize&&!incomplete;i++){
            for(j=0;j<matrixSize;j++){
                if(matrix[i][j]==verifyDigit){
                    break;
                }
            }
            if(j==matrixSize){
                incomplete = true;
                break;
            }
        }

//Columns
        for(j=0;j<matrixSize&&!incomplete;j++){
            for(i=0;i<matrixSize;i++){
                if(matrix[i][j]==verifyDigit){
                    break;
                }
            }
            if(i==matrixSize){
                incomplete = true;
                break;
            }
        }

    }

    return !incomplete;
}?

péssimo desempenho, as expected.

postado por @Giovanni em 07/02/2023 08:10

Aproveitando para quem ta participando, o que vcs acham de resolver uma questão extra por mês, de dificuldade média ?

fica confuso?
teria 1 mês para resolver e discutir

@Giovanni, não fica confuso. Achei a ideia excelente! 

postado por @Giovanni em 07/02/2023 08:10

Aproveitando para quem ta participando, o que vcs acham de resolver uma questão extra por mês, de dificuldade média ?

fica confuso?
teria 1 mês para resolver e discutir

Excelente ideia! Aí no futuro, quando os desafios semanais começarem a ser nível médio, o desafio mensal pode passar a ser nível hard. 

brute force O(n³), melhorando pra O(n²):



Verifica soma, verifica duplicidade no hash. vira todo hash pra 1 numa linha, desvira pra zero na próxima (flipflop) pra não precisar zerar o hash toda vez.

bool checkValid(int** matrix, int matrixSize, int* matrixColSize){

    int i,j,k;
    int req_sum = matrixSize*(matrixSize+1)/2;
    int sum;
    int flipflop = 0;
 
    int freq[matrixSize];

    for(i=0;i<matrixSize;i++)
        freq[i]=0;

    for(i=0;i<matrixSize;i++){
        sum = 0;
        for(j=0;j<matrixSize;j++){
            sum += matrix[i][j];
            if(freq[(matrix[i][j]-1)]==flipflop)
                freq[(matrix[i][j]-1)] = !flipflop;
            else
                return false;
        }
        if(sum!=req_sum){
            return false;
        }

        flipflop=!flipflop;
    }

    for(j=0;j<matrixSize;j++){
        sum = 0;
        for(i=0;i<matrixSize;i++){
            sum += matrix[i][j];
            if(freq[(matrix[i][j]-1)]==flipflop)
                freq[(matrix[i][j]-1)] = !flipflop;
            else
                return false;
        }
        if(sum!=req_sum){
            return false;
        }

        flipflop=!flipflop;
    }

    return true;
}?

OBS: a variável k esqueci de apagar, não serve mais pra nada.

postado por @Giovanni em 07/02/2023 10:09

O que é XGH?

extreme go horse

Java, usando memorização em uma passada pela matriz, memória e runtime: O(nˆ2)


Confesso que esperava um runtime menor.

Bora pros desafios mensais tbm!

C#

public class Solution
{
    public bool CheckValid(int[][] matrix)
    {
        //armazena os número de 1 até x (comprimento da matriz)
        List<int> allNumbers = GetAllNumbers(matrix.Length);

        //para cada linha verificar se todos os itens da lista estão presentes
        for(int i = 0; i< matrix.Length; i++)
        {
            if (!ContainAllNumbers(allNumbers, matrix[i])) return false;
        }

        //para cada coluna verificar se todos os itens da lista estão presentes
        for (int i = 0; i < matrix.Length; i++)
        {
            int[] collum = GetMatrixCollum(matrix, i);
            if (!ContainAllNumbers(allNumbers, collum)) return false;
        }
                  
        return true;
    }

    private int[] GetMatrixCollum(int[][] matrix, int collumIndex)
    {
        List<int> collum = new List<int>();

        for(int i = 0; i < matrix.Length; i++)
        {
            collum.Add(matrix[i][collumIndex]);
        }

        return collum.ToArray();
    }

    private bool ContainAllNumbers(List<int> allNumbers, int[] array)
    {
        List<int> all = new List<int> (allNumbers);

        for(int i = 0; i < array.Length; i++)
        {
            if (all.Contains(array[i]))
            {
                all.Remove(array[i]);
            }
            else
            {
                return false;
            } 
        }

        return true;
    }

    private List<int> GetAllNumbers(int n)
    {
        List<int> allNumbers = new List<int>();

        for(int i = 1; i <= n; i++)
        {
            allNumbers.Add(i);
        }

        return allNumbers;
    }
}?

Dá pra refatorar e aproveitar código. Mas ta ai uma primeira versão.

@Giovanni : XGH -> eXtreme Go Horse (XGH) – GO HORSE PROCESS

class Solution:
    def checkValid(self, matrix: List[List[int]]) -> bool: 
        result = True                                       #considera a resposta como verdadeira até que se prove falsa
        size = len(matrix[0])                               #mede o tamanho da matriz
        
        for i in range(size):                               #primeiro for, para encotrar as linhas e colunas da matriz
            row = Solution.grablist(matrix, i, True)        #puxa cada linha da matriz
            column = Solution.grablist(matrix, i, False)    #puxa cada coluna da matriz

            for k in range(size):                           #segundo for, para iterar dentro de cada linha e coluna se falta algum número
                if k+1 not in row or k+1 not in column:     #se falta um número na linha ou coluna...
                    result = False                          #... então resultado só pode ser falso...
                    break                                   #... e pode quebrar o segundo for
            
            if result == False: break                       #... e também quebra o 1o for

        return result
        
    # função abaixo para auxiliar a solução, recebe uma matriz, uma posição 'index' da matriz e se deseja-se linha ou coluna.
    # Retorna uma lista da enésima linha ou coluna da matriz.
    
    def grablist(matrixB: List[List[int]], index: int, isLine: bool) -> List[int]:
        if isLine == True:
            return matrixB[index]                           #para linha pega a enésima linha da matriz
        else:
            col = []
            for k in range(len(matrixB[0])):                #para coluna pega o enésimo item de cada linha.
                col.append(matrixB[k][index])               #e acrescenta ao fim de uma lista 'col'.
            return col

Criei uma função separada para pegar listas de cada linha ou coluna. Para leitura e compreensão do código acho que ficou bom, mas a eficiência do código ruim. Nessa hora C++ com ponteiros ficaria provavelmente melhor.

De acordo com o desafio mensal.

Ver mais

Solução usando bitwise operation

Beats 100% em CPU e 100% em consumo de memória também

O(n²) CPU
O(1) memory
Linguagem: Dart

Rock'n'roll baby

Kotlin

postado por @FlyCavok em 07/02/2023 23:33

Ver mais

Solução usando bitwise operation

Beats 100% em CPU e 100% em consumo de memória também

O(n²) CPU
O(1) memory
Linguagem: Dart

Rock'n'roll baby

Ta ai uma parada que eu nunca aprendi: bitwise operations haha
Vou aproveitar pra dar uma estudada, obrigado por compartilhar

Meu primeiro código em kotlin abaixo. Aprendi o básico sobre sintaxe, colchetes tal como em C, diferença entre val e var, equivalência de (0..3) com range(4) em Python.
Certamente tem jeito mais virtuoso de fazer, mas é o primeiro.

class Solution {
    fun checkValid(matrix: Array<IntArray>): Boolean {
    // size pega N numa matriz N x N.
    // linecheck e columncheck serão usados no loop para registrar quando
    // encontrado o valor numa linha ou coluna.
        val size = matrix.size
        var linecheck: Boolean
        var columncheck: Boolean

    // primeiro loop para gerar os valores que sãoesperados em cada linha ou coluna
        for (expected_value in 1..size){
    // segundo loop itera cada linha ou coluna da matriz
            for (a in 0..(size - 1)){
                // reset das 2 variáveis check para false
                linecheck = false
                columncheck = false
    // terceiro loop para iterar cada elemento dentro de uma linha ou coluna
                for (b in 0..(size-1)){
    // se encontrar o valor naquele elemento, linecheck torna-se true
                    if (matrix[a][b] == expected_value){
                        linecheck = true
                    }
    // se encontrar o valor naquele elemento, columncheck torna-se true
                    if (matrix[b][a] == expected_value){
                        columncheck = true
                    }
                    
    // se as duas varáveis são true não há porque continuar iterando dentro da linha e coluna
                    if (linecheck == true && columncheck == true){
                        break
                    }
                }
    // ao fim da iteração de cada linha e coluna, se houver um check false, já retorna false
            if (linecheck == false || columncheck == false ){
                return false
                }
            }
        }
    // depois dos loops, se não encontrar nada falso, é porque é verdadeiro
        return true
    }
}?

Queridos,
Queria pedir uma ajuda nesse desafio.
Dado a matriz abaixo, qual o resultado esperado? Ela é válida ou não?

Caso ela não seja válida, qual o critério que invalida ela?

matrix = [
 [15, 7, 18, 11, 19, 10, 14, 16, 8, 2, 3, 6, 5, 1, 17, 12, 9, 4, 13],                      
 [17, 15, 9, 8, 11, 13, 7, 6, 5, 1, 3, 16, 12, 19, 10, 2, 4, 14, 18],                      
 [19, 14, 12, 10, 8, 9, 17, 16, 4, 3, 13, 18, 1, 5, 7, 11, 2, 15, 6],                      
 [4, 2, 10, 15, 19, 16, 8, 9, 5, 3, 1, 11, 13, 14, 6, 18, 12, 17, 7],                      
 [13, 19, 9, 16, 5, 8, 6, 12, 14, 11, 18, 10, 7, 2, 3, 4, 15, 17, 1],                      
 [4, 7, 18, 11, 17, 16, 5, 12, 10, 1, 15, 13, 14, 6, 19, 2, 3, 9, 8],                      
 [14, 5, 15, 1, 18, 6, 12, 7, 8, 9, 3, 13, 2, 10, 19, 4, 11, 16, 17],                      
 [10, 3, 1, 8, 14, 19, 11, 18, 15, 13, 9, 12, 16, 17, 7, 4, 5, 2, 6],                      
 [14, 13, 19, 18, 7, 2, 4, 8, 10, 17, 12, 5, 15, 1, 6, 9, 11, 3, 16],                      
 [19, 8, 10, 18, 16, 12, 11, 17, 4, 9, 7, 2, 5, 13, 15, 3, 6, 1, 14],                      
 [1, 10, 6, 14, 7, 18, 3, 9, 4, 16, 5, 11, 13, 17, 15, 8, 19, 2, 12],                      
 [13, 10, 5, 16, 1, 19, 17, 3, 9, 11, 7, 8, 12, 6, 4, 2, 14, 15, 18],                      
 [17, 2, 1, 6, 9, 19, 18, 14, 4, 11, 12, 13, 16, 5, 8, 7, 3, 10, 15],                      
 [1, 4, 10, 5, 13, 6, 18, 11, 3, 2, 15, 14, 16, 12, 17, 19, 8, 9, 7],                      
 [2, 14, 3, 12, 16, 17, 11, 9, 1, 6, 5, 19, 10, 13, 4, 18, 7, 15, 8],
 [15, 9, 8, 18, 14, 13, 4, 12, 5, 17, 6, 1, 11, 16, 19, 3, 7, 2, 10],
 [15, 8, 12, 16, 13, 2, 6, 19, 18, 14, 10, 5, 11, 9, 7, 1, 3, 17, 4],
 [15, 6, 17, 7, 5, 3, 1, 9, 19, 12, 10, 11, 16, 14, 18, 8, 2, 13, 4],
 [6, 11, 10, 14, 2, 13, 16, 1, 9, 15, 8, 19, 17, 3, 5, 18, 7, 4, 12]] 

O meu resultado tá diferente do caso de teste do site.

Mas, quando eu mando ordenar as linhas ele me mostra uma matriz de 19 colunas por 19 linhas. Com todos os números em cada linha. 
O que eu estou fazendo errado?

matriz_ordenada = [
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]] 

P.S.: @Gustavo, não rola colocar sintaxe pra Ruby, não, né?

Nesse desafio eu passo... rs

estou igual bastter race.  "Nasceu Ontem"

@Abra Já entendi. É o lance da COLUNA não ter todos os números. Eu tava focado só na LINHA.
Obrigado a todos.
@Gustavo muuuuito obrigado.

postado por @Abra em 08/02/2023 10:55

Queridos,
Queria pedir uma ajuda nesse desafio.
Dado a matriz abaixo, qual o resultado esperado? Ela é válida ou não?

Caso ela não seja válida, qual o critério que invalida ela?

matrix = [
 [15, 7, 18, 11, 19, 10, 14, 16, 8, 2, 3, 6, 5, 1, 17, 12, 9, 4, 13],                      
 [17, 15, 9, 8, 11, 13, 7, 6, 5, 1, 3, 16, 12, 19, 10, 2, 4, 14, 18],                      
 [19, 14, 12, 10, 8, 9, 17, 16, 4, 3, 13, 18, 1, 5, 7, 11, 2, 15, 6],                      
 [4, 2, 10, 15, 19, 16, 8, 9, 5, 3, 1, 11, 13, 14, 6, 18, 12, 17, 7],                      
 [13, 19, 9, 16, 5, 8, 6, 12, 14, 11, 18, 10, 7, 2, 3, 4, 15, 17, 1],                      
 [4, 7, 18, 11, 17, 16, 5, 12, 10, 1, 15, 13, 14, 6, 19, 2, 3, 9, 8],                      
 [14, 5, 15, 1, 18, 6, 12, 7, 8, 9, 3, 13, 2, 10, 19, 4, 11, 16, 17],                      
 [10, 3, 1, 8, 14, 19, 11, 18, 15, 13, 9, 12, 16, 17, 7, 4, 5, 2, 6],                      
 [14, 13, 19, 18, 7, 2, 4, 8, 10, 17, 12, 5, 15, 1, 6, 9, 11, 3, 16],                      
 [19, 8, 10, 18, 16, 12, 11, 17, 4, 9, 7, 2, 5, 13, 15, 3, 6, 1, 14],                      
 [1, 10, 6, 14, 7, 18, 3, 9, 4, 16, 5, 11, 13, 17, 15, 8, 19, 2, 12],                      
 [13, 10, 5, 16, 1, 19, 17, 3, 9, 11, 7, 8, 12, 6, 4, 2, 14, 15, 18],                      
 [17, 2, 1, 6, 9, 19, 18, 14, 4, 11, 12, 13, 16, 5, 8, 7, 3, 10, 15],                      
 [1, 4, 10, 5, 13, 6, 18, 11, 3, 2, 15, 14, 16, 12, 17, 19, 8, 9, 7],                      
 [2, 14, 3, 12, 16, 17, 11, 9, 1, 6, 5, 19, 10, 13, 4, 18, 7, 15, 8],
 [15, 9, 8, 18, 14, 13, 4, 12, 5, 17, 6, 1, 11, 16, 19, 3, 7, 2, 10],
 [15, 8, 12, 16, 13, 2, 6, 19, 18, 14, 10, 5, 11, 9, 7, 1, 3, 17, 4],
 [15, 6, 17, 7, 5, 3, 1, 9, 19, 12, 10, 11, 16, 14, 18, 8, 2, 13, 4],
 [6, 11, 10, 14, 2, 13, 16, 1, 9, 15, 8, 19, 17, 3, 5, 18, 7, 4, 12]] 

O meu resultado tá diferente do caso de teste do site.

Mas, quando eu mando ordenar as linhas ele me mostra uma matriz de 19 colunas por 19 linhas. Com todos os números em cada linha. 
O que eu estou fazendo errado?

matriz_ordenada = [
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],                     
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]] 

P.S.: @Gustavo, não rola colocar sintaxe pra Ruby, não, né?

Batendo o olho rapidamente, vi que na 1a coluna tem o 14 e o 1 repetidos, então terá número faltante pelo menos na 1a coluna.

postado por @Abra em 08/02/2023 11:17

Abra Já entendi. É o lance da COLUNA não ter todos os números. Eu tava focado só na LINHA.
Obrigado a todos.
Gustavo muuuuito obrigado.

@Abra
Até aí eu consegui fazer rsrs Problema agora é na coluna..
Se vc tiver uma luz para mim
Valeu!
 

Tentei ser pytônico

Ver mais

Pronto... Já posso mostrar minha versão Ruby não me deixa brincar...
Primeiro a linha de raciocínio:

1. Preciso ver se uma lista tem todos os números entre 1 e o tamanho da lista.

1.1 Cria uma lista com todos os números

expected_line = (1..linha.size).to_a

1.2 Quando eu subtraio uma lista de outra eu recebo uma lista com a diferença. Então, remover a linha a ser validada da linha esperada(a que contem todos os números) vai retornar uma lista vazia para linhas validas.

expected_line - line_to_be_validated == [] # Is equal to [], empty list, for valid lines

1.3 Agora eu preciso aplicar essa função para todas as linhas na matriz. Daí entra o método #reduce que transforma uma lista em um valor. E, eu quero transformar uma lista em um valor true(quando todas as linhas são validas) ou false(quando qualquer uma dessas linhas for inválida).
Maaaas, como fazer para inicializar um acumulador booleano? Aí entra uma maracutaia do Ruby. O método presente nas listas chamado #compact. Ele funciona removendo valores nulos de uma lista.

> [nil, 1, nil, 2, nil, nil, 3].compact
=> [1, 2, 3]

 

E, como o #compact vai ajudar, aqui? Simples: eu inicializo o acumulador do #reduce como nulo. Daí eu coloco a resposta(que começa nula) e a validação da linha em um array. Chamo o compact(pra remover o valor inicial nulo) e chamo um reduce com & que vai fazer uma operação AND nos elementos do array.

matrix.reduce(nil) do |answer, line|
  [answer, (expected_line - line).empty?].compact.reduce(:&)
end

Parece complicado escrevendo. Mas, a execução é algo assim:

[1, 2, 3] # A lista que está sendo testada

# O que acontece em cada elemento nesse reduce:
# Primeiro elemento da lista: 1 o acumulador está nulo.
[nil, true].compact => [true].reduce(:&) => true 

# Segundo elemento da lista: 2. O acumulador está como true.
[true, true].compact => [true, true].reduce(:&) => true & true => true 

# Terceiro elemento da lista: 3. O acumulador está como true.
[true, true].compact => [true, true].reduce(:&) => true & true => true 

 

Nesse ponto eu tenho a validação para as linhas da matriz.
Agora eu preciso da validação das colunas. Eu não tenho idéia de como validar as colunas. Mas, já sei validar as linhas. Então, lembrei das aulas de matemática da 8a série, onde aprendi que tu pode virar uma matriz para que as colunas passem a ser linhas. Com isso eu posso usar a validação que já tenho.
E, mais uma vez o Ruby me deu essa moral de já ter um método para transposição de matriz. Então, foi só aplicar o mesmo validador na matriz. E, na matriz transposta.
Código Final

def check_valid(matrix)
  expected_line = (1..matrix.size).to_a

  validator = ->(m) do
    m.reduce(nil) do |answer, line|
      [answer, (expected_line - line).empty?].compact.reduce(:&)
    end
  end

  [matrix, matrix.transpose].map(&validator).reduce(:&)
end

Observa que eu extrai o código que faz o reduce nas linhas para uma variável chamada validator. Essas seta é pra criar uma bloco executável de código conhecido como lambda.



Daí que eu crio uma lista com a matriz original e a versão transposta dela. Faço um map usando o validador. E, o mesmo reduce entre valores booleanos(feito na validação da linha) pra ter a resposta final.
Resultado Final

@Abra   Você implementou metade.

O problema quer que todas as linhas e todas as colunas tenham 1..n

Então

1 2 3
1 2 3
1 2 3   tá errado. Todas as linhas estão certas, mas na coluna 1 estão faltando 2 e 3, na coluna 2 estão faltando 1 e 3 e na coluna 3 estão faltando 1 e 2.
1 3 2
2 1 3
3 2 1   tá correto

@Padfoot
Explicação:

cada int no dart possui 64 bits.

Daí eu pego cada bit dentro do int para representar um valor de n.

por ex,

n = 1  [ 0000000000000000000000000000000000000000000000000000000000000001]
n = 2  [ 0000000000000000000000000000000000000000000000000000000000000011]
n = 3  [ 0000000000000000000000000000000000000000000000000000000000000111]
...
n = 7  [ 0000000000000000000000000000000000000000000000000000000001111111]

Até o n = 50  [ 00000000000000111111111111111111111111111111111111111111111111111111111]

Se n > 50 aí não vai caber em 1 int só... então eu tenho outro int pra guardar do 51 em diante...

Isso gera um valor que eu chamei de chkSum1 (<= 50) e chkSum2 (>50)

Depois eu faço a mesma conta nas linhas e colunas. Se bater o mesmo chkSum1 e chkSum2, então é pq tem todos os números.

ex: n = 3

chkSum1 = [ ...0000000111]
chkSum2 =  0

1 3 2  =  [ ...0000000111] == chkSum1
2 1 3  =  [ ...0000000111] == chkSum1
3 2 1  =  [ ...0000000111] == chkSum1

Válido.

1 3 3  =  [ ...0000000101] != chkSum1   Inválido
2 1 3  
3 2 1