Andrew adalah seorang ahli kimia, tertarik pada keasaman solusi dan pertanian. Setelah berbulan-bulan penelitian (Google bukan temannya), ia datang dengan tabel berikut * mengenai tingkat keasaman yang dapat dibaca manusia dalam hal pH (potensi Hidrogen) :

         Denominasi | kisaran pH
                             |
    ------------------------- + ------------------------ -----   
    Sangat asam | di bawah 3.5
    ------------------------- + ------------------------ ------
    Sangat asam | antara 3.5 dan 4.4
    ------------------------- + ------------------------ ------
    Sangat asam | antara 4.5 dan 5.0
    ------------------------- + ------------------------ ------
    Sangat asam | antara 5.1 dan 5.5
    ------------------------- + ------------------------ ------
    Cukup asam | antara 5.6 dan 6.0
    ------------------------- + ------------------------ ------
    Sedikit asam | antara 6.1 dan 6.5
    ------------------------- + ------------------------ ------
    Netral | antara 6.6 dan 7.3
    ------------------------- + ------------------------ ------
    Sedikit basa | antara 7.4 dan 7.8
    ------------------------- + ------------------------ ------
    Basa sedang | antara 7,9 dan 8,4
    ------------------------- + ------------------------ ------
    Sangat basa | antara 8.5 dan 9.0
    ------------------------- + ------------------------ ------
    Sangat basa | lebih dari 9.0

Diberikan bilangan desimal non-negatif yang mewakili pH suatu zat, mengeluarkan Denominasinya. Anda dapat mengambil input dan memberikan output dengan metode standar apa pun . Jenis data yang diizinkan untuk Anda input adalah:

• Mengapung
• Dua kali lipat
• Tipe data angka desimal standar bahasa Anda
• Tali

Dan Anda harus menampilkan String yang mewakili denominasi. Built-in yang terkait dengan kimia dilarang (Maaf, Mathematica!) .

Aturan Aproksimasi: Jika pH yang Anda terima berada di antara batas atas suatu denominasi dan batas bawah dari yang berikutnya (misalnya antara 7,8 dan 7,9), ia akan didekati dengan nilai terdekat antara keduanya: jika pH ≥ batas atas dari pertama + 0,5, maka ia harus menerima denominasi kedua, tetapi jika pH <atas batas pertama + 0,5, maka ia harus menerima yang pertama (misalnya 7,85 diperkirakan 7,9, tetapi 7,84999 diperkirakan 7,8). Lihat kasus uji untuk klarifikasi.

Kasus uji:

Input -> Output

6,40 -> Sedikit asam
8.399 -> Basa sedang
3,876 -> Sangat asam
10.60 -> Sangat basa     
0,012 -> Sangat asam
7.30 -> Netral
7.85 -> Basa sedang (aturan aproksimasi diterapkan)
7,849 -> Basa sedikit (aturan aproksimasi diterapkan)
6.55 -> Netral (aturan aproksimasi diterapkan)

Ini adalah kode-golf , sehingga pengiriman terpendek yang valid (dalam byte) menang!

_{* Andrew tidak menemukan itu, itu Wikipedia !}

Jelly ,  77 73  71 byte

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

Tautan monadik yang mengambil nomor dan mengembalikan daftar karakter; atau program lengkap mencetak hasilnya.

Cobalah online!

Bagaimana?

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

Cobalah online!

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

Cobalah online!

Solusi ini mempertimbangkan bahwa ptidak boleh lebih besar dari 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&[email protected]&S$@5&Very [email protected]&[email protected]&Ultra@-1))x(i,j),t WHERE j<a','#',' alkaline'','),'@',' acidic'','),'&','),('''),'$','trongly')EXEC(@)

Input melalui tabel t yang sudah ada sebelumnya dengan DECIMAL(4,1)kolom a , sesuai aturan Input / Output kami .

Karena DECIMAL(4,1)tipe data, pembulatan "aturan aproksimasi" apa pun terjadi ketika nilai dimasukkan ke dalam tabel input, jadi tidak perlu dikelola secara eksplisit oleh kode saya.

Setelah penghematan ruang REPLACESdilakukan, ini adalah kueri SQL sederhana yang bergabung dengan tabel input kami dengan daftar nilai kami:

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

Saya membalikkan urutan jadi TOP 1pilih yang pertama kurang dari nilai input kami.

Bahkan bentuk ini (setelah menghapus jeda baris dan ruang ekstra) cukup bagus, sebesar 318 byte . Menambahkan overhead DECLARE, REPLACESDAN EXEChanya menjadi sepadan dengan semua frasa yang diulang.

EDIT : Simpan 6 byte dengan menghapus "0" yang tidak perlu pada beberapa nilai

05AB1E , 81 80 79 77 76 74 byte

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

Cobalah online!

Suite uji

Penjelasan

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

Cobalah online! Tautan termasuk test suite. Penjelasan:

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

Lipat gandakan input dengan 100 dengan suffixing koma desimal dan dua nol kemudian hapus koma desimal dan semua kecuali dua digit sesudahnya.

.+
$*

Konversikan ke unary.

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

Tangani semua alkali, ubah menjadi singkatan yang akan diperluas nanti.

1{655,}
Neutral

Tangani netral.

1$
1 acidic

Apa pun yang tersisa harus bersifat asam. (Tapi biarkan 1 jika pH-nya 0.001)

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

Tangani semua asam.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Perluas singkatan.

Python 2 , 202 byte

-15 byte terima kasih kepada @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))

Cobalah online!

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

Uji kasus

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

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