Lassen Sie uns etwas Boden-pH-Chemie lernen!

14

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 !

code-golf  string  chemistry 
— Mr. Xcoder
quelle
Sandbox für diejenigen, die gelöschte Beiträge sehen können.
— Mr. Xcoder
Ja, das funktioniert nicht wirklich mit dem tatsächlichen Säuregehalt. Alles, was saurer als Zitronensaft ist, ist extrem sauer
— Destructible Lemon
@DestructibleLemon Wenn Zitronensaft extrem sauer ist, dann ist Fluorantimonsäure , die sich wie −31.3 verhält, eine totale Atombombe :))
— Mr. Xcoder
Oh, ich verstehe, wo du falsch gelaufen bist. 3,5 ph ist nicht ultra sauer, aber es ist ultra sauer, wenn der Boden, in dem Sie Pflanzen anbauen, 3,5 ph ist. Was ich meine ist, diese Tabelle bezieht sich auf den Boden ph
— Destructible Lemon
1
Brownie Punkte für eine Antwort in Python oder Swift :)
— Mr. Xcoder

Antworten:

6

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
— Jonathan Allan
quelle
Ich mag immer die Konkurrenz zwischen 05AB1E und Jelly ... Nur 2 Bytes entfernt
— Mr. Xcoder
3
Jelly schlägt 05AB1E?!?!
— Erik der Outgolfer
5

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!

— Jörg Hülsermann
quelle
4

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.

— Charlie
quelle
4

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

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

— BradC
quelle
3

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
— Emigna
quelle
Dies ist überraschend lang für 05AB1E
— Mr. Xcoder,
Spät auf der Party, aber immer noch neugierig: Programmiert jemand direkt in dieser Sprache (auch wenn es nur um Code-Golf geht) oder ist dies die Ausgabe einer Art "Compiler"?
— Avl42
1
@ avl42: Wir codieren ja direkt in dieser Sprache (in der Regel natürlich nur zum Golfen). Ich würde es hassen, wenn jemand dies im Produktionscode verwendet;) Es ist eine interpretierte Sprache, sodass Code, den Sie in dieser Sprache schreiben, in Python-Code interpretiert wird.
— Emigna
1
@Emigna Ich würde sagen "übersetzt" anstatt "interpretiert" (es ist eine Art entgegengesetzte Bedeutung)
— anatolyg
@anatolyg: Ja, da hast du recht. Ich denke immer aus irgendeinem Grund interpretiert, wahrscheinlich aufgrund von Python. Es ist in eine interpretierte Sprache übersetzt :)
— Emigna
2

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.

— Neil
quelle
Wow, ich glaube, es hat eine Weile
— gedauert
2

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!

— ovs
quelle
2
Du hast meine Brownie-Punkte genommen.
— Mr. Xcoder
2

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

Code-Snippet anzeigen

— Arnauld
quelle
1

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",""))
— Wernisch
quelle
0

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));
Erweitern Sie das Snippet

— Thomas W
quelle
Ich glaube nicht, dass Sie die Funktion einer Variablen zuweisen müssen.
— Zacharý
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.