Is this relationship creepy?

Question

According to this XKCD comic, there is a formula to determine whether or not the age gap in a relationship is "creepy". This formula is defined as:

(Age/2) + 7

being the minimum age of people you can date.

Therefore a relationship is creepy if either of the people in said relationship are younger than the minimum age of the other.

Given the age of two people, can you output whether or not that relationship is creepy?

Rules

1. Your program should take two integers as input, the age of both people in the relationship. These can be taken in any reasonable format.

2. Your program must then output a truthy or falsy value describiing whether or not the relationship is "creepy" (Truthy = Creepy).

3. Standard loopholes are not allowed.
4. This puzzle is Code Golf, so the answer with the shortest source code in bytes wins

Test Cases

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

Answer 1

Jelly, 6 bytes

H+7>ṚṀ

Try it online!

Seemingly different algorithm than Comrade's.

Answer 2

Python 3, 26 bytes

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

Try it online!
The input is a list with both ages

Answer 3

05AB1E, 8 6 bytes

;7+R‹Z

Try it online! or Try all test

         # 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

Answer 4

NAND gates, 551

Created with Logisim

Same principle as my other answer, but takes 2-byte signed inputs, so it can handle 47, 10000. Works for ALL test cases!

This is not optimal for the given test cases, as 10000 can be expressed with only 15 of the 16 bits, but it works for any ages in the range [-32768, 32768). Note that any negative age will return 1.

Inputs on left (no particular order, 1-bit on top). Output in lower right.

Answer 5

NAND gates, 274 262

Original:

Better: Created with Logisim

This takes two inputs on the left as 1-byte signed integers, with the 1-bit at the top. Output is in the lower left; the truthy and falsey here should be obvious.

Works for all test cases except 47, 10000, so I guess this is technically not a valid answer. However, the oldest person on (reliable) record was 122, so 8 bits (max 127) will work for any scenario ever possible to this point. I'll post a new answer (or should I edit this one?) when I finish the 16-bit version.

16-bit version is done!

You'll notice some vertical sections of the circuit. The first one (from the left) determines which input is greater. The next two are multiplexers, sorting the inputs. I then add 11111001 (-7) to the lesser in the fourth section, and I conclude by comparing twice this to the greater input. If it is less, the relationship is creepy. Since I shift the bits to double, I must take into account the unused bit of lesser-7. If this is a 1, then lesser-7 is negative, and the younger of the two is no older than six. Creepy. I finish with an OR gate, so if either creepiness test returns 1, the entire circuit does.

If you look closely, you'll see that I used seven one constants (hardcoding the 11111011 and the trailing 0). I did this because Logisim requires at least one value going in for a logic gate to produce an output. However, each time a constant is used, two NAND gates ensure a 1 value regardless of the constant.

-12 gates thanks to me!

Answer 6

C#, 22 bytes

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

Answer 7

C, 29 bytes

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

How it works:

• #define f(a,b) defines a macro function f that takes two untyped arguments.
• a/2+7>b checks if the first age divided by two plus seven is larger than the second age.
• b/2+7>a checks if the second age divided by two plus seven is larger than the first age.
• If either of the above values are true, return 1 (creepy). Otherwise, return 0 (not creepy).

Try it online!

Answer 8

JavaScript (ES6), 21 bytes

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

Returns 0 for not creepy, 1 for creepy.

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));

Answer 9

R, 26 25 bytes

-1 byte thanks to @djhurio

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

Try it online!

Answer 10

TI-Basic, 20 10 9 bytes

max(2Ans<14+max(Ans

-10 bytes by using a list and part of Timtech's suggestion

-1 byte using lirtosiast's suggestion

Takes in a list of two ages, "{40,42}:prgmNAME"

Returns 1 for 'creepy' and 0 for 'not creepy'.

Answer 11

Retina, 20 bytes

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

Try it online!

Input is in unary with a linefeed between the two numbers. Output is 0 (not creepy) or 1 (creepy).

Explanation

O`.+

Sort the two numbers, so we know that the larger one is second.

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

Call the smaller age a and the larger age b. We first capture a-7 in group 1. Then we try to match 2*(a-7)+1 in b, which means b >= 2*(a-7)+1 or b >= 2*(a-7) or b/2+7 > a which is the criterion for a creepy relationship.

Answer 12

Python 3, 74 45 bytes

First Code Golf, probably terrible.

29 byte reduction by @Phoenix

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

Answer 13

GNU APL 1.2, 23 bytes

Defines a function that takes two arguments and prints 1 if creepy, 0 if not.

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

Explanation

∇ begins and ends the function
A f B is the function header; function is named f and takes two arguments, A and B (functions in APL can be monadic - taking one argument - or dyadic - taking two arguments)
A⌊B is min(A,B) and A⌈B is max(A,B)
APL is evaluated right-to-left, so parentheses are needed to ensure proper precedence

The other operators are self explanatory.

Code might be golf-able, I'm still new to code-golf.

Answer 14

JavaScript (ES6), 27 bytes

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

No currying (call like f(a,b) instead of f(a)(b))

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

If b > a, swap parameters and retry. Otherwise, check. Currying doesn't save any bytes because of the recursive call.

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

Answer 15

Excel, 26 24 Bytes

Cell formula that takes input as numbers from cell range A1:B1 and output a boolean value representing creepiness to the formula cell

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

Old Version, 26 Bytes

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

Answer 16

Java, 21 bytes

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

Absolutely not original.

Testing

Try it online!

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

Answer 17

Python 3, 31 bytes

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

Not much shorter than the other python submissions, but I found a slightly different way to check for creepiness. I noticed that the acceptable difference between ages is equal to min - 14. This follows from algebraically rearranging the formula.

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

This let me solve without needing two constants, and also without needing to use both max and min, instead using abs(a-b). From a golfing perspective I only got one byte less than @nocturama's solution, but I used a slightly different formula to do it.

Answer 18

Mathics, 16 bytes

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

Try it online!

-2 bytes thanks to @GregMartin

True for not creepy, false for creepy.

            (* 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               *)

Answer 19

TI-Basic, 10 9 10 bytes

2min(Ans)-14≤max(Ans

List input from Ans, outputs 1 if "creepy" or 0 otherwise.

Answer 20

SAS, 77 bytes

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

Answer 21

Röda, 16 bytes

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

Try it online!

This is an anonymous function that takes input as two literals (not an array) from the input stream.

Explanation

{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

Answer 22

Crystal, 44 27 bytes

-17 from looking at daniero's answer in Ruby.

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

Try it online!

Answer 23

Perl 6, 15 bytes

{.max/2+7>.min}

Try it

Expanded

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

  .max / 2 + 7
  >
  .min
}

Answer 24

Python 3 - 32 27 bytes

Unable to comment, but I got a slightly shorter answer than the other Python 3 solution:

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

-5 thanks to @Cyoce!

Answer 25

Fourier, 37 bytes

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

Try it on FourIDE!

Takes two numbers as input. Will golf later.

Answer 26

Japt, 11 bytes

Returns true for "creepy" and false for not.

wV /2+7>UmV

Try it online

---

Explanation

      :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.

Answer 27

PHP, 29 Bytes

prints 1 for creepy, nothing for Not creepy

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

Try it online!

Answer 28

J, 10 bytes

<.<7+2%~>.

Outputs 1 for not creepy, 0 for creepy

Explanation

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

Answer 29

J-uby, 25 bytes

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

Call like f^[80,32]. Gives true for not creepy, false for creepy.

Explanation

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

Answer 30

AWK, 26 bytes

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

Try it online!

Outputs 1 for "Creepy" and 0 for "Not Creepy". Could save 3 bytes if no-output could be consider a falsy value, via:

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

Answer 31

Swift - 33 bytes

var f={max($0,$1)/2+7>min($0,$1)}

A lambda-function's equivalent in Swift, but unfortunately cannot take an array :((. Outputs true for truthy and false for falsy. If one must not count the declaration of the function (Python doesn't) the byte count would be 27. Usage: print(f(age1,age2))

Check it out!

Answer 32

Batch, 50 bytes

@if %1 gtr %2 %0 %2 %1
@cmd/cset/a"%1*2-14-%2>>31

Outputs -1 for creepy, 0 for not creepy.

Since Batch only has integer arithmetic I have to work in units of half years.

Answer 33

Ruby, 21 bytes

->*x{x.max/2+7>x.min}

Yup.

f = ->*x{x.max/2+7>x.min}
f[18,21]  #=> false
f[80,32]  #=> true

Answer 34

z-shell (zsh), 38 bytes

n=(${(no)@});echo $((n[2]/2+7-n[1]>0))

${(no)@} is a numeric sort of the argument array

Answer 35

Perl 5, 34 + 2 (-ap) = 36 bytes

$_=$F[0]/2+7>$F[1]|$F[1]/2+7>$F[0]

Try it online!

Answer 36

FORTH 96 Bytes

: C 2DUP > -1 = IF SWAP THEN 2 /  7 +  SWAP > -1 = IF ."  CREEPY " ELSE ." NOT CREEPY " THEN ;

Output:

40 40 c NOT CREEPY  ok
18 21 c
18 21 c NOT CREEPY  ok
80 32 c
80 32 c  CREEPY  ok
15 50 c
15 50 c  CREEPY  ok
47 10000 c
47 10000 c  CREEPY  ok
37 38 c
37 38 c NOT CREEPY  ok
22 18 c
22 18 c NOT CREEPY  ok

Answer 37

Excel VBA, 28 Bytes

Anonymous immediate window function that tTakes age inputs from cells [A1] and [B1] as expected type Integer and outputs a Boolean value representing creepyness to the VBE immediate window

?[B1]/2+7>[A1]|[A1]/2+7>[B1]

Answer 38

shortC, 21 bytes

D(a,b)a/2+7<b|b/2+7<a

Answer 39

QBIC, 30 bytes

~:>:|c=a┘d=b\c=b┘d=a]?d>=c/2+7

Explanation

           First, we mustsort the input parameters
~:>:       IF a (from cmd line) > b (from cmd line)
|c=a┘d=b   THEN set c and d
\c=b┘d=a   ELSE set c and d in the other way
]          END IF
?d>=c/2+7  PRINT -1 if d is higher than c's lower bound, 0 for creepy

Answer 40

Pyth, 17 16 13 12 bytes

>+7/.)JSQ2hJ

Takes a list. Outputs True for creepy, False for not creepy.

Try it!

explanation

>+7/.)JSQ2hJ
      JSQ        # Sort the input list (Q) and store the result in J
    .)           # pop the last/largest element from J (lets call it x)
          hJ     # the first/only element of J (lets call it y)
>+7/     2       # 7 + x/2 > y

old approach, 13 bytes

s.b<Y+7/N2_QQ

Takes a list. Outputs 1 for creepy, 0 for not-creepy.

Try it!

explanation

s.b<Y+7/N2_QQ
 .b       _QQ        # map over the list and it's reversal (variables: Y,N)
   <Y+7/N2           # Y < N/2 + 7
s                    # sum: False + False = 0; True + False = 1 (; True + True = 2 can never occur, because one of the ages is always larger or equal) 

Answer 41

CJam, 10 bytes

q~$~2d/7+<

Takes input as a list.

Try it online!

Explanation

q~          e# Read and eval input.
  $         e# Sort the list.
   ~        e# Dump the list on the stack.
    2d/7+   e# Apply age/2+7 to the greater age.
         <  e# Check if the other age is less than that.

Answer 42

Actually, 12 bytes

;RZ⌠i½7+≤⌡Mπ

Try it online, or run all test cases!

Outputs 1 if it's not creepy, and 0 if it is.

Explanation:

;RZ⌠i½7+≤⌡Mπ  implicit input: [a, b]
;RZ           zip input with its reverse ([[a,b], [b,a]])
   ⌠i½7+≤⌡M   for each pair:
    i           flatten
     ½7+        half of one plus 7
        ≤       is less than or equal to the other?
           π  product (acts as a boolean AND)

Answer 43

q/kdb+, 17 16 bytes

Solution:

{(x&y)<7+.5*x|y}

Try it online! (oK rather than q/kdb+)

Examples:

q){(x&y)<7+.5*x|y}[22;18]
0b
q){(x&y)<7+.5*x|y}[22;17]
1b

Explanation:

Outputs creepy as boolean 1b (true, creepy) or 0b (false, not creepy)

{(x&y)<7+.5*x|y} / solution
{              } / lambda function with implicit parameters x and y
            x|y  / max of x and y
         .5*     / multiply by 0.5 (aka divide by 2)
       7+        / add 7
      <          / less than?
 (x&y)           / min of x and y

Notes:

Polyglot in:

• q/kdb+
• K
• oK (see TIO link)

Answer 44

Alice, 21 18 bytes

/o
\i@/sh2:-6-.H+n

Try it online!

-3 bytes thanks to Martin Ender.

Input is in any format that includes exactly two integers. Output is 1 if creepy and 0 if not creepy.

Explanation

ish2:-6-.H+no

i                Input numbers
 s               Sort the two ages
  h2:            Divide larger age by 2 rounded up
     -           Subtract from smaller age
      6-         Subtract 6
        .H+      Determine whether result is negative
           n     Push 1 if was negative, 0 otherwise
            o    Output

Answer 45

tcl, 59

scan $argv %d\ %d x y
puts [expr max($x,$y)/2+7>min($x,$y)]

demo

To try, type

tclsh main.tcl Age1 Age2

on the green area.

Answer 46

Tcl, 44

I was losing to answers implementing it as a function, so I had to make mine into a function also:

proc c x\ y {expr max($x,$y)/2+7>min($x,$y)}

demo — You just have to press on the "Execute" button and see the 0 and 1 digits on the green area matching the question's creepiness values.

Answer 47

Wolfram Language, 16 bytes

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

Takes input as a list.

Answer 48

S.I.L.O.S, 64 bytes

readIO
j=i
readIO
x=i/2+7-j
y=j/2+7-i
if x c
if y c
print k
lblc

Try it online!

It prints out the letter "k" if the relationship is ok, otherwise it prints out nothing. I couldn't figure out any mathemagical way with standard mathematical operators to do an if x>0 pr y>0 to save bytes.

---

Alternatively, we can create an "or gate" by exploiting the fact that x^.5 will error out if the number is negative.This removes the need for a conditional, but lengthens our code. This version outputs 0 for creepy and some positive number for not creepy.

S.I.L.O.S, 67 bytes

readIO
j=i
readIO
x=0-i/2-7+j
y=0-j/2-7+i
a=x^.5+y^.5+1
printInt a

Try it online!

Answer 49

Python 3, 115 bytes

Edit : Bugfix according to @Alexx Roche

a=int(input())
b=int(input())
c=a
d=b
if b < a:
 c=b
 d=a
if not c < d/2.0+7:
 print("Not ",end='')
print("Creepy")

Try it online!

Answer 50

MATL, 10 bytes

tEP-X>-14>

My first ever solution. :) Try it online!

Explainer:

t    % push the input array [a b] (possibly redundant)
EP   % push the flipped(P)+doubled(E) array [2b 2a]
-    % subtract to get [a-2b b-2a]
X>   % take the maximum
-14> % if either exceeds -14, then it is creepy af bro!

Answer 51

Ly, 8 bytes

a2/7+Lfp

Try it online!

Explanation:

a2/7+Lfp

a        # sort (implicit input)
 2/7+    # halve and add 7
     L   # less than?
      fp # pop value, leaving just the result
         # implicit output

Answer 52

C, C++, Java, C#, D, 56 bytes

-1 byte thanks to Zacharý

int c(int a,int b){return((a>b?a:b)/2+7)>(a>b?b:a)?1:0;}

C, C++, D optimization : 52 bytes

int c(int a,int b){return((a>b?a:b)/2+7)>(a>b?b:a);}

• C++ convert bool object to int implicitly ( false = 0, true = 1 )
• In C, booleans are represented by integers values, where 0 is false, and 1 is true.
• I barely know how to print something in D, so i won't comment about boolean to int conversions in this language Zacharý just informed me that D bool to int conversion works exactly like in C/C++
• Unfortunately, Java and C# can't convert an integer to a boolean, so we need to use ternary operator.

Answer 53

Dyalog APL, 11 bytes

⌊<(⌊7+.5×⌈)

Try it online!

Answer 54

Sakura, 7 bytes

>Ƣ+ħ⓪7ƣ

Takes input as an array and outputs -1 if creepy and 0 otherwise.

Explanation:

>                     >
 Ƣ      max(         )
  +                +
   ħ             /2
    ⓪       input
     7              7
      ƣ                min(     )
                           input

Answer 55

Jq 1.5, 11 bytes

max/2+7>min

Try it online!

Answer 56

BASH, 135 bytes

I dabbled in this area a few years ago. I think that Greg Martin's point should factor in, and wonder how he picked 13 and not, (for example) 12 as 13 is the upper bound of x < x/2+7. Leo what is the test cases for [14,21], [15,15] and [16,21]?

#!/bin/bash
[ $1 -lt $2 ]&&./$0 $2 $1&&exit
[ $(($1+$2)) -ge $(((($1-$2)/2)**2)) ]&&[ $((((($2*10)+5)/19)+7)) -lt $2 ]&&echo -n 'Not ';echo Creepy

(could save bytes by using ✗ for "Creepy" and ✓ for "Not Creepy" or exit codes)

Answer 57

ARBLE, 25 bytes

lt(min(a,b),max(a,b)/2+7)

Try it online!

Answer 58

><>, 14 Bytes

:{:{(?r2,7+)n;

Pretty simple, but I don't see any obvious ways to cut down on characters.

Explanation:

               | Assume input is on the stack
:{:{           | Duplicate items on the stack (we pop them for inequality testing)
    (?r        | Sort them, so that the larger is on top of the stack
       2,7+    | Divide top item by 2 and add 7
           )n; | Print the truthy value of younger > (older/2) + 7

Prints 1 for non-creepy relationships, 0 for creepy ones

Answer 59

Add++, 8 bytes

L,#2/7+>

Try it online!

2 bytes off Jelly just feels weird

How it works

L,   - Lambda function
     - Example arguments: [15 50]
  #  - Sort;      STACK = [15 50]
  2/ - Halve;     STACK = [15 25]
  7+ - Add 7;     STACK = [15 32]
  >  - Greater;   STACK = [1]

Answer 60

Befunge, 28 bytes

&:&:00p`00g\> #0 #\_\7-2*`.@

Try It Online

Since Befunge uses integer math, I flipped it and added 7 to the minimum then multiplied by 2. 1 = Creepy, 0 = Not creepy

Answer 61

Pyt, 7 bytes

Đ↔₂7+≥Π

Try it online!

Takes input as an array of integers

Explanation:

       Implicit input [x,y]
Đ      Duplicate the array  [x,y],[x,y]
↔      Flip the top array   [x,y],[y,x]
₂      Divide the top of the stack by 2    [x,y],[y/2,x/2]
7+     Add 7 to each element of the top of the stack    [x,y],[y/2+7,x/2+7]
≥      Is the second on the stack greater than or equal to the top elementwise [x>=y/2+7,y>=x/2+7]
Π      Take the product (auto-casts to integers)
       Implicit print

Answer 62

Stax, 6 bytes

Æ╠àá;╚

Run and debug online

Here's the ungolfed ascii representation of the same program.

oE  sort inputs and push each to stack, now the larger age is on top of the stack
^h  increment larger age and integer divide by 2
7+  add 7
<   is the first number less than the second?

Run this one

Answer 63

Japt, 10 bytes

n v <U/2+7

Try it online!

Takes a 2-element array as input.

How it works

Un v <U/2+7

Un  Sort the input
v   Pop the first element (smaller one)
<   less than...
U/2+7  Implicitly cast the remaining 1-length array to number (larger one)
       then calculate /2+7