Sommaire

On a demandé à un enseignant de préparer des problèmes de mots pour les élèves. On lui donne une liste d'équations et lui dit de les écrire comme problème de mot correspondant. Cependant, elle est très paresseuse, donc elle n'y met pas beaucoup de créativité. Au lieu de cela, elle l'écrit simplement littéralement. Par exemple, quand elle lit 1+1, elle écrit one plus one, 47 * 2se transformerait forty seven times twoet 56.2 / 7.4deviendrait fifty six point two divided by seven point four.

Écrivez du code pour aider ce professeur paresseux.

Détails

• Les nombres peuvent inclure un point décimal et un signe négatif.
• Les chiffres doivent être écrits dans une échelle courte. (c'est-à-dire, 1,000,000,000est one billion)
• Les nombres peuvent aller jusqu'à 999 999 999 999 999 999 ( nine hundred ninety nine quadrillion...nine hundred ninety nine).
• Les groupes de zéros doivent être omis. par exemple ne l' 1,000,000est one millionpas one million zero thousand zero hundred.
• Il peut y avoir arbitrairement plusieurs chiffres au-delà de la virgule décimale.
• Les chiffres après la virgule décimale doivent être répertoriés chiffre par chiffre. par exemple ne l' 12.34est twelve point three fourpas twelve point thirty four.
• Deux nombres sont toujours séparés par un opérateur.
• Les opérateurs valides sont plus ( +), moins ( -), fois ( *) et divisés par ( /).
• Il n'y a pas de parenthèses.
• Des nombres tels que 1234peuvent éventuellement inclure un anddans leur sortie, comme dans one thousand two hundred *and* thirty four.
• Les virgules et les espaces sur l'entrée peuvent être ignorés.

Exemples

Entrée: 24 + 65
Sortie:twenty four plus sixty five

Entrée: 3.33333 - 0
Sortie:three point three three three three three minus zero

Entrée: 3.6 * 18.18 / 999.0
Sortie:three point six times eighteen point one eight divided by nine hundred ninety nine point zero

Entrée: 1-1
Sortie:one minus one

Entrée: 1+-1
Sortie:one plus negative one

Entrée: 1,000,000,000 + 0.2
Sortie:one billion plus zero point two

Entrée: 123,000,456,789,012,345.6789
Sortie:one hundred twenty three quadrillion four hundred fifty six billion seven hundred eighty nine million twelve thousand three hundred forty five point six seven eight nine

Entrée: -4.3 * 7
Sortie:negative four point three times seven

Entrée: -1-1--1
Sortie:negative one minus one minus negative one

JavaScript (ES6), 552 532 octets

Ce monstre sale vient directement des profondeurs de l'enfer du golf de code.

Attend une chaîne d'entrée sans aucun espace.

S=>S[R='replace'](/[\d.,]+|./g,s=>1/s[0]?a(+s[S=0]&&14)+s[R](/(\D?)(\d+)/g,(_,s,n)=>s>','?' point'+n[R](/./g,a):j--*n?(u=a(n%10||14),n>99?a(n[0])+' hundred':'')+((n%=100)<13?a(n||14):n<20?(a(n)||u)+'teen':(a(n/10+18)||a(n/10))+'ty'+u)+a(j+27)+(j>1?'illion':''):'',j=s.split`,`.length):a(S='+-*/'.indexOf(s=='-'&&S||s)+34),a=n=>(s='zero0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir00fif000eigh00twen0thir0for0fif000eigh00thousand0m0b0tr0quadr0negative0plus0minus0times0divided by'.split`0`[n|0])&&' '+s).trim()

Essayez-le en ligne!

Perl 6 , 434 401 387 359 octets

{~S:g/\d+/{n($//100+64184)x($/>100),$/%100>19&&(n($//10%10+64175),n($!=$/%10)x?$!)||n($/%100+7679),[$,"thousand",|(<m b tr quadr>X~"illion")][+$/.postmatch.words[0].comb(',')]if +$/} /.trans("+,-/*"=><<plus''minus"divided by"times>>).words}o{S:g/\.(\d)+/ point {$0>>.&n}/}o{S:g/[\s|^]0/ zero/}o{S:g/\-(\d)/negative $0/}
my&n=(*+1632+|0).uniname.lc.words[2..*]

Essayez-le en ligne!

Certainement matière à amélioration ici. Je dis cela, mais je continue de remarquer des cas marginaux que je n'ai pas traités :(. Suppose que l'entrée a des opérateurs séparés par des espaces et que le négatif d'un nombre n'est pas séparé.

Explication:

my&n=(*+1632+|0).uniname.lc.words[2..*]  # Define a helper function
           # This gets the unicode name, e.g ARABIC-INDIC DIGIT ZERO
           #                              or AEGEAN NUMBER ONE HUNDRED
           # And returns the 3rd word onwards in lowercase e.g. 'zero' or 'one hundred'
{S:g/\-(\d)/negative $0/}  # Turn dashes before numbers to negative
{S:g/[\s|^]0/ zero/}       # Handle zeros
{S:g/\.(\d)+/ point {$0>>.&n}/}  # Replace decimals
{~S:g/\d+/        # Replace series of numbers with
    n($//100+64184)x($/>100)  # The hundreds if the num is bigger than 100
    $/%100>19&&               # If the number is bigger than 19
      (
      n($//10%10+64175),         # The tens number
      n($!=$/%10)x?$!            # And the singles number (if it's not zero)
      )
    ||                        # Else
      n($/%100+7679)             # The name of the number below 20
    ,                      # Then
    [$,"thousand",|(<m b tr quadr>X~"illion")][   # Index into the list of postfixes
      +                         .comb(',')   # The number of commas
       $/.postmatch.words[0]  # in the rest of the number
  if +$/           # All if the number is not 0
.trans("+,-/*"=><<plus''minus"divided by"times>>)  # Translate operators
                                                   # And remove commas
.words}     # And remove all the excess spaces between words

Rubis + Swift 4, 283 279 270 octets

$_=gsub(/(?<=\d)-/,"minus ").gsub(/[*-\/]/,?.=>"point ",?-=>"negative ",?+=>"plus ",?*=>"times ",?/=>"divided by ").gsub(/(?<=^|[^t] )\d+|\d/){`echo "import Foundation
var f=NumberFormatter()
f.numberStyle = .spellOut
print(f.string(from:#$&)!)">.a
swift .a`.tr'-
',' '}

Essayez-le en ligne!

Je dois être fou de proposer une telle solution Frankenstein, mais d'une part, il est très tentant d'utiliser la fonctionnalité intégrée de Swift pour cette tâche, et d'autre part, le traitement des chaînes avec Regexes dans Swift semble être une catastrophe de golf.

Par conséquent, j'ai décidé de faire un traitement de chaîne de base dans Ruby, mais pour épeler les nombres, je les stocke dans un fichier source Swift, exécute Swift dans une commande shell et collecte la sortie.

Il s'avère que le formateur de nombres "spellOut" de Swift fait presque exactement ce dont nous avons besoin, sauf en insérant des tirets inutiles pour les nombres à deux chiffres, comme dans twenty-two. En fait, même la sortie en virgule flottante au format integer part point digit digit...est bonne, mais voici la mise en garde - il n'y a pas de précision infinie, et avec des nombres suffisamment grands ou beaucoup de chiffres décimaux, les résultats vont mal. Par conséquent, j'ai dû séparer les parties entières et fractionnaires et alimenter la fraction chiffre par chiffre.

sfk , 853 octets

xed -i
"_*_ [part1]_"
+xed
_+_plus_
_\*_times_
"_/_divided by_"
"_- _minus _"
"_-_negative _"
+xed
"_,[keep][19 chars of 0-9,]_quadr@ _"
"_,[keep][15 chars of 0-9,]_tr@ _"
"_,[keep][11 chars of 0-9,]_b@ _"
"_,[keep][digits],[digits],_b@ _"
"_,[keep][digits],_m@ _"
"_,_ thousand _"
+xed
"_ 000[chars]@__"
"_ 000__"
"_ 00[keep][digit]_ _"
"_ 0[keep][2 digits]_ @_"
"_ [digit][keep][2 digits]_[part2]hundred @_"
"_ [ortext] 0[digit]0_ @[part2]_"
"_ [keep][2 digits]_ @_"
"_@_illion _"
+xed
_@11_eleven_
_@12_twelve_
_@1[digit]_@[part2]teen_
_@1_ten_
_@4_forty_
_@[digit]_@[part2]ty_
+xed
_@2_twen_
_@3_thir_
_@4_four_
_@5_fif_
_@6_six_
_@7_seven_
_@8_eigh_
_@9_nine_
+xed
"_0_ zero _"
"_1_ one _"
"_2_ two _"
"_3_ three _"
"_4_ four _"
"_5_ five _"
"_6_ six _"
"_7_ seven _"
"_8_ eight _"
"_9_ nine _"
"_._ point _"
+xed
"_[white]_ _"
+xed
"_[lstart] __"

Essayez-le en ligne!

Les opérateurs et les nombres doivent être séparés par au moins un espace.

Nettoyer , 766 ... 687 octets

import StdEnv,Text
m=""
z="zero"
@ =digitToInt
r=reverse
l k=(!!)k o@
^s=l[s:split" ""one two three four five six seven eight nine"]
g s=l[m,m,"twen","thir",s,"fif","six","seven","eigh","nine"]
~['0':t]= ~t
~[a,b,c]= ^""a+" hundred "+ ~[b,c]
~[b,c]|b>'1'=g"for"b+"ty "+ ^""c|c>'2'=g"four"c+"teen"=["ten","eleven","twelve"]!!(@c)
~[c]= ^""c
~_=m
$[]=m
$[x:y]#(h,t)=span(\e=e>'/'||e==',')if(x<'1')y[x:y]
=trim(join" "((case x of'0'=[z];'-'=["negative",$h];'.'=["point":map(^z)h];_=(r[u+v\\u<-r(map~(split[',']h))&v<-[m," thousand":[" "+k+"illion"\\k<-["m","b","tr","quadr"]]]|u>m]))++[?t]))
?['-':t]="minus "+ $t
?['+':t]="plus "+ $t
?['/':t]="divided by "+ $t
?['*':t]="times "+ $t
?t= $t

Essayez-le en ligne!

Attend une chaîne sans espace.

05AB1E , 315 295 282 276 octets

"+-*/"DˆS¡εDõQi'¢…ë'.¡VYнD_i\'¡×ðë',¡DgUε0›i.•6b©•ð“†ìˆÈŒšï¿Ÿ¯¥Š“©'tKJ#'…§«…€µ‚•„í#®#«…—¿áÓÁÏ#«ìD9£©.•4º»Ÿć'Rþн•ŽH$S£“Œšï¿Ÿ¯¥Š“'tK#«„ty«sõšâðý«õšD®'°¡ðì«sâðý«yèð.•cG3₅¦„¥F•8ô'¾ß«…¡›‡È±°#«õªRXN-<èJëõ}}ðý}Yg<i®'¡×šYθSè'…®šðý}}J}s¯`Ã哉´Øè„ƺߓ#¤… by«¸s¨ì¯`ykè}.ιðý„  ð:„¢…Øè'¢…:

Prend la saisie sans aucun espace.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

"+-*/"                    # Push string "+-*/"
Dˆ                        # Duplicate it, pop the copy, and push it to the global array
S¡                        # Split the input by any "+", "-", "*", or "/"
ε                         # Map each number to:
 DõQi                     #  If the item is empty (happens for negative numbers)
     '¢…                 '#   Push string "negative"
 ë                        #  Else:
  '.¡                    '#   Split by "."
  VY                      #   Store it in variable `Y`
  н                       #   Take the first number (the integer part)
  D                       #   Duplicate this integer part
  _i                      #   If the integer part is exactly 0:
    \                     #    Discard the duplicated integer part
    '¡×                  '#    Push string "zero"
    ð                     #    Push a space " "
  ë                       #   Else:
   ',¡                   '#    Split by ","
   DgU                    #    Pop and store the amount of items in variable `X`
      ε                   #    Map each part to:
       0›i                #     If it's larger than 0:
          .•6b©•          #      Push string "thir"
          ð               #      Push a space " "
          “†ìˆÈŒšï¿Ÿ¯¥Š“  #      Push string "four five six seven eight nine"
          ©               #      Store it in the register (without popping)
           'tK           '#      Remove all "t" (so "eight" becomes "eigh")
          J               #      Join it together with the "thir" and space
          #               #      Split by spaces
          '…§            '#      Push string "teen"
             «            #      And append it to every string in the list
                          #      (We now have ["thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"])
          …€µ‚•„í         #      Push string "one two three"
                 #        #      Split by spaces
          ®               #      Push the string from the register ("four" through "nine")
           #«             #      Split by spaces, and merge both lists together
          …—¿áÓÁÏ         #      Push string "ten eleven twelve"
                 #«       #      Split by spaces, and also merge both lists together
          ì               #      Prepend "one" through "twelve" before "thirteen" through "nineteen"
          D9£             #      Duplicate it, and take the first nine ("one" through "nine")
             ©            #      Store it in the register (without popping)
          .•4º»Ÿć'Rþн•   '#      Push string "twenthirforfif"
          ŽH$             #      Push integer 4433
             S            #      Split to digits: [4,4,3,3]
              £           #      And split the to parts of that size: ["twen","thir","for","fif"]
          “Œšï¿Ÿ¯¥Š“      #      Push string "six seven eight nine"
                    'tK  '#      Remove all "t" (so "eight" becomes "eigh")
                       #« #      Split by spaces, and merge both lists together
          „ty             #      Push string "ty"
             «            #      And append it to every string in the list
                          #      (We now have ["twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"])
          s               #      Swap so the list "one" through "nine" is at the top again
           õš             #      Prepend an empty string to that list
             â            #      Create every possible pair of "one" through "nine" with "twenty" through "ninety"
              ðý          #      Join each pair with a space delimiter
          «               #      Merge the "twenty" through "ninety nine" list with "one" through "nineteen"
           õš             #      Prepend an empty string to that list
          D               #      Duplicate the entire list
          ®               #      Push the string from the register ("one" through "nine")
          '°¡            '#      Push string "hundred"
             ðì           #      Prepend it with a space " "
               «          #      Append it to every string in the list
                          #      (We now have ["one hundred","two hundred",...,"nine hundred"])
          s               #      Swap the two lists
           â              #      Create every possible pair of "one hundred" through "nine hundred" with "" through "ninety nine"
            ðý            #      Join each pair with a space delimiter
              «           #      Merge the "one" through "ninety nine" with "one hundred " through "nine hundred ninety nine"
                          #      (We now have ["","one",...,"nine hundred ninety nine"])
          y               #      Get the current number of the map
           è              #      And index it into this list
          ð               #      Push a space " "
          .•cG3₅¦„¥F•     #      Push string "quadrilltrill"
                     8ô   #      Split into pieces of size 8: ["quadrill","trill"]
          '¾ß            '#      Push string "ion"
             «            #      Append it to every string in the list
          …¡›‡È±°         #      Push string "billion million thousand"
                 #        #      Split by spaces
                  «       #      And merge both lists together
          õª              #      Append an empty string
            R             #      Reverse the list
                          #      (We now have ["","thousand","million","billion","trillion","quadrillion"])
          X               #      Push variable `X`
           N-             #      Subtract the map-index from it
             <            #      Subtract an additional 1
              è           #      And index it into the list
          J               #      Join the stack together
       ë                  #     Else:
        õ                 #      Push an empty string ""
       }                  #     Close the if-else
      }                   #    Close the map
      ðý                  #    Join the mapped values with space delimiter
  }                       #   Close the if-else
  Y                       #   Push variable `Y`
  g<i                     #   If its length is exactly 2:
     ®                    #    Push the string from the register ("one" through "nine")
     '¡×                 '#    Push "zero"
        š                 #    Prepend it to the list
      Yθ                  #    Push variable `Y` again, and leave the second number (the decimal part)
        S                 #    Split it to digits
         è                #    And index each into the list
      '…®                '#    Push string "point"
         š                #    Prepend it in front of that list
      ðý                  #    Join the list with space delimiter
  }                       #   Close the if
 }                        #  Close the if-else
 J                        #  Join the stack together
}                         # Close the map
s                         # Swap to take the (implicit) input again
¯`                        # Push the global array, and dump it's content (string "+-*/")
  Ã                       # Only keep all "+", "-", "*", and "/", and remove everything else
ε                         # Map each to:
 “‰´Øè„ƺߓ               #  Push string "plus minus times divided"
           #              #  Split by spaces
 ¤                        #  Take the last item (without popping the list)
  … by«                   #  Append it with string " by"
       ¸                  #  Wrap it to a list: ["divided by"]
 s                        #  Swap to take the list again
  ¨                       #  Remove the last item
   ì                      #  Prepend it in front of the list: ["plus","minus","times","divided by"]
 ¯`                       # Push the global array, and dump it's content (string "+-*/")
   yk                     #  Push the index in this string for the current map-value `y`
     è                    #  And use that index to index into the string-list
}                         # Close the map
.ι                        # Interweave the list of numbers and list of operators
  ðý                      # Join everything with space delimiter
„  ð:                     # Replace every two spaces for a single space
„¢…Øè'¢…:                '# And replace every "negative minus" with "negative"
                          # (and output the result implicitly)

Voir cette astuce de mes 05AB1E (sections ? Comment utiliser le dictionnaire , ? Comment les chaînes Compresser ne font pas partie du dictionnaire , et ? Comment compresser les grands entiers ) pour comprendre pourquoi:

• ( Comment utiliser le dictionnaire? ) - '¢…est "negative"; '¡×est "zero"; “†ìˆÈŒšï¿Ÿ¯¥Š“est "four five six seven eight nine"; '…§est "teen"; …€µ‚•„íest "one two three"; …—¿áÓÁÏest "ten eleven twelve"; '°¡est "hundred"; '¾ßest "ion"; …¡›‡È±°est "billion million thousand"; '…®est "point"; et “‰´Øè„ƺߓest "plus minus times divided".
• ( Comment compresser des chaînes ne faisant pas partie du dictionnaire? ) - .•6b©•est "thir"; .•4º»Ÿć'Rþн•est "twenthirforfif"; et .•cG3₅¦„¥F•est "quadrilltrill".
• ( Comment compresser de grands entiers? ) - ŽH$est 4433.

Python 2 , 790 774 octets

lambda T:B("([+/*-])",lambda m:dict(zip("+/*-",S("z"," plus z divided by z times z minus ")))[m.group(0)],B("([+/*-]|^)-",r"\1negative ",B("[^+/*-]+","{}",T))).format(*[J([g[int(S("\.",j)[0])]+S("z",B("y","illion","z thousandz myz byz tryz quadry"))[len(S(",",m))+~i]+(" point "+J(s[int(c)]for c in S("\.",j)[-1]))*("."in j)for i,j in E(S(",",m))if 0<float(j)+(m<"1")])for m in S("[+/*-]+",T)[T[0]=='-':]])
from re import*
E,S,B,P=enumerate,split,sub," ";J=P.join
s,e=S(P,"zero one two three four five six seven eight nine"),[B("urty","rty",j)for i,j in E(c+d for d in S(P,"teen ty")for c in S(P,"twen thir four fif six seven eigh nine"))]
g=s+S(P,"ten eleven twelve")+e[1:8]+[a+(P+b)*(i>0)for a in e[8:]for i,b in E(s)]
g=[(j+" hundred ")*(i>0)+k for i,j in E(s)for k in g]

Essayez-le en ligne!

Tant de mauvaises pratiques. Cela faisait presque mal d'écrire ....

Attend une chaîne non unicode sans espace en entrée.

Explication:

# import all functions from re (python regex library)
from re import*

# rename some repeatedly-used functions/variables for reduced bytecount
E,S,B,P=enumerate,split,sub," ";J=P.join

# list the names of 0-9
s=S(P,"zero one two three four five six seven eight nine")
# generate "twenteen" through nineteen and twenty though ninety, changing "fourty" to forty
# using enumerate (E) even though i is not required b/c it's shorter than range(len(x))
# using re.split (S) instead of string.split since it's shorter
e=[B("urty","rty",j)for i,j in E(c+d for d in S(P,"teen ty")for c in S(P,"twen thir four fif six seven eigh nine"))]
# generate 0-999
# 0-9
g=s+
   # 10, 11, 12
   +S(P,"ten eleven twelve")+
                            # remove "twenteen", 13-19
                            +e[1:8]+
                                   # tens' place + ones' place, if ones' place is not zero
                                   +[a+(P+b)*(i>0)                               ]
                                                   # for each tens' place in 20-90
                                                   for a in e[8:]
                                                                  # for each index, value in ones' places 0-9
                                                                  for i,b in E(s)


# hundreds' place if at least 100, plus tens' and ones' place (already calculated and stored in g from before)
g=[(j+" hundred ")*(i>0)+k                          ]
                           # (s) stores names for 0-9, need index to avoid "zero hundred"
                           for i,j in E(s)
                                          # for each hundred, iterate over all values (0-99) already in g
                                          for k in g

# actual function to call. uses previously declared global variable g.
def f(T):
    # gets the numbers in the supplied string (T) by splitting (T) on any operator character
    # remove first item if blank (only happens when staring with a - for negative numbers)
    n=S("[+/*-]+",T)[T[0]=='-':]

    # triply-nested set of re.subs to convert (T) to a sting of where the operators are replaced by their names and numbers are replaced by "{}"
    # EX: "-1-1--1" -> "-{}-{}--{}" -> "negative {}-{}-negative {}" -> "negative {} minus {} minus negative {}"
    # this sub happens last
    # re.sub (B) any operator, with the operators in a group "()" so that they return in match.group
    T=B("([+/*-])",                                                                                                                                        )
                  # an anonymous function to accept match objects (m) from re.sub's search.
                  ,lambda m:
                            # create a dictionary from the combination of operators and their names
                            # like {"+":" plus ",...}
                            # operator names are surrounded by spaces since number names are NOT
                            dict(zip("+/*-",S("z"," plus z divided by z times z minus ")))
                                                                                          # from the constructed dictionary, select the operator matched by re.sub's search and return it for replacement
                                                                                          [m.group(0)],
                                                                                                      # this substitution is second
                                                                                                      # re.sub (B) any operator followed by a minus (-), OR a minus at the beginning of the string
                                                                                                      # operators/start are grouped, trailing minus is not
                                                                                                      ,B("([+/*-]|^)-",                                    )
                                                                                                                      # replace match with the grouped items plus the word "negative"
                                                                                                                      # EX: "-1-1--1" -> "-{}-{}--{}" -> "negative {}-{}-negative {}"
                                                                                                                      ,r"\1negative ",
                                                                                                                                     # this substitution is done first
                                                                                                                                     # replace any sequence of NON-operators with "{}"
                                                                                                                                     # this removes numbers so the names can be inserted later
                                                                                                                                     # EX: "-1-1--1" -> "-{}-{}--{}"
                                                                                                                                     ,B("[^+/*-]+","{}",T))

    # technically the previous construction of (T) and (n) can be placed here to save 5 bytes but my poor eyes can't handle that.
    # insert constructed names back into original string.
    # EX: "-1-1--1" -> "negative {} minus {} minus negative {}" -> "negative one minus one minus negative one"
    print T.format(                                                                                                                                                                                                                     )
                   # string.format needs items in array unpacked, or it will attempt to insert the string representation of the array itself
                   *[                                                                                                                                                                                                                  ]
                     # for each number pulled from (T), generate names and join generated items back together with spaces
                     # EX: "1,456" -> ["1", "456"] -> ["one thousand", "four hundred fifty six"] -> "one thousand four hundred fifty six"
                     J(                                                                                                                                                                                                     )for m in n
                       # split j on periods (.) and take the first item
                       # convert that item into an integer and find the item at that index in g (0-999)
                       [g[int(S("\.",j)[0])]+                                                                                                                                                                              ]
                                            # insert prefix for millions +, split string on "z" (spaces must be preserved for proper separation)
                                            +S("z",B("y","illion","z thousandz myz byz tryz quadry"))
                                                                                                     # left is largest, so take the item at index (total # of groups - current place - 1)
                                                                                                     [len(S(",",m))+~i]+
                                                                                                                       # if group had a period, split string on period and take last item
                                                                                                                       # replace every character in group with number 0-9 name
                                                                                                                       # join them with spaces and add back to rest of group
                                                                                                                       +(" point "+J(s[int(c)]for c in S("\.",j)[-1]))*("."in j)
                                                                                                                                                                                # split number into groups by comma
                                                                                                                                                                                # EX: "123,456" -> ["123","456"]
                                                                                                                                                                                # only return item if j != 0 (avoids returning empty string which will result in too many joined spaces)
                                                                                                                                                                                # OR if m == 0 (avoids not returning anything when should return "zero")
                                                                                                                                                                                for i,j in E(S(",",m))if 0

_{J'ai réduit d'environ 150 octets lors de l'écriture de l'explication. Qu'on ne dise jamais que commenter / réviser votre code n'est pas utile!}