helpi :( Java primeiro trabalho

Sugestão de resolução

Código: 
boolean CHECK = true;

for (int linha = 0; (linha < matriz_a_usar.length()) & CHECK; linha++)  {
     for (int coluna = 0; (coluna < matriz_a_usar[linha].length()) & check; coluna++) {
          CHECK =(matriz_a_usar[linha][coluna] <0) | (matriz_a_usar[linha][coluna] > 9)) 
     }

}
if (CHECK)
   System.out.println("Matriz Correcta (todos os valores estão no intervalo [0-9])");
else
    
     System.out.println("Matriz Incorrecta (contém valores fora do intervalo [0-9])")
Modificado, para corrigir a palavra "true" mal escrita...
 
Última edição:
theforbidden1 disse:
Sugestão de resolução

Código: 
boolean CHECK = [COLOR=Red]ture[/COLOR];

for (int linha = 0; (linha < matriz_a_usar.length()) [COLOR=Red]&[/COLOR] check; linha++)  {
     for (int coluna = 0; (coluna < matriz_a_usar[linha].length()) [COLOR=Red]&[/COLOR] check; coluna++) {
          CHECK =(matriz_a_usar[linha][coluna] <0) [COLOR=Red]|[/COLOR] (matriz_a_usar[linha][coluna] > 9)) 
     }

}
if (CHECK)
   System.out.println("Matriz Correcta (todos os valores estão no intervalo [0-9])");
else
    
     System.out.println("Matriz Incorrecta (contém valores fora do intervalo [0-9])")
Clicar para expandir...
De realçar que é true (erro de escrita, é normal).

De realçar que & é diferente de &&. O & é a comparação(não é bem comparação, mas serve como exemplo) de bits, bitwise, o mesmo se aplica ao | e ||.

Não queres compara bits, mas sim tipos.

Tem atenção a isto, por vezes podem coincidir resultados, mas é mesmo uma coincidência.
 
HecKel disse:
O break não tem nada de má prática, de facto prefiro o uso de variáveis de controlo tal como tentei na minha solução inicial, só que dei o || em vez do &&. Tal como referi, o break foi a solução alternativa.

Quanto à velocidade..., não há qualquer alteração de desempenho, a comparação é exactamente a mesma. A diferença está na memória utilizada para armazenar a variável, um booleano requer menos que um inteiro, no entanto isso não afecta absolutamente nada no desempenho do programa, pelo menos em programas pequenos.
Clicar para expandir...

por vezes a instrução break ou goto são boas praticas, pois são efectivamente as instruções mais eficientes. No caso do uso de 1 variável de controlo há uma sobrecarga de processamento, pois é mais uma condição logica (no caso dos exemplo por vos dados duas!) a cada execução do ciclo...
 
O problema dos gotos e dos breaks é que são a chamada programação esparguete, é terrível de analisar mais tarde ou de ser analisado por outro programador.

É o único problema disso, no entanto se formos a olhar para Assembly..., enfim..., é quase tudo gotos :P
 
Está-me cá a parecer que a implementação do goto no Java não passou das primeiras versões, devido às razões já mencionadas.

Com excepção de algumas linguagens, o uso do goto é geralmente uma má politica.
 
HecKel disse:
De realçar que é true (erro de escrita, é normal).

De realçar que & é diferente de &&. O & é a comparação(não é bem comparação, mas serve como exemplo) de bits, bitwise, o mesmo se aplica ao | e ||.

Não queres compara bits, mas sim tipos.

Tem atenção a isto, por vezes podem coincidir resultados, mas é mesmo uma coincidência.
Clicar para expandir...

Obrigado pela correcção do true :)


O heckel tem toda a razão, aqueles operadores funcionam no modo binário. As operações binarias funcionam bem sobre booleans...
 
Acredita, é pior estares horas à volta do teu código à procura de um erro e depois descobrires que é um ponto e virgula..., ou mesmo alta burrice que tu nunca detectaste porque tu nunca farias tal coisa.

Em trabalhos da faculdade era bom a identificar problemas nos trabalhos dos outros..., mas nunca nos meus. Nunca olhava para os meus trabalhos com uma visão critica, nunca pensava que era capaz de fazer erros tão parvos :x

Ao que acabaste de sofrer chama-se progresso :P Pelo menos tentaste, e é isso que é importante ;)
 
Já agora, ha alguma forma alternativa de fazer isto?
Clicar para expandir...
Sure!
Em Perl eu faria qualquer coisa como:
Código: 
#!/usr/bin/perl
use strict;
use warnings;

my @matrizes;

# Incorrecta (valor -1)
$matrizes[0] = [
    [qw/-1 0 3 0 0 5 6 0 0/], [qw/0 0 0 0 0 0 0 0 0/],
    [qw/0 0 0 7 0 0 0 0 0/],  [qw/0 0 0 8 0 0 0 4 0/],
    [qw/0 0 2 0 0 0 0 6 0/],  [qw/0 0 4 0 0 0 0 0 0/],
    [qw/0 0 5 0 0 0 0 0 1/],  [qw/0 0 9 0 0 0 0 1 0/],
];

# Incorrecta (valor 10)
$matrizes[1] = [
    [qw/8 0 3 0 0 5 6 0 0/],  [qw/0 0 0 0 0 0 0 0 0/],
    [qw/0 0 0 7 0 0 0 0 0/],  [qw/0 0 0 8 0 0 0 4 0/],
    [qw/0 0 2 0 0 0 0 6 0/],  [qw/0 0 4 0 0 0 0 0 0/],
    [qw/0 0 5 0 0 0 0 0 1/],  [qw/10 0 9 0 0 0 0 1 0/],
];

# Incorrecta (10 elementos)
$matrizes[2] = [
    [qw/6 0 3 0 0 5 6 0 0/],  [qw/0 0 0 0 0 0 0 0 0/],
    [qw/0 0 0 7 0 0 0 0 0/],  [qw/0 0 0 8 0 0 0 4 0 1/],
    [qw/0 0 2 0 0 0 0 6 0/],  [qw/0 0 4 0 0 0 0 0 0/],
    [qw/0 0 5 0 0 0 0 0 1/],  [qw/0 0 9 0 0 0 0 1 0/],
];

# Incorrecta (9 linhas)
$matrizes[3] = [
    [qw/6 0 3 0 0 5 6 0 0/], [qw/0 0 0 0 0 0 0 0 0/],
    [qw/0 0 0 7 0 0 0 0 0/], [qw/0 0 0 8 0 0 0 4 0/],
    [qw/0 0 2 0 0 0 0 6 0/], [qw/0 0 4 0 0 0 0 0 0/],
    [qw/0 0 5 0 0 0 0 0 1/], [qw/0 0 9 0 0 0 0 1 0/],
    [qw/0 0 5 0 0 0 0 0 1/]
];

# Correcta
$matrizes[4] = [
    [qw/6 0 3 0 0 5 6 0 0/], [qw/0 0 0 0 0 0 0 0 0/],
    [qw/0 0 0 7 0 0 0 0 0/], [qw/0 0 0 8 0 0 0 4 0/],
    [qw/0 0 2 0 0 0 0 6 0/], [qw/0 0 4 0 0 0 0 0 0/],
    [qw/0 0 5 0 0 0 0 0 1/], [qw/0 0 9 0 0 0 0 1 0/],
];

MATRIZ:
for my $i (0 .. $#matrizes) {

    # Cada matriz tem de ter 8 linhas
    unless ( scalar @{$matrizes[$i]} == 8 ) {
        print "Matriz ", $i, " incorrecta! Nao tem 8 linhas.\n"; next MATRIZ;
    }

    foreach my $linha (@{$matrizes[$i]}) {

        # cada linha tem de ter 9 elementos
        unless ( scalar @$linha == 9 ) {
            print "Matriz ", $i, " incorrecta! Nao tem 9 elementos.\n"; next MATRIZ
        }

        foreach my $elemento (@$linha) {
            unless ($elemento =~/^\d$/mx) {
                print "Matriz ", $i, " incorrecta! Elemento '", $elemento, "' diferente de 0-9\n";
                next MATRIZ;
            }
        }
    }

    # se chegámos aqui, a matriz está ok
    print "Matriz ", $i, " Correcta!\n";

}

e o resultado seria:
Código: 
~$ perl matriz.pl
Matriz 0 incorrecta! Elemento '-1' diferente de 0-9
Matriz 1 incorrecta! Elemento '10' diferente de 0-9
Matriz 2 incorrecta! Nao tem 9 elementos.
Matriz 3 incorrecta! Nao tem 8 linhas.
Matriz 4 Correcta!

... a menos que eu não tenha percebido nada do que se pretendia!
 
Inicie sessão ou registe-se para poder participar.
Back
Topo