Murilo :P

C++, Computação, Programação, Web e afins :)

Archive for October 2009

Static Template Matrix – uma abordagem diferente

with 5 comments

Static Template Matrix?

C++
De fato eu nunca vi esse nome em outro lugar, mas foi o nome que eu pensei que se aproxima mais da implementação que veremos nesse post.

Trata-se template de uma matriz (matrix) de duas dimensões de tamanho constante (static). Uma das diferenças dessa matriz é que ao invés de se usar o convencional operator[] para acessar os elementos, nessa abordagem iremos utilizar o operator().

Motivações

Na realidade, não tem muito mais utilidades práticas do que matrizes normais. Pode ser que pode servir em algo para você. Então minha motivação é puramente de aprendizagem, principalmente da linguagem.

matrix.h

#ifndef _CLASS_MATRIX_H__
#define _CLASS_MATRIX_H__

/**
 * matrix.h
 * Defines a template type 'matrix' wich is a constant-sized 2-dimensioned
 * 	matrix and generic typed elements.
 *
 * author: Murilo Adriano Vasconcelos
 * website: https://murilo.wordpress.com
 */

/**
 * T = value type
 * R = number of rows
 * C = number of columns
 */
template <typename T, unsigned R, unsigned C>
class matrix
{
    //data matrix
    T data[R][C];

public:
    //type of the current matrix
    typedef matrix<T, R, C> type;
    typedef T            value_type;

    //quantity of rows
    const unsigned rows;
    //quantity of columns
    const unsigned columns;

    //default ctor
    matrix(): rows(R), columns(C) {};

    /*ctor wich initializes the matrix filled
      with 'value' elements */
    matrix(const T& value);

    //copy ctor: copies the matrix 'tocopy'
    matrix(const type& tocopy);

    /*gets and/or set the value of the element
      in the row 'i', column 'j' */
    T& operator()(unsigned i, unsigned j);

    /*gets the value of the element in the
      row 'i', column 'j' */
    const T& operator()(unsigned i, unsigned j) const;

    //copy operator
    type& operator=(const type& tocopy);
};

/* class functions definition */

template <typename T, unsigned R, unsigned C>
matrix<T, R, C>::matrix(const matrix& tocopy): rows(R), columns(C)
{
    for (unsigned i = 0; i < R; i++)
        for (unsigned j = 0; j < C; j++)
            data[i][j] = tocopy(i, j);
}

template <typename T, unsigned R, unsigned C>
matrix<T, R, C>::matrix(const T& value): rows(R), columns(C)
{
    for (unsigned i = 0; i < R; i++)
        for (unsigned j = 0; j < C; j++)
            data[i][j] = value;
}

template <typename T, unsigned R, unsigned C>
matrix<T, R, C>& matrix<T, R, C>::operator=(const matrix& tocopy)
{
    for (unsigned i = 0; i < R; i++)
        for (unsigned j = 0; j < C; j++)
            data[i][j] = tocopy(i, j);

    return *this;
}

template <typename T, unsigned R, unsigned C>
T& matrix<T, R, C>::operator()(unsigned i, unsigned j)
{
    return data[i][j];
}

template <typename T, unsigned R, unsigned C>
const T& matrix<T, R, C>::operator()(unsigned i, unsigned j) const
{
    return data[i][j];
}

#endif

main.cpp

#include "matrix.h" //our matrix
#include <iostream>  //cout'ing
#include <string>   //for strings

int main()
{
        //declares a 3x3 matrix filled with "nil"
        matrix<std::string, 5, 5> mat("nil");

        //modifies the value in the position (1, 1) to C++
        mat(1, 1) = "C++";

        //we can use the const atribbutes rows and columns
        //to check our limits
        for (unsigned i = 0; i < mat.rows; i++) {
                for (unsigned j = 0; j < mat.columns; j++) {
                        //getting, setting the value of matrix elements
                        //is the same way
                        std::cout << mat(i, j) << ' ';
                }

                std::cout << '\n';
        }

        std::cout << '\n';

        matrix<int, 3, 3> ones(1), identity;
        //copy
        identity = ones;

        //so silly
        for (unsigned i = 0; i < identity.rows; i++) {
                for (unsigned j = i; j < identity.columns; j++) {
                        if (i != j) {
                                identity(i, j) = identity(j, i) = 0;
                        }
                }
        }

        for (unsigned i = 0; i < identity.rows; i++) {
                for (unsigned j = 0; j < identity.columns; j++) {
                        std::cout << identity(i, j) << ' ';
                }

                std::cout << '\n';
        }

        return 0;
}

Como vocês puderam notar, a forma de acesso e modificação (get, set) dos elementos da matriz é da mesma forma. Outra coisa que podemos notar é que passamos o tipo e a quantidade de linhas e colunas direto no template. A quantidade de linha e colunas passada deve ser uma constante.

Bom, até mais.

obs.: Eu odeio profundamente o source highlight bugado do WordPress que converte todos os meus < e > e etc. para &lt; &gt;. Por isso os fontes acima não estão com hl.

Fixed!

Agora sim, até mais.

Written by Murilo Adriano

12 de October de 2009 at 21:08

Regional da Maratona de Programação 2009

with 2 comments

Considerações

Bem, eu ainda não tinha escrito nada sobre a fase regional da XIV Maratona de Programação que ocorreu dia 19 de setembro por falta de tempo e porque não havia recebido as fotos do evento.

O primeiro ponto que quero destacar é a estrutura da regional aqui de Goiânia. Não deixou nada a desejar! Ambiente ótimo, infra-estrutura boa, máquinas, espaço, equipamento, organização. Tenho que parabenizar os professores que organizaram o evento, principalmente os professores Humberto Longo e Cláudio Nogueira do INF-UFG.

Esse ano (2º da regional de Goiânia) participaram 11 equipes de 5 instituições: ALFA (1), IFG-Morrinhos (2), UEG (2), PUC-GO (3) e INF-UFG (3).

Local da competição

Local da competição

Antes…

Na chegada das equipes, pude reencontrar vários amigos, principalmente da PUC-GO e aí os assuntos ficaram em dia (conversamos sobre computação, lógico). O clima estava típico de uma decisão mesmo: em um segunto estávamos conversando e rindo, no outro estávamos tensos e pensativos.

Galera no corredor

Galera no corredor

Antes de começar o warm-up, tivemos uma “mini-palestra” sobre as regras da maratona e de como usar o sistema BOCA e entregas de credenciais, logins/senhas e das plaquinhas que identificam as equipes.

Antes do warm-up

Pré-warm-up

O warm-up foi tranquilo, só pra testes mesmo. Parece que houve um problema no julgamento do problema “Bolhas e Baldes” que posteriormente foi solucionado.

Fim de warm-up, fomos almoçar. Como o campus é uma cidade a parte, quase todo mundo almoçou no mesmo lugar, tendo calculado o menor caminho ou não :).

Começa a maratona e aí vira tensão…

Começa a competição e com 6 minutos, minha equipe (UFG – Monkeys) recebe o primeiro AC da competição: problema B – “Alarme”, Carlitos na implementação. Não sei dizer mas acho que esse foi um dos balões mais rápidos do Brasil.

Não demorou e nossa principal rival, a PUC-GO – Mother Focas, e a UFG – Sobrevientes do RU conseguiram também seus balões amarelos.

Os Focas

Os Focas: Jackie, Divinera e Marciano

Até os 3 primeiros balões nós lideramos com uma certa vantagem no tempo. O problema foi quando os Focas conseguiram o quarto balão e nós não. Aí bateu aquele “caramba, agora fodeo!”. Aí focamos no problema (que por sinal era muito simples) e mandamos… Recebemos um NO bem grande e aí bateu o desespero. Consegui achar a lógica, conferi com meus colegas a corretude e, finalmente YES! Na hora olhamos para o Score que estava num telão na nossa frente e vimos que tinhamos passado os Focas (na verdade olhei o score mesmo assim deu um branco não saquei nada e tive que perguntar a nossa posição pra minha equipe [sic]).

Alguns balões

Alguns balões

Ficamos focados no problema G – “Registrador” e perdemos tempo, muito tempo [sic²]. Quando vimos, tinham 6 equipes com 4 balões, aí de novo bateu o pensamento “fodeo”…

No freeze, conseguimos formular um algoritmo pro E – “Dragster” mas aí já era tarde… Estávamos exaustos e não conseguimos codificá-lo. Enquanto isso, eu estava tentando ter a sacada do F – “Torres de Celular” (pô, tava na cara e eu não enxerguei). E o freeze-time foi isso: Diego e Carlos no Dragster (esse dava hein) e eu tentando algo no Torres de Celular.

Nosso quarto balão

Nosso quarto balão. Monkeys: Murilo, Carlos e Diego

A cada vez que nós víamos alguem teclando algo no freeze, dava um frio na barriga. Tentamos fazer uns “cortes” no registrador e mandamos várias outras vezes.

Score Final

Por um problema na rede (ou de juízes engraçadinhos), o score final demorou uma eternidade após a competição a ser apresentado a nós (aproximadamente 4min e 30seg). Anunciado o vencedor, só alegria.

Comemoração

Comemoração

Mais algumas fotos

PUC-GO Bit a bit

PUC-GO Bit a bit: Douttor, Mauricinho e Loos

UFG - Sons of a Bit

UFG - Sons of a Bit: Nemo, Will e PC

UFG - Sobreviventes do RU

UFG - Sobreviventes do RU: Everton, Will e Lup

dsc08344

A única competidora

A única competidora, o japa e o barba

Os melança

Os melança

Premiação

É… teve premiação com direito a reitor e tudo mais. Auditório cheio e prêmios para os vencedores 🙂

As três primeiras equipes ganharam camisetas geeks, medalhas e trófeus além de um livro (alguns dos prêmios concedidos pela SistemasAbertos).

Nós da Monkeys ganhamos uma camiseta personalizada da Maratona de Programação, como essa abaixo do Longo branca.

3º Lugar - UFG - Sons of a Bit

3º Lugar - UFG - Sons of a Bit e o coach Humberto Longo

2º Lugar - PUC-GO - MotherFocas

2º Lugar - PUC-GO - MotherFocas, pró-reitora de graduação e o coach Alexandre

1º Lugar - UFG - Monkeys

1º Lugar - UFG - Monkeys, coach: Humberto Longo e o reitor

MONKEYS

MONKEYS

E agora…

Final Nacional em Campinas

Final Nacional em Campinas

Rumo a Tóquio, ops, Harbin na China!! 🙂

Ballon Face

O scoreboard, clarifications e etc podem ser visualizados aqui.

Written by Murilo Adriano

9 de October de 2009 at 22:31

Trabalho Em Equipe

with one comment

Pessoal não ando postando algo aqui porque estou muito sem tempo mesmo. Meu time (UFG – Monkeys) passou para a final nacional da maratona de programação, as matérias do período estão bastante árduas e comecei a estagiar na universidade por isso a falta de tempo.

Encerro esse post com uma imagem que achei na grande rede sobre trabalho em equipe:
Trabalho em Equipe

Esse é o caminho 🙂

Written by Murilo Adriano

9 de October de 2009 at 13:58

Posted in Cotidiano

Tagged with ,