{"id":242,"date":"2022-06-06T07:54:46","date_gmt":"2022-06-06T06:54:46","guid":{"rendered":"https:\/\/blog.univ-angers.fr\/mathsinfo\/?p=242"},"modified":"2022-06-19T08:02:22","modified_gmt":"2022-06-19T07:02:22","slug":"kata5","status":"publish","type":"post","link":"https:\/\/blog.univ-angers.fr\/mathsinfo\/2022\/06\/06\/kata5\/","title":{"rendered":"Cinqui\u00e8me exercice en Python, JavaScript et APL"},"content":{"rendered":"\n
\"\"<\/a><\/figure>\n\n\n\n

Exemple 1<\/span> : ~O~O~O~OP<\/code>
Tous les rats vont bien vers le joueur de fl\u00fbte, donc aucun n’est sourd. Valeur attendue = 0<\/strong><\/p>\n\n\n\n

Exemple 2<\/span> : PO~O~~O<\/u>O~<\/code>
Le rat soulign\u00e9 va dans la mauvaise direction, il est donc sourd. Valeur attendue = 1<\/strong><\/p>\n\n\n\n

Exemple 3<\/span> : ~OO~<\/u>~O~OP~O<\/u>O~O~<\/code>
Cette fois il y a 2 rats sourds. Valeur attendue = 2<\/strong><\/p>\n\n\n\n

S\u00e9parer les rats \u00e0 gauche et \u00e0 droite du joueur de fl\u00fbte<\/h2>\n\n\n\n

Une premi\u00e8re id\u00e9e<\/span> est de r\u00e9cup\u00e9rer les rats qui sont \u00e0 gauche<\/strong> et \u00e0 droite<\/strong> du joueur de fl\u00fbte. Pour cela on utilise split<\/strong> en Python\/JavaScript ou \u2286<\/strong> en APL.<\/p>\n\n\n\n

Python & Javascript<\/h3>\n\n\n\n
>> '~O~O~O~OP'.split('P')\n['~O~O~O~O', '']\n\n>> 'PO~O~~OO~'.split('P')\n['', 'O~O~~OO~']\n\n>> '~OO~~O~OP~OO~O~'.split('P')\n['~OO~~O~O', '~OO~O~']<\/code><\/pre>\n\n\n\n
APL<\/h3>\n\n\n\n
      {('P'\u2260\u2375) \u2286 \u2375} '~OO~~O~OP~OO~O~'\n\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n\u2502~OO~~O~O\u2502~OO~O~\u2502\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2518<\/code><\/pre>\n\n\n\n
Ensuite, un rat sera sourd dans la partie gauche<\/strong> s’il y a un ‘O’ \u00e0 une position paire<\/strong> (puisque l’on est cens\u00e9 avoir d\u00e9j\u00e0 la queue du rat puis la t\u00eate ~O et pas l’inverse). De la m\u00eame fa\u00e7on, dans la partie droite<\/strong>, un rat est sourd si on trouve un ‘O’ \u00e0 une position impaire<\/strong>. On pourrait donc imaginer faire 2 boucles, chacune ressemblant \u00e0 :<\/p>\n\n\n\n
for i in range(len(gauche)):\n  if gauche[i] == 'O' and i%2 == 0:   # un 'O' \u00e0 une position paire\n    sourds += 1     <\/code><\/pre>\n\n\n\n
Une boucle suffit si on concat\u00e8ne gauche<\/strong> et droite<\/strong> (et que l’on retourne une des 2 chaines). C’est-\u00e0-dire passer de [‘~OO~~O~O<\/strong>‘, ‘~OO~O~’] \u00e0 l’unique chaine ‘~OO~~O~O<\/strong><\/strong>~O~OO~’ (on a retourn\u00e9 tous les rats qui \u00e9taient dans la partie droite<\/strong>). Les rats sourds sont ceux o\u00f9 il y a un ‘O’ \u00e0 une position paire (rappel, en Python et JavaScript, le premier \u00e9l\u00e9ment d’une chaine ou d’un tableau est \u00e0 la position 0<\/strong>).<\/p>\n\n\n\n
retourner une chaine en Python<\/h3>\n\n\n\n
>> 'bonjour'[::-1]\n'ruojnob'<\/code><\/pre>\n\n\n\n
Retourner une chaine en javascript<\/h3>\n\n\n\n
Javascript sait inverser un tableau mais pas une chaine. On va donc convertir la chaine en tableau, inverser ce tableau puis revenir \u00e0 une chaine :<\/p>\n\n\n\n
>>[...'bonjour']\n['b', 'o', 'n', 'j', 'o', 'u', 'r']\n\n>> [...'bonjour'].reverse()\n['r', 'u', 'o', 'j', 'n', 'o', 'b']\n\n>> [...'bonjour'].reverse().join('')\n'ruojnob'<\/code><\/pre>\n\n\n\n
Si on a fr\u00e9quemment besoin d’inverser une chaine en JavaScript, soit on trouve une biblioth\u00e8que (comme E<\/a>srever<\/a>) contenant cette fonctionnalit\u00e9, ou on cr\u00e9e un prototype<\/strong> :<\/p>\n\n\n\n
>> String.prototype.reverse = function() {\n  return this.split(\"\").reverse().join(\"\");\n}\n\n>> 'bonjour'.reverse()\n'ruojnob'<\/code><\/pre>\n\n\n\n
en apl<\/h3>\n\n\n\n
      \u233d'bonjour'       \u235d Admirez le symbole utilis\u00e9\nruojnob<\/code><\/pre>\n\n\n\n
version finale en python<\/h3>\n\n\n\n
Il faut donc parcourir toutes les lettres de la chaine contenant les rats et regarder s’il y a un ‘O’ \u00e0 une position paire. Pour cela on utilise enumerate<\/strong> qui permettra de r\u00e9cup\u00e9rer \u00e0 la fois le caract\u00e8re et son rang :<\/p>\n\n\n\n
>> list(enumerate('~OO~~O~O~O~OO~'))\n[(0, '~'), (1, 'O'), (2, 'O'), (3, '~'), (4, '~'), (5, 'O'), (6, '~'), (7, 'O'), (8, '~'), (9, 'O'), (10, '~'), (11, 'O'), (12, 'O'), (13, '~')]<\/code><\/pre>\n\n\n\n
Vous avez tout pour comprendre cette version \u00e0 tester ici<\/a> :<\/p>\n\n\n\n
def rats_sourds(town):\n    [gauche, droite] = town.split('P')\n    rats = gauche + droite[::-1]\n    return sum([c == 'O' and i % 2 == 0 for i,c in enumerate(rats)])\n\n>> rats_sourds('~O~O~O~OP')\n0\n>> rats_sourds('PO~O~~OO~')\n1\n>> rats_sourds('~OO~~O~OP~OO~O~')\n2<\/code><\/pre>\n\n\n\n
Javascript<\/h3>\n\n\n\n
Nous avons besoin de parcourir une chaine et accumuler le nombre de rats sourds, cela fait penser \u00e0 reduce<\/strong> que nous avons utilis\u00e9 au premier exercice. Notre accumulateur a<\/strong> sera le nombre de rats sourds (initialis\u00e9 \u00e0 0<\/strong>) qui incr\u00e9mentera de 1 au fur et \u00e0 mesure si besoin.<\/p>\n\n\n\n
>> var rats_sourds = ville => {\n    [gauche, droite] = ville.split('P');\n    rats = gauche + [...droite].reverse().join('');\n    return [...rats]\n       .reduce((a, c, i) => i%2 == 0 && c == 'O' ? a + 1 : a, 0)}\n\n>> rats_sourds('~O~O~O~OP')\n0\n>> rats_sourds('PO~O~~OO~')\n1\n>> rats_sourds('~OO~~O~OP~OO~O~')\n2<\/code><\/pre>\n\n\n\n
Remarque<\/span> : reduce<\/strong> existe aussi en Python, en utilisant la biblioth\u00e8que functools<\/strong>. Voici un exemple o\u00f9 l’on compte par accumulation le nombre de ‘e’ dans une liste de mots :<\/p>\n\n\n\n
>> from functools import reduce\n>> mots = ['hello', 'yes', 'no', 'eleve']   # Liste de mots\n\n>> reduce(lambda a, c : a + c.count('e'), mots, 0)\n5<\/code><\/pre>\n\n\n\n
A-t-on vraiment besoin de s\u00e9parer la gauche et la droite ?<\/h2>\n\n\n\n
En observant un peu plus attentivement la chaine repr\u00e9sentant une ville, par exemple ‘~OO~~O~OP~OO~O~’, on se rend compte que peu importe l’emplacement du joueur de fl\u00fbte, il y aura un rat sourd d\u00e8s qu’un ‘O’ est observ\u00e9 \u00e0 une position paire<\/strong>. Par exemple dans la ville ‘P~O<\/strong>O~O~’, la t\u00eate du rat sourd est bien \u00e0 une position paire.<\/p>\n\n\n\n
Finalement, il suffit de compter le nombre de ‘O’ qu’il y a dans la ville en n’ayant r\u00e9cup\u00e9r\u00e9 que les lettres qui sont aux positions paires.<\/em><\/p>\n\n\n\n
Python<\/h3>\n\n\n\n
Il est tr\u00e8s facile de r\u00e9cup\u00e9rer une lettre sur 2 en Python :<\/p>\n\n\n\n
>> 'UneLettreSurDeux'[::2]\n'UeeteuDu'<\/code><\/pre>\n\n\n\n
Et le programme final, beaucoup plus court suite \u00e0 notre analyse : <\/p>\n\n\n\n
>> def rats_sourds(ville):\n    return ville[::2].count('O')<\/code><\/pre>\n\n\n\n
javascript<\/h3>\n\n\n\n
>> var rats_sourds = ville => [...ville]\n       .reduce((a, c, i) => i%2 == 0 && c == 'O' ? a + 1 : a, 0)<\/code><\/pre>\n\n\n\n
On peut aussi utiliser un filtre<\/strong> pour ne garder que les ‘O’ qui sont \u00e0 des positions paires puis compter<\/strong> le nombre d’\u00e9l\u00e9ments (length<\/strong>) :<\/p>\n\n\n\n
>> var rats_sourds = ville => [...ville]\n       .filter((c, i) => i%2 == 0 && c == 'O').length\n\n>> rats_sourds('~O~O~O~OP')\n0\n>> rats_sourds('PO~O~~OO~')\n1\n>> rats_sourds('~OO~~O~OP~OO~O~')\n2<\/code><\/pre>\n\n\n\n
apl<\/h3>\n\n\n\n
Pour s\u00e9lectionner, en APL, des \u00e9l\u00e9ments d’une chaine, d’un vecteur ou d’une matrice, on utilise \/<\/strong> et un vecteur bool\u00e9en<\/strong> (constitu\u00e9 de 1<\/strong> ou de 0<\/strong>). Par exemple :<\/p>\n\n\n\n
      2 | \u23737               \u235d Restes des divisions de 1, 2..., 7 par 2\n1 0 1 0 1 0 1\n      (2 | \u23737) \/ 'bonjour' \u235d qui sert \u00e0 s\u00e9lectionner une lettre sur 2\nbnor<\/code><\/pre>\n\n\n\n
Au lieu de 7 comme dans l’exemple, on utilisera \u2374\u2375 pour r\u00e9cup\u00e9rer la taille de la ville. On peut finalement rep\u00e9rer les ‘O’ qui sont aux positions paires :<\/p>\n\n\n\n
      rats_sourds_version_0 \u2190 {'O' = (2|\u2373\u2374\u2375) \/ \u2375}\n\n      rats_sourds_version_0 '~OO~~O~OP~OO~O~'\n0 1 0 0 0 1 0 0         \u235d Les 1 correspondent aux t\u00eates des rats sourds<\/code><\/pre>\n\n\n\n
Et ensuite les compter, c’est-\u00e0-dire faire une r\u00e9duction par la somme :<\/p>\n\n\n\n
      rats_sourds_version_1 \u2190 {+\/ 'O' = (2|\u2373\u2374\u2375) \/ \u2375}\n\n      rats_sourds_version_1 '~OO~~O~OP~OO~O~'\n2<\/code><\/pre>\n\n\n\n
Observez que l’on a fait des tests ( ‘O’ = …) qui donne des 0 ou des 1 puis l’addition de ces valeurs. De fa\u00e7on analogue, la fonction SOMMEPROD<\/strong> d’Excel fait des produits et ensuite leur somme. C’est ce qu’on appelle un produit interne<\/strong>. En voici quelques exemples (\u2308 permet de r\u00e9cup\u00e9rer le plus grand entre 2 nombres) :<\/p>\n\n\n\n
    +\/  2 6 \u00d7 4 5    \u235d (2 \u00d7 4) + (6 \u00d7 5) = 38 (somme des produits)\n38\n\n   2 6  +.\u00d7 4 5      \u235d M\u00eame r\u00e9sultat en utilisant un produit interne\n38\n\n    \u00d7\/  2 6 \u2308 4 5    \u235d (2 \u2308 4) \u00d7 (6 \u2308 5) = 4 \u00d7 6 = 24\n24\n\n   2 6 \u00d7.\u2308 4 5       \u235d Produit des plus grands termes\n24<\/code><\/pre>\n\n\n\n
Version finale en APL :<\/p>\n\n\n\n
Lien pour tester directement le code ci-dessous<\/a> :<\/p>\n\n\n\n
      rats_sourds \u2190 {'O' +.= (2|\u2373\u2374\u2375) \/ \u2375}\n\n      rats_sourds '~O~O~O~OP'\n0\n      rats_sourds 'PO~O~~OO~'\n1\n      rats_sourds '~OO~~O~OP~OO~O~'\n2<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"
Exemple 1 : ~O~O~O~OP Tous les rats vont bien vers le joueur de fl\u00fbte, donc aucun n’est sourd. Valeur attendue = 0 Exemple 2 : PO~O~~OO~Le rat soulign\u00e9 va dans la mauvaise direction, il est donc sourd. Valeur attendue = … Continuer la lecture →<\/span><\/a><\/p>\n","protected":false},"author":4913,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6],"tags":[],"class_list":["post-242","post","type-post","status-publish","format-standard","hentry","category-twitter"],"_links":{"self":[{"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/posts\/242","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/users\/4913"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/comments?post=242"}],"version-history":[{"count":23,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/posts\/242\/revisions"}],"predecessor-version":[{"id":654,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/posts\/242\/revisions\/654"}],"wp:attachment":[{"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/media?parent=242"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/categories?post=242"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.univ-angers.fr\/mathsinfo\/wp-json\/wp\/v2\/tags?post=242"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}