Wir leben in einem wundervollen Zeitalter der Technologie, in dem wir auf unseren Fernsehern wunderschön detaillierte 8K-Bildschirme und auf unseren Handys sogar 2K-Bildschirme für unser mobiles Surfvergnügen haben können. In den letzten Jahren haben wir in Bezug auf die Bildschirmtechnologie einen langen Weg zurückgelegt.

Eines der Produkte davon ist ein Begriff, der von Apple, Retina, populär gemacht wurde . Dies bezieht sich auf die Pixeldichte der fraglichen Anzeige, die so hoch ist, dass bei einem Betrachtungsabstand von 10 bis 12 Zoll einzelne Pixel nicht einfach herausgegriffen werden können.

Steve Jobs sagte, dass die Pixeldichte, bei der dies auftritt, ungefähr 300 Pixel pro Zoll beträgt , und sie begannen, Pixeldichten in diesem Bereich auf ihren Geräten mit dem für Werbung verwendeten Retina- Schlagwort zu verwenden.

Die Pixeldichte kann mit der folgenden Formel berechnet werden:

Wo dist die Diagonale des Bildschirms in Zoll, wist die Anzahl der Pixel auf der horizontalen Achse und hist die Anzahl der Pixel auf der vertikalen Achse.

Deine Aufgabe

Für diese Aufgabe verwenden Sie den Retina- Standard, um zu entscheiden, welche Produkte es wert sind, gekauft zu werden. Als der moderne Verbraucher, der Sie sind, möchten Sie beim Kauf von Geräten sicherstellen, dass Sie ein gutes Produkt erhalten, kein Gerät aus den 90er Jahren! Als solches möchten Sie ein Programm oder eine Funktion erstellen , die die Bildschirmbreite, -höhe und -diagonale als Eingabe- oder Funktionsparameter verwendet und Ihnen mitteilt, ob der jeweilige Bildschirm als Retina-Bildschirm ( D > 300) qualifiziert ist, indem Sie auf den Bildschirm drucken oder zurückkehren .

Aufgrund Ihrer Missachtung von Nicht-Retina-Geräten wird Ihr Programm oder Ihre Funktion ausgegeben, Retina!wenn sich das Gerät qualifiziert und Trash!wenn dies nicht der Fall ist.

Sie können davon ausgehen, dass alle Zahlen größer als 0 sind. Pixelwerte für Breite und Höhe sind immer ganze Zahlen. Die Bildschirmgröße kann beliebig interpretiert werden, sofern Dezimalstellen unterstützt werden. Die Eingabe kann in beliebiger Reihenfolge erfolgen und sich auch in bis zu 3 separaten Zeilen befinden.

Beispiel I / O

1920 1080 4.95   -> Retina!
2560 1440 5.96   -> Retina!
1920 1080 10.5   -> Trash!
10 10 0.04       -> Retina!
4096 2160 19(.0) -> Trash!
8192 4320 100.00 -> Trash!
3000 1500 11.18  -> Retina!
180 240 1(.0)    -> Trash!

Das ist Code-Golf , also gewinnt die geringste Anzahl von Bytes.

^{Hier ist eine Stuck-Lösung, eine stapelbasierte Programmiersprache, die ich mache:}

r;`;/300>"Retina!""Trash!"?

Pyth - 27 Bytes

Verwendet den ternären Operator und abszur Berechnung des Pythagoras.

?>c.avzQ300"Retina!""Trash!

Nimmt Eingaben in zwei Zeilen vor, erste Zeile width, height, zweite Zeile diag.

Die Regeln waren locker, also rollte sie zurück.

Probieren Sie es hier online aus .

Retina , 530 220 210 202 201 193 191 187 185 (184) Bytes

Dank an randomra für das Speichern von 3 Bytes! (Und ebnen den Weg für ein paar mehr.)

+`\.(\d)(.+)( .+)
$1.$2_$3_
\b
#
+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#
\d
11
(?=(1*)\1)[^.]
$1
^(1+)\.\1{90000}1+
Retina!
1.+
Trash!

Zu Zwecken der Byte-Zählung wird jede Zeile in eine separate Datei geschrieben. Sie können den obigen Code jedoch wie aus einer einzelnen Datei ausführen, indem Sie Retina mit dem -sFlag aufrufen .

Dies erwartet zuerst die Dichte (die einen Dezimalpunkt enthalten muss , auch wenn es sich um einen nachgestellten handelt), gefolgt von Breite und Höhe, d d w h. H.

Das ist etwas langsam. Ich würde die meisten Testfälle nicht ausprobieren, da sie ewig laufen werden. Sie können jedoch überprüfen, ob es mit den Testfällen ordnungsgemäß funktioniert

19. 4096 2160     -> Trash!
1. 180 240        -> Trash!
1. 181 240        -> Retina!
1. 180 241        -> Retina!
0.04 10 10        -> Retina!

Nach dem Multiplizieren aller Zahlen, um die Dichte zu einer Ganzzahl zu machen, soll die Breite und Höhe nicht mehr als 4 Stellen haben.

Dies ist zwar langsam, aber völlig genau ... es gibt keine Fließkomma-Probleme oder ähnliches. Alle Arithmetik verwendet (unäre) Ganzzahlen.

Im Prinzip könnte ich ein weiteres Byte ^weglassen : das kann weggelassen werden, aber es wird Trash!Testfälle aufgrund von übermäßig viel Backtracking schrecklich langsam machen .

Erläuterung

Zuerst ordnen wir die Ungleichung neu an, um Gleitkommaoperationen zu vermeiden:

√(w2 + h2) / d > 300
√(w2 + h2) > 300 d
w2 + h2 > 90000 d2

Wir können auch feststellen , dass diese invariant unter Multiplikation ist w, hund ddurch die gleiche Anzahl x:

w2 + h2 > 90000 d2
(x w)2 + (x h)2 > 90000 (x d)2
x2 (w2 + h2) > 90000 x2 d2
w2 + h2 > 90000 d2

Es gibt verschiedene Möglichkeiten, eine unäre Zahl zu quadrieren, aber wir werden die Identität nutzen

n2 = Σi=1..2n ⌊i/2⌋

Dies gibt uns eine Möglichkeit, das Problem nur mit einer Ganzzahlarithmetik (die Ganzzahlen in Unary darstellt) zu lösen.

Lass uns den Code durchgehen. Jedes Zeilenpaar ist eine reguläre Ersetzung.

+`\.(\d)(.+)( .+)
$1.$2_$3_

Dadurch wird der Dezimalpunkt in der Dichte wiederholt nach rechts verschoben, während Breite und Höhe mit 10 multipliziert werden (siehe xoben). Dies soll sicherstellen, dass alle Zahlen Ganzzahlen sind. Anstatt Nullen anzufügen, füge ich Nullen hinzu, _die ich später als Null behandeln werde. (Dies ist ein Golf-Trick, da ich sonst schreiben müsste ...${3}0, um Mehrdeutigkeiten zu vermeiden $30.) Das +vor der Regex weist Retina an, diese Ersetzung zu wiederholen, bis sich das Ergebnis nicht mehr ändert (was der Fall ist, wenn das Muster nicht mehr übereinstimmt). .

\b
#

Wir bereiten die drei Zahlen für die Umwandlung in Unary vor. Grundsätzlich benötigen wir einen Marker (das #) vor jeder Zahl, aber es ist auch kürzer, einen am Ende jeder Zahl hinzuzufügen, was den Konvertierungsschritt nicht beeinflusst.

+`(\d*)#((((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|\w)
$1$1$1$1$1$1$1$1$1$1$3$4$5$6$7$8$9$10$11#

Dies ist die Umstellung auf Unary mit einem von dan1111 entwickelten Trick . Im Wesentlichen übersetze ich jede Ziffer in eine Wiederholungsziffer für sich selbst, während ich die vorhandenen Ziffern mit 10 multipliziere (dabei bewege ich den #Marker nach rechts). Diese binäre Darstellung ist ein Durcheinander verschiedener Ziffern, aber die Gesamtzahl entspricht dem Wert der ursprünglichen Ganzzahl. Beachten Sie die \wam Ende - normalerweise ist dies nur 0, aber wir möchten auch _als Null behandeln (was in regulären Ausdrücken als Wortzeichen betrachtet wird).

\d
11

Wir wandeln jede Ziffer in zwei 1s um, um a) sicherzustellen, dass alle Ziffern gleich sind (was später erforderlich sein wird) und b) jede der Zahlen zu verdoppeln.

(?=(1*)\1)[^.]
$1

Dies führt zu zwei Dingen: Es quadriert alle Zahlen (oder vielmehr die Hälfte jeder Zahl, indem eine Summe berechnet wird 2n) und addiert die resultierenden Quadrate der Breite und der Höhe. Beachten Sie, dass s, Markierungen und Leerzeichen [^.]übereinstimmen . Wenn es sich um ein oder ein Leerzeichen handelt, erfasst der Lookahead nichts. Dies bedeutet, dass alle Elemente einfach entfernt werden, dh die Ergebnisse für die Breite und Höhe werden verkettet / hinzugefügt. Das Komma bleibt, um das Ergebnis von diesen zu trennen . Wenn Streichhölzer ein statt, dann sind die Look - Ahead stellt sicher , dass wir capture Hälfte der s , nachdem es (abgerundet) in der Gruppe . Dies berechnet die oben erwähnte Summe, die dann das Quadrat der ursprünglichen Zahl ergibt.1##.d[^.]111

^(1+)\.\1{90000}1+
Retina!

Die Zeichenfolge ist jetzt (in unary), dann , dann (in unary). Wir wollen wissen, ob die erste unäre Zahl kürzer ist als die zweite. Wir können diese Multiplikation leicht mit einer Erfassungsgruppen- und Wiederholungssyntax durchführen. Wir verwenden (anstatt ) danach, um sicherzustellen, dass die zweite Zahl tatsächlich größer als diese und nicht gleich ist. Wenn ja, ersetzen wir das alles durch .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Wenn die zweite Zahl nicht groß genug war, hat der vorherige Schritt nichts geändert und die Zeichenfolge beginnt immer noch mit einem 1. In diesem Fall ersetzen wir einfach die gesamte Zeichenfolge durch Trash!und sind fertig.

Python, 49

lambda w,h,d:"RTertaisnha!!"[w*w+h*h<=9e4*d*d::2]

Verwendet String-Interleaving.

Es stellte sich heraus, dass es kürzer war, beide Seiten zu quadrieren, als die komplexe Norm zu verwenden.

w*w+h*h<=9e4*d*d
abs(w+1j*h)<=300*d

Retina , 312 Bytes

(\d+) (\d+) (\d+)(?:\.(\d+))?
a$1bc$2dj300ke$3fg$4h9iiiiiiiii8iiiiiiii7iiiiiii6iiiiii5iiiii4iiii3iii2ii1i0
+`(b.*)(d.*)fg(\d)
0$10$2$4fg
+`(a|c|e|j)(\d)(\d*)(i*)((?:b|d|f|k).*h.*\2(i*))
$1$3$4$4$4$4$4$4$4$4$4$4$6$5
g`(i+)
Q$1R$1
+`Q(i+)Ri
$1Q$1R
+`(j(i*).*e)i(.*f)
$1$3$2
a(i*).*c(i*).*f\1\2.*
Trash!
.*0
Retina!

Das dauert eine Weile, aber es scheint zu funktionieren.

Könnte wohl noch viel mehr golfen werden ...

Erläuterung:

(\d+) (\d+) (\d+)(?:\.(\d+))?
a$1bc$2dj300ke$3fg$4h9iiiiiiiii8iiiiiiii7iiiiiii6iiiiii5iiiii4iiii3iii2ii1i0

Fügen Sie Tags hinzu, um das Parsen der Zeichenfolge zu vereinfachen, und fügen Sie Junk hinzu, um die Konvertierung in Basis 1 zu vereinfachen, und fügen Sie 300 hinzu, um sie mit später zu multiplizieren

+`(b.*)(d.*)fg(\d)
0$10$2$4fg

Fügen Sie 0s an die Breite und Höhe an, während Sie den Dezimalteil der Diagonale an den ganzzahligen Teil anhängen. In diesem Fall ist die Diagonale eine ganze Zahl, und Breite und Höhe werden mit den 10erforderlichen Werten multipliziert .

+`(a|c|e|j)(\d)(\d*)(i*)((?:b|d|f|k).*h.*\2(i*))
$1$3$4$4$4$4$4$4$4$4$4$4$6$5

Konvertieren Sie alle Zahlen zur Basis 1, indem Sie die im ersten Schritt angehängte Nachschlagetabelle verwenden

g`(i+)
Q$1R$1

Bereiten Sie sich darauf vor, alle Zahlen zu quadrieren

+`Q(i+)Ri
$1Q$1R

Quadrieren Sie jede Zahl

+`(j(i*).*e)i(.*f)
$1$3$2

Multiplizieren Sie das Quadrat der Diagonale mit dem Quadrat der 300, die Sie im ersten Schritt eingefügt haben

a(i*).*c(i*).*f\1\2.*
Trash!

Wenn die an die Höhe angehängte Breite in das gerade berechnete Produkt passt, ist die Pixeldichte zu niedrig und es handelt sich um Papierkorb!

.*0
Retina!

Ansonsten ist es Retina!

CJam, 30 29 27 Bytes

q~mh300/<"Retina""Trash"?'!

Erfordert die Eingabe in Form von diagonal width height

UPDATE: 1 Byte gespart dank Dennis!

Probieren Sie es hier online aus

APL, 40 36 Bytes

4 Bytes gespart dank Dennis!

{(9E4×⍵*2)<+/⍺*2:'Retina!'⋄'Trash!'}

Dies erzeugt eine unbenannte dyadische Funktion, die die ersten beiden Argumente links und das dritte rechts übernimmt. Es wird geprüft, ob die Summe der Quadrate der linken Werte größer ist als das 300-fache des Quadrats der rechten. Die Ausgabe wird entsprechend gedruckt.

Sie können es online ausprobieren !

TI-BASIC, 43

Legt Breite und Höhe als Liste mit zwei Elementen über den Homescreen und diagonal über die Eingabe fest.

Input D
If 300D>√(sum(Ans²
Then
Disp "Retina!
Else
"Trash!

Die 2-Byte-Kleinbuchstaben von TI-BASIC addieren 7 Byte (da ies sich um die imaginäre Einheit handelt, die aus einem Byte besteht), wodurch die Wettbewerbsfähigkeit beeinträchtigt wird. Zum Glück !ist auch ein Byte, weil es die Fakultätsfunktion darstellt.

JavaScript ES6, 49 Byte

(w,h,d)=>Math.hypot(w,h)/d>300?'Retina!':'Trash!'

Ich hasse es, dass JavaScript so lange mathematische Operatoren hat. Aber selbst wenn es einen Math.pythagoreangäbe, wäre dieser kürzer.

Excel, 44 Bytes

Geben Sie Ihre Eingaben in diese Zellen ein.

• A1 = Breite in Pixel
• B1 = Höhe in Pixel
• C1 = Diagonale in Zoll

Und diese Formel gibt Ihr Ergebnis:

=IF((300*C1)^2<A1^2+B1^2,"Retina!","Trash!")

Prolog, 51 Bytes

a(W,H,D,R):-9e4*D*D<W*W+H*H,R="Retina!";R="Trash!".

Laufende a(8192,4320,100.0,R).Ausgaben:R = "Trash!" .

Edit: Danke an @PaulButcher für das Korrigieren eines Edge-Cases und das Golfen eines Bytes.

JavaScript (ES6), 45 Byte

f=(w,h,d)=>w*w+h*h>d*d*9e4?'Retina!':'Trash!'

CoffeeScript, 47 Bytes

Kein ternärer Operator, aber es gibt eine Potenzierung (die beim letzten Versuch nicht hilft).

f=(w,h,d)->w*w+h*h>d*d*9e4&&'Retina!'||'Trash!'

# Previous attempt
f=(w,h,d)->(w*w+h*h)**.5/d>300&&'Retina!'||'Trash!'

O , 40 37 Bytes

jjjrmd \ / 'īu> {"Retina!" p} {"Trash!" p}?

Viele Bytes für die Eingabeformatierung: \

Probieren Sie es online aus

Pure Bash (kein bc / andere externe Befehle), 138 136 135 82 83 Bytes

a=${3#*.}
d=${a//?/0}
r=(Trash Retina)
echo ${r[$1$d**2+$2$d**2>90000*${3/./}**2]}!

Ich beschloss, es in purer Bash zu versuchen. Ich habe wahrscheinlich ein paar offensichtliche Ineffizienzen gemacht, da dies mein erstes Mal Code-Golfen ist, aber ich bin SEHR vertraut mit Bash und hatte in der Vergangenheit Spaß daran, Dinge zu schreiben, die keine externen Befehle verwenden (dh reine Bash).

Die printf-Anweisung ist am ärgerlichsten. Hat jemand bessere Ideen für das Auffüllen von Zahlen mit Nullen?

BEARBEITEN: Zwei Bytes gespeichert. Es stellt sich heraus, dass printf ein leeres Argument für Null akzeptiert. Hat ein weiteres Byte gespeichert, hat sich herausgestellt, dass ich zuvor falsch gezählt habe, und die Ausgabe von printf nur einer Variablen zuzuweisen, ist kleiner als die Verwendung von -v.

EDIT2: Dank Digital Trauma in den Kommentaren ist dies jetzt viel deutlicher gesunken. Tricks: Verwenden Sie die Regex-Unterstützung von bash, um die Ziffernfolge durch Nullen zu ersetzen, anstatt sie zu zählen, und drucken Sie dann diese Anzahl von Nullen aus (scheint offensichtlich, wenn ich es so ausdrücke ...). Speichern Sie die Zeichenfolgen in einem Bash-Array, um ein Echo zu speichern. und unter Berücksichtigung einer geringfügigen Änderung der Regeln, dh Sie können alle eingegebenen Zahlen in .0 beenden.

EDIT3: Ein Byte wurde hinzugefügt, um den Fehler zu beheben, der durch die vorgeschlagene Änderung von Digital Trauma verursacht wurde.

Gleichstrom, 41 Bytes

[[Retina!]pq]sr?d*rd*+vr/300<r[Trash!]p

Benötigt die Eingabe von Argumenten in der richtigen d, w, hReihenfolge - ich hoffe, das ist in Ordnung.

Testausgang:

$ for t in \
> "4.95 1920 1080" \
> "5.96 2560 1440" \
> "10.5 1920 1080" \
> "0.04 10 10" \
> "19 4096 2160" \
> "100.00 8192 4320" \
> "11.18 3000 1500" ; do \
> echo $t | dc -e'9k[[Retina!]pq]sr?d*rd*+vr/300<r[Trash!]p'
> done
Retina!
Retina!
Trash!
Retina!
Trash!
Trash!
Retina!
$ 

Julia, 46 45 42 Bytes

f(w,h,d)=w^2+h^2>9e4d^2?"Retina!":"Trash!"

Dadurch wird eine Funktion erstellt, die drei numerische Werte akzeptiert und eine Zeichenfolge zurückgibt.

Es ist eine direkte Implementierung der Formel, die nur ein wenig umgestellt wurde. Beide Seiten der Ungleichung wurden ddann zum Quadrat multipliziert .

R 59 55 Bytes

Als unbenannte Funktion jetzt

function(h,w,d)if(h^2+w^2>9e4*d^2)'Retina!'else'Trash!'

Sehr einfache Implementierung, bei der keine Indexverweise erforderlich sind.

Bisherige

cat(if((n=scan()^2)[1]+n[2]>9e4*n[3])'Retina!'else'Trash!')

Ziemlich einfach ist es, die Eingabe vom Scan in einen Vektor zu übertragen (einzeilig, durch Leerzeichen getrennt oder mehrzeilig). Quadrieren Sie den Vektor. Mach die Berechnung und kater das Ergebnis.

MATLAB - 49 45 Bytes

c={'Trash!','Retina!'};c{(w*w+h*h>9e4*d*d)+1}

Ich musste zuerst ein Zellenarray deklarieren, das die Positionen 1 und 2 des Zellenarrays enthält Trash!und in Retina!diesen gespeichert ist. Als nächstes benutze ich die Beobachtung, die von vielen beobachtet wurde, um die Gleichung neu zu ordnen, so dass Sie die Bedingung nur mit Ganzzahlarithmetik überprüfen. Ich habe 90000 dargestellt 9e4, um einige Bytes zu sparen. Wenn diese Bedingung erfüllt ist, geben wir eine 1 aus, ansonsten eine 0. Mit dieser Ausgabe indiziere ich direkt in das Zellenarray. Da MATLAB mit der Indizierung bei 1 beginnt, musste ich auch 1 hinzufügen, um die Indizierung abzuschließen. Was schön ist, ist, dass das Hinzufügen truemit 1 2 ergibt, während das Hinzufügen falsemit 1 1 ergibt. Dies wird entweder Trash!oder Retina!in der MATLAB-Eingabeaufforderung ausgegeben .

Beispiel

>> w=1920;h=1080;d=4.95;
>> c={'Trash!','Retina!'};c{(w*w+h*h>9e4*d*d)+1}

ans =

Retina!

XSLT, 400 Bytes

Dies ist das Debüt einer noch nie dagewesenen Sprache bei PPCG, und ich hoffe, dass ich sie in Zukunft mehr verwenden kann, wenn ich sie näher kennenlerne.

Code:

<?xml version="1.0" encoding="UTF-8"?><xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template match="input"><xsl:variable name="n" select="for $i in tokenize(.,'[^\d\.]+')return number($i)" /><xsl:choose><xsl:when test="$n[1]*$n[1]+$n[2]*$n[2]>90000*$n[3]*$n[3]">Retina!</xsl:when><xsl:otherwise>Trash!</xsl:otherwise></xsl:choose></xsl:template></xsl:stylesheet>

Ziemlich gedruckt

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="input">
        <xsl:variable name="n" select="for $i in tokenize(.,'[^\d\.]+')return number($i)" />
        <xsl:choose>
            <xsl:when test="$n[1]*$n[1]+$n[2]*$n[2]>90000*$n[3]*$n[3]">
                Retina!
            </xsl:when>
            <xsl:otherwise>
                Trash!
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
</xsl:stylesheet>

Anmerkungen:

Da XSLT keine Möglichkeit zur Eingabe über STDIN bietet, müssen wir eine XML-Datei verwenden, bei der die Eingabe zwischen zwei <input>Tags erfolgt. Natürlich hat diese Methode ihre Grenzen, aber für die meisten Herausforderungen funktioniert sie einwandfrei.

Beispiel I / O

Eingabedatei:

<?xml version="1.0" encoding="ISO-8859-1"?>
<input>3000 1500 11.18</input> 

Ausgabedatei:

<?xml version="1.0" encoding="UTF-8"?>Retina!

Eingabedatei:

<?xml version="1.0" encoding="ISO-8859-1"?>
<input>1920 1080 10.5</input>

Ausgabedatei:

<?xml version="1.0" encoding="UTF-8"?>Trash!

C # (81)

string D(int w,int h,double d){return Math.Sqrt(w*w+h*h)/d>300?"Retina":"Trash";}

Ungolfed:

string Density(int width, int height, double diagonal)
{
    return Math.Sqrt(width * width + height * height) / diagonal > 300 ? "Retina" : "Trash";
}

Schnell, 77 Bytes

Deklarationen von Funktionsparametern bedeuten, dass dies viel mehr Zeichen erfordert, als es sollte:

func r(w:Float,h:Float,d:Float){print((w*w+h*h)>9e4*d*d ?"Retina!":"Trash!")}

Schnell, 56 Bytes

let r={print($0*$0+$1*$1>9e4*$2*$2 ?"Retina!":"Trash!")}

Grundsätzlich dasselbe wie bei GoatInTheMachine , jedoch mit impliziten Schließparametern

Wenn Code Golfing mit Swift immer solche Methoden deklariert, ist es viel kürzer

Haskell, 46

f w h d|w^2+h^2>d^2*9e4="Retina!"|0<1="Trash!"

C ++ 72 70 Byte

void F(int w,int h,float d){cout<<w*w+h*h>9e4*d*d?"Retina!":"Trash!";}

Ähnlich wie bei anderen Lösungen habe ich mich mit Codegolf aufgewärmt.

Hier ist mein Beitrag für dieses Problem

Ruby, 67 Bytes, die von stdin lesen

w,h,d=ARGV.map{|v|Float(v)}
puts w*w+h*h>d*d*9e4?"Retina!":"Trash!"

Ruby, 56 Bytes in einer Funktion

Ein bisschen kürzer

def r(w,h,d)
puts w*w+h*h>d*d*9e4?"Retina!":"Trash!"
end

Vielen Dank an die bisherigen Mitwirkenden für den 9e4!

Code-Golf Rubin

Bash, 85 Bytes

if [ $(echo "sqrt($1^2+$2^2)/$3"|bc) -gt 300 ];then
echo Retina!
else
echo Trash!
fi

PHP, 47 , 43 , 40, 38 Bytes

<?=sqrt($w*$w+$h*$h)/$d>300?'Retina':'Trash'?>!
<?=sqrt($w*$w+$h*$h)/$d>300?Retina:Trash?>!
<?=$w*$w+$h*$h>9e4*$d*$d?Retina:Trash?>!

<?=hypot($w,$h)/$d>300?Retina:Trash?>!

Benötigt register_globals==true(was es niemals sein sollte!), Mit GET-Werten w, h, d
- 4 Bytes durch Entfernen von Anführungszeichen um den String gespeichert. Schlechte Codierung, aber es funktioniert.
- Verschoben dund Quadratwurzel auf die andere Seite der Gleichung, Speichern der sqrt()Funktion
- 2 Bytes durch Umschalten auf gespeichert hypot()(danke Lucas Costa)

C # 6, 67 Bytes

string D(int w,int h,double d)=>w*w+h*h>9e4*d*d?"Retina!":"Trash!";

Diese Antwort basiert auf der Antwort von Wolfsheads. Ich habe es mit einer neuen Funktion von C # 6 um 8 Bytes kürzer gemacht.

JavaScript (ES6) 58 54 43 Bytes

43 Bytes

Funktionszuweisung (gemäß PPCG-Regeln) entfernt (-2) sowie Quadratwurzel entfernt und mit 900 (300 ^ 2) verglichen (-12)

(w,h,d)=>w*w+h*h/d*d>300?"Retina!":"Trash!"

54 Bytes

Unnötige Klammern (-4 Bytes) loswerden

a=(w,h,d)=>Math.sqrt(w*w+h*h)/d>300?"Retina!":"Trash!"

58 Bytes

a=(w,h,d)=>Math.sqrt((w*w)+(h*h))/d>300?"Retina!":"Trash!"

Erklärung hier:

a =                           // The function is a
 (w,h,d) =>                   // Accepts the three arguments
   Math.sqrt((w*w)+(h*h))/d   // Calculate pixel density
   > 300                      // Above the threshold
   ? "Retina!"                // If so, return "Retina!"
   : "Trash!"                 // Otherwise return "Trash!"

Hierbei werden ternäre Operatoren verwendet , um die Dichte zu testen, und mithilfe von Pfeilfunktionen werden einige Bytes gelöscht

Java, 82 74 Bytes

String g(int w,int h,double d){return 9e4*d*d>w*w+h*h?"Trash!":"Retina!";}

Nennen Sie es mit g(width,height,diagonal)

Clojure, 58 Bytes

#(if(>(+(* %1%1)(* %2%2))(* %3%3 90000))"Retina!""Trash!")

Benutzt @ Kroltans ausgefallene Mathematik, um dies zu verkürzen. Verwendet implizite Argumente, die in der Reihenfolge (w, h, d) übergeben werden.

Erste Clojure Golf ... Ich war überrascht, wie viel Leerzeichen ich auslassen darf