Últimamente he hablado acerca del I concurso de programación de Tuenti. Un concurso de programación Online que se llevó acabo durante la semana pasada (del 13 al 20 de Junio, muy mala fecha).
Podéis ver los enunciados de todos los problemas, con ejemplos sobre la entrada y salida (aunque a veces no hay que haerles mucho caso) en la web oficial del concurso, pero en Vidas Concurrentes lo encontramos todo en español.
Challenge #14 : Colors are beautiful
Nos dan una imagen para que la carguemos, y luego nos dirán una componente y un número de línea, para que hagamos la suma de esa componente a lo largo de toda la línea
Soluciones:
Si no estás en la lista y quieres plantear tu solución, deja un comentario con tu link !
Actualización 2011/06/28 08:30 : Añadida solución de @theom3ga
Actualización 2011/06/28 08:35 : Añadida solución de @ricardclau
Actualización 2011/07/03 01:49 : Añadida solución de @frisco82
Actualización 2011/07/03 13:45 : Añadida solución de @Rosapolis
Actualización 2011/07/14 14:55 : Añadida solución de @lagunex
Categories: #tuentiContest, C/C++, General, Imagen Digital, Linux, PHP Tags: componentes, concurso, contest, imagen, lectura, linea, pixel, programacion, puntos, suma, tuenti
Aquí llega mi primera aportación a las soluciones de los retos del I concurso de programación de Tuenti. La utilización de números grandes es algo que siempre me llamó la atención, y normalmente utilizo bc cuando necesito algún cálculo. Este reto se podía resolver con bash/sed/bc y, aunque varios lenguajes permiten la utilización de números de precisión arbitraria “de serie” como python y Java, yo decidí hacerlo en C, utilizando la biblioteca GMP.
En un lenguaje como C, es normal que no podamos utilizar números de precisión arbitraria con los operadores normales (+, -, *,…), en este caso tendremos que hacer llamadas a funciones de la biblioteca para realizar las operaciones, tampoco podremos utilizar un printf() normal para mostrarlos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| /**
*************************************************************
* @file hardsum.c
* @brief Tuenti Contest Test Phase
* Sum numbers separated by space line by line
*
* @author Gaspar Fernández <blakeyed@totaki.com>
* @version 0.0.2
* @date 12 jun 2011
*
* http://totaki.com/poesiabinaria
*
*************************************************************/
#include <stdio.h>
#include <string.h>
#include <gmp.h>
/* Huge string */
#define STRSIZE 1000
int main()
{
char bigstr[STRSIZE];
mpz_t tmp, sum;
char * token;
/* Initialize gmp numbers */
mpz_init(tmp);
mpz_init(sum);
/* Read until EOF in stdin */
while (fgets(bigstr, STRSIZE, stdin)!=NULL)
{
/* reset sum */
mpz_set_si(sum, 0);
token=strtok(bigstr, " \n");
while (token!=NULL)
{
gmp_sscanf(token, "%Zd", &tmp); /* Extract number from token string */
mpz_add(sum, sum, tmp); /* Adds numbers */
token=strtok(NULL, " \n");
}
gmp_printf("%Zd\n", sum);
}
return 0;
} |
Para compilar, debemos incluir gmp:
$ gcc -o hardsum hardsum.c -lgmp
Para utilizar este tipo de variables numéricas, primero tendremos que inicializarlas con mpz_init(), otras funciones interesantes son:
- mpz_set_si(): inicializa el número con un valor entero.
- gmp_sscanf(): igual que scanf(), pero con la posibilidad de utilizar estas nuevas variables.
- mpz_add(): realiza la suma de dos números
- gmp_printf(): igual que printf(), pero con la posibilidad de utilizar estas nuevas variables.
GMP tiene muchísimas funciones para realizar gran cantidad de operaciones, se puede consultar la documentación aquí.
Categories: C/C++ Tags: adición, arbitraria, Bash, bc, bits, concurso, gmp, grandes, numeros, precisión, programacion, sed, suma, tuenti
Hace unos días empecé con la serie Bailando con Bits (aunque llevaba escrito varios meses) trata de formas para trabajar a nivel de bit desde C.
Hoy voy a proponer otra forma, quizás menos intuitiva que la anterior, pero diferente. Esta vez no utilizaremos un registro enorme ni nada parecido, utilizaremos un mismo número entero para hacer el ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| #include <stdio.h>
#define PESOBIT(bpos) 1<<bpos
#define COGEBIT(var,bpos) (var & PESOBIT(bpos))?1:0
#define PONE_1(var,bpos) var | PESOBIT(bpos)
#define PONE_0(var,bpos) var & ~(PESOBIT(bpos))
#define CAMBIA(var,bpos) var ^ PESOBIT(bpos)
int main ()
{
int numero ;
int i ;
numero =63;
printf ("Numero: %d\n", numero );
for (i =31; i >=0; i --)
printf("%4d", i );
printf("\n");
for (i =31; i >=0; i --)
printf("%4d",COGEBIT (numero ,i ));
printf("\n");
numero =PONE_1 (numero , 17);
numero =PONE_0 (numero , 3);
numero =CAMBIA (numero , 20);
numero =CAMBIA (numero , 5);
for (i =31; i >=0; i --)
printf("%4d",COGEBIT (numero ,i ));
printf("\nNúmero: %d\n", numero );
} |
Ahora usamos varias macros que harán operaciones de bit con la variable a analizar (están definidas en la parte de arriba), tenemos PESOBIT, COGEBIT, PONE_1, PONE_0 y CAMBIA:
- PESOBIT: Nos dice cuánto vale un bit con valor 1 en la posición especificada, por ejemplo en la posición 0 (LSB) vale 1, en la posición 1, vale 2, en la posición 3, vale 4, en la posición 4, vale 8…
- COGEBIT: Nos dice si el bit en la posición bpos de la variable var vale 0 ó 1
- PONE_1: Pone un 1 en el bit bpos de la variable var
- PONE_0: Pone un 0 en el bit bpos de la variable var
- CAMBIA: Cambia el valor (de 0 a 1 y viceversa) del bit en la posición bpos de la variable var
Como vemos en el ejemplo si queremos poner a 1 el bit 5 de numero, tendremos que hacer numero=PONE_1(numero,5), aunque en el siguiente ejemplo veremos cómo simplificar todo eso.
Con este ejemplo podemos jugar con los bits de números enteros. Pero, y si queremos utilizar otro tipo de variables? (aunque estamos limitados a 32bits) También tenemos este ejemplo con un tipo float:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| #include <stdio.h>
#define PESOBIT(bpos) 1<<bpos
#define COGEBIT(var,bpos) (*(unsigned*)&var & PESOBIT(bpos))?1:0
#define PONE_1(var,bpos) *(unsigned*)&var |= PESOBIT(bpos)
#define PONE_0(var,bpos) *(unsigned*)&var &= ~(PESOBIT(bpos))
#define CAMBIA(var,bpos) *(unsigned*)&var ^= PESOBIT(bpos)
int main ()
{
float numero ;
int i ;
numero =63.2317;
printf ("Numero: %f\n", numero );
for (i =31; i >=0; i --)
printf("%4d", i );
printf("\n");
for (i =31; i >=0; i --)
printf("%4d",COGEBIT (numero ,i ));
printf("\n");
PONE_1 (numero , 5);
PONE_0 (numero , 3);
CAMBIA (numero , 20);
CAMBIA (numero , 5);
CAMBIA (numero , 31);
for (i =31; i >=0; i --)
printf("%4d",COGEBIT (numero ,i ));
printf("\n");
printf("\nNúmero: %f\n", numero );
} |
En este caso no tenemos que hacer una variable igual a PONE_1(variable, 5) para poner su bit a 1; simplemente con PONE_1(variable, 5) nos vale. En este ejemplo podemos ver una variable de tipo float desglosada en bits y podemos modificar a nivel de bit para obtener otros valores. (No le veo mucha utilidad a esto, pero bueno).
Post dedicado a algm, por su comentario en el artículo Bailando con bits anterior.
Categories: C/C++ Tags: and, bailar, bits, byte, float, inspeccionar, int, investigar, logica, or, recorrer, resta, suma, variable, xor
Últimos comentarios