根据该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只能用16位中的15位表示，但是它适用于[-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，则整个电路都会执行。

如果仔细看，您会发现我使用了七个 1常量s（对11111011和后跟进行硬编码0）。我这样做是因为Logisim至少需要输入一个值才能使逻辑门产生输出。但是，每次使用一个常数时，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 检查第一个年龄除以2加7的结果是否大于第二个年龄。
• b/2+7>a 检查第二年龄除以二加七是否大于第一年龄。
• 如果以上任何一个值为true，则返回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基本（20 10 9字节）

max(2Ans<14+max(Ans

通过使用清单和Timtech建议的一部分获得-10个字节

-1字节，使用lirtosiast的建议

接受两个年龄段的列表，“ {40,42}：prgmNAME”

对于“令人毛骨悚然”返回1，对于“不令人毛骨悚然”返回0。

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

First Code高尔夫，可能很糟糕。

@Phoenix减少29字节

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，则交换参数并重试。否则，请检查。由于递归调用，Currying不会节省任何字节。

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基本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
}

水晶，44 27字节

-17从Ruby中查看daniero的答案。

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！

Fourier，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表示“蠕变”，0表示“不蠕变”。如果通过以下方式将无输出视为虚假值，则可以节省3个字节：

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