Согласно этому комиксу XKCD , существует формула, определяющая, является ли разница в возрасте в отношениях «жуткой». Эта формула определяется как:

(Age/2) + 7

минимальный возраст людей, с которыми вы можете встречаться.

Поэтому отношения являются жуткими, если один из людей в этих отношениях моложе минимального возраста другого.

Принимая во внимание возраст двух человек, можете ли вы сказать, являются ли эти отношения жуткими или нет?

правила

1. Ваша программа должна принимать в качестве входных данных два целых числа - возраст обоих людей в отношениях. Они могут быть приняты в любом разумном формате.

2. Ваша программа должна затем вывести истинное или ложное значение, описывающее, является ли отношение "жутким" (Truthy = Creepy).

3. Стандартные лазейки не допускаются.
4. Эта головоломка - Code Golf, поэтому выигрывает ответ с самым коротким исходным кодом в байтах

Тестовые случаи

40, 40    - Not Creepy
18, 21    - Not Creepy
80, 32    - Creepy
15, 50    - Creepy
47, 10000 - Creepy
37, 38    - Not Creepy
22, 18    - Not Creepy

Желе , 6 байт

H+7>ṚṀ

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

По-видимому, другой алгоритм, чем у товарища.

Python 3 , 26 байт

lambda x:max(x)/2+7>min(x)

Попробуйте онлайн!
Вход представляет собой список с обоими возрастами

05AB1E , 8 6 байт

;7+R‹Z

Попробуйте онлайн! или попробуй все проверить

         # Implicit Input: an array of the ages
;        # Divide both ages by 2
 7+      # Add 7 to both ages
   R     # Reverse the order of the ages
         #    this makes the "minimum age" line up with the partner's actual age
    ‹    # Check for less than the input (vectorized)
     Z   # Push largest value in the list

NAND ворота, 551

Создано с Logisim

Тот же принцип, что и в моем другом ответе , но он принимает 2-байтовые подписанные входные данные, поэтому он может справиться 47, 10000. Работает для всех тестовых случаев!

Это не оптимально для данных тестовых случаев, поскольку 10000 можно выразить только 15 из 16 битов, но оно работает для любого возраста в диапазоне [-32768, 32768). Обратите внимание, что любой отрицательный возраст вернется 1.

Входы слева (без определенного порядка, 1-битный сверху). Вывод в правом нижнем углу.

NAND ворота, 274 262

Оригинал:

Лучше: Создано с Logisim

Это принимает два входа слева как 1-байтовые целые числа со знаком, с 1-битным сверху. Выход в левом нижнем углу; правда и ложь здесь должны быть очевидны.

Работает для всех тестовых случаев, кроме 47, 10000, так что я думаю, что это технически неверный ответ. Однако самый старый человек в (надежной) записи был 122, поэтому 8 бит (максимум 127) будут работать для любого сценария, когда-либо возможного до этого момента. Я опубликую новый ответ (или я должен отредактировать этот?), Когда я закончу 16-битную версию.

16-битная версия готова!

Вы заметите некоторые вертикальные участки цепи. Первый (слева) определяет, какой вход больше. Следующие два - мультиплексоры, сортирующие входы. Затем я добавляю 11111001(-7) к меньшему в четвертом разделе, и в заключение я сравниваю это вдвое с большим значением. Если оно меньше, отношения жуткие. Поскольку я сдвигаю биты вдвое, я должен учитывать неиспользованный бит lesser-7. Если это 1, то lesser-7отрицательный, и младший из двух не старше шести. Жутко. Я заканчиваю с логическим элементом ИЛИ, так что если какой-либо тест на ползучесть возвращается 1, вся схема делает.

Если вы посмотрите внимательно, вы увидите, что я использовал семь один константа s (жесткое кодирование 11111011и трейлинг 0). Я сделал это, потому что Logisim требует, чтобы по крайней мере одно значение входило в логический вентиль, чтобы произвести вывод. Однако каждый раз, когда используется константа, два вентиля NAND обеспечивают 1значение независимо от константы.

-12 ворот благодаря мне !

C #, 22 байта

n=>m=>n<m/2+7|m<n/2+7;

C, 29 байт

#define f(a,b)a/2+7>b|b/2+7>a

Как это устроено:

• #define f(a,b)определяет макро-функцию, fкоторая принимает два нетипизированных аргумента.
• a/2+7>b проверяет, больше ли первый возраст, деленный на два плюс семь, чем второй возраст.
• b/2+7>a проверяет, больше ли второй возраст, деленный на два плюс семь, чем первый возраст.
• Если любое из приведенных выше значений истинно, верните 1 (жуткий). В противном случае верните 0 (не страшно).

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

JavaScript (ES6), 21 байт

a=>b=>a<b/2+7|b<a/2+7

Возвращает 0 для не жутких, 1 для жутких.

f=a=>b=>a<b/2+7|b<a/2+7

console.log(f(40)(40));
console.log(f(18)(21));
console.log(f(80)(32));
console.log(f(15)(50));
console.log(f(47)(10000));
console.log(f(37)(38));
console.log(f(22)(18));

R , 26 25 байт

-1 байт благодаря @djhurio

any(rev(a<-scan())<a/2+7)

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

Сетчатка , 20 байт

O`.+
^1{7}(1+)¶1\1\1

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

Ввод одинарный с переводом строки между двумя числами. Вывод 0(не жуткий) или 1(жуткий).

объяснение

O`.+

Отсортируйте два числа, чтобы мы знали, что большее число является вторым.

^1{7}(1+)¶1\1\1

Назовите меньший возраст aи больший возраст b. Мы сначала захватить a-7в группе 1. Тогда мы стараемся соответствовать 2*(a-7)+1в b, что означает b >= 2*(a-7)+1или b >= 2*(a-7)или b/2+7 > aчто является критерием для жутких отношений.

TI-Basic, 20 10 9 байт

max(2Ans<14+max(Ans

-10 байт, используя список и часть предложения Timtech

-1 байт, используя предложение lirtosiast

Принимает в список двух возрастов, "{40,42}: prgmNAME"

Возвращает 1 для «creepy» и 0 для «not creepy».

GNU APL 1.2, 23 байта

Определяет функцию, которая принимает два аргумента и печатает 1, если страшно, 0, если нет.

∇A f B
(A⌊B)<7+.5×A⌈B
∇

объяснение

∇начинается и заканчивается функция
A f B- заголовок функции; Функция имеет имя fи принимает два аргумента, Aа B(функции в APL могут быть монадическими - с одним аргументом - или диадическими - с двумя аргументами)
A⌊B- это min(A,B)и A⌈Bявляется max(A,B)
APL, вычисляемым справа налево, поэтому скобки необходимы для обеспечения надлежащего приоритета

Другие операторы говорят сами за себя.

Код может быть в гольфе, я все еще новичок в код-гольфе.

Python 3, 74 45 байт

Первый код Гольф, наверное, ужасен.

29 байтовое уменьшение @Phoenix

lambda a,b:0 if(a/2)+7>b or(b/2)+7>a else 1

JavaScript (ES6), 27 байт

f=a=>b=>b>a?f(b)(a):b>a/2+7

Нет карри (звоните как f(a,b)вместо f(a)(b))

f=(a,b)=>b>a?f(b,a):b>a/2+7

Если b > a, поменяйте местами параметры и повторите попытку. В противном случае проверьте. Карринг не сохраняет никаких байтов из-за рекурсивного вызова.

f=a=>b=>b>a?f(b)(a):b>a/2+7

console.log(f(18)(22))
console.log(f(22)(18))
console.log(f(18)(21))

Java, 21 байт

a->b->a/2+7>b|b/2+7>a

Абсолютно не оригинально.

тестирование

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

import java.util.function.*;

public class Pcg122520 {
  static IntFunction<IntPredicate> f = a->b->a/2+7>b|b/2+7>a;
  public static void main(String[] args) {
    int[][] tests = {
      {40, 40},
      {18, 21},
      {80, 32},
      {15, 50},
      {47, 10000},
      {37, 38},
      {22, 18}
    };
    for (int[] test: tests) {
      System.out.printf("%d, %d - %s%n", test[0], test[1], f.apply(test[0]).test(test[1]) ? "Creepy" : "Not creepy");
    }
  }
}

Python 3, 31 байт

lambda a,b:abs(a-b)>min(a,b)-14

Не намного короче, чем другие представления Python, но я нашел немного другой способ проверки на жуткость. Я заметил, что допустимая разница между возрастами равна min - 14. Это следует из алгебраической перестановки формулы.

min = (max/2) + 7
min - 7 = max/2
2*min - 14 = max

dif = max - min
max = dif + min

2*min - 14 = dif + min
min - 14 = dif

Это позволило мне решить без необходимости использования двух констант, а также без необходимости использовать max и min вместо использования abs (ab). С точки зрения игры в гольф я получил всего на один байт меньше, чем решение @ nocturama, но я использовал немного другую формулу, чтобы сделать это.

Excel, 26 24 байта

Формула ячейки, которая принимает входные данные в виде чисел из диапазона ячеек A1:B1и выводит логическое значение, представляющее ползучесть для ячейки формулы

=OR(A1/2+7>B1,B1/2+7>A1)

Старая версия, 26 байт

=MAX(A1:B1)/2+7>MIN(A1:B1)

TI-Basic, 10 9 10 байт

2min(Ans)-14≤max(Ans

Список входных данных Ans, выходов, 1если "жуткий" или 0иным образом.

Математика , 16 байт

Max@#/2+7<Min@#&

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

-2 байта благодаря @GregMartin

Верно для не жутко, ложно для жутко.

            (* Argument: A list of integers     *)
Max@#       (* The maximum of the input         *)
 /2+7       (* Divided by 2, plus 7             *)
  <         (* Is less than?                    *)
   Min@#    (* The minimum of the input         *)
    &       (* Anonymous function               *)

SAS, 77 байт

%macro t(a,b);%put%eval(%sysfunc(max(&a,&b))/2+7>%sysfunc(min(&a,&b)));%mend;

Röda , 16 байт

{sort|[_<_/2+7]}

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

Это анонимная функция, которая принимает входные данные как два литерала (а не массив) из входного потока.

объяснение

{sort|[_<_/2+7]}                 Anonymous function
 sort                            Sorts the numbers in the input stream
     |[       ]                  And push
       _<                        whether the smaller value  is less than
         _/2+7                   the greater value / 2 + 7

Perl 6 , 15 байт

{.max/2+7>.min}

Попробуй

расширенный

{ # bare block lambda with implicit parameter ｢$_｣
  # (input is a List)

  .max / 2 + 7
  >
  .min
}

Crystal , 44 27 байт

-17 от взгляда на ответ Даньеро в Ruby.

def a(a)7+a.max/2>a.min end

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

Python 3 - 32 27 байт

Невозможно прокомментировать, но я получил немного более короткий ответ, чем другое решение Python 3:

lambda *a:min(a)<max(a)/2+7

-5 спасибо @Cyoce!

Фурье, 37 байт

oI~AI~B>A{1}{A~SA~BS~B}A/2+7>B{1}{@o}

Попробуйте это на FourIDE!

Принимает два числа в качестве ввода. Будет гольф позже.

PHP, 29 байт

печатает 1 для жуткого, ничего для не жуткого

<?=max($_GET)/2+7>min($_GET);

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

Japt , 11 байт

Возвращает trueза "жуткий" и falseза нет.

wV /2+7>UmV

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

объяснение

      :Implicit input of first integer U
wV    :Get the maximum of U and the second integer V
/2+7  :Divide by 2 & add 7
>     :Check if the result is greater than...
UmV   :the minimum of the two integers.

J, 10 байт

<.<7+2%~>.

Выходы 1не жуткие, 0жуткие

объяснение

<.          NB. the minimum
  >         NB. is greater than
    7+2%~>. NB. half the maximum + 7

J-uby , 25 байтов

:>%[:min,:max|~:/&2|:+&7]

Звоните как f^[80,32]. Дает trueне жутко, falseжутко.

объяснение

    :min                  # the minimum
:>%[    ,               ] # is greater than
         :max|            # the maximum...
              ~:/&2|        # over two...
                    :+&7    # plus 7 

AWK , 26 байт

{$0=$1/2+7>$2||$2/2+7>$1}1

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

Выходы 1 для «Creepy» и 0 для «Not Creepy». Может сохранить 3 байта, если нет-вывода можно считать ложным значением, через:

$0=$1/2+7>$2||$2/2+7>$1