我们生活在一个技术时代，可以在电视上显示精美的8K屏幕，甚至可以在手机上使用2K显示屏，以享受移动浏览的乐趣。近年来，在屏幕技术方面，我们已经走了很长一段路。

其中一个产品是苹果公司Retina所流行的术语。这是指所讨论的显示器的像素密度非常高，以至于在10-12英寸的观看距离处，不容易拾取单个像素。

史蒂夫·乔布斯（Steve Jobs）表示，发生这种情况的像素密度大约为每英寸300像素，并且他们开始在设备上采用此范围内的像素密度，并使用Retina流行语来做广告。

像素密度可以通过以下公式计算：

其中d，屏幕的对角线以英寸w为单位，水平轴上h的像素数，垂直轴上的像素数。

你的任务

对于此任务，您将使用Retina标准来确定哪些产品值得购买。身为现代消费者，在购买设备时，您要确保自己获得的是好产品，而不是90年代的某些设备！因此，您想构建一个程序或函数，将屏幕的宽度，高度和对角线长度作为输入或函数参数，并D > 300通过打印到屏幕或返回来告诉您特定屏幕是否符合视网膜屏幕（）的要求。

由于您鄙视非Retina设备，因此您的程序或函数将Retina!在设备合格或不合格Trash!时输出。

您可以假设所有数字都大于0。宽度和高度的像素值将始终为整数。屏幕大小可以任何方式解释，只要它支持小数。输入可以按照您选择的任何顺序进行，也可以多达3条单独的行。

示例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!

这是代码高尔夫球，因此最少的字节数获胜。

^{这是Stuck解决方案，我正在使用基于堆栈的编程语言：}

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

Pyth-27个字节

使用三元运算符并abs计算勾股数。

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

接受两行输入，第一行width, height，第二行diag。

规则放松了，所以回滚了。

在这里在线尝试。

视网膜，530 220 210 202 201 193 191 187 185（184）个字节

归功于randomra以节省3个字节！（并为更多人铺平道路。）

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

为了进行字节计数，每行都在一个单独的文件中，但是您可以通过使用-s标志调用Retina，从单个文件中直接运行上述代码。

这首先需要密度（即使是尾随的，也要包含小数点），然后是宽度和高度，即d w h。

这有点慢。我不会尝试大多数给定的测试用例，因为它将运行很长时间。但是，您可以检查它是否与测试用例一起正常工作

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

基本上，在将所有数字相乘以使密度成为整数之后，您不希望宽度和高度的位数超过4位。

虽然这很慢，但完全正确……没有浮点问题或类似问题。所有算术都使用（一元）整数。

原则上，我可以再减少一个字节：^可以将其省略，但是Trash!由于回溯量过多，这会使测试用例非常慢。

说明

首先，让我们重新排列不等式以避免浮点运算：

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

我们也可以看到，这是在乘不变w，h并且d由相同数量的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

有几种方法可以对一元数求平方，但是我们将使用身份

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

这为我们提供了一种仅使用整数算术（以一元表示整数）解决问题的方法。

让我们看一下代码。每对线都是一个正则表达式替换。

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

在宽度和高度乘以10（x以上）的同时，这会反复将密度的小数点向右移动。这是为了确保所有数字都是整数。我没有附加零，而是附加了_，以后将其视为零。（这是一个打高尔夫球的技巧，因为否则我需要写出来...${3}0以避免与产生歧义$30。）+regex前面的内容告诉Retina重复此替换，直到结果停止更改为止（这种情况是模式不再匹配的情况） 。

\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#

这是使用dan1111开发的技巧转换为一元。本质上，我将每个数字转换为其自身的代表数字，同时将现有数字乘以10（#在过程中将标记向右移动）。该二进制表示形式将是由不同数字组成的混杂物，但是总数将等于原始整数的值。请注意\w最后-通常是just 0，但我们也希望将其_视为零（在正则表达式中被视为单词字符）。

\d
11

我们将每个数字转换为两个1s，从而a）确保所有数字相同（稍后将需要）和b）将每个数字加倍。

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

这样做有两件事：对所有数字求平方（或通过对求和，求出每个数字的一​​半2n），然后将宽度和高度的平方相加。请注意[^.]匹配1s，#标记和空格。如果是a #或空格，则前瞻不会捕获任何内容，这意味着所有内容都将被删除，即，将宽度和高度的结果连接/相加。小数点.仍保留以将结果与小数点分开d。如果[^.]匹配a 1，则前瞻确保我们1在group中捕获了它后的s（向下取整）的一半1。这将计算出我上面提到的总和，然后将得出原始数字的平方。

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

现在，字符串是（一元），然后是，然后是（一元）。我们想知道第一个一进制数是否小于第二个。我们可以使用捕获组和重复语法轻松地进行此乘法。之后，我们使用（而不是）来确保第二个数字实际上大于该数字，而不仅仅是相等。如果是这样，我们将全部替换为。d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

如果第二个数字不够大，则上一步将保持不变，字符串仍将以开头1。如果是这种情况，我们只需将整个字符串替换为Trash!并完成。

Python，49岁

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

使用字符串交织。

事实证明，比使用复杂的规范更短的对双方进行平方。

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

视网膜，312字节

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

这确实需要花费相当长的时间才能运行，但似乎可以正常工作。

可能还会打更多的高尔夫球...

说明：

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

添加标签以使字符串更易于解析，并添加一些垃圾使其更易于转换为基数1，并添加300以供以后乘以

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

将0s 附加到宽度和高度，同时将对角线的小数部分附加到整数部分。完成此操作后，对角线将为整数，并且宽度和高度将乘以10s （无论是否需要）。

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

使用第一步中附加的查找表将所有数字转换为基数1

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

准备对所有数字求平方

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

平方每个数字

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

将对角线的平方乘以第一步中插入的300的平方

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

如果附加到高度的宽度适合我们刚才计算的乘积，则像素密度太低，这是“垃圾箱”！

.*0
Retina!

否则，就是视网膜！

CJam，30 29 27字节

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

要求输入形式为 diagonal width height

更新：感谢丹尼斯节省了1个字节！

在这里在线尝试

APL，40 36字节

感谢丹尼斯节省了4个字节！

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

这将创建一个未命名的二进位函数，该函数采用左边的前两个参数，右边的第三个参数。它检查左侧值的平方和是否大于右侧值的平方的300 ^ 2倍。相应地打印输出。

您可以在线尝试！

TI-BASIC，43岁

通过主屏幕将宽度和高度作为两个元素的列表，将对角线作为输入。

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

TI-BASIC的两字节小写字母加7个字节（i代表虚数单位为一个字节），导致它没有竞争力。值得庆幸的是，!它也是一个字节，因为它代表阶乘函数。

JavaScript ES6，49个字节

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

我讨厌JavaScript具有如此长的数学运算符。但是，即使有一个，Math.pythagorean它也会更短。

Excel，44个字节

在这些单元格中输入您的输入。

• A1 =宽度（以像素为单位）
• B1 =高度（以像素为单位）
• C1 =英寸对角线

这个公式给出了您的结果：

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

Prolog，51个字节

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

运行a(8192,4320,100.0,R).输出：R = "Trash!" .

编辑：感谢@PaulButcher纠正边缘情况和打高尔夫球一个字节。

JavaScript（ES6），45个字节

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

CoffeeScript，47个字节

没有三元运算符，但是有幂运算（这对最近的尝试没有帮助）。

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字节

jjjrmd \ /'īu> {“ Retina！” p} {“ Trash！” p}？

输入格式很多字节：\

在线尝试

纯击（没有BC /其他外部命令），138 136 135 82 83个字节

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

我决定尝试以纯正的方式进行。由于这是我的第一次代码打高尔夫球，所以我可能已经犯了一些明显的低效率问题，但是我对bash非常熟悉，并且在过去尝试编写不使用任何外部命令（即纯bash）的东西时玩得很开心。

printf语句是最烦人的。有人对用零填充数字有更好的主意吗？

编辑：保存了两个字节，结果printf将为零的空参数。保存了另一个字节，结果原来我以前算错了，只是将printf的输出分配给一个变量比使用-v小。

EDIT2：多亏了Digital Trauma的评论，这一点现在大大减少了。技巧：使用bash的正则表达式支持将数字字符串替换为零，而不是对其进行计数，然后打印该数字为零（当我这样放置时似乎很明显...），将字符串存储在bash数组中以保存回显，并考虑到规则的微小变化，这意味着您可以将所有输入数字都以.0结尾。

EDIT3：添加了一个字节来修复Digital Trauma的建议修改所引入的错误。

dc，41个字节

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

需要按d, w, h顺序输入args- 我希望可以。

测试输出：

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

朱莉娅46 45 42字节

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

这将创建一个接受三个数值并返回一个字符串的函数。

这是公式的直接实现，只是重新排列了一下。不平等的两面都乘以d然后平方。

R，59 55字节

现在作为一个未命名的函数

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

非常简单的实现，消除了对索引引用的需求。

以前

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

非常简单，将输入从扫描输入到矢量中（单行，空格或多行）。平方向量。进行计算并计算结果。

MATLAB- 49 45字节

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

我首先必须声明一个单元格数组，其中包含Trash!，Retina!并将它们存储在单元格数组的位置1和2中。接下来，我将使用许多人观察到的观察结果来重新排列方程式，以便仅使用整数算术检查条件。我代表90000 9e4以节省一些字节。如果此条件为真，则输出1，否则输出0。我使用此输出直接索引单元格数组。因为MATLAB从1开始索引，所以我还必须加1才能完成索引。什么是好的是，将true有1给出2，同时加入false以1给出1.这将输出无论是Trash!或Retina!在MATLAB命令提示符。

例

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

ans =

Retina!

XSLT，400字节

这是PPCG上前所未有的语言的首次亮相，随着我对它的了解越来越多，我希望将来会更多地使用它。

码：

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

漂亮印刷

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

笔记：

由于XSLT无法通过STDIN接收输入，因此我们必须使用XML文件，且输入必须在两个<input>标签之间。当然，这种方法有其局限性，但对于大多数挑战而言，它都能很好地工作。

示例I / O

输入文件：

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

输出文件：

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

输入文件：

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

输出文件：

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

取消高尔夫：

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

迅捷，77个字节

函数参数整理说明这将占用更多的字符，而不是应该的：

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

迅捷，56个字节

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

基本上与GoatInTheMachine相同，但具有隐式关闭参数

使用Swift进行Code Golfing时，总是声明这样的方法，它要短得多

哈斯克尔（46）

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

C ++ 72 70字节

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

与其他解决方案类似，他发现自己要热衷于代码高尔夫。

这是我对这个问题的贡献

Ruby，从stdin读取的67个字节

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

Ruby，函数中有56个字节

短一点

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

感谢9e4的先前贡献者！

高尔夫红宝石

Bash，85个字节

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

PHP，47,43,40 38字节

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

要求register_globals==true（永远不要！），GET值w，h，d-
通过删除字符串周围的引号来节省4个字节。编码错误，但可以。
-将d平方根移到等式的另一侧，保存sqrt()函数
-通过切换到hypot()（谢谢Lucas Costa），节省了2个字节

C＃6，67字节

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

该答案基于Wolfsheads答案。我使用C＃6的新功能将其缩短了8个字节。

JavaScript（ES6）58 54 43字节

43字节

删除了功能分配（根据PPCG规则）（-2），以及删除了平方根并与900（300 ^ 2）（-12）比较

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

54字节

消除了不必要的括号（-4字节）

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

58字节

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

此处说明：

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

这使用三元运算符来测试密度，并通过使用箭头函数杀死几个字节

Java，82 74字节

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

叫它 g(width,height,diagonal)

Clojure，58个字节

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

使用@Kroltan的奇特数学来缩短此时间。使用按（w，h，d）顺序传递的隐式参数。

第一次Clojure高尔夫...我很惊讶我被允许留出多少空白