Rapport entre les lettres majuscules et les minuscules

28

Dans ce défi, vous et vos amis discutez du meilleur cas, en majuscule ou en minuscule? Pour le savoir, vous écrivez un programme pour le faire pour vous.

Parce que esolangs fait peur à vos amis et que le code détaillé vous fait peur, votre code devra être aussi court que possible.


Exemples

PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.58 uppercase

Foo BaR Baz
0.56 lowercase

Caractéristiques

L'entrée consistera uniquement en caractères ASCII. Tous les caractères non alphabétiques doivent être ignorés. Il y aura au moins 1 caractère de chaque cas

La sortie doit être la quantité de cas qui apparaît le plus souvent sur la quantité totale de caractères alphabétiques. Il doit s'agir d'une décimale précise d' au moins 2 décimales. Si les majuscules apparaissent plus souvent, la sortie doit se terminer par uppercase, ou lowercase.

Il n'y aura jamais autant de majuscules et de minuscules.

Downgoat
la source
7
Les esolangs ne font pas peur à mes amis. Cela signifie-t-il que mon code peut être extrêmement verbeux?
Alex A.
@AlexA. un code détaillé vous fait peur, donc votre code devra également être joué.
Downgoat
16
Ah oui, j'avais oublié mes cauchemars Java récurrents.
Alex A.
4
Y aura-t-il une entrée avec un seul cas?
manatwork
1
"Précise à au moins 2 décimales" nécessite-t-il au moins deux décimales pour être imprimé, ou peut-on laisser une deuxième décimale de zéro?
HVD

Réponses:

2

Pyth - 40 octets

C'est la première fois que j'utilise un formatage de chaîne vectorisé, ce qui est plutôt cool.

Kml-zrzd2eS%Vm+cdsK" %sercase"Kc"upp low

Suite de tests .

Maltysen
la source
7

JavaScript (ES6) 87 octets

modifier 1 octet enregistré thx ETHProductions
Modifier 1 octet supplémentaire enregistré thx l4me

Une fonction anonyme. Long, mais je n'ai pas trouvé un moyen de jouer au golf plus

s=>(l=t=0,s.replace(/[a-z]/ig,c=>l+=++t&&c>'Z'),l/=t,l<.5?1-l+' upp':l+' low')+'ercase'

Moins golfé

s=>( // arrow function returning the value of an expression
  // here I use comma for clarity, 
  // in the golfed version it's all merged in a single expression
  t = 0, // counter for letters
  l = 0, // counter for lowercase letters 
  s.replace(
    /[a-z]/ig, // find all alphabetic chars, upper or lowercase
    c => // execute for each found char (in c)
        l += ++t && c>'Z', // increment t, increment l if c is lowercase
  ),
  l /= t, // l is the ratio now
  ( l < .5 // if ratio < 1/2
    ? (1-l) +' upp' // uppercase count / total (+" upp")
    : l +' low'     // lowrcase count / total (+" low")
  ) + 'ercase' // common suffix
)
edc65
la source
Je pense que vous pourriez économiser un octet en utilisant &&` ${t-l>l?1-l/t+'upp':l/t+'low'}ercase` .
ETHproductions
De plus, c=>l+=++t&&c>'Z'cela fonctionnerait, je pense ...?
ETHproductions
@ETHproductions votre premier indice ne semble pas utile, le second est intelligent, thx
edc65
1
Peut-on voir la version non golfée avec une explication?
Cyoce
Explication @Cyoce ajoutée - c'est simple en fait
edc65
4

CJam, 47 45 octets

q__eu-\_el-]:,_:+df/" low upp"4/.+:e>"ercase"

Essayez-le en ligne.

Je ne joue pas au golf trop longtemps ...

Explication

q               e# Read input.
__eu-           e# Get only the lowercase characters.
\_el-           e# Get only the uppercase characters.
]:,             e# Get the lengths of the two strings.
_:+             e# Sum of the lengths.
df/             e# Lengths divided by the sum of the lengths.
" low upp"4/.+  e# Append the first number with " low" and the second " upp"
:e>             e# Find the maximum of the two.
"ercase"        e# Output other things.
jimmy23013
la source
4

Japt , 58 octets

A=Uf"[a-z]" l /Uf"[A-Za-z]" l)>½?A+" low":1-A+" upp" +`ÖÐ

(Remarque: SE a supprimé un caractère spécial avant Ö, alors veuillez cliquer sur le lien pour obtenir le code approprié)

nicael
la source
Bon travail! Votre première expression régulière (y compris les signes dollar) peut être remplacée par "[a-z]", et la seconde par "A-Za-z". 0.5est égal à ½. Vous pouvez également supprimer le guillemet final.
ETHproductions
Avec les changements mentionnés et la compression de chaîne, j'obtiens 58: A=Uf"[a-z]" l /Uf"[A-Za-z]" l)>½?A+" low":1-A+" upp" +`\x80ÖÐvous pouvez obtenir la version brute des trois derniers octets avec Oc"ercase.
ETHproductions
@Eth \x80ne semblait rien faire, et a ÖÐproduit "case" ... Peut-être des caractères invisi qui ont été tronqués? Btw, fourni mon propre mod, merci pour les conseils
nicael
@ETH Ok, j'ai réussi à utiliser cet invisi-char :)
nicael
Malheureusement, les barres obliques inverses doivent être doublées à l'intérieur des chaînes pour que l'analyseur rationnel fonctionne. Dans ce cas, "\w"correspond simplement à tous les ws et "\\w"correspond à tous A-Za-z0-9_. Je pense donc que vous devrez continuer "[a-z]".
ETHproductions
4

R , 133 123 118 118 108 106 105 105 104 octets

Golfé 10 octets grâce à @ ovs, 8 grâce à @Giuseppe et 10 encore grâce à @ngm. À ce stade, c'est vraiment un effort de collaboration où je fournis les octets et d'autres les enlèvent;)

function(x)cat(max(U<-mean(utf8ToInt(gsub('[^a-zA-Z]',"",x))<91),1-U),c("lowercase","uppercase")[1+2*U])

Essayez-le en ligne!

JayCe
la source
rasé 1 octet de plus.
JayCe
3

MATL , 49 50 octets

Utilise la version actuelle (4.1.1) de la langue, qui est antérieure au défi.

jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h

Exemples

>> matl
 > jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h
 > 
> PrOgRaMiNgPuZzLeS & CoDe GoLf
0.52 uppercase

>> matl
 > jt3Y2m)tk=Ymt.5<?1w-YU' upp'h}YU' low'h]'ercase'h
 > 
> Foo BaR Baz
0.55556 lowercase

Explication

j                   % input string
t3Y2m)              % duplicate. Keep only letters
tk=Ym               % duplicate. Proportion of lowercase letters
t.5<?               % if less than .5
    1w-             % compute complement of proportion
    YU' upp'h       % convert to string and append ' upp'
}                   % else
    YU' low'h       % convert to string and append ' low' 
]                   % end
'ercase'            % append 'ercase'
Luis Mendo
la source
3

Julia, 76 74 octets

s->(x=sum(isupper,s)/sum(isalpha,s);(x>0.5?"$x upp":"$(1-x) low")"ercase")

Il s'agit d'une fonction lambda qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

Non golfé:

function f(s::AbstractString)
    # Compute the proportion of uppercase letters
    x = sum(isupper, s) / sum(isalpha, s)

    # Return a string construct as x or 1-x and the appropriate case
    (x > 0.5 ? "$x upp" : "$(1-x) low") * "ercase"
end

Enregistré 2 octets grâce à edc65!

Alex A.
la source
1
U peut sûrement enregistrer 2 octets en utilisant ercaseau lieu decase
edc65
@ edc65 Excellente idée, merci!
Alex A.
3

Perl 6 ,  91 70 69 63   61 octets

{($/=($/=@=.comb(/\w/)).grep(*~&' 'ne' ')/$/);"{$/>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 91
{$/=m:g{<upper>}/m:g{\w};"{$/>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 70
{"{($/=m:g{<upper>}/m:g{\w})>.5??$/!!1-$/} {<low upp>[$/>.5]}ercase"} # 69
{"{($/=m:g{<upper>}/m:g{\w})>.5??"$/ upp"!!1-$/~' low'}ercase"} # 63

{"{($/=m:g{<:Lu>}/m:g{\w})>.5??"$/ upp"!!1-$/~' low'}ercase"} # 61

Usage:

# give it a lexical name
my &code = {...}

.say for (
  'PrOgRaMiNgPuZzLeS & CoDe GoLf',
  'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT',
  'Foo BaR Baz',
)».&code;
0.52 uppercase
0.580645 uppercase
0.555556 lowercase
Brad Gilbert b2gills
la source
2
Blocs de code barrés? C'est quelque chose de nouveau ...
Bojidar Marinov
1
Perdez 3 caractères en remplaçant ternaire par max ("0,55 upp", "0,45 low"): Essayez-le
Phil H
3

C #, 135 octets

A besoin:

using System.Linq;

Fonction réelle:

string U(string s){var c=s.Count(char.IsUpper)*1F/s.Count(char.IsLetter);return(c>0.5?c+" upp":1-c+" low")+"ercase";}

Avec explication:

string U(string s)
{
    var c = s.Count(char.IsUpper) // count uppercase letters
               * 1F               // make it a float (less bytes than (float) cast)
               / s.Count(char.IsLetter); // divide it by the total count of letters
    return (c > 0.5 
        ? c + " upp"  // if ratio is greater than 0.5, the result is "<ratio> upp"
        : 1 - c + " low") // otherwise, "<ratio> low"
        + "ercase"; // add "ercase" to the output string
}
ProgramFOX
la source
3

Python 2, 114 110 octets

i=input()
n=1.*sum('@'<c<'['for c in i)/sum(c.isalpha()for c in i)
print max(n,1-n),'ulpopw'[n<.5::2]+'ercase'
TFeld
la source
1
Vous pouvez enregistrer 2 octets en remplaçant ['upp','low'][n<.5]par 'ulpopw'[n<.5::2]et 3 autres en remplaçant [n,1-n][n<.5]par max(n,1-n).
PurkkaKoodari
2

Mathematica, 139 105 octets

a=ToString;If[(b=1.#~(c=StringCount)~Alphabet[]/c[#,_?LetterQ])<.5,a[1-b]<>" upp",a@b<>" low"]<>"ercase"&

Le code verbeux fait peur , mais je vais devoir vivre avec ...

LegionMammal978
la source
2

PHP, 140 129 caractères

Ma première partie de golf - pas trop mal pour une langue «standard», hein? :-)

Original:

function f($s){$a=count_chars($s);for($i=65;$i<91;$i++){$u+=$a[$i];$l+=$a[$i+32];}return max($u,$l)/($u+$l).($u<$l?' low':' upp').'ercase';}

Raccourci à 129 caractères grâce à @manatwork:

function f($s){$a=count_chars($s);for(;$i<26;$u+=$a[$i+++65])$l+=$a[$i+97];return max($u,$l)/($u+$l).' '.($u<$l?low:upp).ercase;}

Avec commentaires:

function uclcratio($s)
{
  // Get info about string, see http://php.net/manual/de/function.count-chars.php
  $array = count_chars($s);

  // Loop through A to Z
  for ($i = 65; $i < 91; $i++) // <91 rather than <=90 to save a byte
  {
    // Add up occurrences of uppercase letters (ASCII 65-90)
    $uppercount += $array[$i];
    // Same with lowercase (ASCII 97-122)
    $lowercount += $array[$i+32];
  }
  // Compose output
  // Ratio is max over sum
  return max($uppercount, $lowercount) / ($uppercount + $lowercount)
  // in favour of which, equality not possible per challenge definition
         . ($uppercount < $lowercount ? ' low' : ' upp') . 'ercase';
}
Christallkeks
la source
Compte tenu de la $u+=…, je suppose que vous avez déjà error_reportingpar défaut, donc silencieux des avertissements. Retirez ensuite quelques citations: ' '.($u<$l?low:upp).ercase.
manatwork
Si vous n'aviez qu'une seule déclaration à répéter par le for, vous pourriez supprimer les accolades qui l'entourent. for($i=65;$i<91;$u+=$a[$i++])$l+=$a[$i+32];
manatwork
Avec le prix d'un autre avertissement, vous pouvez épargner l' forinitialisation de la variable de contrôle en bouclant 0..26 au lieu de 65..91:for(;$i<26;$u+=$a[$i+++65])$l+=$a[$i+97];
manatwork
Wow, merci @manatwork, je ne savais pas à quel point PHP est tolérant! : D Le second est très intelligent. J'ai mis en œuvre vos idées, ce qui porte le nombre à 140-4-5-2 = 129 :-)
Christallkeks
2

Rubis, 81 + 1 = 82

Avec drapeau -p,

$_=["#{r=$_.count(a='a-z').fdiv$_.count(a+'A-Z')} low","#{1-r} upp"].max+'ercase'

Heureusement que pour les nombres entre 0 et 1, le tri lexicographique est le même que le tri numérique.

histocrate
la source
2

Lisp commun, 132 octets

(setq s(read-line)f(/(count-if'upper-case-p s)(count-if'alpha-char-p s)))(format t"~f ~aercase"(max f(- 1 f))(if(> f .5)"upp""low"))

Essayez-le en ligne!

Renzo
la source
Dans le test, 0,52 est en majuscules et non en minuscules ...
RosLuP
1
@RosLuP, corrigé, merci beaucoup!
Renzo
1

Gema, 125 caractères

\A=@set{l;0}@set{u;0}
<J1>=@incr{l}
<K1>=@incr{u}
?=
\Z=0.@div{@cmpn{$l;$u;$u;;$l}00;@add{$l;$u}} @cmpn{$l;$u;upp;;low}ercase

Exemple d'exécution:

bash-4.3$ for input in 'PrOgRaMiNgPuZzLeS & CoDe GoLf' 'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT' 'Foo BaR Baz'; do
>     gema '\A=@set{l;0}@set{u;0};<J1>=@incr{l};<K1>=@incr{u};?=;\Z=0.@div{@cmpn{$l;$u;$u;;$l}00;@add{$l;$u}} @cmpn{$l;$u;upp;;low}ercase' <<< "$input"
>     echo " <- $input"
> done
0.52 uppercase <- PrOgRaMiNgPuZzLeS & CoDe GoLf
0.58 uppercase <- DowNGoAT RiGHtGoAt LeFTGoat UpGoAT
0.55 lowercase <- Foo BaR Baz
homme au travail
la source
-1 parce que les esolangs font peur à vos amis. (jk, vote positif)
ev3commander
1

Sérieusement, 58 octets

" upp"" low"k"ercase"@+╗,;;ú;û+∩@-@-;l@ú@-l/;1-k;i<@╜@ZEεj

Vidage hexadécimal:

22207570702222206c6f77226b2265726361736522402bbb2c3b3ba33b
962bef402d402d3b6c40a3402d6c2f3b312d6b3b693c40bd405a45ee6a

Il ne fonctionne que sur l'interpréteur téléchargeable ... celui en ligne est toujours en panne.

Explication:

" upp"" low"k"ercase"@+╗                                    Put [" lowercase"," uppercase"]
                                                            in reg0
                        ,;;ú;û+∩@-@-                        Read input, remove non-alpha
                                    ;l@                     Put its length below it
                                       ú@-                  Delete lowercase
                                          l                 Get its length
                                           /                Get the ratio of upper/total
                                            ;1-k            Make list [upp-ratio,low-ratio]
                                                ;i<         Push 1 if low-ratio is higher
                                                   @        Move list to top
                                                    ╜@Z     Zip it with list from reg0
                                                       E    Pick the one with higher ratio
                                                        εj  Convert list to string.
quintopie
la source
1

Pyth, 45 octets

AeSK.e,s/LzbkrBG1s[cGshMKd?H"upp""low""ercase

Essayez-le en ligne. Suite de tests.

Explication

             rBG1               pair of alphabet, uppercase alphabet
    .e                          map k, b over enumerate of that:
      ,                           pair of
           b                          lowercase or uppercase alphabet
        /Lz                           counts of these characters in input
       s                              sum of that
                                    and
            k                         0 for lowercase, 1 for uppercase
   K                            save result in K
 eS                             sort the pairs & take the larger one
A                               save the number of letters in and the 0 or 1 in H

s[                              print the following on one line:
  cG                              larger number of letters divided by
    shMK                            sum of first items of all items of K
                                    (= the total number of letters)
        d                         space
         ?H"upp""low"             "upp" if H is 1 (for uppercase), otherwise "low"
                     "ercase      "ercase"
PurkkaKoodari
la source
1

CoffeeScript, 104 caractères

 (a)->(r=1.0*a.replace(/\W|[A-Z]/g,'').length/a.length)&&"#{(r>.5&&(r+' low')||(1-r+' upp'))+'ercase'}"

coffeescript essayait initialement de passer la valeur de retour prévue comme argument à la valeur "r", ce qui a échoué et était super ennuyeux car r était un nombre, pas une fonction. Je l'ai contourné en plaçant un &&entre les déclarations pour les séparer.

john dikeman
la source
1

Pyth, 54 53

Un octet sauvé grâce à @Maltysen

K0VzI}NG=hZ)I}NrG1=hK;ceS,ZK+ZK+?>ZK"low""upp""ercase

Essayez-le en ligne

K0                  " Set K to 0
                    " (Implicit: Set Z to 0)

Vz                  " For all characters (V) in input (z):
  I}NG              " If the character (N) is in (}) the lowercase alphabet (G):
    =hZ             " Increment (=h) Z
  )                 " End statement
  I}NrG1            " If the character is in the uppercase alphabet (rG1):
    =hK             " Increment K
;                   " End all unclosed statements/loops

c                   " (Implicit print) The division of
  e                 " the last element of
    S,ZK           " the sorted (S) list of Z and K (this returns the max value)
+ZK                 " by the sum of Z and K

+                   " (Implicit print) The concatenation of
  ?>ZK"low""upp"    " "low" if Z > K, else "upp"
  "ercase"          " and the string "ercase".
RK.
la source
,<any><any>est une commande à deux arités qui est la même que celle [<any><any>)qui peut vous faire économiser un octet
Maltysen
1

Ruby, 97 caractères

->s{'%f %sercase'%[(l,u=[/[a-z]/,/[A-Z]/].map{|r|s.scan(r).size}).max.fdiv(l+u),l>u ?:low: :upp]}

Exemple d'exécution:

2.1.5 :001 > ['PrOgRaMiNgPuZzLeS & CoDe GoLf', 'DowNGoAT RiGHtGoAt LeFTGoat UpGoAT', 'Foo BaR Baz'].map{|s|->s{'%f %sercase'%[(l,u=[/[a-z]/,/[A-Z]/].map{|r|s.scan(r).size}).max.fdiv(l+u),l>u ?:low: :upp]}[s]}
 => ["0.520000 uppercase", "0.580645 uppercase", "0.555556 lowercase"] 
homme au travail
la source
1

05AB1E , 28 octets

ʒ.u}gság/Dò©_αð„Œ„›…#'ƒß«®èJ

Essayez-le en ligne!


ʒ.u}g                        # filter all but uppercase letters, get length.
     ság/                    # Differential between uppercase and input length.
         Dò©                 # Round up store result in register w/o pop.
            _α               # Negated, absolute difference.
              ð              # Push space.
               „Œ„›…         # Push "upper lower"
                    #        # Split on space.
                     'ƒß«    # Concat "case" resulting in [uppercase,lowercase]
                         ®èJ # Bring it all together.
Urne de poulpe magique
la source
1

Java 8, 136 130 octets

s->{float l=s.replaceAll("[^a-z]","").length();l/=l+s.replaceAll("[^A-Z]","").length();return(l<.5?1-l+" upp":l+" low")+"ercase";}

-6 octets créant un port de réponse @ProgramFOX 'C # .NET .

Essayez-le en ligne.

Explication:

s->{                  // Method with String as both parameter and return-type
  float l=s.replaceAll("[^a-z]","").length();
                      //  Amount of lowercase
  l/=l+s.replaceAll("[^A-Z]","").length();
                      //  Lowercase compared to total amount of letters
  return(l<.5?        //  If this is below 0.5:
          1-l+" upp"  //   Return `1-l`, and append " upp"
         :            //  Else:
          l+" low")   //   Return `l`, and append " low"
        +"ercase";}   //  And append "ercase"
Kevin Cruijssen
la source
1

REXX, 144 octets

a=arg(1)
l=n(upper(a))
u=n(lower(a))
c.0='upp';c.1='low'
d=u<l
say 1/((u+l)/max(u,l)) c.d'ercase'
n:return length(space(translate(a,,arg(1)),0))
idrougge
la source
1

Kotlin , 138 octets

Code

let{var u=0.0
var l=0.0
forEach{when{it.isUpperCase()->u++
it.isLowerCase()->l++}}
"${maxOf(u,l)/(u+l)} ${if(u>l)"upp" else "low"}ercase"}

Usage

fun String.y():String =let{var u=0.0
var l=0.0
forEach{when{it.isUpperCase()->u++
it.isLowerCase()->l++}}
"${maxOf(u,l)/(u+l)} ${if(u>l)"upp" else "low"}ercase"}

fun main(args: Array<String>) {
    println("PrOgRaMiNgPuZzLeS & CoDe GoLf".y())
    println("DowNGoAT RiGHtGoAt LeFTGoat UpGoAT".y())
    println("Foo BaR Baz".y())
}
jrtapsell
la source
1

Pyth, 40 39 octets

Jml@dQrBG1+jdeS.T,cRsJJc2."kw񽙽""ercase

Essayez-le ici

Explication

Jml@dQrBG1+jdeS.T,cRsJJc2."kw񽙽""ercase
 m    rBG1                                For the lower and uppercase alphabet...
  l@dQ                                    ... count the occurrences in the input.
J                 cRsJJ                   Convert to frequencies.
               .T,     c2."kw񽙽"          Pair each with the appropriate case.
             eS                           Get the more frequent.
          +jd                    "ercase  Stick it all together.

la source
1

PowerShell Core , 134 128 octets

Filter F{$p=($_-creplace"[^A-Z]",'').Length/($_-replace"[^a-z]",'').Length;$l=1-$p;(.({"$p upp"},{"$l low"})[$p-lt$l])+"ercase"}

Essayez-le en ligne!

Merci, Veskah , d'avoir économisé six octets en convertissant la fonction en filtre!

Jeff Freeman
la source
1
Vous pouvez enregistrer deux octets gratuits en en faisant un filtre au lieu d'une fonction, c'est-à-dire le filtre F (code)
Veskah
Je n'ai jamais su que c'était une chose! Merci, Veskah!
Jeff Freeman
1

Tcl , 166 octets

proc C s {lmap c [split $s ""] {if [string is u $c] {incr u}
if [string is lo $c] {incr l}}
puts [expr $u>$l?"[expr $u./($u+$l)] upp":"[expr $l./($u+$l)] low"]ercase}

Essayez-le en ligne!

sergiol
la source
1

APL (NARS), 58 caractères, 116 octets

{m←+/⍵∊⎕A⋄n←+/⍵∊⎕a⋄∊((n⌈m)÷m+n),{m>n:'upp'⋄'low'}'ercase'}

tester:

  h←{m←+/⍵∊⎕A⋄n←+/⍵∊⎕a⋄∊((n⌈m)÷m+n),{m>n:'upp'⋄'low'}'ercase'}
  h "PrOgRaMiNgPuZzLeS & CoDe GoLf"
0.52 uppercase
  h "DowNGoAT RiGHtGoAt LeFTGoat UpGoAT"
0.5806451613 uppercase
  h "Foo BaR Baz"
0.5555555556 lowercase
RosLuP
la source
1

C, 120 octets

f(char*a){int m=0,k=0,c;for(;isalpha(c=*a++)?c&32?++k:++m:c;);printf("%f %sercase",(m>k?m:k)/(m+k+.0),m>k?"upp":"low");}

test et résultat:

main()
{char *p="PrOgRaMiNgPuZzLeS & CoDe GoLf", *q="DowNGoAT RiGHtGoAt LeFTGoat UpGoAT", *m="Foo BaR Baz";
 f(p);printf("\n");f(q);printf("\n");f(m);printf("\n");
}

résultats

0.520000 uppercase
0.580645 uppercase
0.555556 lowercase

Cela suppose un jeu de caractères Ascii.

RosLuP
la source
116 octets
plafond
@ceilingcat, vous pouvez mettre à jour vos 116 octets ... Ces 120 octets pour moi si c'est suffisant ...
RosLuP