Secondo questo fumetto di XKCD , esiste una formula per determinare se il divario di età in una relazione è "inquietante". Questa formula è definita come:

(Age/2) + 7

essendo l'età minima delle persone che puoi frequentare.

Pertanto una relazione è inquietante se una delle persone in detta relazione è più giovane dell'età minima dell'altra.

Data l'età di due persone, puoi capire se quella relazione è inquietante?

Regole

1. Il tuo programma dovrebbe prendere due numeri interi come input, l'età di entrambe le persone nella relazione. Questi possono essere presi in qualsiasi formato ragionevole.

2. Il tuo programma deve quindi generare un valore di verità o falsità che descriva se la relazione è "inquietante" (Verità = Creepy).

3. Non sono ammesse scappatoie standard.
4. Questo puzzle è Code Golf, quindi vince la risposta con il codice sorgente più breve in byte

Casi test

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 byte

H+7>ṚṀ

Provalo online!

Algoritmo apparentemente diverso da quello del compagno.

Python 3 , 26 byte

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

Provalo online!
L'input è un elenco con entrambe le età

05AB1E , 8 6 byte

;7+R‹Z

Provalo online! oppure prova tutti i 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

Cancelli NAND, 551

Creato con Logisim

Stesso principio dell'altra mia risposta , ma accetta input con segno a 2 byte, quindi può gestirlo 47, 10000. Funziona con TUTTI i casi di test!

Questo non è ottimale per i casi di test dati, poiché 10000 possono essere espressi con solo 15 dei 16 bit, ma funziona per tutte le età nell'intervallo [-32768, 32768). Si noti che qualsiasi età negativa verrà restituita 1.

Ingressi a sinistra (nessun ordine particolare, 1 bit in alto). Uscita in basso a destra.

Porte NAND, 274 262

Originale:

Meglio: creato con Logisim

Questo accetta due input a sinistra come numeri interi con segno a 1 byte, con 1 bit in alto. L'output è in basso a sinistra; la verità e la falsità qui dovrebbero essere ovvie.

Funziona con tutti i casi di test tranne 47, 10000, quindi immagino che tecnicamente questa non sia una risposta valida. Tuttavia, la persona più anziana sul record (affidabile) era 122, quindi 8 bit (max 127) funzioneranno per qualsiasi scenario possibile fino a questo punto. Pubblicherò una nuova risposta (o dovrei modificarla?) Quando finisco la versione a 16 bit.

La versione a 16 bit è terminata!

Noterai alcune sezioni verticali del circuito. Il primo (da sinistra) determina quale input è maggiore. I prossimi due sono multiplexer, ordinando gli input. Aggiungo quindi 11111001(-7) al minore nella quarta sezione e concludo confrontando due volte questo con l'input maggiore. Se è inferiore, la relazione è inquietante. Dato che cambio i bit per raddoppiare, devo prendere in considerazione il bit inutilizzato di lesser-7. Se questo è un 1, allora lesser-7è negativo e il più giovane dei due non ha più di sei anni. Raccapricciante. Termino con un gate OR, quindi se uno dei test di creepiness ritorna 1, l'intero circuito lo fa.

Se guardi da vicino, vedrai che ho usato sette una costante s (codifica dura 11111011e finale 0). L'ho fatto perché Logisim richiede almeno un valore per un gate logico per produrre un output. Tuttavia, ogni volta che viene utilizzata una costante, due porte NAND garantiscono un 1valore indipendentemente dalla costante.

-12 porte grazie a me !

C #, 22 byte

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

C, 29 byte

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

Come funziona:

• #define f(a,b)definisce una funzione macro fche accetta due argomenti non tipizzati.
• a/2+7>b controlla se la prima età divisa per due più sette è più grande della seconda età.
• b/2+7>a controlla se la seconda età divisa per due più sette è più grande della prima età.
• Se uno dei valori sopra è vero, restituisce 1 (inquietante). Altrimenti, restituisce 0 (non inquietante).

Provalo online!

JavaScript (ES6), 21 byte

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

Restituisce 0 per non inquietante, 1 per inquietante.

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 byte

-1 byte grazie a @djhurio

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

Provalo online!

Retina , 20 byte

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

Provalo online!

L'input è unario con un avanzamento di riga tra i due numeri. L'output è 0(non inquietante) o 1(inquietante).

Spiegazione

O`.+

Ordina i due numeri, quindi sappiamo che quello più grande è il secondo.

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

Chiama l'età più piccola ae l'età più grande b. Prima catturiamo a-7in gruppo 1. Poi cerchiamo di abbinare 2*(a-7)+1in b, il che significa b >= 2*(a-7)+1o b >= 2*(a-7)o b/2+7 > ache è il criterio per un rapporto inquietante.

TI-Basic, 20 10 9 byte

max(2Ans<14+max(Ans

-10 byte usando un elenco e parte del suggerimento di Timtech

-1 byte usando il suggerimento di lirtosiast

Comprende un elenco di due età, "{40,42}: prgmNAME"

Restituisce 1 per "inquietante" e 0 per "non inquietante".

GNU APL 1.2, 23 byte

Definisce una funzione che accetta due argomenti e stampa 1 se inquietante, 0 se no.

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

Spiegazione

∇inizia e termina la funzione
A f Bè l'intestazione della funzione; La funzione viene denominata fe accetta due argomenti Ae B(le funzioni in APL possono essere monadiche - prendere un argomento - o diadico - prendere due argomenti)
A⌊Bè min(A,B)ed A⌈Bè max(A,B)
APL valutata da destra a sinistra, quindi sono necessarie le parentesi per garantire la corretta precedenza

Gli altri operatori si spiegano da soli.

Il codice potrebbe essere in grado di giocare a golf, io sono ancora nuovo a code-golf.

Python 3, 74 45 byte

First Code Golf, probabilmente terribile.

Riduzione di 29 byte di @Phoenix

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

JavaScript (ES6), 27 byte

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

Nessun curry (chiama come f(a,b)invece di f(a)(b))

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

Se b > a, scambiare i parametri e riprovare. Altrimenti, controlla. Currying non salva alcun byte a causa della chiamata ricorsiva.

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 byte

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

Assolutamente non originale.

analisi

Provalo 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 byte

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

Non molto più breve degli altri invii di Python, ma ho trovato un modo leggermente diverso per verificare la presenza di brividi. Ho notato che la differenza accettabile tra le età è pari a min - 14. Ciò deriva dalla riorganizzazione algebrica della 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

Questo mi consente di risolvere senza ricorrere a due costanti e anche senza utilizzare sia il massimo sia il minimo, invece di usare abs (ab). Dal punto di vista del golf ho ottenuto solo un byte in meno rispetto alla soluzione di @ nocturama, ma ho usato una formula leggermente diversa per farlo.

Excel, 26 24 byte

Formula della cella che accetta input come numeri dall'intervallo di celle A1:B1e genera un valore booleano che rappresenta la creepiness nella cella della formula

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

Vecchia versione, 26 byte

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

TI-Basic, 10 9 10 byte

2min(Ans)-14≤max(Ans

Elenco input da Ans, output 1se "inquietante" o 0altro.

Matematica , 16 byte

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

Provalo online!

-2 byte grazie a @GregMartin

Vero per non inquietante, falso per inquietante.

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

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

Röda , 16 byte

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

Provalo online!

Questa è una funzione anonima che accetta input come due letterali (non una matrice) dal flusso di input.

Spiegazione

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

{.max/2+7>.min}

Provalo

allargato

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

  .max / 2 + 7
  >
  .min
}

Crystal , 44 27 byte

-17 osservando la risposta di daniero in Ruby.

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

Provalo online!

Python 3 - 32 27 byte

Impossibile commentare, ma ho ottenuto una risposta leggermente più breve rispetto all'altra soluzione Python 3:

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

-5 grazie a @Cyoce!

Fourier, 37 byte

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

Provalo su FourIDE!

Accetta due numeri come input. Giocherà a golf più tardi.

PHP, 29 byte

stampa 1 per raccapricciante, niente per non inquietante

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

Provalo online!

Japt , 11 byte

Ritorna trueper "raccapricciante" e falseper non.

wV /2+7>UmV

Provalo online

Spiegazione

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

<.<7+2%~>.

Uscite 1per non inquietanti, 0per inquietanti

Spiegazione

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

J-uby , 25 byte

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

Chiama come f^[80,32]. Dà trueper non inquietante,false per inquietante.

Spiegazione

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

AWK , 26 byte

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

Provalo online!

Uscite 1 per "Creepy" e 0 per "Not Creepy". Potrebbe salvare 3 byte se nessun output potrebbe essere considerato un valore errato, tramite:

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