Andrew est chimiste, intéressé par l'acidité des solutions et par l'agriculture. Après des mois de recherche (Google n'est pas son ami), il est parvenu au tableau * suivant concernant le niveau d'acidité lisible par l'homme en termes de pH (potentiel de l'hydrogène) :

         Dénomination | Gamme de pH
                             |
    ------------------------- + ------------------------ -----   
    Ultra acide | en dessous de 3,5
    ------------------------- + ------------------------ ------
    Extrêmement acide | entre 3,5 et 4,4
    ------------------------- + ------------------------ ------
    Très fortement acide | entre 4,5 et 5,0
    ------------------------- + ------------------------ ------
    Fortement acide | entre 5,1 et 5,5
    ------------------------- + ------------------------ ------
    Modérément acide | entre 5,6 et 6,0
    ------------------------- + ------------------------ ------
    Légèrement acide | entre 6,1 et 6,5
    ------------------------- + ------------------------ ------
    Neutre | entre 6,6 et 7,3
    ------------------------- + ------------------------ ------
    Légèrement alcalin | entre 7,4 et 7,8
    ------------------------- + ------------------------ ------
    Modérément alcalin | entre 7,9 et 8,4
    ------------------------- + ------------------------ ------
    Fortement alcalin | entre 8,5 et 9,0
    ------------------------- + ------------------------ ------
    Très fortement alcalin | plus de 9,0

Étant donné un nombre décimal non négatif représentant le pH d'une substance, affichez sa dénomination. Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard . Les types de données avec lesquels vous êtes autorisé à saisir sont:

• Flotte
• Double
• Type de données du nombre décimal standard de votre langue
• Chaîne

Et vous devez produire une chaîne représentant la dénomination. Les intégrations liées à la chimie sont interdites (Désolé, Mathematica!) .

Règle d'approximation: Si le pH que vous recevez se situe entre une limite supérieure d'une dénomination et la limite inférieure de la suivante (par exemple entre 7,8 et 7,9), il est approximé à la valeur la plus proche entre les deux: si le pH ≥ limite supérieure de la d'abord + 0,5, alors il devrait recevoir la deuxième dénomination, mais si le pH <limite supérieure du premier + 0,5, alors il devrait recevoir la première (par exemple, 7,85 est approximativement égal à 7,9, mais 7,84999 est approximativement égal à 7,8). Voir les cas de test pour des clarifications.

Cas de test:

Entrée -> Sortie

6,40 -> légèrement acide
8.399 -> Modérément alcalin
3.876 -> Extrêmement acide
10.60 -> Très fortement alcalin     
0,012 -> Ultra acide
7h30 -> Neutre
7.85 -> Modérément alcalin (la règle d'approximation est appliquée)
7.849 -> Légèrement alcalin (la règle d'approximation est appliquée)
6.55 -> Neutre (la règle d'approximation est appliquée)

Il s'agit de code-golf , donc la soumission valide la plus courte (en octets) gagne!

_{* Andrew n'est pas venu avec ça, c'était Wikipedia !}

Gelée ,  77 73  71 octets

“£RĿÐƭðṚ°ƲṂṾẒ=ʂXḣsịɠ<»Ḳµ,Ṛ;€"“¡D⁺“a&»j“¿<z»W¤ṙ3
×20<“FYeoy³ƓɗʋṆ‘Sị¢⁾. y

Un lien monadique prenant le numéro et renvoyant une liste de personnages; ou un programme complet imprimant le résultat.

Essayez-le en ligne!

Comment?

“ ... »Ḳµ,Ṛ;€"“¡D⁺“a&»j“¿<z»W¤ṙ3 - Link 1, name list: no arguments
“ ... »                          - compression of "Ultra Extremely Very.strongly Strongly Moderately Slightly"
       Ḳ                         - split at spaces
        µ                        - monadic chain separation, call that adjectives
          Ṛ                      - reverse adjectives
         ,                       - pair these two lists
              “¡D⁺“a&»           - compression of [" alkaline"," acidic"]
             "                   - zip with:
           ;€                    -   concatenate for €ach
                             ¤   - nilad followed by links as a nilad
                       “¿<z»     -   compression of "Neutral"
                            W    -   wrap in a list
                      j          - join
                              ṙ3 - rotate left by 3: ["Strongly alkaline","Moderately alkaline","Slightly alkaline","Neutral","Slightly acidic","Moderately acidic","Strongly acidic","Very.strongly acidic","Extremely acidic","Ultra acidic","Ultra alkaline","Extremely alkaline","Very.strongly alkaline"]

×20<“FYeoy³ƓɗʋṆ‘Sị¢⁾. y - Main link: number, pH
×20                     - multiply by 20
    “FYeqy³ƓɗʋṆ‘        - code-page indexes = [70,89,101,111,121,131,147,157,169,180]
   <                    - less than? (vectorises)
                        -   i.e.: pH < [3.5,4.45,5.05,5.55,6.05,6.55,7.35,7.85,8.45,9]
                S       - sum
                  ¢     - call last link (1) as a nilad
                 ị      - index into (1-indexed and modular)
                        - ...note that the sum is never 11 or 12, so "Ultra alkaline" and
                        -    "Extremely alkaline" wont be fetched, but that a sum of 0
                        -    fetches "Very.strongly alkaline", as required.
                   ⁾.   - literal list of characters ['.', ' ']
                      y - translate (replace any '.' with a ' ' i.e. for "Very.strongly")
                        - if running as a full program, implicit print

PHP , 199 octets

foreach([35,9.5,6,5,5,5,8,5,6,5.5]as$l)$p+=$argn*10>=$s+=$l;$p-=$argn==9;echo[Ultra,Extremely,"Very strongly",Strongly,Moderately,Slightly][$p>6?12-$p:$p],[" acidic",Neutral," alkaline"][1+($p<=>6)];

Essayez-le en ligne!

C # (.NET Core) , 236 octets

p=>{var l=new[]{70,89,101,111,121,131,147,157,169,180,280};var a="Ultra,Extremely,Very strongly,Strongly,Moderately,Slighty, acidic,Neutral, alkaline".Split(',');int i=0;for(;p*20>=l[i];i++);return i==6?a[7]:i<6?a[i]+a[6]:a[12-i]+a[8];}

Essayez-le en ligne!

Cette solution considère que pne peut pas être supérieur à 14.

T-SQL, 305 299 octets

DECLARE @ char(999)=REPLACE(REPLACE(REPLACE(REPLACE('SELECT TOP 1i FROM(VALUES(''Very s$#9&S$#8.4&Moderately#7.8&Slightly#7.3&Neutral'',6.5&Slightly@6&Moderately@5.5&S$@5&Very s$@4.4&Extremely@3.4&Ultra@-1))x(i,j),t WHERE j<a','#',' alkaline'','),'@',' acidic'','),'&','),('''),'$','trongly')EXEC(@)

L'entrée se fait via un tableau préexistant t avec la DECIMAL(4,1)colonne a , selon nos règles d'entrée / sortie .

En raison du DECIMAL(4,1)type de données, tout arrondi de "règle d'approximation" a lieu lorsque la valeur est entrée dans la table d'entrée, donc n'a pas besoin d'être explicitement géré par mon code.

Une fois les économies d'espace REPLACESeffectuées, il s'agit d'une simple requête SQL joignant notre table d'entrée à notre liste de valeurs:

SELECT TOP 1 i
FROM(VALUES
    ('Very strongly alkaline',9),
    ('Strongly alkaline',8.4),
    ('Moderately alkaline',7.8),
    ('Slightly alkaline',7.3),
    ('Neutral',6.5),
    ('Slightly acidic',6),
    ('Moderately acidic',5.5),
    ('Strongly acidic',5),
    ('Very strongly acidic',4.4),
    ('Extremely acidic',3.4),
    ('Ultra acidic',-1)
) x(i,j), t
WHERE j<a

J'inverse l'ordre donc TOP 1 choisir le premier de moins que notre valeur d'entrée.

Même cette forme (après avoir supprimé les sauts de ligne et les espaces supplémentaires) est assez bonne, à 318 octets . Ajout de la tête du DECLARE, REPLACESETEXEC ne devient en valeur avec toutes les phrases répétées.

EDIT : économisez 6 octets en supprimant les ".0" inutiles sur plusieurs valeurs

05AB1E , 81 80 79 77 76 74 octets

'Ĉ“¢³¿™ly³¾‚Òw““³¾§ÓªÅ“«#¦¦’šÉaƒ£’«Š’w¡Îic’«)˜™'wð:I•t{~À•ST+.¥70+20/‹Oè

Essayez-le en ligne!

Suite de tests

Explication

'Ĉ                   # push the string "neutral"
“¢³¿™ly³¾‚Òw“         # push the string "slightly moderately strongly veryw"
“³¾§ÓªÅ“              # push the string "strongly extremely ultra"
«                     # concatenate the top 2 items on the stack
 #                    # split on spaces
  Â                   # push a reversed copy
   ¦¦                 # remove the first 2 elements of the copy ("ultra", "extremely")
’šÉaƒ£’«              # append the string "walkaline" to each ("walk"+"a"+"line")
        Š             # move down 2 places on the stack
’w¡Îic’«              # append the string "wacidic" to each ("w"+"acid"+"ic")
        )˜            # wrap stack in a list and flatten
          ™           # title case each
           'wð:       # replace each instance of "w" with a space
I                     # push input
 •t{~À•               # push the base 255 compressed number 920006021
       ST+            # split to list of digits and add 10 to each
          .¥          # undelta (compute increments from 0)
            70+       # add 70 to each
               20/    # divide each by 20
                  ‹   # compute input less than for each
                   O  # sum
                    è # use this to index into list of strings

Rétine , 228 octets

$
.00
\.(.)\.?(.).*
$1$2
.+
$*
1{900,}
VA
1{845,}
STA
1{785,}
MA
1{735,}
SLA
1{655,}
Neutral
1$
1 acidic
1{605,}
SL
1{555,}
M
1{505,}
ST
1{445,}
V
1{350,}
Extremely
1+
Ultra
M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

$
.00
\.(.)\.?(.).*
$1$2

Multipliez l'entrée par 100 en suffixant une virgule décimale de rechange et deux zéros, puis supprimez la virgule décimale et tous les chiffres sauf deux après.

.+
$*

Convertissez en unaire.

1{900,}
VA
1{845,}
STA
1{785,}
MA
1{735,}
SLA

Manipulez tous les alcalis, en les convertissant en abréviations qui seront développées plus tard.

1{655,}
Neutral

Poignée neutre.

1$
1 acidic

Tout ce qui reste doit être acide. (Mais laissez le 1 au cas où le pH est de 0,001)

1{605,}
SL
1{555,}
M
1{505,}
ST
1{445,}
V
1{350,}
Extremely
1+
Ultra

Manipulez tous les acides.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Développez les abréviations.

Python 2 , 202 octets

-15 octets grâce à @JonathanAllan

lambda k:'Neutral_Slightly_Moderately_Strongly_Very strongly_Extremely_Ultra'.split('_')[abs(sum(round(k*10)>ord(i)for i in'",27<AINT')+(k>9)-(3.45<k<3.5)-6)]+(' acidic'*(k<6.55)or' alkaline'*(k>=7.35))

Essayez-le en ligne!

JavaScript (ES6), 192 189 185 185 184 octets

k=>([...'09544474540'].some(n=>(i--,k-=++n)<0,i=7,k=k*10-33.5),'Neutral,Slightly,Moderately,Strongly,Very strongly,Extremely,Ultra'.split`,`[i<0?-i:i]+(i?i>0?' acidic':' alkaline':''))

Cas de test

let f =

k=>([...'09544474540'].some(n=>(i--,k-=++n)<0,i=7,k=k*10-33.5),'Neutral,Slightly,Moderately,Strongly,Very strongly,Extremely,Ultra'.split`,`[i<0?-i:i]+(i?i>0?' acidic':' alkaline':''))

console.log(f(6.40))  //  Slightly acidic
console.log(f(8.399)) //  Moderately alkaline
console.log(f(3.876)) //  Extremely acidic
console.log(f(10.60)) //  Very strongly alkaline     
console.log(f(0.012)) //  Ultra acidic
console.log(f(7.30))  //  Neutral
console.log(f(7.85))  //  Moderately alkaline
console.log(f(7.849)) //  Slightly alkaline
console.log(f(6.55))  //  Neutral

Excel, 240 octets

=CHOOSE((A1<6.55)+(A1<6.05)+(A1<5.55)+(A1<5.05)+(A1<4.45)+(A1<3.5)+(A1>=7.35)+(A1>=7.85)+(A1>=8.45)+(A1>9)+1,"Neutral","Slightly","Moderately","Strongly","Very Strongly","Extremely","Ultra")&IF(A1<6.55," acidic",IF(A1>=7.35," alkaline",""))

Javascript, 222 209 octets

x=>'Very strongly,Strongly,Moderately,Slightly,Neutral,Extremely,Ultra'.split(',',7,x-=0.049)[x>9?0:x>8.4?1:x>7.8?2:x>7.3?3:x>6.5?4:x>6?3:x>5.5?2:x>5?1:x>4.4?0:x>3.5?5:6]+(x<6.5?' acidic':x>7.3?' alkaline':'')

Je joue encore un peu au golf

var f = x=>'Very strongly,Strongly,Moderately,Slightly,Neutral,Extremely,Ultra'.split(',',7,x-=0.049)[x>9?0:x>8.4?1:x>7.8?2:x>7.3?3:x>6.5?4:x>6?3:x>5.5?2:x>5?1:x>4.4?0:x>3.5?5:6]+(x<6.5?' acidic':x>7.3?' alkaline':'')

console.log(f(6.40));
console.log(f(8.399));
console.log(f(3.876));
console.log(f(10.60));
console.log(f(0.012));
console.log(f(7.30));
console.log(f(7.85));
console.log(f(7.849));
console.log(f(6.55));