Android - Manejando Resources

Cuando programamos para android, debemos tener en cuenta de que hay que separar la parte gŕafica (UI), del código de nuestra futura app.

La parte visual se escribe en XML y el código es Java. La misma distinción que se hace entre CSS y HTML.

Tras crear el proyecto, si nos fijamos en eclipse, vemos que se nos han generado una serie de carpetas. (assets, bin, libs, res, etc)

Aquí nos vamos a centrar en la carpeta res que es donde se almacenan las resources, los elementos que tienen que ver con la parte visual de la app.

Entre estos elementos tenemos las cadenas de texto, los menús, los colores, la disposición de los elementos en la pantalla (layout), etc.

Si consultamos las guías de Android para desarrolladores, los elementos que podemos tener en esta carpeta son:

Animation Resources

Animaciones

Se guardan en res/anim/ y accedemos a ellos desde nuestro código a través de la clase R.anim.

Color State List Resource

Colores
 Se guardan en res/color/ con un valor hexadecimal y accedemos a ellos desde nuestro código a través de la clase R.color.

Drawable Resources

Elementos gráficos.
Se guardan en  res/drawable/ y accedemos a ellos desde nuestro código a través de la clase R.drawable.

Layout Resource

Define la disposición que tendrán los elementos en la pantalla.
Se guardan en res/layout/ y accedemos a ellos desde nuestro código a través de la clase R.layout.

Menu Resource

Menús de nuestra app.
Se guardan en res/menu/ y accedemos a ellos desde nuestro código a través de la clase R.menu.

String Resources

Cadenas de texto, desde las de título de nuestra app hasta el texto que ponemos en un botón, además almacena conjuntos de cadenas de texto y plurales, (Incluye estilos).
Se guardan en res/values/ y accedemos a ellas desde nuestro código a través de las clases R.string, R.array, y R.plurals.

Style Resource

Define el estilo y el formato de los elementos que aparecen en la interfaz.
Se guarda en res/values/ y accedemos a ellos desde nuestro código a través de la clase R.style.

More Resource Types

Define distintos tipos de valores como booleanos, enteros, dimensiones, colores, y arrays.
Se guarda en res/values/ pero se accede a cada uno desde su propia clase (Ej. R.bool, R.integer, R.dimen, etc.).

Python - Programas de práctica Nuclear Reactors

Esta es una solución al problema de practica Nuclear Reactors de codechef.com, la solución es correcta pero para los casos grandes se pasa del tiempo.

Enunciado:

There are K nuclear reactor chambers labelled from 0 to K-1. Particles are bombarded onto chamber 0. The particles keep collecting in the chamber 0. However if at any time, there are more than N particles in a chamber, a reaction will cause 1 particle to move to the immediate next chamber(if current chamber is 0, then to chamber number 1), and all the particles in the current chamber will be be destroyed and same continues till no chamber has number of particles greater than N. Given K,N and the total number of particles bombarded (A), find the final distribution of particles in the K chambers. Particles are bombarded one at a time. After one particle is bombarded, the set of reactions, as described, take place. After all reactions are over, the next particle is bombarded. If a particle is going out from the last chamber, it has nowhere to go and is lost.

Enunciado completo

Código:

#!/usr/bin/env python
linea = raw_input()
i=0
c=0
linea = linea.split()
n_centrales = 0
n_centrales = int(linea[2])
max = 0 
max = int(linea[1])
n_bombardeos = 0 
n_bombardeos = int(linea[0])
centrales = [0] * n_centrales
def bombardear( n ):
 if n >= n_centrales:
  return
 else:
  centrales[n] = centrales[n] + 1
  if centrales[n] > max:
   centrales[n] = 0
   bombardear(n+1)
  return
  
while i < n_bombardeos:
 bombardear(0)
 i = i + 1

while c < n_centrales - 1:
 print centrales[c],
 c = c + 1

print centrales[n_centrales - 1], 

Para mejorar el tiempo habría que eliminar la recursividad.

Programación - Reglas para optimizar código en python

Como en anteriores entradas donde mostraba formas más eficientes de hacer operaciones de entrada/salida en C/C++ ahora voy a dar unos consejos parecidos para programar en Python con restricciones de tiempo.

1) Importar lo mínimo y siempre que sea extrictamente necesario:

Resolviendo un problema para una web, me lo rechazaban por no terminar en el tiempo límite, eliminé un import string que necesitaba para una función que necesitaba y mirad la diferencia.

Y eso que esa operación que eliminé solo la ultilizaba una vez para dar formato a la información de entrada, de haberla usado en un bucle por ejemplo la mejora sería mayor.
2) Evitar recursividad
Siempre es más eficiente, tanto en Python como en otros lenguajes hacer algo de forma iterativa que hacerlo con recursividad, el problema anterior tenia recursividad y para entradas muy grandes se quedaba sin tiempo.

3) Trabajar con listas

Intentar trbajar con listas ya que en Python están bastante optimizadas.

Programación - Creando un proyecto para Android

Para comenzar a crear una App para Android los primero es crear un nuevo proyecto, yo uso eclipse aunque se puede usar otro programa.

Aquí dejo un par de enlaces para ver como se instala Eclipse y el SDK de Android en Linux, Windows o Mac

Ubuntu: http://xcodigoinformatico.blogspot.com.es/2012/09/instalar-sdk-android-en-ubuntu-1204.html

Windows / Mac: http://tugrancatalogo.com/viewarticle.php?id=17

Una vez instalado todo, ejecutamos eclipse y seleccionamos un Workspace. Creamos el proyecto new >> Android application project.

Veremos esta pantalla:

En esta se nos pide el nombre de la App, el nombre del proyecto, que por defecto es el mismo y el nombre del Package que debe ser único por defecto se crea com.example.(Nombre_app) pero yo lo he cambiado a bada.

Luego vemos Minimum required SDK esto es la versión más baja de Android en la que puede funcionar nuestra App, Target SDK que es la versión más alta de Android en la que puede funcionar, Compile with es el SDK que se va a utilizar, normalmente se usa la última versión y Theme es el aspecto de nuestra App.

Una vez pulsemos Next veremos esta pantalla:

Aquí podemos decidir si creamos un icono personalizado, si creamos una actividad, una actividad es una pantalla con la que el usuario interactua, y el directorio donde guardar el proyecto.

Creamos el icono y seguimos:

Elegimos el tipo de actividad que queremos crear.

Le damos un nombre y hemos terminado:

Ya tenemos creado el proyecto de nuestra App

Programación - Programas de practica

Hoy muestro la solución de uno de los problemas de practica de la web codechef.com, titulado Closind the Tweets.
Aqui el enunciado:

Little kids, Jack and Evan like playing their favorite game Glass-and-Stone. Today they want to play something new and came across Twitter on their father's laptop.

They saw it for the first time but were already getting bored to see a bunch of sentences having at most 140 characters each. The only thing they liked to play with it is, closing and opening tweets.

There are N tweets on the page and each tweet can be opened by clicking on it, to see some statistics related to that tweet. Initially all the tweets are closed. Clicking on an open tweet closes it and clicking on a closed tweet opens it. There is also a button to close all the open tweets. Given a sequence of K clicks by Jack, Evan has to guess the total number of open tweets just after each click. Please help Evan in this game. 

Aquí el enunciado completo.

Código:

#include &ltcstdlib>
#include &ltiostream>
#include &ltstdio.h>
#include &ltcstring>
#include &ltmath.h>
using namespace std;

inline void fastRead_string(string *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a="";
     while (c>33)
     {
         *a+=c;
         c=getchar();
     }
}
inline void fastRead(int *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a=0;
     while (c>33)
     {
         *a=*a*10+c-'0';
         c=getchar();
     }
}
int main(int argc, char *argv[])
{
    int N,K;
    fastRead(&N);
    fastRead(&K);
    int tweets[N];
    memset(tweets, 0, sizeof(tweets));
    int click_tweet;
    int tweet_open=0;
    string read;
    for(int i=0; i<K; i++){
        fastRead_string(&read);
        if(read[read.length()-1] == 'L'){
            memset(tweets, 0, sizeof(tweets));
            printf("0\n");
            tweet_open=0;
        }else{
            fastRead(&click_tweet);
            if(tweets[click_tweet-1] == 1){
                tweets[click_tweet-1] = 0;
                tweet_open--;
                }else{
                    tweets[click_tweet-1] = 1;
                    tweet_open++;
                }
                printf("%d\n",tweet_open); 
        }
    }

    return EXIT_SUCCESS;
}

La solución tarda 0.03 segundos, quedando la 144 de 335, podría quedar mejor de entregarlo antes ya que los programas se ordenan por el tiempo que tardan y si hay empates el ultimo en subirse queda al final.

Programación - Codechef November Challenge 2012

Ha terminado el concurso de diciembre, y aquí dejo la solución a uno de los problemas planteados:

Coin Flip

El enunciado es este:

Little Elephant was fond of inventing new games. After a lot of research, Little Elephant came to know that most of the animals in the forest were showing less interest to play the multi-player games.Little Elephant had started to invent single player games, and succeeded in inventing the new single player game named COIN FLIP.

In this game the player will use N coins numbered from 1 to N, and all the coins will be facing in "Same direction" (Either Head or Tail),which will be decided by the player before starting of the game.

The player needs to play N rounds.In the k-th round the player will flip the face of the all coins whose number is less than or equal to k. That is, the face of coin i will be reversed, from Head to Tail, or, from Tail to Head, for i ≤ k.

Elephant needs to guess the total number of coins showing a particular face after playing N rounds. Elephant really becomes quite fond of this game COIN FLIP, so Elephant plays G times. Please help the Elephant to find out the answer.

Podeis encontrar el enunciado completo aqui: Enunciado

La solución que he propuesto es la siguiente:

#include &ltcstdlib>
#include &ltstdio.h>
#include &ltcstdio>
using namespace std;

inline void fastRead(int *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a=0;
     while (c>33)
     {
         *a=*a*10+c-'0';
         c=getchar();
     }
}
    
int main(int argc, char *argv[])
{
    int T, G;
    fastRead(&T);
    for(int k=0; k<T; k++){
    fastRead(&G);
    int games[G][3]; 
    for(int i=0; i<G;i++){
        for(int j=0; j<3;j++){
        fastRead(&games[i][j]);
    }
        if(games[i][1]%2 == 0){ 
                printf("%d\n", games[i][1]/2);
        }else{
            if(games[i][0] == games[i][2]){ 
               printf("%d\n", games[i][1]/2);
            }else{printf("%d\n", (games[i][1]/2)+1);}
        }

}  
}

    return 0;
}

Esta solución ha quedado la 129 de 2192 soluciones correctas. En comparación con la mejor solución, yo tengo una peor I/O, y aunque los dos nos hemos dado cuenta de que la clave era la comparación de los números de la entrada, el otro programador se ahorra una comparación que yo si hago, que posiblemente no sea necesaria. Para practicar de cara al concurso de diciembre intentaré hacer algunas practicas que hay en la web y las subire si salen bien.

Programación - Lectura de ficheros en Java

Seguimos con el tema de la entrada/salida, esta vez con lectura de ficheros en Java.
Este pequeño trozo de código se encarga de leer un fichero que contenga números separados por uno o varios caracteres: 1,2,3 ó 4 5 6 ó 7@8@9 ó 1asd4asd7asd9 y genera un array con los números leidos

El código es el que sigue:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;


 public static  int[] leer(String a, String d){
 BufferedReader br = null;
 int[] vector = {};
 String[] partes = null;
 try {

  String sCurrentLine;
  
  String delimiter = d;
  br = new BufferedReader(new FileReader(a));

  while ((sCurrentLine = br.readLine()) != null) {
   partes = sCurrentLine.split(delimiter);
   int[] aux2 = new int[vector.length];
   System.arraycopy(vector, 0, aux2, 0, vector.length);
   vector = new int[partes.length+aux2.length];
   int [] aux = new int[partes.length];
   for(int i=0; i< partes.length; i++){
    aux[i] = Integer.parseInt(partes[i]);
   }
   System.arraycopy(aux2, 0, vector, 0, aux2.length);
   System.arraycopy(aux, 0, vector, aux2.length, aux.length);
  }

 } catch (IOException e) {
  e.printStackTrace();
 } finally {
  try {
   if (br != null)br.close();
  } catch (IOException ex) {
   ex.printStackTrace();
  }
 } 
 return vector; 
}
 
 

Para que funcione le debeis de pasar la ruta al fichero que vais a leer, y entre comillas la cadeda delimitadora ";", "asd", etc.
Edit:Se ha modificado el código para que lea el fichero entero y no solo la última línea en caso de tener varias líneas con números.

Programación - Fast I/O

Para los que participen en concursos de programación con límite de tiempo les voy a dar un pequeño código que les puede ser útil.

Es código que vale para C/C++ y mejora la lectura de datos desde entrada estandar.

Si estamos en C++ lo normal es usar "cin" y en C "scanf". Pues existe una forma de hacer esa lectura aun más rápido, que es usar estos trozos de código:

Nota: Cuando aparece &lt, equivale a <

Para leer números enteros:

inline void fastRead(int *a){
     register char c=0;
     while (c &lt 33) c=getchar();
     *a=0;
     while (c>33)
     {
         *a=*a*10+c-'0';
         c=getchar();
     }
}

Como me han hecho falta para algunos problemas, he creado versiones de este mismo código para leer char, strings y demás, aquí las dejo:

Para leer un char:

inline void fastRead_char(char *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a=c;
}

Para leer un int seguido de un char que no se quiere tener en cuenta (Ej. 12$, 90%, etc):

inline void fastRead_int(int *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a=0;
     while (c> 47 && c &lt 58)
     {
         *a=*a*10+c-'0';
         c=getchar();
     }
}

Para leer un string (C++):

inline void fastRead_string(string *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a="";
     while (c>33)
     {
         *a+=c;
         c=getchar();
     }
}

Para leer un string que contenga espacios (C++) (Ej. Hola mundo, en el anterior solo guardaria "Hola")

inline void fastRead_string2(string *a){
     register char c=0;
     while (c&lt33) c=getchar();
     *a="";
     while (c>31)
     {
         *a+=c;
         c=getchar();
     }
}

Estos códigos se pueden mejorar utilizando getchar_unlocked() en vez de getchar(), probadlo ya que a mi me dice que no encuentra "getchar_unlocked()"

¿Concursos de informática?

Esta entrada va a tratar sobre los concursos de informática, en estos concursos se participia resolviendo problemas, de programación, de inteligencia artificial, de hacking, etc.

Se pueden encontrar concursos de muchos niveles de dificultad, no hace falta ser experto. Y como todo concurso la mayoria tiene un premio, muchas veces económico de hasta 10,000$ los más grandes.

Pueden ser un punto de partida para los aficionados a la programación de resolver cosas con un cierto nivel de complejidad. Ya que no es solo resolver el problema, ya que muchas veces hay límite en el tiempo de respuesta o se nos van a dar unos datos de entrada muy grandes y el programa no debe fallar.

Para los interesados dejo los enlaces, avisaré por twitter de los nuevos concursos o fechas.

Programación
Codechef (Concursos mensuales)	http://www.codechef.com/
Google Code Jam	http://code.google.com/codejam
Challenge24	http://ch24.org/
Programacion en matlab	http://www.mathworks.com/matlabcentral/contest/
Tuenti Contest	https://contest.tuenti.net/

Inteligencia Artificial
AI Challenge	http://aichallenge.org/
Mario AI Championship	http://www.marioai.org/
Ms Pac-Man vs Ghosts League	http://www.pacman-vs-ghosts.net/

Hacking
Facebook Hacker Cup	https://www.facebook.com/hackercup/

También compartiré los trucos que me encuentre que puedan ser utiles para los concursos.
Saludos y si os animais no olvideos contar como habeis quedado