Andrew jest chemikiem, zainteresowanym kwasowością roztworów i rolnictwem. Po miesiącach badań (Google nie jest jego przyjacielem), wymyślił następującą tabelę * dotyczącą czytelnego dla człowieka poziomu kwasowości pod względem pH (potencjał wodoru) :

         Nominał | zakres pH
                             |
    ------------------------- + ------------------------ -----   
    Ultra kwaśny | poniżej 3,5
    ------------------------- + ------------------------ ------
    Niezwykle kwaśny | od 3,5 do 4,4
    ------------------------- + ------------------------ ------
    Bardzo silnie kwaśny | od 4,5 do 5,0
    ------------------------- + ------------------------ ------
    Silnie kwaśny | od 5,1 do 5,5
    ------------------------- + ------------------------ ------
    Umiarkowanie kwaśny | od 5,6 do 6,0
    ------------------------- + ------------------------ ------
    Lekko kwaśny | od 6,1 do 6,5
    ------------------------- + ------------------------ ------
    Neutralny | od 6,6 do 7,3
    ------------------------- + ------------------------ ------
    Lekko alkaliczny | od 7,4 do 7,8
    ------------------------- + ------------------------ ------
    Umiarkowanie zasadowy | między 7,9 a 8,4
    ------------------------- + ------------------------ ------
    Silnie alkaliczny | od 8,5 do 9,0
    ------------------------- + ------------------------ ------
    Bardzo silnie alkaliczny | ponad 9,0

Biorąc pod uwagę nieujemną liczbę dziesiętną reprezentującą pH substancji, podaj jej nominał. Możesz pobierać dane wejściowe i dostarczać dane wyjściowe dowolną standardową metodą . Typy danych, z którymi możesz przyjmować dane wejściowe, to:

• Pływak
• Podwójnie
• Standardowy typ danych liczb dziesiętnych w Twoim języku
• Strunowy

I musisz wygenerować ciąg znaków reprezentujący nominał. Wbudowane związane z chemią są zabronione (Przepraszamy, Mathematica!) .

Reguła aproksymacji: Jeśli otrzymywane pH mieści się między górną granicą nominału a dolną granicą następnej (np. Między 7,8 a 7,9), przybliża się do najbliższej wartości między nimi: jeśli pH ≥ górna granica najpierw + 0,5, to powinien otrzymać drugi nominał, ale jeśli pH <górna granica pierwszego + 0,5, to powinien otrzymać pierwszy (np. 7,85 jest zbliżony do 7,9, ale 7,84999 jest zbliżony do 7,8). Wyjaśnienia znajdują się w przypadkach testowych.

Przypadki testowe:

Wejście -> Wyjście

6,40 -> Lekko kwaśny
8,399 -> Umiarkowanie alkaliczny
3,876 -> Niezwykle kwaśny
10,60 -> Bardzo silnie alkaliczny     
0,012 -> Ultra kwaśny
7,30 -> Neutralny
7,85 -> Umiarkowanie alkaliczny (stosowana jest zasada przybliżenia)
7,849 -> Lekko alkaliczny (stosowana jest zasada przybliżenia)
6,55 -> Neutralny (stosowana jest zasada przybliżenia)

To jest golf golfowy , więc wygrywa najkrótsze prawidłowe zgłoszenie (w bajtach)!

_{* Andrew nie wymyślił tego, to była Wikipedia !}

Galaretka ,  77 73  71 bajtów

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

Monadyczny link pobierający liczbę i zwracający listę znaków; lub pełny program drukujący wynik.

Wypróbuj online!

W jaki sposób?

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

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

Wypróbuj online!

C # (.NET Core) , 236 bajtów

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

Wypróbuj online!

To rozwiązanie uważa, że pnie może być większe niż 14.

T-SQL, 305 299 bajtów

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

Wejście jest za pomocą wstępnie istniejącej tabeli T z DECIMAL(4,1)kolumny A , zgodnie z naszymi zasadami / Input Output .

Z powodu DECIMAL(4,1) typ danych wszelkie zaokrąglenia z „regułami aproksymacji” mają miejsce po wprowadzeniu wartości do tabeli wejściowej, więc mój kod nie musi jawnie nimi zarządzać.

Po wykonaniu oszczędności miejsca REPLACESjest to proste zapytanie SQL łączące naszą tabelę wejściową z naszą listą wartości:

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

Odwracam kolejność, więc TOP 1wybiera pierwszą mniejszą niż nasza wartość wejściowa.

Nawet ta forma (po usunięciu podziałów linii i dodatkowych spacji) jest całkiem dobra, ma 318 bajtów . Dodanie narzut DECLARE, REPLACESI EXECtylko staje warto ze wszystkich powtarzających się fraz.

EDYCJA : Zapisz 6 bajtów, usuwając niepotrzebne „.0” dla kilku wartości

05AB1E , 81 80 79 77 76 74 bajtów

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

Wypróbuj online!

Zestaw testowy

Wyjaśnienie

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

Siatkówka , 228 bajtów

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

Wypróbuj online! Link zawiera pakiet testowy. Wyjaśnienie:

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

Pomnóż dane wejściowe przez 100, dodając przyrostkowy zapasowy przecinek dziesiętny i dwa zera, a następnie usuwając przecinek dziesiętny i wszystkie cyfry oprócz dwóch po nim.

.+
$*

Konwertuj na unary.

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

Obsługuj wszystkie zasady, przekształcając je w skróty, które zostaną rozwinięte później.

1{655,}
Neutral

Uchwyt neutralny.

1$
1 acidic

Wszystko, co zostało, musi być kwaśne. (Ale zostaw 1, jeśli pH wynosi 0,001)

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

Obchodź się z wszystkimi kwasami.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Rozwiń skróty.

Python 2 , 202 bajty

-15 bajtów dzięki @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))

Wypróbuj online!

JavaScript (ES6), 192 189 185 184 bajtów

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

Przypadki testowe

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 bajtów

=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 bajtów

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

Nadal trochę to gra w golfa

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