Hardprogrammer

J2ME - My students 2010/2011

2011-06-29T20:06:00.000+02:00

These are the games/technical demos developed by my students from the Master in Videogame Programming by the UEM. Greate job :)

Tunnels

José María Sánchez Rodríguez
Diana Villa Bokov

Ranita

Carlos Trillo Suarez
Noe Tortosa
Raquel García

Kill Willy

Sergio Gómez Silván
Javier Hernández Sanchiz

Milky Way

Iñaki Simón Tercero
Rubén Ortega Vera
Miguel López Ramírez

Angry Pigs

Asier Pastor
Noe Tortosa
Daniel Sánchez

Cajas

Tomás Alberto Pedrajas Ferrer.
Guillermo Pérez-Tomé Estévez.

River Raid

Yago Fernández-Miranda Mondelo
Leopoldo Ríos

You Can Save Carmine

Daniel Elrio Lopez
Manuel Lorite Fernandez
Mario Quiros Nuñez

Space Diver

Myself :)

Google Wave to Line

2011-01-31T10:31:00.011+01:00

I had an idea for a software development web-based of an application to manage bullets of text with version control. For example, this application could be used as:

TODO list
SCRUM backlog
Software release notes
Brainstorming board
Event organization
Task tracking

As far as the idea was maturing, I realised that most of the functionality was already implemented by Google Wave, but some details. So, instead of starting a new project, I decided to share the new features I would add to Google Wave in order to get feedback and perhaps I could get Google to include this features in next Google Wave releases.

Why Line?

The name comes from the idea of treating each input as a line in the timeline. Each line changes in the time. The changes are tracked, storing when a line was changed and what the change was.

1. Line states

Each line would have an state for their content:

Approved: the content of the line is considered valid.
Draft: the content of the line is tentative.
Active / inactive
Deleted

2. Line reordering

Lines should be able to be reordered. The user must be able to drag and drop one line and move it up/down in the list of lines. This way, we can consider a wave as a list of lines ordered by importance.

3. Line survey

A user could open a proposal of different contents for a line. The line would pass to draft state. The users joined to that wave would be able to vote for any of the proposed options. At the end of the survey, the line will have the value of the most voted option.

4. Line discussion

Similar to surveys, the line would pass to draft state. In this case, a forum will be opened where any user joined to the wave could leave an opinion. When an agreement is reached, a user redact the content of the line, the discussion would be closed and the line turns to approved state.

5. Snapshot

An instant in the time such as a transverse cut in the time line. An snapshot defines a photo of the lines in the moment the snapshot is taken. An snapshot would have to be defined by a name. Only approved and active lines would be considered part of the snapshot. This way, we can define easily release notes for a software development.

6. Line split / join

One line could be splitted in several different. For example, in a brainstorming, an idea could be separated in other smaller.

Several lines are joined in one.

7. Mode timeline

It would be the way to review the tracking of changes. This mode would be very visual. This view would show each line as that, a line in the time. The timeline would have a zoom in/out in the time scale (from minutes to months or years). Everything would be shown: surveys, discussions, snapshots, splits, joins, states.

Feedback

What do you think?

OpenGL, camera 3 levels of freedom

2010-12-12T22:03:00.005+01:00

This is an implementation using quaterniones of a world with objects with 3 levels of freedom.

Download it at this link.

Camera:

Up: I

Down: K

Left: J

Right: L

Backward: H

Forwad: Y

Speed+: T

Speed-: G

Pitch right: D

Pitch left: A

Yaw up: W

Yaw down: S

Roll right: X

Roll left: Y

Triangle:

Speed+: Arrow up

Speed-: Arrow down

Pitch right: Arrow right

Pitch left: Arrow left

Yaw up: N

Yaw down: B

Roll right: V

Roll left: C

Racing 4k --> 4k Grand Prix Simulator

2010-12-12T20:34:00.014+01:00

Version 0.0: Basic

Version 0.1: Added splines.

Version 0.2: Faked physics. Marks on the ground.

Version 0.3 (current): AI. New Circuits.

Version 1.0: 4k version. Some bugs fixed. Graphical details.

Inspired by my old Grand Prix Simulator for my Amstrad CPC 646.

Accelerate: Up arrow

Break: Down arrow

Turn right: Right arrow

Turn left: Left arrow

Click: Start/Restart

1-3: Select circuit

Play it at 2011 Java4k contest.

uCertify review

2010-08-20T13:37:00.007+02:00

I was contacted to make a review for the software provided by uCertify to prepare many IT certifications. I've got a full version for the Sun certification CX310-065 SCJP 6.0.

First of all, you have to know that this software is a support for people who already know something about Java. If you are a complete novice, start studying the basics, and then prepare for the certification.

For me, the most helpful feature I've found have been the teorical content assoccated to the exam objectives. It wasn't easy to get to it, but when I did, I saw the light. This is perfect because you have all the notes in a printable interface and they are associated with concret exam objectives. To get to this feature, you have to click "Exam objectives", where you'll find the official list of them; there, click the top-right button "Go to objectives with notes" to expand all the notes by objective. I would add the feature of remarking important parts of the notes with a highligther.

If you don't like to study the notes because it is boring and not so practical, you can go through the tests in "Learn Mode" that allows you to make visible the question theorical note as feedbak while you are making the test. The program allows you to create custom test, feature I would add the option to create tests based on the dificulty of the questions. Perhaps this can be supplied by the adaptative tests, but I feel I would like to have a bit more control in the level of the questions I go through, to manage my study pace.

You can keep track of all your progress in the tests. I would add tracking on the time you spend studying the notes, with an estimation of the effort they needs depending on the difficulty, to evaluate my dedication to that subject.

The sofware is pretty intuitive. You will get used to it quickly. The only feature I couldn't find easily and I couldn't evaluate was the option "Discuss It". This feature must allow us to leave comments on test questions or on notes, share them with other users and read what other users had typed. I haven't found any comment from others, so I suppose this functionality is not used very much. As proposal, I would make an study of the real use of this feature; if it us widely used, I leave it as it is now, else, I would remove it and I would replace it by a standard centralized forum, instead of linking comments to specific contents. Please, if anybody finds a comment and finds it useful, please, share with us.

So, download the trial version an evaluate it by yourself. I think it could provide you with useful content and an way to auto-evaluate your progress to your certificacion. If you have interest in any specific point I could help with, don't hesitate to leave a comment.

J2ME - My student projects

2009-07-20T23:51:00.006+02:00

These are the videos from the project that my students did. They belong to the course 08/09 of the Master in Videogames of the European University of Madrid.

Thanks all my student for the interest and the effort. The merit is theirs, I pushed them a bit :).

San Fermín

Santiago Revelo

Crisis behind

Cipri Sanchez Herraiz

Zelda

Pacoman2

Daniel Hernandez Zafra

Aviones

Alvaro Ruiz Ray

Pulso

Cipri Sanchez Herraiz
Alvaro Cañizares

Arkanoid

Carlos Casero
Laura Gil Sanz

Xax

Diego Lizarazo

Perl: normalizador de ficheros / files normalizer

2007-11-07T20:50:00.000+01:00

Perl, normalizador de ficheros: Un script en Perl para normalizar el formato del contenido de ficheros de texto: saltos de línea (windows/unix), tabulaciones, espacios al final de línea y saltos de línea al final de fichero.
(más)

Perl, files normalizer: A Perl script for normalization the format of the content of text files: new lines (windows/unix), tabulations, ending line white spaces and ending file new lines.
(read more)

Hanoi Towers 64 Gadget

2007-06-25T00:38:00.001+02:00

Adaptation of Hanoi of Towers with 64 discs to gadget.

Customizable, in elements and appearance.

As a curiosity, if you set the gadtet with an interval of 989 milliseconds and 15 discs, the completion takes 9 hours, that is, the duration of a normal job day of 8 hours (plus one hour for lunch).

Hanoi Towers with 64 disks

2007-06-19T00:33:00.003+02:00

There are several versions of the legend, but all of them say that the end of the world will be reached as soon as all the disks are moved from the source peg to the destination one. Then, the following Java implementation of the Hanoi Towers in an applet with 64 disks can be considered a count down to the end of the world, :).

The puzzle consists in moving all the disks from the source peg to the destination one. Only one disk can be moved in each movement, and a bigger disk can’t ever moved on a smaller one.

The minimum number of movements needed for n disks are 2ⁿ-1, the, with 64 disks and moving one disk each second, the puzzle solution would last 585.442 billions years (calculus fromWikipedia).

This would be the actual position of the disks if the execution would have started on 1883, when the puzzle was ivented by Édouard Lucas.

Oh Mummy gadget

2007-06-02T21:47:00.002+02:00

Adaptation of Oh Mummy! to gadget.

The classic Oh Mummy in a gadget. Use the arrow keys for walking all around the blocks until finding the 2 green blocks and then pass to the next level coming back to the initial position. Add it easily to your iGoogle with the Add to Google. button.

It has been changed from the original one. The mummies AI and velocities have been addapted. The game is divided in phases, and each phase consists of 5 miniphases; any time you continue the game, you will start from the beginning of the phase you are.

Subset

2007-05-23T23:52:00.004+02:00

Given a set S, what are their subset?, what are their k-subset?. I’ve compiled several Java methods which iterate over these subset. Due to its low efficiency, this technique only should be used in brute force algorithms.

Contents

Notation
All the subset
All the k-subset
Auxiliar methods
References

Notation

S is the set with elements {n₁, n₂, n₃, ... n_n}. The number of elements of S is |S|=n.

K is the subset of S {k₁, k₂, k₃, ... k_k}, where k_i belongs to S and k_i doesn’t represent the same element S that k_j does, with 1<=i,j<=k. The number of elements of K is |K|=k and takes values from 0 to n.

The subset of S will be represented byt set of n elements of {0, 1}, where 1 means belonging and 0 means not belonging. The number of elements of the suset |K|=k is the number of 1's that it has.

(contents)

All the subset

All the subset of S have subset from 0 elements to n. There are 2ⁿ of subset.

All the subset.

|S|=3

K₀={0,0,0}
K₁={0,0,1}
K₂={0,1,0}
K₃={0,1,1}
K₄={1,0,0}
K₅={1,0,1}
K₆={1,1,0}
K₇={1,1,1}

allSubsetBit(int) (iterative)

/**
* Iterates over all the subset of a given set of n elements.
*
* The maximun number of elements of the given set is 63.
* Subset are represented at bit level, 1 means belonging,
* and 0 not belonging.
* @param n Number of elements of the set, 0<=n<=63. 
*/ 
public static void allSubsetBit(int n) {
  for (long i = 0, lim = 1L << n; i < lim; ++i) {
    printSubset(n, i);
  }
}

allSubsetArrayIterative(int) (iterative)

/**
* Iterates over all the subset of a given set of n elements.
*
* The size of the set doesn't have any restriction, but
* the memory heap size.
* The subset is represented by an array of booleans, where
* true means belonging, and false means not belonging.
* @param n Number of elements of the set, n<=0.
*/
public static void allSubsetArrayIterative(int n)  {

boolean[] subset = new boolean[n];

while (true) {

  printSubset(n, subset);

  // Add 1
  int i=0; 
  do {
    subset[i] = !subset[i]; 
    ++i;         
  } while (i<n && !subset[i-1]);

  if (i>=n && !subset[i-1]) break;   
}  
}

allSubsetArrayRecursive(int) (recursive)

/**
* Iterates over all the subset of a given set of n elements,
* recursive version.
*
* The size of the set doesn't have any restriction, but
* the memory heap size.
* The subset is represented by an array of booleans, where
* true means belonging, and false means not belonging.
* @param n Number of elements of the set, n<=0.
*/
public static void allSubsetArrayRecursive(int n) {
  boolean[] subset = new boolean[n];
  allSubsetArrayRecursion(n, subset, 0);
}

private static void allSubsetArrayRecursion(int n, boolean[] subset, int i) {

  if (i < n) {
    subset[i] = true;
    allSubsetArrayRecursion(n, subset, i + 1);
  
    subset[i] = false;
    allSubsetArrayRecursion(n, subset, i + 1);
  } else {
    printSubset(n, subset);
  }
}

(contents)

All the k-subset

All the subset of S with k elements. The number of k-subset is:

	n!
\|k-subset\|=
	(n-k)!·k!

All the k-subset.

|S|=5
k=3

K₀={0,0,1,1,1}
K₁={0,1,0,1,1}
K₂={0,1,1,0,1}
K₃={0,1,1,1,0}
K₄={1,0,0,1,1}
K₅={1,0,1,0,1}
K₆={1,0,1,1,0}
K₇={1,1,0,0,1}
K₈={1,1,0,1,0}
K₉={1,1,1,0,0}

The following code has been taken from the book Hacker's Delight by Henry S. Warren Jr. It is a bitwise trick for getting the next greater number than one given with the same number of 1’s in binary representation.

allSubsetKBit(int,int)

/**
* Iterates over all the subset of k elements in a set of n
* elements.
*
* The maximun number of elements of the given set is 63.
* k must be 0<k<=n.
* Subset are represented at bit level, 1 means belonging,
* and 0 not belonging.
* REF: Warren, Hackers Delight, p.14.
* @param n Number of elements of the set, 0<=n<=63.
* @param k Number of element of the subset, 0<k<=n.
*/
public static void allSubsetKBit(int n, int k) {

long subset = 0;
// Set 1 k first bits
for (int i=0; i<k; ++i) {
  subset |= 1<<i;
}

long limite = 1<<n;

long smallest, ripple, ones;
while (subset < limite) {
  printSubset(n, subset);
   
  // From Hacker's Delight
  // Next greater number with the same number of 1's.
  smallest = subset & -subset;
  ripple = subset + smallest;
  ones = subset ^ ripple;
  ones = (ones>>2)/smallest;
  subset = ripple | ones;
}
}

allSubsetKArrayIterative(int,int)

/**
* Iterates over all the subset of a given set of n elements,
* iterative version.
*
* The size of the set doesn't have any restriction, but
* the memory heap size.
* k must be 0<k<=n.
* The subset is represented by an array of booleans, where
* true means belonging, and false means not belonging.
* @param n Number of elements of the set. No restrictions.
* @param k Number of element of the subset, 0<=k<=n.
*/
public static void allSubsetKArrayIterative(int n, int k)  {
boolean[] subset = new boolean[n];

while (true) {

  int subsetCount = 0;
  for (int i=0; i<n; ++i) {
    if (subset[i]) {
      ++subsetCount;
    }
  }

  if (subsetCount==k) {
    printSubset(n, subset);
  }

  // Add 1
  int i=0; 
  do {
    subset[i] = !subset[i]; 
    ++i;         
  } while (i<n && !subset[i-1]);

  if (i>=n && !subset[i-1]) break;   
}  
}

allSubsetKArrayRecursive(int,int)

/**
* Iterates over all the subset of a given set of n elements,
* recursive version.
*
* The size of the set doesn't have any restriction, but
* the memory heap size.
* k must be 0<k<=n.
* The subset is represented by an array of booleans, where
* true means belonging, and false means not belonging.
* @param n Number of elements of the set. No restrictions.
* @param k Number of element of the subset, 0<k<=n.
*/
public static void allSubsetKArrayRecursive(int n, int k) {
boolean[] subset = new boolean[n];
allSubsetKArrayRecursion(n, k, subset, 0, 0);
}

private static void allSubsetKArrayRecursion(int n, int k, boolean[] subset, int subsetElements, int i) {

if (i < n) {
  subset[i] = true;
  allSubsetKArrayRecursion(n, k, subset, subsetElements+1, i+1);

  subset[i] = false;
  allSubsetKArrayRecursion(n, k, subset, subsetElements, i + 1);
} else {

  if (k==subsetElements) {
    printSubset(n, subset);
  }
}
}

(contents)

Auxiliar methods

These methods do a function with the subset given by the methods above. In this case, they print the subset. These are the methods that need to be changed for changing the behaviour.

printSubset(int,long)

/**
* Prints a subset represented with the bits of a long.
*
* @param n Maximum number of elements of the subset.
* @param subset Bit representation of the subset.
*/
private static void printSubset(int n, long subset) {
for (int j = n-1; j >= 0; --j) {
  System.out.printf("%d", ((subset & (1L << j)) != 0) ? 1 : 0);
}
System.out.printf("%n");
}

printSubset(int,boolean[])

/**
* Prints a subset represented by an array of booleans.
*
* @param n Maximum number of elementos of the subset.
* @param subset Subser represented by an array of booleans.
*/
private static void printSubset(int n, boolean[] subset) {
for (int j = n-1; j >= 0; --j) {
  System.out.printf("%d", (subset[j]) ? 1 : 0);
}
System.out.printf("%n");
}

(contents)

Referencess

"Hacker's Delight", by Henry S. Warren Jr.
"k-subconjuntos.".

(contents)

Hano Cup

2007-03-11T23:22:00.001+01:00

It is my customized java framework based on and compatible to Java Cup 2007 competition. It provides an interface to simulate football (soccer) matches between programmed teams that implement 'Tactica' interface. I have added several useful characteristics to program new teams. Details about this project are here. It includes an auto-executable jar file and an Eclipse project with the sources.

OH MUMMY!

2007-02-14T09:33:00.002+01:00

Play it here!

Classics are back, and I wanted to pay tribute to one of the first games I had, the mythical OH MUMMY. This is a new entry for the J4K 2007 Contest, so, its size is less than 4K.
Any comment or suggestion is always welcome.

Introduction

It is a long time ago when I had my first computer, an Amstrad CPC 464. Now, its 4Mhz and 64K of RAM seem to be tiny, but thanks to it, with BASIC as programming language, I started to like programming.

Then, games are loaded from a cassette, and loading last very long. Bugs were really annoying, because you had to load the complete program (about 30-60 minutes) to realize that it didn’t work

One of the first games I got was Oh mummy!. It was funny trying to deal with more and more mummyes. I’m sure that if you had played this game, you remember its song; you can find it here.

How to play

The objective is to find the two objects that allow you to pass to the next level. In the original game, the objects were a key and a kind of sarcophagus, but due to the size of the final jar file has to be under 4k, I had to substitute them by green blocks. For knowing what a block hides, you have to walk all around it.

For passing of level, after finding the two green blocks, you have to go back to the initial position.

Be careful with the mummies. They look slow at the beginning, but the are cleverer and cleverer in each new level.

Controls are the direction arrows.

Source code

Finally I submitted the source you can download it at ohmummy_src.zip.

The code is optimized for 4 Kbytes, and I had to apply my own compression format to the sprite image to mimimize its size. Compression:

1 bit for transparency
- 0 = transparent
- 1 = colored
If colored, 2 bits for the color
- 2 bits = index in the color palette 0-based

Original	Compressed
6.966 bytes	418 bytes

Billard4K

2007-01-09T10:53:00.004+01:00

The objective is to introduce all the red balls into the holes, hitting them with the white ball. To hit the white ball, we have to use the stick when all the balls on the table are stopped.

To start to play, there is to click on the screen. Each hit follows these steps:

Direction: moving the mouse, we indicate where we hit the white ball from.
Strength: when we have the direction, click and hold the button pressed, the strength is proportional to the distance between the mouse and the white ball; to hit the ball, release the button.
Wait until all the balls are stopped.

This game was submitted to the J4K 2007 Contest.

Download the code here:
Source

Permutations with repetitions

2006-11-19T08:05:00.001+01:00

Permutations are all the different orders of the elements of a set. The number of permutations is n! (n factorial), where n is the number of elements of the set. If there are repeated elements in the set to permute, the number of permutations will be smaller. I have compiled some methods in Java to obtain all the permutations with repetitions.

Contents
Introduction
Permutations with repetitions
References

Introduction

The number of permutations of a set of elements with n elements is n! (n factorial). If there are repeated elements in the set, we will have to divide by the factorial of the number of repetitions of each repeated element.

REF: "Permutaciones con repetición"

The number of permutations with repetition of n elements, with groups of k elements because of repetitions (where k = r₁+ r₂ + ...+ r_n), written as P_{_k}^r1,r2...rn and equal to:

P_{_k}^r1^,r2^...rn =

	n!

	r₁!r₂! ... r_n!

Permutations with repetitions

Based on the permutations generator algorithms, the following methods generate the permutations for a set with repetition:
1. The set is sorted.
2. When there are to permute, they consider if the elements are equal or no.

permutationsRep(int[]) (recursive)


/** 
 * Given ps, integer set with repetitions, it sorts it, and
 * calls the method to permute it.
 *
 * @param ps Array of integers with repetitions, set of 
 * elements to permute.
 */
public void permutationsRep(int[] ps) {
    Arrays.sort(ps);
    permuteRep(ps, 0, ps.length);
}
  
/** 
 * Calls doSomething() method with all the permutations
 * of the ps set.
 *
 * It considers when elements are repeated.
 *
 * Initial call: permute(ps, 0, ps.length);
 *
 * @param ps Array of integers with repetitions, set of 
 * elements to permute.
 * @param start Index where permutation begins.
 * @param n Number of elements of ps.
 */
public static void permute(int[] ps, int start, int n) {
    doSomething(ps);
    int tmp = 0;

    if (start < n) {
      for (int i = n - 2; i >= start; i--) {
        for (int j = i + 1; j < n; j++) {
          if (ps[i] != ps[j]) {
            // swap ps[i] <--> ps[j]
            tmp = ps[i];
            ps[i] = ps[j];
            ps[j] = tmp;

            permute(ps, i + 1, n);
          }
        }

        // Undo all modifications done by
        // recursive calls and swapping
        tmp = ps[i];
        for (int k = i; k < n - 1;)
          ps[k] = ps[++k];
        ps[n - 1] = tmp;
      }
    }
  }

permuteRepIteretive(int[]) (iterative)


/**
* Calls the doSomething() method with all the permutaions
* of ps.
*
* It considers when elements are repeated.
*
* @param ps Array of integers with repetitions, set of
* elements to permute.
*/
public void permuteRepIteretive(int[] ps) {
   doSomething(ps);
   int n = ps.length;
   int tmp = 0;

   // indexes[i] = i+1;
   int[] indexes = new int[n];
   for (int i=0; i<n-1; ) indexes[i] = ++i;

   for (int i = n-2; i >= 0;) {
  
     while(indexes[i]<n && ps[indexes[i]] == ps[i]) {
       indexes[i]++;
     }
    
     // swap ps[i] <--> ps[indexes[i]
     if (indexes[i]<n) {
       tmp = ps[indexes[i]];
       ps[indexes[i]] = ps[i];
       ps[i] = tmp;
      
       doSomething(ps);
     }
    
     indexes[i]++;     

     i = n-2;

     while (i >= 0 && indexes[i] >= n) {
       // Undo previous permutation from i+1
       // Cyclical rotation to the left from i+1
       // ps[k] = ps[k+1]
       tmp = ps[i];
       for (int k = i; k < n-1;)
         ps[k] = ps[++k];
       ps[n-1] = tmp;

       // indexes[i]=i+1;
       // i--;
       indexes[i] = i-- + 1;
     }
   }
 }

References

"Counting problems", by Johan.Claeys.
"Permutaciones con repetición".

Potencia, divide y vencerás / Exponentiation, divide and conquer

2006-10-30T21:50:00.000+01:00

Potencia: La potencia de un número es la multiplicación de ese número por sí mismo un número determinado de veces. La potencia n de x se expresa como xⁿ y equivale x · x · ... · x · x n veces. x⁰ es 1. Los siguientes métodos en Java implementan diferentes formas del cálculo de la potencia de un número.
(más)

Exponentiation: The exponentiation of a number is the multiplication of that number by itself a determined number of times. Raising x to the power n is expressed like xⁿ and is x • x • ... • x • x n times. x⁰ is 1. The following methods in Java implements different ways to calculate the exponentiation of a number.
(read more)

Permutaciones / Permutations

2006-10-14T01:23:00.000+02:00

Permutaciones: Las permutaciones son todas las distintas ordenaciones que se pueden obtener de un conjunto de elementos dados. El número de permutaciones de un conjunto dado es n! (n factorial), dónde n es el número de elementos del conjunto. El numero de permutaciones crece rápidamente con el número de elementos del conjunto, así que computacionalmente es desaconsejable en caso de conjuntos grandes, pero en ocasiones puede ser útil para conjuntos pequeños. Aquí recojo algunos métodos útiles para trabajar con permutaciones en Java.
(más)

Permutations: Permutations are all the different orders of the elements of a set. The number of permutations is n! (n factorial), where n is the number of elements of the set. The number of permutations grows quickly with the number of elements of the set, so permutations are heavy computationally, but in specific situations, they can be useful in small sets. Here I compile several useful methods related to permutations in Java.
(read more)

Palíndromos en java / Palindromes in Java

2006-10-06T02:20:00.000+02:00

Palíndromos en Java: He actualizado el artículo dedicado a palíndromos y he añadido nuevos métodos en Java.

Palindromes in Java: I have updated the article dedicated to palindromes and I have added new methods in Java.

Nivel de bits / Bitwise tricks

2006-09-29T13:38:00.000+02:00

Trucos a nivel de bits: Compilación de útiles e interesantes trucos a nivel de bits.

Bitwise tricks: A compilation of useful and interesting bitwise tricks.

Factoriales / Factorials

2006-09-21T19:06:00.000+02:00

Factoriales: La función factorial está muy extendida en computación y matemáticas discretas. Es una breve explicación sobre el factorial, código que puede ser útil y links interesantes relacionados con factoriales.

Factorials: The factorial function is widely used in computing and discrete Mathematics. It is a brief explanation about factorial function, useful source code and interesting links related to factorials.

Algoritmo de Boyer-Moore / Boyer-Moore Algorithm

2006-09-18T01:52:00.000+02:00

Algoritmo de Boyer-Moore: es el más eficiente en la búsqueda de patrones en cadenas de caracteres. Es una breve explicación del algoritmo, su código con sus pruebas y links adjuntos.

Boyer-Moore algorithm: the most efficient algorithm in pattern matching. It is a short explanation of the algorithm, its code whit its tests and attached links.

Nuevo diseño web / New web design

2006-09-16T11:33:00.000+02:00

Nuevo diseño de mi página web: http://es.geocities.com/luisja80.

New design of my web page: http://es.geocities.com/luisja80.

Generador de Palíndromos en Java / Java Palindromes Generator

2006-09-09T00:21:00.000+02:00

Generador de palíndromos numéricos: Un método en Java que genera un palíndromo numérico a partir de un número pasado como parámetro.

Numeric palindromes generator: A Java method generates a numeric palindrome from a number given.

Mi CV / My CV

2006-09-06T09:52:00.000+02:00

Luis Javier López Arredondo, CV en inglés.
Ver mi CV

Luis Javier López Arredondo, English CV.
See my CV

Fichero JAR ejecutable / Executable JAR file

2006-09-01T17:56:00.000+02:00

Cómo hacer un fichero JAR ejecutable.
Fichero JAR ejecutable

How to make a JAR file executable.
Executable JAR file

Bienvenido / Welcome

2006-07-31T21:27:00.000+02:00

Bienvenido a mi blog.

Welcome to my blog.