Ендрю - хімік, цікавиться кислотністю розчинів та сільським господарством. Після кількох місяців досліджень (Google не є його другом) він створив наступну таблицю * щодо людського рівня читаності рівня кислотності з точки зору рН (потенціал Гідрогену) :

         Номінал | Діапазон pH
                             |
    ------------------------- + ------------------------ -----   
    Ультракислий | нижче 3,5
    ------------------------- + ------------------------ ------
    Надзвичайно кислий | від 3,5 до 4,4
    ------------------------- + ------------------------ ------
    Дуже сильно кислий | між 4,5 і 5,0
    ------------------------- + ------------------------ ------
    Сильно кислотні | між 5,1 і 5,5
    ------------------------- + ------------------------ ------
    Помірно кислий | між 5,6 та 6,0
    ------------------------- + ------------------------ ------
    Злегка кислий | між 6,1 та 6,5
    ------------------------- + ------------------------ ------
    Нейтральна | між 6,6 та 7,3
    ------------------------- + ------------------------ ------
    Злегка лужна | між 7,4 та 7,8
    ------------------------- + ------------------------ ------
    Помірно лужна | між 7,9 та 8,4
    ------------------------- + ------------------------ ------
    Сильно лужна | між 8,5 та 9,0
    ------------------------- + ------------------------ ------
    Дуже сильно лужна | понад 9,0

Враховуючи невід'ємне десяткове число, що представляє pH речовини, виведіть його Номінал. Ви можете взяти введення та надати вихід будь-яким стандартним методом . Типи даних, з якими ви можете приймати дані, це:

• Поплавок
• Подвійний
• Стандартний тип даних про десяткову кількість вашої мови
• Рядок

І ви повинні вивести рядок, що представляє номінал. Вбудовані, пов'язані з хімією, заборонені (Вибачте, Mathematica!) .

Правило наближення: Якщо рН, який ви отримуєте, знаходиться між верхньою межею номіналу та нижньою межею наступного (наприклад, між 7,8 і 7,9), він стає приблизним до найближчого значення між двома: якщо рН ≥ верхній межі перший + 0,5, тоді він повинен отримати друге номінал, але якщо рН <верхній межі першого + 0,5, то він повинен отримувати перше (наприклад, 7,85 приблизний до 7,9, але 7,84999 - приблизно 7,8). Для роз'яснень див. Тестові приклади.

Випробування:

Вхід -> Вихід

6.40 -> Слабокислий
8.399 -> Помірно лужна
3.876 -> Надзвичайно кислий
10.60 -> Дуже сильно лужна     
0,012 -> Ультракислий
7.30 -> Нейтральний
7.85 -> Помірно лужний (застосовується правило наближення)
7.849 -> Легкощелочний (застосовується правило наближення)
6.55 -> Нейтральний (застосовується правило наближення)

Це код-гольф , тому найкоротше дійсне подання (у байтах) виграє!

_{* Ендрю цього не придумав, це була Вікіпедія !}

Желе ,  77 73  71 байт

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

Монадійне посилання, що приймає число та повертає список символів; або повну програму, друкуючи результат.

Спробуйте в Інтернеті!

Як?

“ ... »Ḳµ,Ṛ;€"“¡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 байт

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

Спробуйте в Інтернеті!

C # (.NET Core) , 236 байт

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

Спробуйте в Інтернеті!

Це рішення вважає, що pне може бути більше 14.

T-SQL, 305 299 байт

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

Введення здійснюється через попередньо існуючу таблицю t зі DECIMAL(4,1)стовпцем a , згідно з нашими правилами введення / виводу .

Через DECIMAL(4,1) тип даних будь-яке округлення "правила наближення" відбувається при введенні значення у таблицю введення, тому не потрібно чітко керувати моїм кодом.

Після виконання економії місця REPLACESце простий SQL-запит, який з'єднує нашу вхідну таблицю з нашим списком значень:

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

Я повертаю порядок, так що TOP 1вибирається перший менший, ніж наше вхідне значення.

Навіть ця форма (після видалення перерв рядків та додаткових пробілів) є досить хорошою, у 318 байт . Додавання накладних витрат з DECLARE, REPLACESіEXEC стає тільки варто з усіма повторюваними фразами.

EDIT : Збережіть 6 байтів, видаливши непотрібні ".0" на декількох значеннях

05AB1E , 81 80 79 77 76 74 байт

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

Спробуйте в Інтернеті!

Тестовий набір

Пояснення

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

Сітківка , 228 байт

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

Спробуйте в Інтернеті! Посилання включає тестовий набір. Пояснення:

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

Помножте введення на 100 шляхом суфіксації запасної десяткової крапки та двох нулів, а потім видалення десяткової крапки і всіх, крім двох цифр, після неї.

.+
$*

Перетворити в одинарне.

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

Обробляйте всі луги, перетворюючи на скорочення, які згодом розширяться.

1{655,}
Neutral

Ручка нейтральна.

1$
1 acidic

Все, що залишилося, повинно бути кислим. (Але залиште 1, якщо рН 0,001)

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

Розгорніть скорочення.

Пітон 2 , 202 байти

-15 байт завдяки @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))

Спробуйте в Інтернеті!

JavaScript (ES6), 192 189 185 184 байт

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

Тестові справи

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 байт

=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 байт

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

Ще гольф це трохи

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