Dropbox

    Olá, após muito tempo sem postar, trago a vocês o dropbox, um sistema de armazenamento online semelhante ao skydrive (Microsoft), e GoogleDrive (Google).

    O Dropbox é o lugar certo para todos os seus arquivos, fotos e vídeos. Qualquer coisa que você adicionar ao seu Dropbox aparecerá automaticamente em todos os seus computadores, celulares e até mesmo no site do Dropbox , para que você possa acessar tudo de qualquer lugar.

    Com o Dropbox, compartilhar arquivos com outras pessoas é superfácil, não importa se você é estudante ou profissional, um pai ou um avô. Mesmo se você derramar café sem querer no laptop, não fique com medo! Relaxe com a certeza de que todos os seus arquivos estão seguros no Dropbox e nunca se perderão.

Por isso não perca a oportunidade de ganhar 2GB de armazenamento, basta acessar:

www.dropbox.com

Filme - Forrest Gump

Sinopse: Forrest Gump é um homem muito especial. Considerado estúpido por todos que o conheçem, ele é na verdade apenas uma pessoa ingênua que vê o mundo por uma perspectiva diferente. Gump acidentalmente participa de alguns dos momentos mais importantes da história recente dos Estados Unidos - Guerra do Vietnã, Caso Wategate, entre outros - enquanto tenta ir atrás do grande amor de sua vida. Sua história é contada com drama e bom humor em iguais proporções, surpreendendo o espectador a cada cena.

Opnião: Filme muito interessante, apesar de ser de 1994 apresenta um enredo e uma história envolvente, é o tipo de filme que eu nunca havia assistido, o que mais impressiona é a capacidade do mesmo de amar uma mulher depois de tudo que ela o fez passar. O filme combina situações tanto de drama quanto de comédia, se você é uma pessoa que facilmente chora ao assistir um filme, neste as duas situações serão misturadas. Muito recomentado!

"Corra Forrest, Corra!"

Fonte da Sinopse: www.webcine.com.br

Resolução - Revisão de Contrato - 2010

Questão da maratona de programação de 2010, basicamente um contador que não cuidou muito bem de seu computador pede sua ajuda para determinar o real valor de seus contratos. Neste problema eu trabalhei na base de string, o número da tecla problemática recebo como inteiro e somo com 48 para obter o seu respectivo número na tabela ASCII, e o número seguinte recebo como uma string.
No tratamento do valor eu substituo todos os valores iguais ao valor problemático por 'A', após isso se a string for composta somente por zeros imprimo "0", senão eu imprimo a partir do primeiro valor diferente de zero.

LINK PARA DOWNLOAD DO CÓDIGO: Código Revisão de Contrato

SITE: http://www.urionlinejudge.com.br/judge/problems/view/1120

Resolução - Robô colecionador - 2010

Questão da maratona de programação de 2010, consiste em elaborar um algoritmo para calcular quantas figurinhas serão coletas pelo robô. O modo mais simples que veio a minha cabeça foi criar uma matriz de char para armazenar todos os elementos da arena e uma struct para armazenar a posição inicial e a próxima posição que ele irá ocupar:

struct pos {
    int x;
    int y;
    int prox_x;
    int prox_y;
}pos;

Com isto basta apenas receber a string de comandos, prestar atenção nas bordas, nas colunas, apagar as figurinhas coletadas e criar um contador para armazenar o número de figuras coletadas!
Vamos lá:


#include<stdio.h>
struct pos {
    int x;
    int y;
    int prox_x;
    int prox_y;
}pos;



int main (void) {
    int L, C, S;
    while (scanf("%d %d %d", &L, &C, &S)&&L!=0) {
        int i, j, fig=0;
        char tab[L][C], cmd[S+1];
        getchar();
        for(i=0; i<L; i++) {
            for(j=0; j<C; j++) {
                tab[i][j]=getchar();
                if(tab[i][j]!='.'&&tab[i][j]!='*'&&tab[i][j]!='#') {
                    pos.x=i;
                    pos.y=j;
                    switch (tab[i][j]) {
                        case 'N':
                            pos.prox_x=i-1;
                            pos.prox_y=j;
                            break;
                        case 'S':
                            pos.prox_x=i+1;
                            pos.prox_y=j;
                            break;
                        case 'L':
                            pos.prox_x=i;
                            pos.prox_y=j+1;
                            break;
                        case 'O':
                            pos.prox_x=i;
                            pos.prox_y=j-1;
                            break;
                    }
                }
            }
            getchar();
        }
        scanf("%s", cmd);
        for (i=0; i<S; i++) {
            switch (cmd[i]) {
                case 'D':
                    if (pos.prox_y==pos.y) {
                        if (pos.prox_x>pos.x) {
                            pos.prox_x=pos.x;
                            pos.prox_y=pos.y-1;
                        }
                        else {
                            pos.prox_x=pos.x;
                            pos.prox_y=pos.y+1;
                        }
                    }
                    else {
                        if (pos.prox_y>pos.y) {
                            pos.prox_y=pos.y;
                            pos.prox_x=pos.x+1;
                        }
                        else {
                            pos.prox_y=pos.y;
                            pos.prox_x=pos.x-1;
                        }
                    }
                    break;
                case 'E':
                    if (pos.prox_x==pos.x) {
                        if (pos.prox_y>pos.y) {
                            pos.prox_y=pos.y;
                            pos.prox_x=pos.x-1;
                        }
                        else {
                            pos.prox_y=pos.y;
                            pos.prox_x=pos.x+1;
                        }
                    }
                    else {
                        if (pos.prox_x>pos.x) {
                            pos.prox_x=pos.x;
                            pos.prox_y=pos.y+1;
                        }
                        else {
                            pos.prox_x=pos.x;
                            pos.prox_y=pos.y-1;
                        }
                    }
                    break;
                case 'F':
                    if (tab[pos.prox_x][pos.prox_y]!='#'&&(pos.prox_x<L&&pos.prox_x>-1)&&(pos.prox_y<C&&pos.prox_y>-1)) {
                        if (tab[pos.prox_x][pos.prox_y]=='*') {
                            tab[pos.prox_x][pos.prox_y]='.';
                            fig++;
                        }
                        if (pos.prox_y==pos.y) {
                            if (pos.prox_x>pos.x) {
                                pos.x=pos.prox_x;
                                pos.prox_x++;

                            }
                            else {
                                pos.x=pos.prox_x;
                                pos.prox_x--;
                            }
                        }
                        else {
                            if (pos.prox_y>pos.y) {
                                pos.y=pos.prox_y;
                                pos.prox_y++;

                            }
                            else {
                                pos.y=pos.prox_y;
                                pos.prox_y--;
                            }
                        }
                    }
                    break;
            }

        }
        printf("%d\n", fig);
    }
    return 0;
}

Admito que o código é bem deselegante mas é uma forma simples e fácil de implementar
SITE: http://www.urionlinejudge.com.br/judge/problems/view/1121



[sourcecode language="c"] Escreva aqui seu código-fonte. [/sourcecode]

Resolução - Piscina - 2005

Questão da maratona de programação de 2005, consiste em determinar a quantidade de ladrilhos para recobrir a piscina e obter o menor custo, nesta questão usamos o famoso algoritmo guloso, sendo que o melhor custo/área coberta é em ordem: 30x30, 15x15, 5x5. Assim você primeiro recobre primeiro com 30x30 e assim por diante.
Quando eu tentei resolver pela primeira vez calculei a área total da piscina depois dividí pela área de 30x30, 15x15, e 5x5 respectivamente, mas, com isso foi necessário quebrar os ladrilhos. Assim, a melhor solução é calcular os ladrilhos para cada parede, simples!
Aí o código:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int P = 0, M = 0, G = 0;
void ladrilhos05 (int Xa, int Xb, int *p, int *m, int *g) {
    int i, mod=Xa/5;
    for (i=0; i<mod; i++) {
        (*p)+=Xb/5;
        P-=Xb/5;
    }
}
void ladrilhos15 (int Xa, int Xb, int *p, int *m, int *g) {
    int i, mod=Xa/15, aux;
    for (i=0; i<mod; i++) {
        if (Xb/15>M) {
            (*m)+=aux=M;
            M=0;
        }
        else {
            (*m)+=aux=Xb/15;
            M-=Xb/15;
        }
        aux*=15;
        if (Xb-aux) ladrilhos05 (15, Xb-aux, &(*p), &(*m), &(*g));
    }
    ladrilhos05 (Xa-mod*15, Xb, &(*p), &(*m), &(*g));
}
void ladrilhos30 (int Xa, int Xb, int *p, int *m, int *g) {
    int i, mod=Xa/30, aux=0;
    for (i=0; i<mod; i++) {
        if (Xb/30>G) {
            (*g)+=aux=G;
            G=0;
        }
        else {
            (*g)+=aux=Xb/30;
            G-=Xb/30;
        }
        aux*=30;
        if (Xb-aux) ladrilhos15 (30, Xb-aux, &(*p), &(*m), &(*g));
    }
    ladrilhos15 (Xa-mod*30, Xb, &(*p), &(*m), &(*g));
}
int main () {
    do {
        int Xa = 0, Xb = 0, Ya = 0, Yb = 0, Za = 0, Zb = 0;
        scanf ("%d.%d %d.%d %d.%d", &Xa, &Xb, &Ya, &Yb, &Za, &Zb);
        Xa = (10*Xa+Xb)*10;
        Ya = (10*Ya+Yb)*10;
        Za = (10*Za+Zb)*10;
        if (Xa==0 && Ya==0 && Za==0) break;
        scanf ("%d %d %d", &P, &M, &G);
        int qtdG = 0, qtdM = 0, qtdP = 0;
        int tempP=P, tempM=M, tempG=G;
        ladrilhos30 (Xa, Za, &qtdP, &qtdM, &qtdG);
        ladrilhos30 (Xa, Za, &qtdP, &qtdM, &qtdG);
        ladrilhos30 (Ya, Za, &qtdP, &qtdM, &qtdG);
        ladrilhos30 (Ya, Za, &qtdP, &qtdM, &qtdG);
        ladrilhos30 (Xa, Ya, &qtdP, &qtdM, &qtdG);
        if (qtdP>tempP) printf ("impossivel\n");
        else printf ("%d %d %d\n", qtdP, qtdM, qtdG);
    } while (1);
    return 0;
}


SITE: http://br.spoj.com/problems/PISCINA/

Resolução - Botas Perdidas - 2011

Esta é uma questão da primeira fase da maratona de programação de 2011, para sua resolução é necessário que se formem todos os pares possíveis. Antes de tudo imagine dois guada sapatos com espaços para alojar todos os números dos calçados.

Pronto! Tendo em mente este arranjo, basta apenas analisar cada prateleira, observando que o número máximo de pares formados vai ser o menor dos dois. Vamos ao código em C:

#include<stdio.h>

int main () {
    int i, n, tam, D[31], E[31];
    while (scanf("%d", &n)>0) {
        int total=0;
        for (i=0; i<31; i++) D[i]=E[i]=0;
        char pe;
        for (i=0; i<n; i++) {
            scanf ("%d %c", &tam, &pe);
            if(pe=='D') D[tam-30]++;
            if(pe=='E') E[tam-30]++;
        }
        for (i=0; i<31; i++) {
            if (D[i]<=E[i]) total += D[i];
            else total += E[i];
        }
        printf ("%d\n", total);
    }
    return 0;
}

SITE: http://br.spoj.com/problems/BOTAS/

Se isto lhe foi útil não esqueça de agradecer!

Resolução - Questão Guarda Costeira - 2011

Esta é uma questão da primeira fase da maratona de programação de 2011, consiste basicamente em calcular se o barco do fugitivo irá cruzar a linha de limite primeiro. A imagem a Seguir exemplifica melhor:

Assim, poderemos calcular o tempo Tg = S/Vg e Tf = 12/Vf (Tg: tempo que o barco da guarda costeira leva para chegar ao limite, Tf: tempo que o barco do fugitivo leva para chegar ao limine), após feita esta análise podemos constatar que, se o Tg for menor ou igual a Tf o fugitivo será preso, senão estará livre. Visto isso podemos aplicar ao código em C.

#include<stdio.h>
#include<math.h>

int main () {
    int D, Vf, Vg;
    while (scanf ("%d %d %d", &D, &Vf, &Vg)>0) {
         float S, Tg, Tf;
         S = sqrt (pow(D, 2) + 144);
         Tg = S/Vg;
         Tf = 12.0/Vf;
         if (Tg <= Tf) printf("S\n");
         else printf ("N\n");
    }
    return 0;
}

SITE: http://br.spoj.com/problems/GUARDCOS/
Se isto lhe foi útil não esqueça de agradecer!