Мы живем в эпоху замечательных технологий, где у нас могут быть великолепно детализированные 8K-экраны на наших телевизорах и даже 2K-экраны на наших телефонах для нашего мобильного просмотра. В последние годы мы прошли долгий путь с точки зрения технологии экранов.

Одним из продуктов этого термина стал популярный термин Apple, Retina . Это означает, что плотность пикселей рассматриваемого дисплея настолько высока, что на расстоянии просмотра 10-12 дюймов отдельные пиксели не могут быть легко выбраны.

Стив Джобс сказал, что плотность пикселей, где это происходит, составляет около 300 пикселей на дюйм , и они начали использовать плотность пикселей в этом диапазоне на своих устройствах с умным словом Retina, используемым для рекламы.

Плотность пикселей можно рассчитать по следующей формуле:

Где dдиагональ экрана в дюймах, wэто количество пикселей на горизонтальной оси и hколичество пикселей на вертикальной оси.

Твое задание

Для этой задачи вы будете использовать стандарт Retina, чтобы решить, какие продукты стоит покупать. Будучи современным потребителем, когда вы покупаете устройства, вы хотите убедиться, что получаете хороший продукт, а не какое-то устройство из 90-х! Таким образом, вы хотите создать программу или функцию, которая принимает ширину экрана, высоту и длину диагонали в качестве входных параметров или параметров функции и сообщает вам, соответствует ли конкретный экран экрану сетчатки ( D > 300) путем печати на экране или возврата .

Из-за вашего презрения к устройствам, не относящимся к Retina, ваша программа или функция будут выводить данные, Retina!когда устройство соответствует требованиям, а Trash!когда нет.

Вы можете предположить, что все числа будут больше 0. Значения пикселей для ширины и высоты всегда будут целыми числами. Размер экрана можно интерпретировать любым способом, если он поддерживает десятичные дроби. Ввод может быть в любом порядке по вашему выбору, а также может содержать до 3 отдельных строк.

Пример ввода / вывода

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.

Правила были смягчены, поэтому откат.

Попробуйте это онлайн здесь .

Retina , 530 220 210 202 201 193 191 187 185 (184) байт

Кредиты рандоме для сохранения 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!

Для подсчета байтов каждая строка идет в отдельном файле, но вы можете запустить приведенный выше код как один из одного файла, вызвав Retina с -sфлагом.

Это первое ожидает , что плотность (которая должна содержать десятичную точку, даже если это замыкающий один), а затем по ширине и высоте, то есть 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.) +Перед регулярным выражением перед 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на конец - обычно это просто 0, но мы также хотим трактовать _как ноль (который в регулярном выражении считается символом слова).

\d
11

Мы превращаем каждую цифру в две 1s, тем самым а) обеспечивая, чтобы все цифры были одинаковыми (что будет необходимо позже), и б) удваивая каждое из чисел.

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

Это делает две вещи: он возводит в квадрат все числа (или, точнее, половину каждого числа, вычисляя сумму над 2n) и добавляет полученные квадраты ширины и высоты. Обратите внимание, что [^.]соответствует 1s, #маркеры и пробелы. Если это #или пробел, заглядывание не будет ничего захватывать, что означает, что все они просто удаляются, то есть результаты для ширины и высоты объединяются / добавляются. Десятичная точка .остается отделить результат для dтех. Если вместо этого [^.]совпадает с a 1, то предварительный просмотр гарантирует, что мы захватим половину 1s после него (округлено) в группе 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!

Иначе это 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!")

Пролог, 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!'

О , 40 37 байт

jjjrmd \ / 'IU> { "Retina!" р} { "Trash!" р}?

Много байтов для форматирования ввода: \

Попробуйте онлайн

Pure Bash (без 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.

РЕДАКТИРОВАТЬ 2: Благодаря цифровой травме в комментариях, теперь это гораздо более существенно. Трюки: использование поддержки регулярных выражений в bash для замены строки цифр на нули вместо подсчета, а затем печать этого числа нулей (кажется очевидным, когда я так говорю ...), сохранение строк в массиве bash для сохранения эха, и принимая во внимание небольшое изменение в правилах, это означает, что вы можете завершить все вводимые числа в .0.

EDIT3: добавлен байт для исправления ошибки, представленной предложенной модификацией Digital Trauma.

постоянный ток, 41 байт

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

Требует ввода аргументов в d, w, hпорядке - я надеюсь, что это нормально.

Тестовый вывод:

$ 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>тегами. Конечно, у этого метода есть свои ограничения, но он будет отлично работать для большинства задач.

Пример ввода / вывода

Входной файл:

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

Ungolfed:

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

Swift, 77 байт

Значения параметров функции означают, что они занимают больше символов, чем должны:

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

Swift, 56 байт

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

В основном так же, как GoatInTheMachine , но с неявными параметрами закрытия

Когда Code Golfing с Swift, всегда объявляйте такие методы, это намного короче

Хаскелл, 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, чтение 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!

код-гольф рубин

Баш, 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()функции
- Сохранение 2 байтов путем переключения на hypot()(спасибо Лукас Коста)

C # 6, 67 байт

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

Этот ответ основан на ответе Wolfsheads. Я сделал его на 8 байт короче, используя новую функцию C # 6.

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 ... Я был удивлен, сколько пробелов мне позволено пропустить