¡Aprendamos algo de química del pH del suelo!

14

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 , por lo que gana el envío válido más corto (en bytes).

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

Sr. Xcoder
fuente
Sandbox para aquellos que pueden ver publicaciones eliminadas.
Sr. Xcoder
Sí, esto realmente no funciona con los niveles de acidez reales. cualquier cosa más ácida que el jugo de limón es ultra ácida
Destructible Lemon
@DestructibleLemon Si el jugo de limón es ultra ácido, entonces el ácido fluoroantimónico , que se comporta como si tuviera −31.3 es una bomba atómica total :))
Sr. Xcoder
Oh, ya veo dónde te equivocaste. 3.5 ph no es ultra ácido, pero es ultra ácido si el suelo en el que cultiva plantas es de 3.5 ph. lo que quiero decir es que esta tabla se refiere al ph del suelo
Destructible Lemon
1
Brownie señala una respuesta en Python o Swift :)
Sr. Xcoder

Respuestas:

6

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
Jonathan Allan
fuente
Siempre disfruto de la competencia entre 05AB1E y Jelly ... A solo 2 bytes de distancia
Sr. Xcoder
3
Jelly beats 05AB1E?!?!
Erik the Outgolfer
5

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!

Jörg Hülsermann
fuente
4

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.

Charlie
fuente
4

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&[email protected]&S$@5&Very [email protected]&[email protected]&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

BradC
fuente
3

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
Emigna
fuente
Esto es sorprendentemente largo para 05AB1E
Sr. Xcoder
Tarde a la fiesta, pero aún curioso: ¿alguien programa directamente en este idioma (aunque solo sea para golf de código) o es la salida de algún tipo de "compilador"?
avl42
1
@ avl42: codificamos directamente en este idioma sí (generalmente solo para golf, por supuesto). Odiaría ver a alguien usar esto en el código de producción;) Es un lenguaje interpretado, por lo que el código que escribes en este idioma se interpreta como código python.
Emigna
1
@Emigna Yo diría "traducido" en lugar de "interpretado" (es un significado opuesto)
anatolyg
@anatolyg: Sí, tienes razón allí. Siempre pienso interpretado por alguna razón, probablemente debido a Python. Está traducido a un idioma interpretado :)
Emigna
2

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.

Neil
fuente
Wow, creo que tomó un tiempo jugar golf ...
Sr. Xcoder
2

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!

ovs
fuente
2
Te llevaste mis puntos brownie.
Sr. Xcoder
2

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

Arnauld
fuente
1

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",""))
Wernisch
fuente
0

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

Thomas W
fuente
No creo que necesite asignar la función a una variable.
Zacharý