De acordo com esta história em quadrinhos do XKCD , existe uma fórmula para determinar se a diferença de idade em um relacionamento é "assustadora". Esta fórmula é definida como:

(Age/2) + 7

sendo a idade mínima das pessoas com quem você pode namorar.

Portanto, um relacionamento é assustador se uma das pessoas desse relacionamento for menor do que a idade mínima da outra.

Dada a idade de duas pessoas, você pode mostrar se esse relacionamento é assustador ou não?

Regras

1. Seu programa deve receber dois números inteiros como entrada, a idade de ambas as pessoas no relacionamento. Estes podem ser obtidos em qualquer formato razoável.

2. Seu programa deve gerar um valor verdadeiro ou falso, descrevendo se o relacionamento é ou não "assustador" (Verdade = assustador).

3. As brechas padrão não são permitidas.
4. Esse quebra-cabeça é o Code Golf, então a resposta com o menor código-fonte em bytes ganha

Casos de teste

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

Gelatina , 6 bytes

H+7>ṚṀ

Experimente online!

Algoritmo aparentemente diferente do do camarada.

Python 3 , 26 bytes

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

Experimente online!
A entrada é uma lista com ambas as idades

05AB1E , 8 6 bytes

;7+R‹Z

Experimente online! ou Experimente todos os testes

         # 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

Portões NAND, 551

Criado com o Logisim

Mesmo princípio que minha outra resposta , mas aceita entradas assinadas de 2 bytes, para que possa lidar 47, 10000. Funciona para TODOS os casos de teste!

Isso não é ideal para os casos de teste fornecidos, pois 10000 pode ser expresso com apenas 15 dos 16 bits, mas funciona para todas as idades no intervalo [-32768, 32768). Observe que qualquer idade negativa retornará 1.

Entradas à esquerda (sem ordem específica, 1 bit na parte superior). Saída no canto inferior direito.

Portas NAND, 274 262

Original:

Melhor: Criado com o Logisim

Isso leva duas entradas à esquerda como números inteiros assinados de 1 byte, com o 1 bit na parte superior. A saída está no canto inferior esquerdo; a verdade e a falsidade aqui devem ser óbvias.

Funciona para todos os casos de teste, exceto 47, 10000, então acho que tecnicamente não é uma resposta válida. No entanto, a pessoa mais velha no registro (confiável) era 122, portanto, 8 bits (máximo 127) funcionarão para qualquer cenário possível até este ponto. Vou postar uma nova resposta (ou devo editar esta?) Quando terminar a versão de 16 bits.

Versão de 16 bits está pronta!

Você notará algumas seções verticais do circuito. O primeiro (da esquerda) determina qual entrada é maior. Os próximos dois são multiplexadores, classificando as entradas. Em seguida, adicionar 11111001(-7) para o menor na quarta secção, e concluo comparando duas vezes aqui a entrada maior. Se for menor, o relacionamento é assustador. Como mudo os bits para o dobro, devo levar em consideração o pouco não utilizado de lesser-7. Se este é um 1, então lesser-7é negativo, e o mais novo dos dois não tem mais que seis. Arrepiante. Termino com um portão OR, portanto, se um dos testes de fluidez retornar 1, todo o circuito retornará .

Se você olhar de perto, verá que usei sete uma constante s (codificando permanentemente o 11111011e o final 0). Eu fiz isso porque o Logisim requer pelo menos um valor para um portão lógico produzir uma saída. No entanto, cada vez que uma constante é usada, duas portas NAND garantem um 1valor independentemente da constante.

-12 portões graças a mim !

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

Como funciona:

• #define f(a,b)define uma função macro fque recebe dois argumentos não digitados.
• a/2+7>b verifica se a primeira idade dividida por dois mais sete é maior que a segunda idade.
• b/2+7>a verifica se a segunda idade dividida por dois mais sete é maior que a primeira idade.
• Se um dos valores acima for verdadeiro, retorne 1 (assustador). Caso contrário, retorne 0 (não é assustador).

Experimente online!

JavaScript (ES6), 21 bytes

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

Retorna 0 para não assustador, 1 para assustador.

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

-1 byte graças a @djhurio

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

Experimente online!

Retina , 20 bytes

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

Experimente online!

A entrada é unária com um avanço de linha entre os dois números. A saída é 0(não assustadora) ou 1(assustadora).

Explicação

O`.+

Classifique os dois números, para que saibamos que o maior é o segundo.

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

Chame a idade menor ae a maior b. Primeiro capturamos a-7em grupo 1. Em seguida, tentar igualar 2*(a-7)+1em b, o que significa b >= 2*(a-7)+1ou b >= 2*(a-7)ou b/2+7 > ao que é o critério para uma relação assustador.

TI-Basic, 20 10 9 bytes

max(2Ans<14+max(Ans

-10 bytes usando uma lista e parte da sugestão da Timtech

-1 byte usando a sugestão de lirtosiast

Apresenta uma lista de duas idades, "{40,42}: prgmNAME"

Retorna 1 para 'assustador' e 0 para 'não assustador'.

GNU APL 1.2, 23 bytes

Define uma função que recebe dois argumentos e imprime 1 se assustador, 0 se não.

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

Explicação

∇inicia e termina a função
A f Bé o cabeçalho da função; A função é nomeada fe recebe dois argumentos Ae B(as funções na APL podem ser monádicas - com um argumento - ou diádicas - com dois argumentos) -
A⌊Bsão min(A,B)e A⌈Bsão max(A,B)
APL avaliadas da direita para a esquerda; portanto, são necessários parênteses para garantir a precedência adequada

Os outros operadores são auto-explicativos.

Código pode ser capaz de golfe, eu ainda sou novo em código de golfe.

Python 3, 74 45 bytes

Primeiro código Golf, provavelmente terrível.

Redução 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

Sem currying (chame como em f(a,b)vez de f(a)(b))

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

Se b > a, troque os parâmetros e tente novamente. Caso contrário, verifique. A currying não salva bytes por causa da chamada 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 não original.

Testando

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

Python 3, 31 bytes

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

Não é muito mais curto do que os outros envios de python, mas eu encontrei uma maneira um pouco diferente de verificar se há algo estranho. Notei que a diferença aceitável entre as idades é igual a min - 14. Isso decorre da reorganização algébrica da 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

Isso permite que eu resolva sem precisar de duas constantes e também sem precisar usar max e min, em vez de usar abs (ab). Do ponto de vista do golfe, obtive apenas um byte a menos que a solução do @ nocturama, mas usei uma fórmula ligeiramente diferente para isso.

Excel, 26 24 Bytes

Fórmula de célula que recebe a entrada como números do intervalo de células A1:B1e gera um valor booleano que representa a aspereza para a célula da fórmula

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

Versão antiga, 26 bytes

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

TI-Basic, 10 9 10 bytes

2min(Ans)-14≤max(Ans

Listar as entradas de Ans, saídas, 1se "assustador" ou 0não.

Matemática , 16 bytes

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

Experimente online!

-2 bytes graças a @GregMartin

Verdadeiro para não assustador, falso para assustador.

            (* 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]}

Experimente online!

Essa é uma função anônima que recebe a entrada como dois literais (não uma matriz) do fluxo de entrada.

Explicação

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

Tente

Expandido

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

  .max / 2 + 7
  >
  .min
}

Cristal , 44 27 bytes

-17 de olhar a resposta de daniero em Ruby.

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

Experimente online!

Python 3-32 27 bytes

Não foi possível comentar, mas recebi uma resposta um pouco mais curta do que a outra solução Python 3:

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

-5 graças a @Cyoce!

Fourier, 37 bytes

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

Experimente no FourIDE!

Toma dois números como entrada. Golf mais tarde.

PHP, 29 bytes

imprime 1 para assustador, nada para Não assustador

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

Experimente online!

Japonês , 11 bytes

Retorna truepara "assustador" e falsepara não.

wV /2+7>UmV

Experimente online

Explicação

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

Saídas 1para não assustador, 0para assustador

Explicação

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

J-uby , 25 bytes

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

Ligue como f^[80,32]. Dá truepara não assustador, falsepara assustador.

Explicação

    :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

Experimente online!

Saídas 1 para "Assustador" e 0 para "Não Assustador". Pode salvar 3 bytes se nenhuma saída puder ser considerada um valor falso, via:

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