L'Univers D'Adjanakis » Développement

Codingame du 23 novembre 2013 : Rejouons la partition

Adjanakis — Sun, 24 Nov 2013 00:46:48 +0000

C’est avec un grand regret que je n’ai pas pu finir à temps ma composition pour aider le Docteur Who à sortir d’un bien mauvais pas. J’ai pu constater avec plaisir qu’il avait pu s’en sortir grâce aux quelques algorithmes qui ont pu être livrés à temps.

Mais pour ceux qui n’en peuvent plus d’attendre de lire un algo qui se rapprocherait de la solution, voici ce que j’aurais dû soumettre pendant le codingame si le manque de temps ne m’avait pas finalement poussé vers une voie de mauvais garçon (à voir sur le site codingame :evil:).

Les constantes ne sont pas les bonnes pour les noires et les blanches et ce code n’a été testé que sur un seul jeu de données(« Only 1 pixel wide – in10.txt »). Cependant, l’idée qui y est présentée me semble bonne et ne devrait souffrir que de petits ajustements pour pouvoir passer l’ensemble des tests.

En quelques mots, les étapes de la résolution sont indiquées dans la méthode main. Tout d’abord, une lecture des données en entrée permet de récupérer dans un tableau à deux dimensions les pixels de l’image. La difficulté est ici de devoir jouer avec les lignes du tableau indépendamment de la lecture du flux en entrée. Une lecture un peu plus complexe que dans la moyenne des codingame, une source de temps perdu, mais une difficulté surmontable.

Ensuite, on peut constater que dans toutes les partitions de musique, les premiers pixels correspondent aux 5 lignes noires. Dans l’algorithme choisi ici, la phase suivante consiste à repérer les coordonnées de ces lignes. Pour cela, la colonne sélectionnée sera la première de l’image contenant des pixels noirs. Cette colonne aura été préalablement déterminée lors de la lecture de la partition. Une sixième ligne pouvant intervenir, on en calcule la position en admettant que toutes les lignes sont séparées par des intervalles réguliers.

La phase suivante est déterminante pour arriver au résultat désiré. Les lignes de la partition déterminent des zones auxquelles on affectera un flag. Pour chaque colonne, on calculera une empreinte qui correspondra à l’ensemble des zones où apparaît un pixel noir, sans tenir compte des pixels des lignes de la portée. On comptabilise par contre le nombre de pixel noir de la colonne pour analyser plus tard la longueur des notes.

Une fois cette étape statistique réalisée, il ne reste plus qu’à en tirer des conclusions. Les colonnes considérées comme ne possédant aucun pixel sont à ignorer. Celles correspondant à une queue de note sont également ignorées car les zones traversées ne correspondant pas à une empreinte de note valide. Lorsqu’une empreinte est valide on conserve l’information et on compare la quantité de pixel noir entre la première et la deuxième colonne où la note apparaît. En effet, les notes blanches ont davantage de pixels noirs sur les côtés, alors que les notes noirs en ont davantage ! En calculant l’évolution de ce nombre, on connait la durée de la note.

Après ces quelques explications, j’espère que vous comprendrez le code source qui suit.

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class Solution {

private static final int DOWN = 1;
private static final int UP = 0;
private static final String BLACK = "B";
private static final String WHITE = "W";
private static int width = 0;
private static int height = 0;
private static boolean[][] score = null;
private static int blackFirstX = -1;
private static int[][] lignes = new int[6][2];
private static int betweenLines;
private static int[] statZone;
private static int[] statPond;

public static void main(String args[]) throws FileNotFoundException {
readScoreInput();

guessScoreLines();

retrieveStatistics();

System.out.println(buildResult());
}

private static void guessScoreLines() {
int line_number = 0;
boolean onLine = false;
for (int y = 0; y < height; y++) {
if (score[y][blackFirstX]) {
lignes[line_number][DOWN] = y;
if (!onLine) {
onLine = true;
lignes[line_number][UP] = y;
}
} else if (onLine) {
line_number++;
onLine = false;
}
}
betweenLines = lignes[1][UP] - lignes[0][UP];
lignes[5][UP] = lignes[4][UP] + betweenLines;
lignes[5][DOWN] = lignes[4][DOWN] + betweenLines;
}

private static void retrieveStatistics() {

for (int w = 0; w < width; w++) {
int currentZone = 0;
int currentZoneFlag = 1 << currentZone;
int nextLine = 0;
int h = 0;
while (h < height) {
if (nextLine < lignes.length && h == lignes[nextLine][UP]) {
h = lignes[nextLine][DOWN] + 1;
currentZone++;
nextLine++;
currentZoneFlag = 1 << currentZone;
}
if (score[h][w]) {
statZone[w] |= currentZoneFlag;
statPond[w]++;
}
h++;
}
}

}

private static String buildResult() {
Map zoneMapping = new HashMap(13);
zoneMapping.put(1, "G");
zoneMapping.put(3, "F");
zoneMapping.put(2, "E");
zoneMapping.put(6, "D");
zoneMapping.put(4, "C");
zoneMapping.put(12, "B");
zoneMapping.put(8, "A");
zoneMapping.put(24, "G");
zoneMapping.put(16, "F");
zoneMapping.put(48, "E");
zoneMapping.put(32, "D");
zoneMapping.put(96, "C");
zoneMapping.put(64, "B");

StringBuilder result = new StringBuilder();

int currentZone = 0;
int currentPond = 0;
boolean typeIsKnow = false;
for (int w = 0; w = currentPond) ? BLACK : WHITE)
.append(" ");
typeIsKnow = true;
}
}

return result.toString();
}

private static void readScoreInput() throws FileNotFoundException {
Scanner in = new Scanner(new File("test.txt"));
width = in.nextInt();
height = in.nextInt();

score = new boolean[height][width];
statZone = new int[width];
statPond = new int[width];

Arrays.fill(statZone, 0);
Arrays.fill(statPond, 0);

boolean scoreCompleted = false;
int number, w = 0, h = 0;
String color;
blackFirstX = width;

while (!scoreCompleted) {
color = in.next("\\s*[WB]\\s*");
number = in.nextInt();
boolean colorBool = charToBoolean(color);

// tant que l'entrée n'est pas consommée
while (number > 0) {
if (blackFirstX > w && color.trim().equals("B")) {
blackFirstX = w;
}
if (number > (width - w)) {
Arrays.fill(score[h], w, width, colorBool);
number = number - (width - w);
w = 0;
h++;
} else {
Arrays.fill(score[h], w, w + number, charToBoolean(color));
w = w + number;
number = 0;
}
}
scoreCompleted = (h == height - 1);

}
in.close();
}

private static boolean charToBoolean(String color) {
return "B".equals(color.trim());
}
}

Un répondeur vocal fait maison avec Twilio

Adjanakis — Tue, 20 Aug 2013 21:48:37 +0000

Twilio est une société que j’ai connu un peu par hasard en assouvissant mon besoin de nouvelles découvertes il y a de cela presque 9 mois (Wow, déjà !). Le premier contact a eu lieu lors d’un webinar de la société talend. Au cours de cette présentation, twilio a été utilisé afin de fournir un point d’entrée vers Talend ESB. Concrètement, les utilisateurs peuvent voter par téléphone pour choisir le futur président des Etats-Unis d’Amérique. Twilio est l’outil permettant de recevoir un appel vocal, et de guider l’utilisateur grâce aux instructions qu’il reçoit de la part du Système d’informations mis en place par le présentateur. C’est ainsi que cette startup a piqué une première fois ma curiosité au vif. J’ai été séduit par la facilité avec laquelle il était possible de donner un accès vocal a un contenu Web.

Ma deuxième confrontation avec ce sujet fut lors de la découverte de la takeoffconf, dont le premier opus a eu lieu à Lille en janvier 2013. J’ai tout d’abord été surpris, en scrollant dans la page d’accueil, de voir apparaître le logo de la société parmi les sponsors. Ensuite, en descendant encore, j’ai pu noter la présence d’une session présentée par Rob Spectre. Lors de cette présentation sur les Solutions orientées architecture, il évoquera la stratégie produit de la startup qu’il représente.

Cette seconde expérience a servi de piqûre de rappel. Il fallait que j’aille plus loin dans cette découverte. C’est ainsi qu’il y a quelques mois, j’ai décidé de me rendre sur le site de twilio afin de me forger une expérience utilisateur sur ce nouveau service. Celle-ci s’est donc terminée par la mise en place d’un répondeur vocale en commençant par une étape cruciale, l’inscription.

Formulaire classique d’Inscription

Pas de fioriture pour s’inscrire, c’est simple et clair, ce qui permet de pouvoir commencer à s’amuser assez rapidement.

Vérification vocale au lieu d’un captcha

Et oui, c’est original de demander un numéro de téléphone pour contrôler que celui qui s’inscrit n’est pas un robot. Dans un premier temps, l’utilisateur pourrait être choqué, mais après tout, c’est du vocal que l’on veut faire ici !

Attribution du numéro de test

L’attribution d’un numéro de test est extrêmement rapide, on l’obtient dans la foulée. Si vous ne comptez pas l’utiliser tout de suite, twilio fournit dans son portail d’administration la possibilité de rendre la ligne à nouveau disponible (release) pour d’autres applications de test. J’ai fait le test. Récupérer un nouveau numéro de test par la suite est tout aussi rapide que l’obtention lors de l’inscription. A noter également que si twilio n’a rien de francophone, les numéros obtenus font bien partis de nos bons vieux numéros nationaux.

Partir à la découverte de twilio

Ca y est, Vous avez obtenu le sésame, la bidouille récréative peut maintenant commencer en tentant de passer des appels et en se faisant appeler par l’application mise en place par défaut pour votre compte.

Une fois ce premier contact réalisé, on peut se demander ce qui peut être fait maintenant. Si on a eu une première expérience du vocal, on peut par exemple commencer à chercher où l’on doit mettre le lien pour accéder à notre application VoiceXML. Ce serait faire fausse route. Twilio a pris le parti de ne pas utiliser un langage de communication standard afin, j’imagine, de ne pas en subir les limites. A chaud et après un simple survol de la solution de twilio, je dirais que le TwiML possède les avantages suivants :

Simplicité : Plus simple a prendre en main que le VoiceXML, il permet un apprentissage plus rapide pour un néophyte.
Directif : Je ne sais pas si c’est le bon terme, mais ce qu’il faut comprendre c’est que la où le VoiceXML suppose la compréhension de l’algorithme inhérent (FIA), le TwiML permet d’avoir le contrôle total de l’application. Pour le débutant, là encore, c’est plus simple et rassurant.
Modifiable : Des solutions existent avec le VoiceXML pour ouvrir le langage à de nouvelles fonctionnalités, mais Twilio a fait du SMS un cheval de bataille au même titre que la voix. Il aurait été peu évident de proposer quelque-chose de simple pour le vocal, mais plus complexe pour les messages écrits (ajout d’objet spécifique pour le SMS alors que la voix est native en VoiceXML). Le TwiML est donc modifiable afin de le faire correspondre aux API que désire proposer twilio.

Je vais m’arrêter la pour ce qui est de la comparaison entre ces deux langages XML. La suite dans un prochain billet si cela intéresse du monde.

Les premiers pas avec twilio doivent se poursuivre, à mon humble avis, par la lecture de la documentation abondante présente sur le site, onglet « Docs ». C’est en parcourant cette doc que vous apprendrez que connaître TwiML n’est pas une obligation pour l’élaboration d’une application vocale, puisque des API existent pour le générer le code à partir des langages de développement les plus courants… et plus encore ! C’est en écumant cette documentation que j’ai notamment pu découvrir une application de répondeur vocal déjà créée en PHP et qu’il suffisait d’installer pour pouvoir la tester.

Le tutorial correspondant (https://www.twilio.com/docs/howto/voicemail) étant bien détaillé, je ne vais pas revenir sur les étapes de la mise en place de ce répondeur vocal. Je peux juste témoigner que cela fonctionne pour peu que l’on puisse mettre en place l’application vocale sur un serveur PHP accessible depuis le net :). Le seul problème que j’ai eu à déplorer était dû à la vétusté de mon hébergement chez OVH. Il faut un serveur PHP suffisamment récent, v5.3 minimum a priori. J’ai donc simplement eu besoin d’ajouter la ligne suivante dans mon fichier .htaccess.

SetEnv PHP_VER 5_4

Pour conclure, je vais donc tenter de répondre à une question qui se pose maintenant que l’on sait qu’un répondeur vocal perso peut être mis en place. A quoi ça sert ? La première réponse que je pourrais donner, c’est que ça sert à mettre le pied à l’étrier.Cette mise en bouche permet de mettre du vocal dans une application web. Vous trouverez par ailleurs dans les documentations de nombreux exemples permettant des interactions diverses avec des applications WEB. Drupal, par exemple, fait l’objet d’une API permettant émission et réception de SMS et d’appel vocaux. Ces fonctionnalités s’ouvrent à tout un chacun de façon relativement simple à mon goût.

Ma seconde réponse concernant l’utilité de ce répondeur vocal, c’est que c’est tout à fait pertinent. Certes, nous sommes habitués à avoir un répondeur intégré à l’offre de notre opérateur mobile, de notre fournisseur d’accès à Internet ou encore, de notre combiné de téléphone. Mais pourquoi ne pas héberger soit même un répondeur unique et commun à tous nos téléphones ? Que ce soit sur mobile ou sur un compte de téléphonie SIP par exemple, c’est tout à fait possible. On peut également travailler sur les fonctionnalités de l’application. Et pourquoi ne pas aller plus loin en mettant en place un service à la sauce Google Voice ? Ce service n’est pas encore disponible en France aux dernières nouvelles (elles datent un peu me concernant néanmoins), mais ce concept peut être pertinent !

Google Voice

Voici donc ce que je pourrais dire de cette petite incursion dans le monde de twilio. Un moyen simple de création d’application vocale. Un outil qui se conjugue parfaitement avec talend ESB, en tout cas d’après le webinar plutôt bluffant auquel j’ai pu assister. Néanmoins, ayant moi même travailler dans le domaine des applications vocales, en utilisant le standard VoiceXML, je ne peux pas dire que la solution de twilio s’adapte à tout. En tout cas, je ne peux pas le dire après ce simple exemple. Pour moi, des questions restent ouvertes concernant l’efficience des applications, leur maintenabilité et surtout, leur portage vers un éventuel prestataire concurrent. Après tout, OVH propose une offre alternative en VoiceXML plutôt bon marché… celle-ci fera peut-être l’objet d’un prochain article si j’ai du temps à y consacrer.

Mais où est JavaMake.jar ?

Adjanakis — Tue, 25 Aug 2009 11:32:01 +0000

C’est curieux comme parfois une recherche que l’on croyait simple peut finalement s’avérer compliquée. JavaMake, célèbre compilateur s’il en est se fait assez discret pour ce qui est de sa version packagée en jar, particulièrement pour ANT.

Ainsi, lorsque l’on recherche sur le site officiel de ANT ou encore sur google, on arrive sur une l’URL du fameux outil de compilation en langage Java, mais sans être en mesure de pouvoir télécharger quoique ce soit…

Google est ton ami, mais ce n’est qu’après avoir compris que pleins d’autres personnes ont la même requête mais que nul ne répond, que l’on tombe enfin sur l’URL qui sauve sa journée. J’ouvre donc une nouvelle porte vers ce lien sacré :

Téléchargement de javamake.jar et javamake-ant15.jar

[Java] A la rencontre de JMF

Adjanakis — Sat, 06 Sep 2008 00:57:29 +0000

Lors d’une recherche sur JMF, je me suis aperçu que les ressources francophones disponibles n’étaient pas particulièrement répandues sur la toile. En effet, si on trouve beaucoup des questions semées sur différents forums, on a finalement assez peu de réponses pertinentes. A cela s’ajoute la difficulté pour le débutant d’avoir une idée précise de ce qu’est JMF et de ce qu’il est possible d’en faire.

Alors j’ai décidé d’apporter davantage de visibilité à un tutoriel qui me semble sympathique et dont je pense parcourir les pages au plus vite. Cette Présentation de JMF saura sans nul doute guider les novices dans la connaissance du framework.

Choco Solver

Adjanakis — Fri, 11 Jul 2008 22:20:22 +0000

Choco est une librairie écrite en java permettant de faire ce que l’on appelle de la programmation par contraintes. Grossièrement, cela signifie que cette librairie permet de trouver pour chaque variable d’un problème, un ensemble de valeur satisfaisant des règles(contraintes) imposées. C’est le cas par exemple du problème du sudoku. Dans un tel contexte, les règles seront :

Tous les nombres d’une ligne sont différents
Tous les nombres d’une colonne sont différents
Tous les nombres des carrés de 3 cases de coté sont différents

Le solveur permettra la résolution de la grille de sudoku en donnant des valeurs respectant les contraintes. L’idée de cet article m’est venu en fouillant dans de vieilles sources Java. Afin de démystifier le développement de programme pour la résolution d’une grille de sudoku, voici quelques lignes de code qui pourraient presque prétendre les résoudre à coup sûr.

/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
package org.adjanakis.chokodoku;

import choco.ContradictionException;
import choco.Problem;
import choco.integer.IntVar;

/**
* Chokodoku
*
* This program use to be an example of one usage of the choco-solver. This
* application aims at easily solving any sudoku problem. All sudoku problem
* hasn't been tested. If many solutions are possible, this program will not
* be really accurate.
*
* Based on Choco 1.0b003
*
* @author Adjanakis (http://code.adjanakis.org/)
* @version 0.1.0
*/
public class Chokodoku {

/**
* Number of numbers on one side of the internal square. 3 is the usual value.
*/
private static int CHOKODOKU_SIZE = 3;

/**
* Here is the description of the sudoku problem. Each number represents a value to
* find or a value to get. The values to find are represented by a 0.
*/
private static int[] pbDescr = new int[]{
8,0,4,0,0,0,2,0,9,
0,0,9,0,0,0,1,0,0,
1,0,0,3,0,2,0,0,7,
0,5,0,1,0,4,0,8,0,
0,0,0,0,3,0,0,0,0,
0,1,0,7,0,9,0,2,0,
5,0,0,4,0,3,0,0,8,
0,0,3,0,0,0,4,0,0,
4,0,6,0,0,0,3,0,1
};

/**
* The object used to represent the problem. It will store the constraint a the
* possible value for each value of the sudoku.
*/
private static Problem myPb = new Problem();

/**
* Basic method to launch the program
* @param args parameters are not used
*/
public static void main(String[] args) {
launch();
}

/**
* Method used to resolve a sudoku problem. This problem is hard coded into this method.
*/
public static void launch(){

//The variables will be stored into a vector
IntVar[] myPbVars = new IntVar[CHOKODOKU_SIZE*CHOKODOKU_SIZE*CHOKODOKU_SIZE*CHOKODOKU_SIZE];

//We attribute the possible value for each value of the problem into our vector.
for( int i = 0; i < CHOKODOKU_SIZE*CHOKODOKU_SIZE*CHOKODOKU_SIZE*CHOKODOKU_SIZE; i++ ){
if( pbDescr[i] != 0 ){
//The value defined by the problem
myPbVars[i] = myPb.makeEnumIntVar(null,pbDescr[i],pbDescr[i]);
} else {
//The value is undefined. It may be on from 1 to the max value
myPbVars[i] = myPb.makeEnumIntVar(null,1,CHOKODOKU_SIZE*CHOKODOKU_SIZE);
}
}

//Creation of the sudoku constraint
for( int i = 0; i < 9; i++){
IntVar[] bufIntVarsRow = new IntVar[CHOKODOKU_SIZE*CHOKODOKU_SIZE];
IntVar[] bufIntVarsColumn = new IntVar[CHOKODOKU_SIZE*CHOKODOKU_SIZE];
IntVar[] bufIntVarsInternalSquare = new IntVar[CHOKODOKU_SIZE*CHOKODOKU_SIZE];
for( int j = 0; j < 9; j++){
bufIntVarsRow[j] = myPbVars[ i*CHOKODOKU_SIZE*CHOKODOKU_SIZE + j ];
bufIntVarsColumn[j] = myPbVars[ j*CHOKODOKU_SIZE*CHOKODOKU_SIZE + i ];
bufIntVarsInternalSquare[j] = myPbVars[ (i%CHOKODOKU_SIZE)*CHOKODOKU_SIZE +
j%CHOKODOKU_SIZE +
(i/CHOKODOKU_SIZE)*CHOKODOKU_SIZE*CHOKODOKU_SIZE*CHOKODOKU_SIZE +
(j/CHOKODOKU_SIZE)*CHOKODOKU_SIZE*CHOKODOKU_SIZE];
}
//All values of a line must be different
myPb.post(myPb.allDifferent(bufIntVarsRow));

//All value of a column must be different
myPb.post(myPb.allDifferent(bufIntVarsColumn));

//All value of an internal square must be different
myPb.post(myPb.allDifferent(bufIntVarsInternalSquare));
}

try {
//Have the unique solution of the problem if it exists, or an approximation
myPb.propagate();
}
catch (ContradictionException e) {
//Solving the problem is not possible
System.err.println("This problem is over-constrained");
}
System.out.println("solve");

//Display the result found
for( int i = 0; i < 9; i++){
for( int j = 0; j < 9; j++){
System.out.print(" " + myPbVars[i*9+j].getVal());
}
System.out.println();
}
}
}

CMS: Xoops

Adjanakis — Thu, 18 Jan 2007 23:05:00 +0000

Système de gestion de contenu modulable et complet, xoops est un outil qui mérite d’être connu. La création d’un site web, personnelement, je n’en suis pas friand. Devoir faire tout le graphisme, créer des pages particulières par-ci par-là, bref… Ca ne rime à rien de tout commencer depuis le début à moins que ce ne soit à des fins éducatives. De nos jours, il est si simple d’aller chercher un script PHP tout fait qui permette de gérer son contenu.

Parmi ces scripts tout fait, Xoops est celui qui retient mon suffrage. Si la première prise en main a été un peu compliquée à cause d’un problème de conf indépendante du script, je ne jure maintenant que par cet outil pour la réalisation de sites web. Xoops contient des outils de bases très fournis: articles, gestion d’utilisateur, sondage, etc. Xoops peut également être agrémenter le cas échéant par des produits supplémentaires pour des besoins plus spécifiques comme la gestion de photos, de ventes ou encore de clan. Avant la création d’un site à ambition communautaire, n’hésitez plus ! Passez jeter un coup d’oeil ici :).

Compter les points au tarot

Adjanakis — Thu, 18 Jan 2007 22:30:00 +0000

Ce soir, je voulais parler d’une application que j’ai faite il y a bien longtemps maintenant et dont l’objectif est de compter les points au tarot. Malheureusement, suite à un problème technique, je ne peux pas diffuser le jar de l’application J2ME. Je ne peux donc pas offrir cette oeuvre(un bien grand mot) pour bêta test. Dommage ! J’aurai bien voulu avoir un petit retour sur l’ergonomie et sur les fonctionnalités. Je reviendrai donc un peu plus tard pour mettre à jour ce billet… enfin, si quelqu’un, au moins, est interessé par une telle appli :o). Y a-t-il des fans de tarot dans la salle ?

Faire son shoot’em up J2ME

Adjanakis — Tue, 16 Jan 2007 22:00:00 +0000

Les développements mobiles sont une autres tendances de la mode. Lorsque j’ai commencé à y jeté un coup d’oeil il y a maintenant presqu’un an, j’ai été étonné de la simplicité d’utilisation de J2ME. Muni du SDK compatible avec mon mobile et d’un eclipse des familles, n’importe quel développeur Java peut trouver son bonheur. Je me souviens en particulier d’un exemple fournit dans le SDK qui montrait de la plus simple des manières comment faire évoluer un vaisseau spatial dans un monde virtuel. En modifiant ces sources, il était aisé d’ajouter les fonctionnalités permettant de créer un véritable shoot’em up.

Aujourd’hui, je suis heureux de voir comment le développement J2ME a pu se démocratiser. On le vois notamment à travers toutes les applications gratuites disponibles sur le site officiel de la série 60 de Nokia ou encore sur le site getjar.com qui ouvre en grand les portes aux développements amateurs.

Possibilité de Géolocalisation

Adjanakis — Mon, 15 Jan 2007 22:00:00 +0000

Au cours d’un petit surf sur le net, j’ai trouvé un petit article qui suit parfaitement l’air du temps. J2ME et Géolocalisation, un si joli mariage n’est-il pas ? Dans un registre un peu plus technique, vous trouverez également ce lien. La géolocalisation est une actualité. Les téléphones portables permettent déjà sous certaines conditions d’être géolocalisé(accord de l’utilisateur) et les outils de géolocalisation se multiplient. Voyez par exemple ce blog. Bref, c’est un domaine en plein boum et les nouvelles idées ne tarissent pas !

Challenge de programmation Java

Adjanakis — Fri, 14 Jul 2006 10:00:02 +0000

Le nouveau né des framework de programmation ludique d’IBM a officiellement vu le jour le 29 juin dernier et se prénomme : CodeInvaders Challenge !

Le but est cette fois-ci de programmer le comportement d’un vaisseau spatial avide d’énergie au point de détruire ses concurrents. Ce challenge est ouvert à tous et est accessible du programmeur débutant au plus chevronné d’entre nous. Alors pour les futurs participants, bonne chance et faites un petit coucou de temps en temps par ici histoire d’échanger des idées de stratégie ou des vaisseaux pour les tests :o).