La chanson du jour (1936)

10 décembre 2019

Wrapped Around Your Finger de The Police.

I’ll be wrapped around your finger
I’ll be wrapped around your finger


La chanson du jour (1935)

26 novembre 2019

Reflections (Part 2) de David Foxx.


La chanson du jour (1934)

24 novembre 2019

One Thing de Finger Eleven.

If I traded it all
If I gave it all away for one thing
Just for one thing
If I sorted it out
If I knew all about this one thing
Wouldn’t that be something?


Humour (158)

24 novembre 2019


La chanson du jour (1933)

24 novembre 2019

Desperately Wanting de Better Than Ezra.

I remember running through the wet grass
Falling a step behind
Both of us never tiring
Desperately wanting


L’infrastructure de Twitter

24 novembre 2019

Ouf!  Un article hallucinant sur toute l’artillerie nécessaire pour que Twitter fonctionne!  C’est dément quand on y pense!!!


Smalltalk et les nombres

24 novembre 2019

Je suis tombé sur un autre article intéressant sur l’excellent blogue de John D. Cook où il traite des erreurs possibles de précision quand on effectue des calculs avec des Float ou des Double.

Évidemment, dans le problème énoncé, si on a recours à des calculs en point flottants, Smalltalk n’échappe pas à la situation décrite, comme n’importe quel autre langage de programmation!

Cependant, on a tendance à l’oublier, Smalltalk vient à la base avec une riche hiérarchie sous la classe Number d’aussi loin qu’on se souvienne!  Il y a donc moyen de faire en sorte que l’expression décrite converge vers une solution précise et exacte!  Comment?  Avec des fractions!

C’est symptômatique de chaque Smalltalker, nous oublions trop souvent à quel point les nombres en Smalltalk sont traités de façon transparente, sans que nous ayions besoin de librairies spécialisés pour le « large integer arithmetic » ou les fractions par exemple! Nul besoin de savoir si tel ou tel nombre peut être représenté sur 32 ou 64 bits!  En fait, les LargeIntegers ne sont limités que par la mémoire disponible sur votre ordi! Quel autre langage peut se targuer d’être en mesure de faire les calculs suivants sans avoir besoin de librairies spécialisées ou que votre environnement de développement vous explose en pleine figure??


La chanson du jour (1932)

24 novembre 2019

Alien de Pennywise.

Everyday you feel every crime just stare up at space and wonder why
Afraid deranged


Humour (157)

24 novembre 2019


Maman rage ou anagramme ?

24 novembre 2019

Un article intéressant sur le blogue de John D. Cook concernant la fréquence des anagrammes en anglais.  J’étais donc curieux faire le même exercice et de comparer avec les mots de la langue française!

Pour ce faire, vous aurez besoin du fichier texte de l’ODS 3 (Officiel du scrabble 3) disponible ici ainsi que de quelques requêtes SQL!

En premier lieu, créer une table pour importer tous les mots du dictionnaire.  Pourquoi je n’ai pas spécifié de clé primaire?  Parce que comme les accents ont été éliminés du dictionnaire (on se rappelle qu’il s’agit d’un dictionnaire de Scrabble, ce qui fait du sens!) alors il y aura des doublons lors de l’importation!

CREATE TABLE dictionnaire (
	mot VARCHAR(25) NOT NULL
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;

Maintenant, charger le fichier dans la table dictionnaire! Évidemment, vous modifierez la commande pour refléter l’emplacement du fichier sur votre ordi!

LOAD DATA LOW_PRIORITY LOCAL 
INFILE 'C:\\Data\\Tests\\dico_ruzzle.txt' 
INTO TABLE sandbox.dictionnaire 
FIELDS OPTIONALLY ENCLOSED BY '"' 
LINES TERMINATED BY '\r\n' (mot); 

Afin d’éliminer les doublons, nous allons créer un autre table avec une colonne supplémentaire, signature, qui est en fait une chaîne de caractère triée par valeur ASCII qui nous servira de signature (comme John D. Cook l’appelle).

CREATE TABLE anagrammes (
	mot VARCHAR(25) NOT NULL,
	signature VARCHAR(25) NULL DEFAULT NULL
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB
ROW_FORMAT=DYNAMIC; 

Maintenant, ne reste qu’à insérer les mots uniques dans cette nouvelle table.

INSERT INTO anagrammes(mot, signature)
SELECT DISTINCT(mot), NULL
FROM dictionnaire; 

Pour calculer la signature, nous aurons besoin de cette fonction qui trie les lettres de chaque mot en ordre de valeur ASCII de chaque caractère. Cette procédure stockée est aussi disponible sur mon GitHub ici.

SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='STRICT_TRANS_TABLES';

DROP FUNCTION IF EXISTS ascii_sort;

DELIMITER //

CREATE FUNCTION ascii_sort (stringParam VARCHAR(255))
RETURNS VARCHAR(255)
DETERMINISTIC
NO SQL
SQL SECURITY DEFINER
COMMENT 'Sorts a string based on the ASCII value of each character (v1.00)'

/*****************************************************************************
*
* DESCRIPTION: Sorts the string <stringParam> based on the ASCII value of each character (v1.00)
*
* AUTHOR: Benoît St-Jean <bstjean@yahoo.com>
* URL: http://www.endormitoire.wordpress.com
* VERSION: 1.00
*
* USAGE: SELECT ascii_sort('hsizbap');
* RESULT: 'abhipsz'
*
* PARAMETERS: stringParam string that needs to be ascii sorted
*
* RETURN: VARCHAR(255)
*
* NOTES: https://en.wikipedia.org/wiki/Selection_sort
*
******************************************************************************/

BEGIN
DECLARE newString VARCHAR(255);
DECLARE n TINYINT UNSIGNED;
DECLARE i TINYINT UNSIGNED;
DECLARE j TINYINT UNSIGNED;
DECLARE min_idx TINYINT UNSIGNED;
DECLARE str_j CHAR(1);
DECLARE str_i CHAR(1);
DECLARE str_min_idx CHAR(1);
DECLARE temp CHAR(1);

SET newString = stringParam;
SET n = CHAR_LENGTH(stringParam);

SET i = 1;

WHILE i < n DO
SET min_idx = i;
SET j = i + 1;

/* Find the minimum element in the unsorted part of the string */
WHILE j <= n DO
SET str_j = MID(newString, j, 1);
SET str_min_idx = MID(newString, min_idx, 1);

IF ASCII(str_j) < ASCII(str_min_idx) THEN
SET min_idx = j;
END IF;

SET j = j + 1;
END WHILE;

/* Swap the element found with the first one in the unsorted remaining part of the string */
SET str_i = MID(newString, i, 1);
SET temp = MID(newString, min_idx, 1);

SET newString = INSERT(newString, min_idx, 1, str_i);
SET newString = INSERT(newString, i, 1, temp);


SET i = i + 1;
END WHILE;

RETURN newString;
END
//

DELIMITER ;

SET SQL_MODE=@OLD_SQL_MODE;

Maintenant, calculons la signature de chacun des mots!

 
UPDATE anagrammes
SET signature = ascii_sort(mot);

Règle de base : CHAQUE table devrait TOUJOURS avoir une clé primaire! Ne serait-ce que pour vérifier qu’il n’existe plus aucun doublon dans notre cas!

ALTER TABLE anagrammes
ADD PRIMARY KEY (mot); 

Comme on s’intéresse à la signature pour trouver les anagrammes, un index est nécessaire sur cette colonne!

 
CREATE INDEX signature_idx
ON anagrammes(signature); 

Nous y voici! Déterminons les classes de mots : ceux qui ont une signature unique (frequence = 1), ceux qui ont une anagramme (fréquence = 2), ceux qui ont 2 anagrammes (fréquence =3) et ainsi de suite…

 
SELECT t.frequence, COUNT(*) as total
FROM (
SELECT COUNT(*) as frequence
FROM anagrammes
GROUP BY signature) as t
GROUP BY t.frequence
ORDER BY t.frequence;

Quel est la signature (l’anagramme) la plus fréquente?

 
SELECT *
FROM (
SELECT COUNT(*) as frequence, signature
FROM anagrammes
GROUP BY signature) as t
WHERE frequence = 16;

Quels sont les mots qui ont en commun cette signature et qui sont des anagrammes?

 
SELECT *
FROM anagrammes
WHERE signature = 'aeinrst';

P.S. Vous l’aurez sans doute deviné, « maman rage » est une anagramme pour le mot « anagramme » lui-même!