Żyjemy w cudownym wieku technologii, w którym możemy mieć pięknie szczegółowe ekrany 8K na naszych telewizorach, a nawet wyświetlacze 2K na naszych telefonach dla przyjemności przeglądania mobilnego. W ostatnich latach przeszliśmy długą drogę pod względem technologii ekranów.

Jednym z produktów tego terminu jest popularna przez Apple nazwa Retina . Odnosi się to do tak dużej gęstości pikseli danego wyświetlacza, że ​​przy odległości oglądania 10-12 cali od siebie poszczególne piksele nie mogą być łatwo wybrane.

Steve Jobs powiedział, że gęstość pikseli tam, gdzie ma to miejsce, wynosi około 300 pikseli na cal , i zaczęli stosować gęstości pikseli w tym zakresie na swoich urządzeniach z modnym hasłem Retina używanym do reklamy.

Gęstość pikseli można obliczyć za pomocą następującego wzoru:

Gdzie djest przekątna ekranu w calach, wto liczba pikseli na osi poziomej i hliczba pikseli na osi pionowej.

Twoje zadanie

Do tego zadania użyjesz standardu Retina, aby zdecydować, które produkty warto kupić. Będąc nowoczesnym konsumentem, którym jesteś, kupując urządzenia, chcesz mieć pewność, że otrzymujesz dobry produkt, a nie jakieś urządzenie z lat 90.! Jako taki, chcesz zbudować program lub funkcję, która przyjmuje szerokość, wysokość i długość przekątnej ekranu jako parametry wejściowe lub funkcyjne i informuje, czy dany ekran kwalifikuje się jako ekran siatkówki ( D > 300), drukując na ekranie lub powracając .

Z powodu twojej pogardy dla urządzeń innych niż Retina, twój program lub funkcja wyświetli się, Retina!gdy urządzenie się zakwalifikuje, a Trash!kiedy nie.

Możesz założyć, że wszystkie liczby będą większe niż 0. Wartości w pikselach dla szerokości i wysokości będą zawsze liczbami całkowitymi. Rozmiar ekranu można interpretować w dowolny sposób, o ile obsługuje on ułamki dziesiętne. Dane wejściowe mogą być w dowolnej wybranej przez ciebie kolejności, a także mogą składać się maksymalnie z 3 oddzielnych linii.

Przykład 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!

To jest golf golfowy , więc wygrywa najmniejsza liczba bajtów.

^{Oto rozwiązanie Stuck, które tworzę: język programowania oparty na stosie:}

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

Pyth - 27 bajtów

Używa operatora trójskładnikowego i absoblicza pitagorejczyków.

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

Pobiera dane w dwóch wierszach, pierwszym wierszu width, heighti drugim wierszu diag.

Zasady były rozluźnione, więc wycofano się.

Wypróbuj online tutaj .

Retina , 530 220 210 202 201 193 191 187 185 (184) bajtów

Kredyty dla randomra za zapisanie 3 bajtów! (I torując drogę jeszcze kilku.)

+`\.(\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!

Do celów liczenia bajtów każda linia przechodzi do osobnego pliku, ale można uruchomić powyższy kod z pojedynczego pliku, wywołując Retinę z -sflagą.

Oczekuje się najpierw gęstości (która musi zawierać kropkę dziesiętną, nawet jeśli jest to kropka), a następnie szerokości i wysokości, tj d w h.

To jest trochę powolne. Nie wypróbowałbym większości podanych przypadków testowych, ponieważ będzie działał przez wieki. Możesz jednak sprawdzić, czy działa poprawnie z przypadkami testowymi

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

Zasadniczo po pomnożeniu wszystkich liczb, aby gęstość była liczbą całkowitą, nie chcesz, aby szerokość i wysokość składały się z więcej niż 4 cyfr.

Chociaż jest to powolne, jest całkowicie dokładne ... nie ma żadnych problemów ze zmiennoprzecinkowymi ani nic podobnego. Cała arytmetyka używa (jednych) liczb całkowitych.

Zasadniczo mógłbym ogolić jeszcze jeden bajt: ^można go pominąć, ale spowoduje to, że Trash!przypadki testowe będą strasznie wolne z powodu nadmiernej ilości cofania.

Wyjaśnienie

Po pierwsze, zmieńmy kolejność nierówności, aby uniknąć operacji zmiennoprzecinkowych:

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

Możemy również zauważyć, że jest to niezmienna pod pomnożenie w, ha dprzez ten sam numer 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

Istnieje kilka sposobów, aby obliczyć jednoznaczną liczbę, ale wykorzystamy tożsamość

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

To daje nam sposób na rozwiązanie problemu przy użyciu tylko arytmetyki liczb całkowitych (reprezentujących liczby całkowite w jedności).

Przejdźmy przez kod. Każda para linii jest podstawieniem wyrażenia regularnego.

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

Powoduje to kilkakrotne przesunięcie punktu dziesiętnego gęstości w prawo, mnożąc szerokość i wysokość przez 10 ( xpowyżej). Ma to na celu zapewnienie, że wszystkie liczby są liczbami całkowitymi. Zamiast dopisywać zera, dołączam _, co będę później traktować jako zero. (Jest to sztuczka golfowa, ponieważ w przeciwnym razie musiałbym pisać, ...${3}0aby uniknąć dwuznaczności $30.) +Przed regex mówi Retinie, aby powtarzała tę zamianę, dopóki wynik nie przestanie się zmieniać (co ma miejsce, gdy wzór już nie pasuje) .

\b
#

Przygotowujemy teraz trzy liczby do konwersji na jednoargumentowe. Zasadniczo potrzebujemy znacznika ( #) przed każdą liczbą, ale krótsze jest również dodanie jednego na końcu każdej liczby, co nie wpłynie na krok konwersji.

+`(\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#

Jest to konwersja na unary, przy użyciu sztuczki opracowanej przez dan1111 . Zasadniczo tłumaczę każdą cyfrę na samą cyfrę rep, jednocześnie mnożąc istniejące cyfry przez 10 (przesuwając #znacznik w prawo w trakcie procesu). Ta reprezentacja binarna będzie zbiorem różnych cyfr, ale całkowita liczba będzie równa wartości oryginalnej liczby całkowitej. Zwróć uwagę \wna koniec - zwykle jest to po prostu 0, ale chcemy również traktować _jako zero (co jest uważane za znak słowny w wyrażeniu regularnym).

\d
11

Zamieniamy każdą cyfrę na dwie 1s, tym samym a) upewniając się, że wszystkie cyfry są takie same (co będzie konieczne później) ib) podwajając każdą z liczb.

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

Robi to dwie rzeczy: obciąża wszystkie liczby (a raczej połowę każdej liczby, obliczając sumę 2n) i dodaje wynikowe kwadraty szerokości i wysokości. Zauważ, że [^.]pasuje do 1s, #znaczników i spacji. Jeśli jest to a #lub spacja, lookahead nie przechwyci niczego, co oznacza, że ​​wszystkie są po prostu usuwane, tj. Wyniki dla szerokości i wysokości są łączone / dodawane. .Pozostaje przecinek dziesiętny, aby oddzielić wynik dod tych. Jeśli [^.]pasuje 1zamiast, to lookahead zapewnia, że ​​przechwycimy połowę 1sekundy po nim (zaokrągloną w dół) w grupie 1. To oblicza sumę, o której wspomniałem powyżej, która następnie da kwadrat pierwotnej liczby.

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

Łańcuch jest teraz (w jedności), a następnie (w unary). Chcemy wiedzieć, czy pierwsza liczba jednoargumentowa jest krótsza niż druga. Możemy z łatwością dokonać tego zwielokrotnienia za pomocą składni grupy przechwytywania i powtarzania. Następnie używamy (zamiast ), aby upewnić się, że druga liczba jest rzeczywiście większa od tej, a nie tylko równa. Jeśli tak, zamieniamy to wszystko na .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Jeśli druga liczba nie była wystarczająco duża, to poprzedni krok nic nie zmieni, a ciąg znaków zacznie się od litery 1. Jeśli tak jest, po prostu zastępujemy cały ciąg znaków Trash!i gotowe.

Python, 49

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

Wykorzystuje przeplatanie ciągów.

Okazało się, że krótszy jest kwadrat po obu stronach niż użycie złożonej normy.

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

Siatkówka , 312 bajtów

(\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!

Uruchomienie zajmuje sporo czasu, ale wydaje się, że działa.

Prawdopodobnie można by grać w golfa o wiele więcej ...

Wyjaśnienie:

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

Dodaj tagi, aby ułatwić analizowanie ciągu, i dodaj trochę śmieci, aby ułatwić konwersję do bazy 1, i dodaj 300, aby pomnożyć później

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

Dołącz 0s do szerokości i wysokości, jednocześnie dołączając dziesiętną część przekątnej do części całkowitej. Gdy to nastąpi, przekątna będzie liczbą całkowitą, a szerokość i wysokość zostaną pomnożone przez liczbę 10koniecznych s.

+`(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

Konwertuj wszystkie liczby na bazę 1, korzystając z tabeli odnośników, którą załączyłem w pierwszym kroku

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

Przygotuj do kwadratu wszystkie liczby

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

Kwadrat każdej liczby

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

Pomnóż kwadrat przekątnej przez kwadrat 300, który wstawiliśmy w pierwszym kroku

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

Jeśli szerokość dołączona do wysokości pasuje do właśnie obliczonego produktu, gęstość pikseli jest zbyt niska i jest to Kosz!

.*0
Retina!

W przeciwnym razie jest to siatkówka!

CJam, 30 29 27 bajtów

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

Wymaga, aby dane wejściowe miały postać diagonal width height

AKTUALIZACJA: 1 bajt zapisany dzięki Dennisowi!

Wypróbuj online tutaj

APL, 40 36 bajtów

Zaoszczędź 4 bajty dzięki Dennisowi!

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

Tworzy to nienazwaną funkcję dyadyczną, która przyjmuje dwa pierwsze argumenty po lewej i trzeci po prawej. Sprawdza, czy suma kwadratów lewych wartości jest większa niż 300 ^ 2 razy kwadrat kwadratu prawej. Dane wyjściowe są odpowiednio drukowane.

Możesz spróbować online !

TI-BASIC, 43

Przeciąga szerokość i wysokość przez ekran główny jako listę dwóch elementów, a przekątna przez wejście.

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

Dwubajtowe małe litery TI-BASIC-a dodają 7 bajtów ( iponieważ jest to jednostka wyobrażona, to jeden bajt), co powoduje, że jest dość niekonkurencyjny. Na szczęście !jest również jeden bajt, ponieważ reprezentuje funkcję silni.

JavaScript ES6, 49 bajtów

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

Nienawidzę tego, że JavaScript ma tak długie operatory matematyczne. Ale nawet gdyby tak było, Math.pythagoreanbyłoby to krótsze.

Excel, 44 bajty

Wpisz swoje dane wejściowe w tych komórkach.

• A1 = szerokość w pikselach
• B1 = wysokość w pikselach
• C1 = Przekątna w calach

A ta formuła daje wynik:

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

Prolog, 51 bajtów

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

a(8192,4320,100.0,R).Wyjścia bieżące :R = "Trash!" .

Edycja: Dzięki @PaulButcher za poprawienie wielkości krawędzi i golfowanie o jeden bajt.

JavaScript (ES6), 45 bajtów

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

CoffeeScript, 47 bajtów

Brak operatora trójskładnikowego, ale występuje potęgowanie (co nie pomaga w ostatniej próbie).

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

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

Wiele bajtów do formatowania wejściowego: \

Wypróbuj online

Pure Bash (bez bc / innych poleceń zewnętrznych), 138 136 135 82 83 bajtów

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

Postanowiłem spróbować to zrobić w czystym stylu. Prawdopodobnie zrobiłem kilka oczywistych nieefektywności, ponieważ jest to mój pierwszy raz w golfa kodem, ale jestem BARDZO obeznany z bashem i bawiłem się w przeszłości próbując pisać rzeczy, które nie używają żadnych zewnętrznych poleceń (tj. Czystego basha).

Instrukcja printf jest najbardziej denerwująca. Czy ktoś ma lepsze pomysły na wypełnianie liczb zerami?

EDYCJA: Zapisano dwa bajty, okazuje się, że printf weźmie pusty argument na zero. Zapisałem kolejny bajt, okazuje się, że wcześniej źle przeliczyłem i po prostu przypisanie wyjścia printf do zmiennej jest mniejsze niż użycie -v.

EDYCJA 2: Dzięki Digital Trauma w komentarzach jest to teraz znacznie bardziej znaczące. Sztuczki: użycie obsługi wyrażeń regularnych basha w celu zastąpienia ciągu cyfr zerami zamiast liczenia go, a następnie wydrukowanie tej liczby zer (wydaje się oczywiste, gdy tak to umieszczam ...), przechowywanie ciągów w tablicy bash w celu zapisania echa, i biorąc pod uwagę niewielką zmianę reguł, co oznacza, że ​​możesz zakończyć wszystkie liczby wejściowe w .0.

EDYCJA 3: Dodano bajt, aby naprawić błąd wprowadzony przez sugerowaną modyfikację Digital Trauma.

dc, 41 bajtów

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

Wymaga wprowadzenia argumentów w d, w, hkolejności - mam nadzieję, że to jest w porządku.

Wyjście testowe:

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

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

Tworzy to funkcję, która akceptuje trzy wartości liczbowe i zwraca ciąg znaków.

Jest to bezpośrednia implementacja formuły, tylko nieco zmieniona. Obie strony nierówności zostały dnastępnie pomnożone przez kwadrat.

R, 59 55 bajtów

Teraz jako funkcja bez nazwy

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

Bardzo prosta implementacja, która eliminuje potrzebę odwołań do indeksu.

Poprzedni

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

Dość proste, uzyskaj dane wejściowe ze skanowania do wektora (pojedyncza linia, spacja oddzielona lub wieloliniowa). Kwadrat wektora. Wykonaj obliczenia i sprawdź wynik.

MATLAB - 49 45 bajtów

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

Najpierw musiałem zadeklarować tablicę komórek, która zawiera Trash!i Retina!która jest przechowywana w miejscach 1 i 2 w tablicy komórek. Następnie wykorzystuję obserwację obserwowaną przez wielu do zmiany układu równania, tak aby sprawdzać warunek tylko za pomocą arytmetyki liczb całkowitych. Przedstawiłem 90000, 9e4aby zaoszczędzić trochę bajtów. Jeśli ten warunek jest spełniony, wyprowadzamy 1, w przeciwnym razie wyprowadzamy 0. Używam tego wyniku do indeksowania bezpośrednio do tablicy komórek. Ponieważ MATLAB rozpoczyna indeksowanie od 1, musiałem również dodać 1, aby dokończyć indeksowanie. Przyjemne jest to, że dodawanie za truepomocą 1 daje 2, podczas gdy dodawanie za falsepomocą 1 daje 1. Spowoduje to wyświetlenie jednego Trash!lub Retina!w wierszu polecenia MATLAB.

Przykład

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

ans =

Retina!

XSLT, 400 bajtów

To jest debiut nigdy nie widzianego języka na PPCG, i mam nadzieję, że będę go używać w przyszłości, kiedy go lepiej poznam.

Kod:

<?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>

Dość drukowane

<?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>

Uwagi:

Ponieważ XSLT nie ma możliwości pobierania danych wejściowych przez STDIN, musimy użyć pliku XML z danymi wejściowymi między dwoma <input>znacznikami. Oczywiście ta metoda ma swoje ograniczenia, ale doskonale sprawdzi się w przypadku większości wyzwań.

Przykład I / O

Plik wejściowy:

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

Plik wyjściowy:

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

Plik wejściowy:

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

Plik wyjściowy:

<?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";}

Nie golfowany:

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

Szybki, 77 bajtów

Deklaracje parametrów funkcji oznaczają, że zajmuje to znacznie więcej znaków, niż powinno:

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

Szybki, 56 bajtów

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

Zasadniczo taki sam jak GoatInTheMachine , ale z niejawnymi parametrami zamknięcia

Kiedy Code Golfing z Swift zawsze deklaruje takie metody, jest znacznie krótszy

Haskell, 46

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

C ++ 72 70 bajtów

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

Podobnie jak inne rozwiązania, postanowiłem rozgrzać się w golfa kodu.

Oto mój wkład w rozwiązanie tego problemu

Rubin, 67 bajtów odczytu ze standardowego wejścia

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

Ruby, 56 bajtów w funkcji

Troszkę krótszy

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

Dzięki poprzednim uczestnikom 9e4!

kod-golf ruby

Bash, 85 bajtów

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

PHP, 47,43,40 38 bajtów

<?=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?>!

Wymaga register_globals==true(nigdy nie powinno być!) Wartości GET w, h, d
- Zapisano 4 bajty, usuwając cudzysłowy wokół łańcucha. Złe kodowanie, ale działa.
- Przeniesiono di pierwiastek kwadratowy na drugą stronę równania, zapisując sqrt()funkcję
- Zapisano 2 bajty, przełączając na hypot()(dziękuję Lucas Costa)

C # 6, 67 bajtów

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

Ta odpowiedź jest oparta na odpowiedzi Wolfsheads. Skróciłem go o 8 bajtów, używając nowej funkcji C # 6.

JavaScript (ES6) 58 54 43 bajtów

43 bajtów

Usunięto przypisanie funkcji (zgodnie z zasadami PPCG) (-2), a także usunięto pierwiastek kwadratowy i porównano do 900 (300 ^ 2) (-12)

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

54 bajtów

Pozbyłem się niepotrzebnych nawiasów (-4 bajty)

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

58 bajtów

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

Wyjaśnienie tutaj:

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!"

Używa trójskładnikowych operatorów do testowania gęstości i zabija kilka bajtów za pomocą funkcji strzałek

Java, 82 74 bajty

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

Zadzwoń za pomocą g(width,height,diagonal)

Clojure, 58 bajtów

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

Wykorzystano fantazyjną matematykę @ Kroltana, aby to skrócić. Wykorzystuje niejawne argumenty przekazane w kolejności (w, h, d).

Pierwszy golf Clojure ... Byłem zaskoczony, jak wiele białych znaków mogę pominąć