Vivemos em uma era maravilhosa da tecnologia, onde podemos ter telas 8K lindamente detalhadas em nossas TVs e até telas 2K em nossos telefones para o nosso prazer de navegação móvel. Percorremos um longo caminho nos últimos anos em termos de tecnologia de tela.

Um dos produtos é um termo popularizado pela Apple, Retina . Isso se refere à densidade de pixels da tela em questão ser tão alta que, a uma distância de visualização de 10 a 12 polegadas, os pixels individuais não podem ser facilmente capturados.

Steve Jobs disse que a densidade de pixels em que isso ocorre é de aproximadamente 300 pixels por polegada , e eles começaram a empregar densidades de pixels nessa faixa em seus dispositivos com a palavra-chave Retina usada para publicidade.

A densidade de pixels pode ser calculada pela seguinte fórmula:

Onde dé a diagonal da tela em polegadas, wé o número de pixels no eixo horizontal e hé o número de pixels no eixo vertical.

Sua tarefa

Para esta tarefa, você usará o padrão Retina para decidir quais produtos valem a pena comprar. Sendo o consumidor moderno que você é, quando compra dispositivos, deseja ter certeza de que está obtendo um bom produto, não um dispositivo dos anos 90! Como tal, você deseja criar um programa ou função que considere a largura, a altura e o comprimento diagonal da tela como parâmetros de entrada ou função e informa se uma determinada tela se qualifica como uma tela retina ( D > 300) imprimindo na tela ou retornando .

Devido ao seu desprezo por dispositivos que não sejam da Retina, seu programa ou função será exibidoRetina! quando o dispositivo for qualificado e Trash!quando não for.

Você pode assumir que todos os números serão maiores que 0. Os valores de pixel para largura e altura sempre serão números inteiros. O tamanho da tela pode ser interpretado de qualquer forma, contanto que decimais. A entrada pode estar na ordem que você escolher e também pode estar em até 3 linhas separadas.

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

Isso é código-golfe , então o menor número de bytes vence.

^{Aqui está uma solução Stuck, uma linguagem de programação baseada em pilha que estou criando:}

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

Pitão - 27 bytes

Usa operador ternário e abspara calcular pitagórico.

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

Recebe entrada em duas linhas, primeira linha width, height, segunda linha diag.

As regras estavam relaxadas, revertendo.

Experimente online aqui .

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

Créditos ao randomra por economizar 3 bytes! (E abrindo caminho para mais algumas.)

+`\.(\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 fins de contagem de bytes, cada linha entra em um arquivo separado, mas você pode executar o código acima como em um único arquivo, chamando Retina com o -ssinalizador.

Isso espera que a densidade primeiro (que deve conter um ponto decimal, mesmo que seja à direita), seguida por largura e altura, ou seja d w h.

Isso é um pouco lento. Eu não tentaria a maioria dos casos de teste fornecidos, porque ele será executado por séculos. No entanto, você pode verificar se ele funciona corretamente com os casos de teste

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

Basicamente, depois de multiplicar todos os números para tornar a densidade um número inteiro, você não deseja que a largura e a altura tenham mais de 4 dígitos.

Enquanto isso é lento, é completamente exato ... não há problemas de ponto flutuante ou algo assim. Toda aritmética está usando números inteiros (unários).

Em princípio, eu poderia economizar mais um byte: ^pode ser omitido, mas isso tornará Trash!os casos de teste terrivelmente lentos devido a quantidades excessivas de retorno.

Explicação

Primeiro, vamos reorganizar a desigualdade para evitar operações de ponto flutuante:

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

Também podemos notar que este é invariante sob multiplicação w, he dpelo mesmo 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

Existem várias maneiras de colocar um número unário ao quadrado, mas usaremos a identidade

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

Isso nos dá uma maneira de resolver o problema usando apenas aritmética inteira (representando números inteiros em unário).

Vamos analisar o código. Cada par de linhas é uma substituição de regex.

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

Isso move repetidamente o ponto decimal na densidade para a direita, multiplicando a largura e a altura por 10 ( xacima). Isso é para garantir que todos os números sejam inteiros. Em vez de acrescentar zeros, estou acrescentando _, que tratarei como zero mais tarde. (Esse é um truque de golfe, porque, caso contrário, eu precisaria escrever ...${3}0para evitar ambigüidades $30.) O +na frente do regex diz ao Retina para repetir essa substituição até que o resultado pare de mudar (o que acontece quando o padrão não corresponde mais) .

\b
#

Estamos preparando os três números para a conversão em unário agora. Em princípio, precisamos de um marcador (o #) na frente de cada número, mas é mais curto adicionar um ao final de cada número também, o que não afetará a etapa de conversão.

+`(\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 é a conversão para unário, usando um truque que foi desenvolvido por dan1111 . Basicamente, estou traduzindo cada dígito para um dígito repetitivo, enquanto multiplica os dígitos existentes por 10 (movendo o #marcador para a direita no processo). Essa representação binária será uma mistura de dígitos diferentes, mas o número total será igual ao valor do número inteiro original. Observe o \wfinal - normalmente isso é justo 0, mas também queremos tratar _o zero (que é considerado um caractere de palavra no regex).

\d
11

Transformamos cada dígito em dois 1s, assim: a) garantindo que todos os dígitos sejam os mesmos (o que será necessário posteriormente) eb) dobrando cada um dos números.

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

Isso faz duas coisas: esquadra todos os números (ou melhor, metade de cada número, calculando uma soma acima 2n) e adiciona os quadrados resultantes da largura e da altura. Observe que [^.]corresponde a 1s, #marcadores e espaços. Se for um #ou um espaço, a cabeça de impressão não captura nada, o que significa que todos são simplesmente removidos, ou seja, os resultados para a largura e altura são concatenados / adicionados. O ponto decimal .permanece para separar o resultado ddaqueles. Se [^.]corresponder a um 1, o lookahead garantirá que capturamos metade dos 1s depois dele (arredondado para baixo) no grupo 1. Isso calcula a soma que eu mencionei acima, que produzirá o quadrado do número original.

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

A cadeia é agora (em unário), então , então (em unário). Queremos saber se o primeiro número unário vezes é menor que o segundo. Podemos facilmente fazer essa multiplicação usando um grupo de captura e sintaxe de repetição. Usamos (em vez de ) posteriormente para garantir que o segundo número seja realmente maior que isso e não apenas igual. Nesse caso, substituímos tudo isso por .d2.w2 + h290000{n}1+1*Retina!

1.+
Trash!

Se o segundo número não for grande o suficiente, a etapa anterior não terá alterado nada e a sequência ainda começará com a 1. Se for esse o caso, apenas substituímos a cadeia inteira por Trash!e pronto.

Python, 49

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

Usa intercalação de strings.

Descobriu-se mais curto ao quadrado de ambos os lados do que usar a norma complexa.

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!

Isso demora um pouco para ser executado, mas parece funcionar.

Provavelmente poderia ser jogado muito mais ...

Explicação:

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

Adicione tags para tornar a string mais conveniente para analisar e adicione algum lixo para facilitar a conversão para a base 1 e adicione 300 para multiplicar mais tarde

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

Acrescente 0s à largura e altura, enquanto a parte decimal da diagonal à parte inteira. Quando isso for feito, a diagonal será um número inteiro, e a largura e a altura serão multiplicadas por quantos 10s forem necessários.

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

Converta todos os números na base 1, usando a tabela de consulta que eu anexei na primeira etapa

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

Prepare o quadrado de todos os números

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

Esquadre cada número

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

Multiplique o quadrado da diagonal pelo quadrado dos 300 que inserimos na primeira etapa

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

Se a largura anexada à altura se encaixa no produto que acabamos de calcular, a densidade de pixels é muito baixa e é Lixo!

.*0
Retina!

Caso contrário, é Retina!

CJam, 30 29 27 bytes

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

Requer que a entrada esteja na forma de diagonal width height

ATUALIZAÇÃO: 1 byte economizado graças ao Dennis!

Experimente online aqui

APL, 40 36 bytes

Economizou 4 bytes graças a Dennis!

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

Isso cria uma função diádica sem nome que recebe os dois primeiros argumentos à esquerda e o terceiro à direita. Ele verifica se a soma dos quadrados dos valores da esquerda é maior que 300 ^ 2 vezes o quadrado do valor da direita. A saída é impressa de acordo.

Você pode experimentá-lo online !

TI-BASIC, 43

Leva largura e altura através da tela inicial como uma lista de dois elementos e diagonal através de Entrada.

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

As letras minúsculas de dois bytes da TI-BASIC adicionam 7 bytes ( isendo a unidade imaginária, é de um byte), fazendo com que seja bastante competitivo. Felizmente, !também é um byte porque representa a função fatorial.

JavaScript ES6, 49 bytes

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

Odeio que o JavaScript tenha operadores de matemática tão longos. Mas, mesmo que houvesse um, Math.pythagoreanisso seria mais curto.

Excel, 44 bytes

Digite suas entradas nessas células.

• A1 = Largura em pixels
• B1 = Altura em pixels
• C1 = Diagonal em polegadas

E esta fórmula fornece seu resultado:

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

a(8192,4320,100.0,R).Saídas em execução :R = "Trash!" .

Edit: Obrigado a @PaulButcher por corrigir um caso de borda e jogar um byte.

JavaScript (ES6), 45 bytes

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

CoffeeScript, 47 bytes

Nenhum operador ternário, mas existe exponenciação (que não ajuda na última tentativa).

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} {"Lixo!" p}?

Muitos bytes para a formatação de entrada: \

Experimente online

Pure Bash (sem bc / outros 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]}!

Eu decidi tentar fazê-lo em pura festa. Provavelmente fiz algumas ineficiências óbvias, pois esta é minha primeira vez com código de golfe, mas estou MUITO familiarizado com o bash e me diverti no passado tentando escrever coisas que não usam nenhum comando externo (por exemplo, bash puro).

A declaração printf é a mais irritante. Alguém tem alguma idéia melhor para preencher números com zeros?

EDIT: Salvo dois bytes, verifica-se printf terá um argumento vazio para zero. Salvei outro byte, descobri que eu desconectei anteriormente e apenas atribuir a saída de printf a uma variável é menor do que usar -v.

EDIT2: Graças ao Digital Trauma nos comentários, isso agora diminuiu muito mais significativamente. Truques: usando o suporte a regex do bash para substituir a sequência de dígitos por zeros em vez de contá-lo e imprimindo esse número de zeros (parece óbvio quando eu coloco assim ...), armazenando as strings em uma matriz do bash para salvar um eco, e levando em consideração uma pequena alteração nas regras, o que significa que você pode finalizar todos os números de entrada em 0,0.

EDIT3: Adicionado um byte para corrigir o erro introduzido pela modificação sugerida pelo Digital Trauma.

dc, 41 bytes

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

Requer args para serem inseridos em d, w, hordem - espero que esteja tudo bem.

Saída de teste:

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

Isso cria uma função que aceita três valores numéricos e retorna uma string.

É uma implementação direta da fórmula, apenas reorganizada um pouco. Ambos os lados da desigualdade foram multiplicados por dentão ao quadrado.

R, 59 55 bytes

Como uma função sem nome agora

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

Implementação muito simples, que elimina a necessidade das referências de índice.

Anterior

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

Bastante simples, obtenha a entrada da digitalização em um vetor (linha única, espaço separado ou várias linhas). Quadrado o vetor. Faça o cálculo e calcule o resultado.

MATLAB - 49 45 bytes

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

Primeiro tive que declarar uma matriz de células que contém Trash!e Retina!que são armazenadas nos locais 1 e 2 na matriz de células. Em seguida, utilizo a observação observada por muitos para reorganizar a equação, para que você verifique a condição apenas usando aritmética inteira. Eu representei 90000 9e4para salvar alguns bytes. Se essa condição for verdadeira, emitimos um 1, caso contrário, um 0. Eu uso essa saída para indexar diretamente no array de células. Como o MATLAB começa a indexação em 1, eu também precisei adicionar 1 para concluir a indexação. O legal é que adicionar true1 dá 2, enquanto adicionar false1 dá 1. Isso produzirá um Trash!ou Retina!no prompt de comando do MATLAB.

Exemplo

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

ans =

Retina!

XSLT, 400 bytes

Esta é a estréia de uma linguagem nunca vista no PPCG, e espero usá-la mais no futuro à medida que a conhecer.

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>

Pretty Printed

<?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 o XSLT não tem como receber entradas via STDIN, precisamos usar um arquivo XML, com a entrada entre duas <input>tags. Obviamente, esse método tem suas limitações, mas funcionará perfeitamente bem para a maioria dos desafios.

Exemplo de E / S

Arquivo de entrada:

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

Arquivo de saída:

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

Arquivo de entrada:

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

Arquivo de saída:

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

Rápido, 77 bytes

Declerations de parâmetro de função significam que isso ocupa muito mais caracteres do que deveria:

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

Rápido, 56 bytes

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

Basicamente o mesmo que o de GoatInTheMachine , mas com parâmetros implícitos de fechamento

Quando Code Golfing com Swift, sempre declara métodos como este, é muito mais curto

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

Semelhante a outras soluções, imaginei me aquecer com o código de golfe.

Aqui está a minha contribuição para este problema

Ruby, 67 bytes de leitura de stdin

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

Ruby, 56 bytes em uma função

Um pouco mais curto

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

Obrigado aos colaboradores anteriores do 9e4!

código-golfe rubi

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

Requer register_globals==true(que nunca deveria ser!), Com valores GET w, h, d
- salvou 4 bytes removendo aspas ao redor da string. Codificação incorreta, mas funciona.
- Movida de raiz quadrada para o outro lado da equação, salvando a sqrt()função
- Salvo 2 bytes, alternando para hypot()(obrigado Lucas Costa)

C # 6, 67 bytes

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

Esta resposta é baseada na resposta Wolfsheads. Tornei 8 bytes mais curtos usando um novo recurso do C # 6.

JavaScript (ES6) 58 54 43 bytes

43 bytes

Designação de função removida (conforme regras do PPCG) (-2), além de remover raiz quadrada e comparar com 900 (300 ^ 2) (-12)

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

54 bytes

Livre-se dos parênteses indesejáveis ​​(-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!"

Explicação aqui:

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

Isso usa operadores ternários para testar a densidade e mata alguns bytes usando as funções de seta

Java, 82 74 bytes

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

Ligue com g(width,height,diagonal)

Clojure, 58 bytes

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

Usou a matemática sofisticada de @ Kroltan para encurtar isso. Usa argumentos implícitos passados ​​na ordem de (w, h, d).

Primeiro golfe Clojure ... Fiquei surpreso com quanto espaço em branco posso deixar de fora