Vivimos en una era maravillosa de tecnología en la que podemos tener pantallas de 8K bellamente detalladas en nuestros televisores, e incluso pantallas de 2K en nuestros teléfonos para nuestro placer de navegación móvil. Hemos recorrido un largo camino en los últimos años en términos de tecnología de pantalla.

Uno de los productos de esto es un término que Apple hizo popular, Retina . Esto se refiere a que la densidad de píxeles de la pantalla en cuestión es tan alta que a una distancia de visualización de 10-12 pulgadas de distancia, los píxeles individuales no se pueden seleccionar fácilmente.

Steve Jobs dijo que la densidad de píxeles donde esto ocurre es de alrededor de 300 píxeles por pulgada , y comenzaron a emplear densidades de píxeles en este rango en sus dispositivos con la palabra de moda Retina utilizada para publicidad.

La densidad de píxeles se puede calcular mediante la siguiente fórmula:

Donde destá la diagonal de la pantalla en pulgadas, wes el número de píxeles en el eje horizontal y hes el número de píxeles en el eje vertical.

Tu tarea

Para esta tarea, utilizará el estándar Retina para decidir qué productos valen la pena comprar. Siendo el consumidor moderno que eres, cuando compras dispositivos quieres asegurarte de obtener un buen producto, ¡no un dispositivo de los 90! Como tal, desea crear un programa o función que tome el ancho, la altura y la longitud diagonal de la pantalla como parámetros de entrada o función , y le indica si la pantalla en particular califica como una pantalla de retina ( D > 300) imprimiéndola o volviendo .

Debido a su desprecio por los dispositivos que no son Retina, su programa o función saldrá Retina!cuando el dispositivo califique y Trash!cuando no lo haga.

Puede suponer que todos los números serán mayores que 0. Los valores de píxeles para ancho y alto siempre serán números enteros. El tamaño de la pantalla puede interpretarse de cualquier manera, siempre que sea compatible con decimales. La entrada puede estar en el orden que elija, y también puede estar en hasta 3 líneas separadas.

Ejemplo de E / S

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!

Este es el código de golf , por lo que gana la menor cantidad de bytes.

^{Aquí hay una solución Stuck, un lenguaje de programación basado en pila que estoy haciendo:}

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

Pyth - 27 bytes

Utiliza el operador ternario y abspara calcular el pitagórico.

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

Toma entrada en dos líneas, primera línea width, height, segunda línea diag.

Las reglas se relajaron, así que retrocedieron.

Pruébelo en línea aquí .

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

¡Créditos a randomra para guardar 3 bytes! (Y allanando el camino para un par más).

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

Para fines de conteo de bytes, cada línea va en un archivo separado, pero puede ejecutar el código anterior tal como es desde un solo archivo invocando Retina con la -sbandera.

Esto espera primero la densidad (que debe contener un punto decimal, incluso si es uno posterior), seguido de ancho y alto, es decir d w h.

Esto es un poco lento. No probaría la mayoría de los casos de prueba dados, porque durará mucho tiempo. Sin embargo, puede verificar que funciona correctamente con los casos de prueba

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

Básicamente, después de multiplicar todos los números para hacer que la densidad sea un número entero, no desea que el ancho y la altura tengan más de 4 dígitos.

Si bien esto es lento, es completamente exacto ... no hay problemas de coma flotante ni nada de eso. Toda la aritmética está usando enteros (unarios).

En principio, podría eliminar un byte más: ^se puede omitir, pero hará que Trash!los casos de prueba sean terriblemente lentos debido a las cantidades excesivas de retroceso.

Explicación

Primero, reorganicemos la desigualdad para evitar operaciones de coma flotante:

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

También podemos notar que esto es invariante al multiplicar w, hy dpor el mismo número 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

Hay varias formas de cuadrar un número unario, pero haremos uso de la identidad

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

Esto nos da una manera de resolver el problema usando solo aritmética de enteros (que representa enteros en unario).

Veamos el código. Cada par de líneas es una sustitución de expresiones regulares.

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

Esto mueve repetidamente el punto decimal en la densidad hacia la derecha mientras multiplica el ancho y la altura por 10 (lo xanterior). Esto es para asegurar que todos los números sean enteros. En lugar de agregar ceros, estoy agregando _, lo que trataré como cero más adelante. (Este es un truco de golf, porque de lo contrario tendría que escribir ...${3}0para evitar ambigüedades $30). El +frente de la expresión regular le dice a Retina que repita esta sustitución hasta que el resultado deje de cambiar (que es el caso cuando el patrón ya no coincide) .

\b
#

Estamos preparando los tres números para la conversión a unario ahora. En principio, necesitamos un marcador (el #) delante de cada número, pero también es más corto agregar uno al final de cada número, lo que no afectará el paso de conversión.

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

Esta es la conversión a unario, utilizando un truco desarrollado por dan1111 . Esencialmente, estoy traduciendo cada dígito a un dígito de repetición de sí mismo, mientras multiplico los dígitos existentes por 10 (moviendo el #marcador a la derecha en el proceso). Esta representación binaria será una mezcla de diferentes dígitos, pero el número total será igual al valor del entero original. Tenga \wen cuenta que al final, normalmente esto es justo 0, pero también queremos tratarlo _como cero (que se considera un carácter de palabra en expresiones regulares).

\d
11

Convertimos cada dígito en dos 1s, por lo tanto a) asegurando que todos los dígitos sean iguales (lo que será necesario más adelante) yb) duplicando cada uno de los números.

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

Esto hace dos cosas: cuadra todos los números (o más bien la mitad de cada número, calculando una suma 2n), y agrega los cuadrados resultantes del ancho y la altura. Observe que [^.]coincide con 1s, #marcadores y espacios. Si es un #o un espacio, la búsqueda anticipada no capturará nada, lo que significa que todos ellos simplemente se eliminan, es decir, los resultados para el ancho y la altura se concatenan / agregan. El punto decimal .permanece para separar el resultado dde esos. Si [^.]coincide con a 1en su lugar, entonces la búsqueda anticipada asegura que capturamos la mitad de los 1s después (redondeados hacia abajo) en grupo 1. Esto calcula la suma que mencioné anteriormente, que luego arrojará el cuadrado del número original.

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

La cadena es ahora (en unario), luego , luego (en unario). Queremos saber si el primer número unario veces es más corto que el segundo. Podemos hacer esta multiplicación fácilmente usando un grupo de captura y sintaxis de repetición. Usamos (en lugar de ) después para asegurarnos de que el segundo número sea realmente mayor que eso y no solo igual. Si es así, reemplazamos todo eso por .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Si el segundo número no era lo suficientemente grande, entonces el paso anterior no habrá cambiado nada y la cadena aún comenzará con a 1. Si ese es el caso, simplemente reemplazamos la cadena completa por Trash!y listo.

Python, 49

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

Utiliza el entrelazado de cuerdas.

Resultó más corto cuadrar ambos lados que usar la norma compleja.

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!

Esto toma bastante tiempo en ejecutarse, pero parece funcionar.

Probablemente podría jugar mucho más al golf ...

Explicación:

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

Agregue etiquetas para que la cadena sea más conveniente para analizar, y agregue algo de basura para que sea más fácil convertir a la base 1, y agregue un 300 para multiplicar por más tarde

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

Agregue 0s al ancho y alto, mientras agrega la parte decimal de la diagonal a la parte entera. Cuando se hace esto, la diagonal será un número entero, y el ancho y la altura se multiplicarán por cuantos 10s sean necesarios.

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

Convierta todos los números a la base 1, usando la tabla de búsqueda que agregué en el primer paso

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

Prepárate para cuadrar todos los números

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

Cuadra cada número

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

Multiplica el cuadrado de la diagonal por el cuadrado de los 300 que insertamos en el primer paso

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

Si el ancho agregado a la altura se ajusta al producto que acabamos de calcular, la densidad de píxeles es demasiado baja, ¡y es basura!

.*0
Retina!

De lo contrario, es Retina!

CJam, 30 29 27 bytes

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

Requiere entrada para estar en forma de diagonal width height

ACTUALIZACIÓN: 1 byte guardado gracias a Dennis!

Pruébalo en línea aquí

APL, 40 36 bytes

¡Guardado 4 bytes gracias a Dennis!

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

Esto crea una función diádica sin nombre que toma los dos primeros argumentos a la izquierda y el tercero a la derecha. Comprueba si la suma de los cuadrados de los valores de la izquierda es mayor que 300 ^ 2 veces el cuadrado del valor de la derecha. La salida se imprime en consecuencia.

¡Puedes probarlo en línea !

TI-BASIC, 43

Toma ancho y alto a través de la pantalla de inicio como una lista de dos elementos, y diagonal a través de Entrada.

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

Las letras minúsculas de dos bytes de TI-BASIC agregan 7 bytes ( isiendo la unidad imaginaria, es un byte) hacen que sea bastante poco competitivo. Afortunadamente, !también es un byte porque representa la función factorial.

JavaScript ES6, 49 bytes

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

Odio que JavaScript tenga operadores matemáticos tan largos. Pero incluso si hubiera un, Math.pythagoreanesto sería más corto.

Excel, 44 bytes

Escriba sus entradas en estas celdas.

• A1 = Ancho en píxeles
• B1 = Altura en píxeles
• C1 = Diagonal en pulgadas

Y esta fórmula da tu resultado:

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

Prólogo, 51 bytes

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

a(8192,4320,100.0,R).Salidas corrientes :R = "Trash!" .

Editar: Gracias a @PaulButcher por corregir un caso de borde y jugar al golf un byte.

JavaScript (ES6), 45 bytes

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

CoffeeScript, 47 bytes

No hay operador ternario, pero hay exponenciación (que no ayuda en el último intento).

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

Muchos bytes para el formato de entrada: \

Pruébalo en línea

Bash pura (sin BC / otros comandos externos), 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]}!

Decidí intentar hacerlo en puro golpe. Probablemente he cometido algunas ineficiencias obvias, ya que esta es mi primera vez jugando al golf de código, pero estoy MUY familiarizado con bash y me he divertido en el pasado tratando de escribir cosas que no usan ningún comando externo (es decir, bash puro).

La declaración printf es la más molesta. ¿Alguien tiene mejores ideas para rellenar números con ceros?

EDITAR: Guardado dos bytes, resulta que printf tomará un argumento vacío para cero. Guardado otro byte, resulta que previamente había contado mal y solo asignar la salida de printf a una variable es más pequeño que usar -v.

EDIT2: Gracias a Digital Trauma en los comentarios, esto ahora ha disminuido mucho más significativamente. Trucos: usar el soporte de expresiones regulares de bash para reemplazar la cadena de dígitos con ceros en lugar de contarlos y luego imprimir ese número de ceros (parece obvio cuando lo pongo así ...), almacenando las cadenas en una matriz de bash para guardar un eco, y teniendo en cuenta un ligero cambio en las reglas que significa que puede finalizar todos los números de entrada en .0.

EDITAR3: Se agregó un byte para corregir el error introducido por la modificación sugerida por Digital Trauma.

cc, 41 bytes

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

Requiere que se ingresen los argumentos en d, w, horden, espero que esto esté bien.

Prueba de salida:

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

Esto crea una función que acepta tres valores numéricos y devuelve una cadena.

Es una implementación directa de la fórmula, solo reorganizada un poco. Ambos lados de la desigualdad se multiplicaron por al dcuadrado.

R, 59 55 bytes

Como una función sin nombre ahora

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

Implementación muy simple, que elimina la necesidad de referencias de índice.

Anterior

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

Bastante simple, obtenga la entrada del escaneo en un vector (línea única, espacio separado o multilínea). Cuadrar el vector. Haz el cálculo y obtén el resultado.

MATLAB - 49 45 bytes

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

Primero tuve que declarar una matriz de celdas que contiene Trash!y Retina!que se almacenan en las ubicaciones 1 y 2 de la matriz de celdas. A continuación, utilizo la observación observada por muchos para reorganizar la ecuación, de modo que esté verificando la condición solo usando la aritmética de enteros. Representé 90000 como 9e4para guardar algunos bytes. Si esta condición es verdadera, sacamos un 1, de lo contrario sacamos un 0. Uso esta salida para indexar directamente en la matriz de celdas. Debido a que MATLAB comienza a indexar en 1, también tuve que agregar 1 para completar la indexación. Lo bueno es que al agregar truecon 1 se obtiene 2, mientras que al agregar falsecon 1 se obtiene 1. Esto dará como resultado Trash!o Retina!en el símbolo del sistema de MATLAB.

Ejemplo

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

ans =

Retina!

XSLT, 400 bytes

Este es el debut de un lenguaje nunca antes visto en PPCG, y espero usarlo más en el futuro a medida que lo conozca más.

Código:

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

Bastante impreso

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

Notas:

Como XSLT no tiene forma de recibir información a través de STDIN, tenemos que usar un archivo XML, con la información entre dos <input>etiquetas. Por supuesto, este método tiene sus limitaciones, pero funcionará perfectamente para la mayoría de los desafíos.

Ejemplo de E / S

Fichero de entrada:

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

Archivo de salida:

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

Fichero de entrada:

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

Archivo de salida:

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

Sin golf:

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

Swift, 77 bytes

Las declinaciones de los parámetros de función significan que esto ocupa muchos más caracteres de los que debería:

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

Swift, 56 bytes

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

Básicamente igual que el de GoatInTheMachine pero con parámetros de cierre implícitos

Cuando Code Golfing con Swift, siempre declare métodos como este, es mucho más corto

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

Al igual que otras soluciones, descubrí que me calentaría con el código de golf.

Aquí está mi contribución para este problema.

Ruby, 67 bytes leyendo de stdin

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

Ruby, 56 bytes en una función.

Un poco más corto

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

¡Gracias a los contribuyentes anteriores por el 9e4!

código-golf ruby

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

Requiere register_globals==true(¡lo que nunca debería ser!), Con valores GET w, h, d
: guardado 4 bytes eliminando comillas alrededor de la cadena. Mala codificación, pero funciona.
- dRaíz movida y cuadrada al otro lado de la ecuación, guardando la sqrt()función
- Guardado 2 bytes cambiando a hypot()(gracias Lucas Costa)

C # 6, 67 bytes

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

Esta respuesta se basa en la respuesta de Wolfsheads. Lo hice 8 bytes más corto usando una nueva característica de C # 6.

JavaScript (ES6) 58 54 43 Bytes

43 bytes

Se eliminó la asignación de funciones (según las reglas PPCG) (-2), así como también se eliminó la raíz cuadrada y se comparó con 900 (300 ^ 2) (-12)

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

54 bytes

Se deshizo de paréntesis inusuales (-4 bytes)

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

Explicación aquí:

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

Esto utiliza operadores ternarios para probar la densidad y mata un par de bytes mediante el uso de funciones de flecha

Java, 82 74 bytes

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

Llámalo con g(width,height,diagonal)

Clojure, 58 bytes

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

Usé las elegantes matemáticas de @Kroltan para acortar esto. Utiliza argumentos implícitos pasados ​​en el orden de (w, h, d).

Primero golf de Clojure ... Me sorprendió la cantidad de espacio en blanco que tengo permitido dejar fuera