Kita hidup di zaman teknologi yang luar biasa di mana kita dapat memiliki layar 8K yang sangat indah di TV kita, dan bahkan 2K yang ditampilkan di ponsel kita untuk kesenangan menjelajah seluler kita. Kami telah datang jauh dalam beberapa tahun terakhir dalam hal teknologi layar.

Salah satu produk dari ini adalah istilah yang dipopulerkan oleh Apple, Retina . Ini merujuk pada kerapatan piksel layar yang dipermasalahkan begitu tinggi, sehingga pada jarak pandang 10-12 inci, masing-masing piksel tidak dapat dengan mudah dipilih.

Steve Jobs mengatakan bahwa kerapatan piksel tempat ini terjadi tepat di sekitar 300 piksel per inci , dan mereka mulai menggunakan kerapatan piksel dalam kisaran ini di perangkat mereka dengan kata kunci Retina yang digunakan untuk iklan.

Kerapatan piksel dapat dihitung dengan rumus berikut:

Dimana ddiagonal layar dalam inci, wadalah jumlah piksel pada sumbu horizontal, dan hjumlah piksel pada sumbu vertikal.

Tugas Anda

Untuk tugas ini, Anda akan menggunakan standar Retina untuk memutuskan produk apa yang layak dibeli. Menjadi konsumen modern seperti Anda, ketika Anda berbelanja untuk perangkat yang ingin memastikan bahwa Anda mendapatkan produk yang bagus, bukan perangkat dari tahun 90-an! Dengan demikian, Anda ingin membuat program atau fungsi yang menggunakan lebar layar, tinggi dan panjang diagonal sebagai parameter input atau fungsi , dan memberi tahu Anda apakah layar tertentu memenuhi syarat sebagai layar retina ( D > 300) dengan mencetak ke layar atau kembali .

Karena penghinaan Anda untuk perangkat non-Retina, program atau fungsi Anda akan ditampilkan Retina!ketika perangkat memenuhi syarat, dan Trash!ketika itu tidak.

Anda dapat mengasumsikan bahwa semua angka akan lebih besar dari 0. Nilai piksel untuk lebar dan tinggi akan selalu menjadi angka utuh. Ukuran layar dapat ditafsirkan dengan cara apa pun, asalkan mendukung desimal. Input mungkin dalam urutan apa pun yang Anda pilih, dan mungkin juga hingga 3 baris terpisah.

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

Ini adalah kode-golf , sehingga jumlah byte terkecil yang menang.

^{Inilah solusi Stuck, bahasa pemrograman berbasis stack yang saya buat:}

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

Pyth - 27 byte

Menggunakan operator ternary dan absmenghitung pythagoras.

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

Mengambil input dalam dua baris, baris pertama width, height, baris kedua diag.

Aturannya santai jadi berputar kembali.

Cobalah online di sini .

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

Kredit ke randomra untuk menghemat 3 byte! (Dan membuka jalan untuk beberapa lagi.)

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

Untuk keperluan penghitungan byte, setiap baris menggunakan file terpisah, tetapi Anda dapat menjalankan kode di atas seperti dari satu file dengan memanggil Retina dengan -sflag.

Ini mengharapkan kepadatan pertama (yang harus mengandung titik desimal, bahkan jika itu trailing), diikuti oleh lebar dan tinggi, yaitu d w h.

Ini agak lambat. Saya tidak akan mencoba sebagian besar kasus uji yang diberikan, karena akan berjalan lama. Namun, Anda dapat memeriksa apakah itu berfungsi dengan benar dengan kasus uji

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

Pada dasarnya, setelah mengalikan semua angka hingga menjadikan kerapatan bilangan bulat, Anda tidak ingin lebar dan tinggi memiliki lebih dari 4 digit.

Meskipun ini lambat, itu sepenuhnya tepat ... tidak ada masalah floating point atau sesuatu seperti itu. Semua aritmatika menggunakan bilangan bulat (unary).

Pada prinsipnya, saya bisa mengurangi satu byte lagi: byte ^dapat dihilangkan, tetapi itu akan membuat Trash!kasus uji sangat lambat karena jumlah backtracking yang berlebihan.

Penjelasan

Pertama, mari kita atur ulang ketimpangan untuk menghindari operasi floating point:

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

Kami juga dapat melihat bahwa ini tidak berubah di bawah penggandaan w, hdan ddengan nomor yang sama 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

Ada beberapa cara untuk mengkuadratkan angka unary, tetapi kami akan menggunakan identitas itu

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

Ini memberi kita cara untuk menyelesaikan masalah hanya menggunakan bilangan bulat aritmatika (mewakili bilangan bulat di unary).

Mari kita lihat kodenya. Setiap pasangan garis adalah pengganti regex.

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

Ini berulang kali memindahkan titik desimal dalam kepadatan ke kanan sambil mengalikan lebar dan tinggi dengan 10 (di xatas). Ini untuk memastikan bahwa semua angka adalah bilangan bulat. Alih-alih menambahkan nol, saya menambahkan _, yang saya akan memperlakukan sebagai nol nanti. (Ini adalah trik golf, karena kalau tidak saya harus menulis ...${3}0untuk menghindari ambiguitas dengan $30.) Di +depan regex memberitahu Retina untuk mengulangi penggantian ini sampai hasilnya berhenti berubah (yang merupakan kasus ketika polanya tidak lagi cocok) .

\b
#

Kami sedang menyiapkan tiga angka untuk konversi ke unary sekarang. Pada prinsipnya, kita membutuhkan penanda (di #) di depan setiap angka, tetapi lebih pendek untuk menambahkan satu ke akhir setiap angka juga, yang tidak akan mempengaruhi langkah konversi.

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

Ini adalah konversi ke unary, menggunakan trik yang telah dikembangkan oleh dan1111 . Pada dasarnya saya menerjemahkan setiap digit ke rep-digit sendiri, sambil mengalikan digit yang ada dengan 10 (memindahkan #marker ke kanan dalam proses). Representasi biner ini akan menjadi campuran yang berbeda dari angka-angka yang berbeda, tetapi jumlah totalnya akan sama dengan nilai integer asli. Perhatikan \wpada bagian akhir - biasanya ini hanya saja 0, tetapi kami juga ingin memperlakukannya _sebagai nol (yang dianggap sebagai karakter kata dalam regex).

\d
11

Kami mengubah setiap digit menjadi dua 1s, dengan demikian a) memastikan semua digit adalah sama (yang akan diperlukan nanti) dan b) menggandakan masing-masing angka.

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

Ini melakukan dua hal: itu menguadratkan semua angka (atau lebih tepatnya setengah dari setiap angka, dengan menghitung jumlah di atas 2n), dan menambahkan kuadrat yang dihasilkan dari lebar dan tinggi. Perhatikan bahwa [^.]cocok 1dengan, #spidol dan spasi. Jika a #atau spasi, lookahead tidak akan menangkap apa pun, yang berarti semua itu hanya dihapus, yaitu hasil untuk lebar dan tinggi digabungkan / ditambahkan. Titik desimal .tetap memisahkan hasil ddari itu. Jika [^.]cocok dengan 1sebaliknya, maka lookahead memastikan bahwa kami menangkap setengah dari 1setelah itu (dibulatkan ke bawah) dalam grup 1. Ini menghitung jumlah yang saya sebutkan di atas, yang kemudian akan menghasilkan kuadrat dari angka aslinya.

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

String sekarang (di unary), lalu , lalu (di unary). Kami ingin tahu apakah angka unary pertama kali lebih pendek dari yang kedua. Kita dapat dengan mudah melakukan perkalian ini menggunakan capturing group dan sintaks pengulangan. Kami menggunakan (bukan ) setelah itu untuk memastikan bahwa angka kedua sebenarnya lebih besar dari itu dan tidak hanya sama. Jika demikian, kami mengganti semua itu dengan .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Jika angka kedua tidak cukup besar, maka langkah sebelumnya tidak akan mengubah apa pun dan string akan tetap dimulai dengan a 1. Jika itu masalahnya, kami hanya mengganti seluruh string dengan Trash!dan selesai.

Python, 49

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

Menggunakan interleaving string.

Ternyata lebih pendek untuk menyejajarkan kedua sisi daripada menggunakan norma kompleks.

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

Retina , 312 byte

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

Ini berjalan cukup lama, tetapi tampaknya berhasil.

Mungkin bisa bermain golf lebih banyak ...

Penjelasan:

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

Tambahkan tag untuk membuat string lebih mudah diurai, dan tambahkan beberapa sampah untuk membuatnya lebih mudah dikonversi ke basis 1, dan tambahkan 300 untuk dikalikan nanti

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

Tambahkan 0ke lebar dan tinggi, sambil menambahkan bagian desimal dari diagonal ke bagian integer. Ketika ini dilakukan, diagonal akan menjadi bilangan bulat, dan lebar dan tinggi akan dikalikan dengan berapa banyak 10pun yang diperlukan.

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

Ubah semua angka menjadi basis 1, menggunakan tabel pencarian yang saya tambahkan pada langkah pertama

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

Bersiaplah untuk menyusun semua angka

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

Kuadratkan setiap angka

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

Kalikan kuadrat diagonal dengan kuadrat 300 yang kami sisipkan di langkah pertama

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

Jika lebar yang ditambahkan ke ketinggian cocok dengan produk yang baru saja kami hitung, kerapatan piksel terlalu rendah, dan itu Sampah!

.*0
Retina!

Kalau tidak, itu Retina!

CJam, 30 29 27 byte

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

Membutuhkan input dalam bentuk diagonal width height

UPDATE: 1 byte disimpan berkat Dennis!

Cobalah online di sini

APL, 40 36 byte

Disimpan 4 byte berkat Dennis!

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

Ini menciptakan fungsi diad tanpa nama yang mengambil dua argumen pertama di sebelah kiri dan yang ketiga di sebelah kanan. Ia memeriksa apakah jumlah kuadrat dari nilai kiri lebih besar dari 300 ^ 2 kali kuadrat dari nilai yang tepat. Output dicetak sesuai.

Anda dapat mencobanya secara online !

TI-BASIC, 43

Mengambil lebar dan tinggi melalui homescreen sebagai daftar dua elemen, dan diagonal melalui Input.

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

Huruf kecil dua-byte TI-BASIC menambahkan 7 byte ( i, sebagai unit imajiner, adalah satu byte) menyebabkannya menjadi sangat tidak kompetitif. Untungnya, !ini juga satu byte karena mewakili fungsi faktorial.

JavaScript ES6, 49 byte

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

Saya benci bahwa JavaScript memiliki operator matematika yang sangat panjang. Tetapi bahkan jika ada, Math.pythagoreanini akan lebih pendek.

Excel, 44 byte

Ketikkan input Anda di sel-sel ini.

• A1 = Lebar dalam piksel
• B1 = Tinggi dalam piksel
• C1 = Diagonal dalam inci

Dan formula ini memberikan hasil Anda:

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

Prolog, 51 byte

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

Menjalankan a(8192,4320,100.0,R).output:R = "Trash!" .

Sunting: Terima kasih kepada @PaulButcher karena mengoreksi casing tepi dan bermain golf satu byte.

JavaScript (ES6), 45 byte

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

CoffeeScript, 47 byte

Tidak ada operator ternary, tetapi ada eksponensial (yang tidak membantu dalam upaya terbaru).

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 byte

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

Banyak byte untuk pemformatan input: \

Cobalah online

Pure Bash (tanpa bc / perintah eksternal lainnya), 138 136 135 82 83 byte

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

Saya memutuskan untuk mencoba melakukannya di bash murni. Saya mungkin telah membuat beberapa inefisiensi yang jelas karena ini adalah golf kode waktu pertama saya, tetapi saya SANGAT akrab dengan bash dan bersenang-senang di masa lalu mencoba menulis hal-hal yang tidak menggunakan perintah eksternal (yaitu pure bash).

Pernyataan printf adalah yang paling menjengkelkan. Adakah yang punya ide lebih baik untuk menambahkan nomor dengan angka nol?

EDIT: Disimpan dua byte, ternyata printf akan mengambil argumen kosong untuk nol. Disimpan byte lain, ternyata saya sebelumnya salah hitung dan hanya menetapkan output printf ke variabel lebih kecil daripada menggunakan -v.

EDIT2: Berkat Digital Trauma di komentar, ini sekarang turun jauh lebih signifikan. Trik: menggunakan dukungan regex bash untuk mengganti string angka dengan nol alih-alih menghitungnya kemudian mencetak angka nol itu (tampak jelas ketika saya meletakkannya seperti itu ...), menyimpan string dalam array bash untuk menyimpan gema, dan dengan mempertimbangkan sedikit perubahan dalam aturan yang berarti Anda dapat mengakhiri semua angka input dalam .0.

EDIT3: Menambahkan byte untuk memperbaiki bug yang diperkenalkan oleh modifikasi yang disarankan Digital Trauma.

dc, 41 byte

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

Membutuhkan args sebagai input d, w, hagar - saya harap ini OK.

Output tes:

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

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

Ini menciptakan fungsi yang menerima tiga nilai numerik dan mengembalikan string.

Ini adalah implementasi langsung dari formula, hanya disusun ulang sedikit. Kedua sisi ketimpangan dikalikan dsaat itu kuadrat.

R, 59 55 Bytes

Sebagai fungsi yang tidak disebutkan namanya sekarang

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

Implementasi yang sangat sederhana, yang menghilangkan kebutuhan untuk referensi indeks.

Sebelumnya

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

Cukup sederhana, dapatkan input dari pemindaian menjadi vektor (satu baris, spasi terpisah atau multi-baris). Kuadratkan vektor. Lakukan perhitungan dan hasilkan cat.

MATLAB - 49 45 byte

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

Saya pertama kali harus mendeklarasikan array sel yang berisi Trash!dan Retina!yang disimpan di lokasi 1 dan 2 di dalam array sel. Selanjutnya, saya menggunakan pengamatan yang diamati oleh banyak orang untuk mengatur ulang persamaan sehingga Anda memeriksa kondisi hanya menggunakan bilangan bulat aritmatika. Saya mewakili 90000 9e4untuk menghemat beberapa byte. Jika kondisi ini benar, kita output 1, kalau tidak kita output 0. Saya menggunakan output ini untuk mengindeks langsung ke dalam array sel. Karena MATLAB mulai mengindeks pada 1, saya juga harus menambahkan 1 untuk menyelesaikan pengindeksan. Yang menyenangkan adalah menambahkan truedengan 1 memberi 2, sementara menambahkan falsedengan 1 memberi 1. Ini akan menampilkan salah satu Trash!atau Retina!di command prompt MATLAB.

Contoh

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

ans =

Retina!

XSLT, 400 byte

Ini adalah debut dari bahasa yang belum pernah dilihat sebelumnya di PPCG, dan saya berharap dapat menggunakannya lebih banyak di masa depan karena saya lebih mengenalnya.

Kode:

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

Cukup Dicetak

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

Catatan:

Karena XSLT tidak memiliki cara untuk mengambil input melalui STDIN, kita harus menggunakan file XML, dengan input di antara dua <input>tag. Tentu saja, metode ini memiliki keterbatasan tetapi akan bekerja dengan baik untuk sebagian besar tantangan.

Contoh I / O

File input:

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

Berkas keluaran:

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

File input:

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

Berkas keluaran:

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

Tidak Disatukan:

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

Swift, 77 byte

Deklarasi parameter fungsi berarti ini membutuhkan lebih banyak karakter daripada seharusnya:

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

Swift, 56 byte

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

Pada dasarnya sama dengan GoatInTheMachine tetapi dengan parameter penutupan implisit

Ketika Code Golfing dengan Swift, selalu mendeklarasikan metode seperti ini, itu jauh lebih pendek

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

Serupa dengan solusi lain, mencari tahu sendiri untuk pemanasan dengan kode golf.

Inilah kontribusi saya untuk masalah ini

Ruby, 67 byte membaca dari stdin

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

Ruby, 56 byte dalam suatu fungsi

Sedikit lebih pendek

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

Terima kasih kepada kontributor sebelumnya untuk 9e4!

kode-golf ruby

Bash, 85 byte

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

PHP, 47,43,40 38 byte

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

Membutuhkan register_globals==true(yang seharusnya tidak!), Dengan GET nilai w, h, d
- Disimpan 4 byte dengan menghapus tanda kutip di sekitar string. Pengodean yang buruk, tetapi berhasil.
- Pindah ddan akar kuadrat ke sisi lain dari persamaan, menyimpan sqrt()fungsi
- Menyimpan 2 byte dengan beralih ke hypot()(terima kasih Lucas Costa)

C # 6, 67 Bytes

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

Jawaban ini didasarkan pada jawaban Wolfsheads. Saya membuatnya 8 byte lebih pendek menggunakan fitur baru C # 6.

JavaScript (ES6) 58 54 43 Bytes

43 Bytes

Penugasan fungsi yang dihapus (sesuai aturan PPCG) (-2), serta menghapus akar kuadrat dan membandingkannya dengan 900 (300 ^ 2) (-12)

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

54 Bytes

Menyingkirkan tanda kurung yang tidak sehat (-4 byte)

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

Penjelasan di sini:

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

Ini menggunakan operator ternary untuk menguji kepadatan dan membunuh beberapa byte dengan menggunakan fungsi panah

Java, 82 74 byte

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

Sebut saja dengan g(width,height,diagonal)

Clojure, 58 byte

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

Menggunakan matematika mewah @ Kroltan untuk mempersingkat ini. Menggunakan argumen implisit yang disahkan dalam urutan (w, h, d).

Golf Clojure pertama ... Saya terkejut seberapa banyak ruang putih yang saya boleh tinggalkan