Andrew ist ein Chemiker, der sich für die Säure von Lösungen und für die Landwirtschaft interessiert. Nach monatelangen Nachforschungen (Google ist nicht sein Freund) hat er die folgende Tabelle * bezüglich des für Menschen lesbaren Säuregehalts in Bezug auf die gefunden pH-Wert (Potenzial von Wasserstoff) erstellt :

         Stückelung | pH-Bereich
                             |
    ------------------------- + ------------------------ -----   
    Ultra sauer | unter 3,5
    ------------------------- + ------------------------ ------
    Extrem sauer | zwischen 3,5 und 4,4
    ------------------------- + ------------------------ ------
    Sehr stark sauer | zwischen 4,5 und 5,0
    ------------------------- + ------------------------ ------
    Stark sauer | zwischen 5.1 und 5.5
    ------------------------- + ------------------------ ------
    Mäßig sauer | zwischen 5.6 und 6.0
    ------------------------- + ------------------------ ------
    Leicht sauer | zwischen 6.1 und 6.5
    ------------------------- + ------------------------ ------
    Neutral | zwischen 6.6 und 7.3
    ------------------------- + ------------------------ ------
    Leicht alkalisch | zwischen 7.4 und 7.8
    ------------------------- + ------------------------ ------
    Mäßig alkalisch | zwischen 7.9 und 8.4
    ------------------------- + ------------------------ ------
    Stark alkalisch | zwischen 8,5 und 9,0
    ------------------------- + ------------------------ ------
    Sehr stark alkalisch | über 9,0

Geben Sie bei einer nicht negativen Dezimalzahl, die den pH-Wert eines Stoffes angibt, dessen Bezeichnung aus. Sie können die Eingabe und Ausgabe nach einer beliebigen Standardmethode vornehmen . Die Datentypen, mit denen Sie Eingaben vornehmen dürfen, sind:

• Schweben
• Doppelt
• Der Standarddatentyp für Dezimalzahlen in Ihrer Sprache
• String

Und Sie müssen einen String ausgeben, der den Nennwert darstellt. Chemie-bezogene Einbauten sind verboten (Sorry, Mathematica!) .

Annäherungsregel: Wenn der pH-Wert, den Sie erhalten, zwischen der Obergrenze eines Nennwerts und der Untergrenze des nächsten Werts liegt (z. B. zwischen 7,8 und 7,9), wird er auf den nächstgelegenen Wert zwischen den beiden Werten angenähert: wenn der pH-Wert ≥ der Obergrenze von zuerst + 0,5, dann sollte es den zweiten Nennwert erhalten, aber wenn der pH <obere Grenze des ersten + 0,5 ist, sollte es den ersten erhalten (z. B. 7,85 ist auf 7,9 angenähert, aber 7,84999 ist auf 7,8 angenähert). Weitere Informationen finden Sie in den Testfällen.

Testfälle:

Eingabe -> Ausgabe

6.40 -> Leicht sauer
8,399 -> Mäßig alkalisch
3.876 -> Extrem sauer
10,60 -> Sehr stark alkalisch     
0,012 -> Ultra sauer
7.30 -> Neutral
7,85 -> mäßig alkalisch (es gilt die Näherungsregel)
7.849 -> Leicht alkalisch (es gilt die Näherungsregel)
6.55 -> Neutral (die Annäherungsregel wird angewendet)

Das ist Code-Golf , also gewinnt die kürzeste gültige Einsendung (in Bytes)!

_{* Andrew hat sich das nicht ausgedacht, es war Wikipedia !}

Jelly ,  77 73  71 Bytes

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

Ein monadischer Link, der die Nummer aufnimmt und eine Liste von Zeichen zurückgibt. oder ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie?

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

Probieren Sie es 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];}

Probieren Sie es online!

Diese Lösung berücksichtigt, dass pnicht größer als 14 sein kann.

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

Die Eingabe erfolgt über eine bereits vorhandene Tabelle t mit DECIMAL(4,1)Spalte ein , gemäß unserer Input / Output Regeln .

Aufgrund des DECIMAL(4,1)Datentyps findet eine Rundung nach "Näherungsregeln" statt, wenn der Wert in die Eingabetabelle eingegeben wird, sodass er nicht explizit von meinem Code verwaltet werden muss.

Nach erfolgter Platzersparnis REPLACESist dies eine einfache SQL-Abfrage, die unsere Eingabetabelle mit unserer Werteliste verknüpft:

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

Ich kehre die Reihenfolge um, damit TOP 1der erste Wert kleiner als unser Eingabewert ist.

Auch dieses Formular (nach dem Entfernen von Zeilenumbrüchen und zusätzlichen Leerzeichen) ist mit 318 Byte ziemlich gut . Das Hinzufügen des Overheads von DECLARE, REPLACESAND EXEClohnt sich nur bei allen wiederholten Phrasen.

BEARBEITEN : Sparen Sie 6 Bytes, indem Sie unnötige ".0" für mehrere Werte entfernen

05AB1E , 81 80 79 77 76 74 Bytes

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

Probieren Sie es online!

Testsuite

Erläuterung

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

Netzhaut , 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

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

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

Multiplizieren Sie die Eingabe mit 100, indem Sie einen freien Dezimalpunkt und zwei Nullen anfügen und dann den Dezimalpunkt und alle bis auf zwei Ziffern danach löschen.

.+
$*

In Unary konvertieren.

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

Behandeln Sie alle Alkalien und wandeln Sie sie in Abkürzungen um, die später erweitert werden.

1{655,}
Neutral

Neutral behandeln.

1$
1 acidic

Alles, was übrig bleibt, muss sauer sein. (Belassen Sie jedoch die 1, falls der pH-Wert 0,001 beträgt.)

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

Behandeln Sie alle Säuren.

M
Moderately
V
Very sT
T
trongly
L
lightly
A
 alkaline

Erweitern Sie die Abkürzungen.

Python 2 , 202 Bytes

-15 Bytes dank @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))

Probieren Sie es online!

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

Testfälle

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

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

Ich spiele immer noch ein bisschen 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));