Según este cómic de XKCD , hay una fórmula para determinar si la brecha de edad en una relación es "espeluznante". Esta fórmula se define como:

(Age/2) + 7

siendo la edad mínima de las personas con las que puedes salir.

Por lo tanto, una relación es espeluznante si alguna de las personas en dicha relación es más joven que la edad mínima de la otra.

Dada la edad de dos personas, ¿puede indicar si esa relación es espeluznante o no?

Reglas

1. Su programa debe tomar dos enteros como entrada, la edad de ambas personas en la relación. Estos se pueden tomar en cualquier formato razonable.

2. Su programa debe generar un valor verdadero o falso que describa si la relación es "espeluznante" (Verdad = Espeluznante).

3. Las lagunas estándar no están permitidas.
4. Este rompecabezas es Code Golf, por lo que gana la respuesta con el código fuente más corto en bytes

Casos de prueba

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

Jalea , 6 bytes

H+7>ṚṀ

Pruébalo en línea!

Algoritmo aparentemente diferente al del camarada.

Python 3 , 26 bytes

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

Pruébalo en línea!
La entrada es una lista con ambas edades.

05AB1E , 8 6 bytes

;7+R‹Z

Pruébalo en línea! o Prueba todas las pruebas

         # 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

Puertas NAND, 551

Creado con Logisim

El mismo principio que mi otra respuesta , pero toma entradas firmadas de 2 bytes, por lo que puede manejar 47, 10000. ¡Funciona para TODOS los casos de prueba!

Esto no es óptimo para los casos de prueba dados, ya que 10000 se puede expresar con solo 15 de los 16 bits, pero funciona para cualquier edad en el rango [-32768, 32768). Tenga en cuenta que cualquier edad negativa volverá 1.

Entradas a la izquierda (sin orden particular, 1 bit en la parte superior). Salida en la parte inferior derecha.

Puertas NAND, 274 262

Original:

Mejor: creado con Logisim

Esto toma dos entradas a la izquierda como enteros con signo de 1 byte, con 1 bit en la parte superior. La salida está en la esquina inferior izquierda; Lo verdadero y lo falso aquí debería ser obvio.

Funciona para todos los casos de prueba, excepto 47, 10000, así que supongo que técnicamente no es una respuesta válida. Sin embargo, la persona más vieja en el registro (confiable) era 122, por lo que 8 bits (máximo 127) funcionarán para cualquier escenario posible hasta este punto. Publicaré una nueva respuesta (¿o debería editar esta?) Cuando termine la versión de 16 bits.

¡La versión de 16 bits está lista!

Notarás algunas secciones verticales del circuito. El primero (desde la izquierda) determina qué entrada es mayor. Los siguientes dos son multiplexores, clasificando las entradas. Luego agrego 11111001(-7) al menor en la cuarta sección, y concluyo comparando dos veces esto con el mayor aporte. Si es menos, la relación es espeluznante. Como cambio los bits al doble, debo tener en cuenta el bit no utilizado lesser-7. Si esto es a 1, entonces lesser-7es negativo, y el menor de los dos no tiene más de seis años. Siniestro. Termino con una compuerta OR, por lo que si cualquiera de las pruebas de espesura regresa 1, todo el circuito lo hace.

Si se mira de cerca, verá que he utilizado siete Una constante s (codificando el 11111011importantes y el descenso 0). Hice esto porque Logisim requiere al menos un valor para una puerta lógica para producir una salida. Sin embargo, cada vez que se usa una constante, dos compuertas NAND aseguran un 1valor independientemente de la constante.

-12 puertas gracias a mí !

C #, 22 bytes

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

C, 29 bytes

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

Cómo funciona:

• #define f(a,b)define una función macro fque toma dos argumentos sin tipo.
• a/2+7>b comprueba si la primera edad dividida entre dos más siete es mayor que la segunda edad.
• b/2+7>a comprueba si la segunda edad dividida entre dos más siete es mayor que la primera edad.
• Si alguno de los valores anteriores es verdadero, devuelve 1 (espeluznante). De lo contrario, devuelve 0 (no espeluznante).

Pruébalo en línea!

JavaScript (ES6), 21 bytes

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

Devuelve 0 para no espeluznante, 1 para espeluznante.

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 bytes

-1 byte gracias a @djhurio

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

Pruébalo en línea!

Retina , 20 bytes

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

Pruébalo en línea!

La entrada está en unario con un salto de línea entre los dos números. La salida es 0(no espeluznante) o 1(espeluznante).

Explicación

O`.+

Ordene los dos números, para que sepamos que el más grande es el segundo.

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

Llame la edad más pequeña ay la edad más grande b. Primero capturamos a-7en grupo 1. Entonces tratamos de coincidir 2*(a-7)+1en b, lo que significa b >= 2*(a-7)+1o b >= 2*(a-7), o b/2+7 > aque es el criterio para una relación espeluznante.

TI-Basic, 20 10 9 bytes

max(2Ans<14+max(Ans

-10 bytes usando una lista y parte de la sugerencia de Timtech

-1 byte usando la sugerencia de lirtosiast

Toma una lista de dos edades, "{40,42}: prgmNAME"

Devuelve 1 para 'espeluznante' y 0 para 'no espeluznante'.

GNU APL 1.2, 23 bytes

Define una función que toma dos argumentos e imprime 1 si es espeluznante, 0 si no.

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

Explicación

∇comienza y termina la función
A f Bes el encabezado de la función; La función se nombra fy toma dos argumentos, Ay B(las funciones en APL pueden ser monádicas - tomar un argumento - o diádicas - tomar dos argumentos)
A⌊Bes min(A,B)y A⌈Bes max(A,B)
APL se evalúa de derecha a izquierda, por lo que se necesitan paréntesis para garantizar una precedencia adecuada

Los otros operadores se explican por sí mismos.

El código podría ser apto para el golf, todavía soy nuevo en el código del golf.

Python 3, 74 45 bytes

Primer código de golf, probablemente terrible.

Reducción de 29 bytes por @ Phoenix

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

JavaScript (ES6), 27 bytes

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

Sin curry (llame como en f(a,b)lugar de f(a)(b))

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

Si b > a, intercambie parámetros y vuelva a intentarlo. De lo contrario, verifique. El curry no guarda ningún byte debido a la llamada recursiva.

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 bytes

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

Absolutamente no original.

Pruebas

Pruébalo en línea!

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 bytes

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

No mucho más corto que las otras presentaciones de Python, pero encontré una forma ligeramente diferente de verificar si hay escalofríos. Noté que la diferencia aceptable entre edades es igual a min - 14. Esto se deduce de reorganizar algebraicamente la fórmula.

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

Esto me permitió resolver sin necesidad de dos constantes, y también sin necesidad de usar tanto max como min, en lugar de usar abs (ab). Desde la perspectiva del golf, solo obtuve un byte menos que la solución de @nocturama, pero usé una fórmula ligeramente diferente para hacerlo.

Excel, 26 24 bytes

Fórmula de celda que toma la entrada como números del rango de celda A1:B1y genera un valor booleano que representa la espesura a la celda de fórmula

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

Versión antigua, 26 bytes

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

TI-Basic, 10 9 10 bytes

2min(Ans)-14≤max(Ans

Lista de entrada de Ans, salidas 1si es "espeluznante" o de 0otra manera.

Matemáticas , 16 bytes

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

Pruébalo en línea!

-2 bytes gracias a @GregMartin

Verdadero para no espeluznante, falso para espeluznante.

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

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

Röda , 16 bytes

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

Pruébalo en línea!

Esta es una función anónima que toma la entrada como dos literales (no una matriz) de la secuencia de entrada.

Explicación

{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 bytes

{.max/2+7>.min}

Intentalo

Expandido

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

  .max / 2 + 7
  >
  .min
}

Cristal , 44 27 bytes

-17 de mirar la respuesta de daniero en Ruby.

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

Pruébalo en línea!

Python 3 - 32 27 bytes

No puedo comentar, pero obtuve una respuesta un poco más corta que la otra solución de Python 3:

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

-5 gracias a @Cyoce!

Fourier, 37 bytes

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

Pruébalo en FourIDE!

Toma dos números como entrada. Jugará golf más tarde.

PHP, 29 bytes

imprime 1 para espeluznante, nada para no espeluznante

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

Pruébalo en línea!

Japt , 11 bytes

Devuelve truepara "espeluznante" y falsepara no.

wV /2+7>UmV

Pruébalo en línea

Explicación

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

<.<7+2%~>.

Salidas 1para no espeluznante, 0para espeluznante

Explicación

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

J-uby , 25 bytes

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

Llama como f^[80,32]. Da truepor no espeluznante, falsepor espeluznante.

Explicación

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

AWK , 26 bytes

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

Pruébalo en línea!

Salidas 1 para "Creepy" y 0 para "Not Creepy". Podría ahorrar 3 bytes si no se puede considerar una salida como un valor falso, a través de:

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