Andrew es químico, interesado en la acidez de las soluciones y en la agricultura. Después de meses de investigación (Google no es su amigo), se le ocurrió la siguiente tabla * con respecto al nivel de acidez legible por el ser humano en términos del pH (potencial de hidrógeno) :

         Denominación | rango de pH
                             El |
    ------------------------- + ------------------------ -----   
    Ultra ácido | por debajo de 3.5
    ------------------------- + ------------------------ ------
    Extremadamente ácido | entre 3.5 y 4.4
    ------------------------- + ------------------------ ------
    Muy fuertemente ácido | entre 4.5 y 5.0
    ------------------------- + ------------------------ ------
    Fuertemente ácido | entre 5.1 y 5.5
    ------------------------- + ------------------------ ------
    Moderadamente ácido | entre 5.6 y 6.0
    ------------------------- + ------------------------ ------
    Ligeramente ácido | entre 6.1 y 6.5
    ------------------------- + ------------------------ ------
    Neutro | entre 6.6 y 7.3
    ------------------------- + ------------------------ ------
    Ligeramente alcalino | entre 7.4 y 7.8
    ------------------------- + ------------------------ ------
    Moderadamente alcalino | entre 7.9 y 8.4
    ------------------------- + ------------------------ ------
    Fuertemente alcalino | entre 8.5 y 9.0
    ------------------------- + ------------------------ ------
    Muy fuertemente alcalino | más de 9.0

Dado un número decimal no negativo que representa el pH de una sustancia, genera su Denominación. Puede tomar entrada y proporcionar salida por cualquier método estándar . Los tipos de datos con los que puede ingresar son:

• Flotador
• Doble
• Tipo de datos de número decimal estándar de su idioma
• Cuerda

Y debe generar una cadena que represente la denominación. Las incorporaciones relacionadas con la química están prohibidas (¡Lo siento, Mathematica!) .

Regla de aproximación: si el pH que recibe está entre un límite superior de una denominación y el límite inferior del siguiente (por ejemplo, entre 7.8 y 7.9), se aproxima al valor más cercano entre los dos: si el pH ≥ límite superior del primero + 0.5, entonces debería recibir la segunda denominación, pero si el pH <upperBound del primer + 0.5, debería recibir el primero (por ejemplo, 7.85 se aproxima a 7.9, pero 7.84999 se aproxima a 7.8). Vea los casos de prueba para aclaraciones.

Casos de prueba:

Entrada -> Salida

6.40 -> Ligeramente ácido
8.399 -> Moderadamente alcalino
3.876 -> Extremadamente ácido
10.60 -> Muy fuertemente alcalino     
0.012 -> Ultra ácido
7.30 -> Neutro
7.85 -> Moderadamente alcalino (se aplica la regla de aproximación)
7.849 -> Ligeramente alcalino (se aplica la regla de aproximación)
6.55 -> Neutro (se aplica la regla de aproximación)

Este es el código de golf , por lo que gana el envío válido más corto (en bytes).

_{* Andrew no se le ocurrió eso, ¡fue Wikipedia !}

Gelatina ,  77 73  71 bytes

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

Un enlace monádico que toma el número y devuelve una lista de caracteres; o un programa completo imprimiendo el resultado.

Pruébalo en línea!

¿Cómo?

“ ... »Ḳµ,Ṛ;€"“¡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 bytes

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)];

Pruébalo en línea!

C # (.NET Core) , 236 bytes

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];}

Pruébalo en línea!

Esta solución considera que pno puede ser mayor que 14.

T-SQL, 305 299 bytes

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(@)

La entrada es a través de una tabla t preexistente con la DECIMAL(4,1)columna a , según nuestras reglas de Entrada / Salida .

Debido al DECIMAL(4,1)tipo de datos, cualquier redondeo de "regla de aproximación" tiene lugar cuando el valor se ingresa en la tabla de entrada, por lo que no es necesario que mi código lo administre explícitamente.

Después de realizar el ahorro de espacio REPLACES, esta es una consulta SQL simple que une nuestra tabla de entrada con nuestra lista de valores:

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

Invierto el orden, por lo que TOP 1elige el primero menos que nuestro valor de entrada.

Incluso esta forma (después de eliminar saltos de línea y espacios adicionales) es bastante buena, en 318 bytes . Agregar la sobrecarga de DECLARE, REPLACESY EXECsolo vale la pena con todas las frases repetidas.

EDITAR : ahorre 6 bytes eliminando ".0" innecesarios en varios valores

05AB1E , 81 80 79 77 76 74 bytes

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

Pruébalo en línea!

Banco de pruebas

Explicación

'Ĉ                   # 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

Retina , 228 bytes

$
.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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

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

Multiplique la entrada por 100 con el sufijo de un punto decimal de repuesto y dos ceros y luego elimine el punto decimal y todos menos dos dígitos después.

.+
$*

Convierte a unario.

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

Maneje todos los álcalis, convirtiéndolos en abreviaturas que se expandirán más adelante.

1{655,}
Neutral

Manejar neutral.

1$
1 acidic

Todo lo que quede debe ser ácido. (Pero deje el 1 en caso de que el pH sea 0.001)

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

Manejar todos los ácidos.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Expande las abreviaturas.

Python 2 , 202 bytes

-15 bytes gracias a @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))

Pruébalo en línea!

JavaScript (ES6), 192 189 185 184 bytes

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':''))

Casos de prueba

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 bytes

=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 bytes

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':'')

Todavía jugando un poco

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));