Andrew là một nhà hóa học, quan tâm đến tính axit của các giải pháp và trong nông nghiệp. Sau nhiều tháng nghiên cứu (Google không phải là bạn của anh ấy), anh ấy đã đưa ra bảng dưới đây * về mức độ axit có thể đọc được của con người về độ pH (tiềm năng của Hydrogen) :

         Mệnh giá | Phạm vi pH
                             |
    ------------------------- + ------------------------ -----   
    Siêu axit | dưới 3,5
    ------------------------- + ------------------------ ------
    Cực kỳ axit | từ 3,5 đến 4,4
    ------------------------- + ------------------------ ------
    Có tính axit rất mạnh | từ 4,5 đến 5,0
    ------------------------- + ------------------------ ------
    Có tính axit mạnh | từ 5,1 đến 5,5
    ------------------------- + ------------------------ ------
    Axit vừa phải | từ 5,6 đến 6,0
    ------------------------- + ------------------------ ------
    Hơi axit | từ 6,1 đến 6,5
    ------------------------- + ------------------------ ------
    Trung tính | từ 6,6 đến 7,3
    ------------------------- + ------------------------ ------
    Hơi kiềm | từ 7.4 đến 7.8
    ------------------------- + ------------------------ ------
    Kiềm vừa phải | từ 7.9 đến 8.4
    ------------------------- + ------------------------ ------
    Kiềm mạnh | từ 8,5 đến 9,0
    ------------------------- + ------------------------ ------
    Kiềm rất mạnh | trên 9.0

Cho một số thập phân không âm biểu thị pH của một chất, xuất ra Mệnh giá của nó. Bạn có thể lấy đầu vào và cung cấp đầu ra theo bất kỳ phương pháp tiêu chuẩn nào . Các loại dữ liệu bạn được phép lấy đầu vào là:

• Phao nổi
• Gấp đôi
• Kiểu dữ liệu số thập phân chuẩn của ngôn ngữ của bạn
• Chuỗi

Và bạn phải xuất một Chuỗi đại diện cho mệnh giá. Tích hợp liên quan đến hóa học bị cấm (Xin lỗi, Mathicala!) .

Quy tắc gần đúng: Nếu độ pH bạn nhận được nằm giữa giới hạn trên của mệnh giá và giới hạn dưới của mệnh giá tiếp theo (ví dụ: giữa 7.8 và 7.9), nó sẽ xấp xỉ với giá trị gần nhất giữa hai giá trị: nếu pH UpperBound của đầu tiên + 0,5, sau đó nó sẽ nhận được mệnh giá thứ hai, nhưng nếu pH <UpperBound của đầu tiên + 0,5, thì nó sẽ nhận được mệnh giá đầu tiên (ví dụ 7,85 xấp xỉ 7,9, nhưng 7,84999 xấp xỉ bằng 7,8). Xem các trường hợp thử nghiệm để làm rõ.

Các trường hợp thử nghiệm:

Đầu vào -> Đầu ra

6,40 -> Hơi axit
8.399 -> kiềm vừa phải
3.876 -> Cực kỳ axit
10.60 -> kiềm rất mạnh     
0,012 -> Siêu axit
7.30 -> Trung tính
7,85 -> kiềm vừa phải (quy tắc gần đúng được áp dụng)
7.849 -> Hơi kiềm (quy tắc gần đúng được áp dụng)
6.55 -> Trung lập (quy tắc gần đúng được áp dụng)

Đây là môn đánh gôn , vì vậy bài nộp hợp lệ ngắn nhất (tính bằng byte) sẽ thắng!

_{* Andrew đã không nghĩ ra điều đó, đó là Wikipedia !}

Thạch ,  77 73  71 byte

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

Một liên kết đơn âm lấy số và trả về một danh sách các ký tự; hoặc một chương trình đầy đủ in kết quả.

Hãy thử trực tuyến!

Làm sao?

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

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

Hãy thử trực tuyến!

C # (.NET Core) , 236 byte

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

Hãy thử trực tuyến!

Giải pháp này cho rằng pkhông thể lớn hơn 14.

T-SQL, 305 299 byte

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

Đầu vào là thông qua bảng t có sẵn với DECIMAL(4,1)cột a , theo quy tắc Đầu vào / Đầu ra của chúng tôi .

Do DECIMAL(4,1)kiểu dữ liệu, bất kỳ làm tròn "quy tắc gần đúng" nào diễn ra khi giá trị được nhập vào bảng đầu vào, do đó không cần phải được quản lý rõ ràng bởi mã của tôi.

Sau khi tiết kiệm không gian REPLACESđược thực hiện, đây là một truy vấn SQL đơn giản tham gia bảng đầu vào của chúng tôi với danh sách các giá trị:

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

Tôi đảo ngược thứ tự để TOP 1chọn cái đầu tiên ít hơn giá trị đầu vào của chúng tôi.

Ngay cả hình thức này (sau khi loại bỏ ngắt dòng và thêm khoảng trắng) là khá tốt, ở mức 318 byte . Thêm chi phí chung DECLARE, REPLACESVÀ EXECchỉ trở nên có giá trị với tất cả các cụm từ lặp đi lặp lại.

EDIT : Lưu 6 byte bằng cách xóa ".0" không cần thiết trên một số giá trị

05AB1E , 81 80 79 77 76 74 byte

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

Hãy thử trực tuyến!

Bộ kiểm tra

Giải trình

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

Võng mạc , 228 byte

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

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải trình:

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

Nhân số đầu vào với 100 bằng cách thêm một dấu thập phân dự phòng và hai số không sau đó xóa dấu thập phân và tất cả trừ hai chữ số sau nó.

.+
$*

Chuyển đổi sang unary.

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

Xử lý tất cả các chất kiềm, chuyển đổi thành chữ viết tắt sẽ được mở rộng sau này.

1{655,}
Neutral

Xử lý trung tính.

1$
1 acidic

Bất cứ điều gì còn lại phải có tính axit. (Nhưng để lại 1 trong trường hợp pH là 0,001)

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

Xử lý tất cả các axit.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Mở rộng các chữ viết tắt.

Python 2 , 202 byte

-15 byte nhờ @Jonathan ALLan

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

Hãy thử trực tuyến!

JavaScript (ES6), 192 189 185 184 byte

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

Các trường hợp thử nghiệm

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 byte

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

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

Vẫn chơi golf một chút

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