Selon ce comic XKCD , il existe une formule pour déterminer si l'écart d'âge dans une relation est "effrayant". Cette formule est définie comme:

(Age/2) + 7

étant l'âge minimum des personnes avec qui vous pouvez sortir.

Par conséquent, une relation est effrayante si l’une des personnes dans ladite relation est plus jeune que l’âge minimum de l’autre.

Étant donné l'âge de deux personnes, pouvez-vous indiquer si cette relation est effrayante ou non?

Règles

1. Votre programme doit prendre deux nombres entiers en entrée, l’âge des deux personnes dans la relation. Ceux-ci peuvent être pris dans n'importe quel format raisonnable.

2. Votre programme doit alors sortir une valeur de vérité ou de fausseté décrivant si la relation est "effrayante" (Truthy = Creepy).

3. Les failles standard ne sont pas autorisées.
4. Ce casse-tête est Code Golf, donc la réponse avec le code source le plus court en octets gagne

Cas de 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

Gelée , 6 octets

H+7>ṚṀ

Essayez-le en ligne!

Apparemment algorithme différent de celui de camarade.

Python 3 , 26 octets

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

Essayez-le en ligne!
L'entrée est une liste avec les deux âges

05AB1E , 8 à 6 octets

;7+R‹Z

Essayez-le en ligne! ou essayez tous les tests

         # 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

Portes NAND, 551

Créé avec Logisim

Même principe que mon autre réponse , mais prend des entrées signées sur 2 octets, donc il peut gérer 47, 10000. Fonctionne pour TOUS les cas de test!

Ce n'est pas optimal pour les cas de test donnés, car 10000 peut être exprimé avec seulement 15 bits sur 16, mais cela fonctionne pour tous les âges compris dans l'intervalle [-32768, 32768). Notez que tout âge négatif reviendra 1.

Entrées à gauche (pas d'ordre particulier, 1 bit en haut). Sortie en bas à droite.

Portes NAND, 274 262

Original:

Mieux: Créé avec Logisim

Cela prend deux entrées à gauche sous forme d'entiers signés sur 1 octet, avec le bit 1 en haut. La sortie est en bas à gauche; la vérité et falsey ici devraient être évidents.

Fonctionne pour tous les cas de test sauf 47, 10000, alors je suppose que ce n’est techniquement pas une réponse valable. Cependant, la personne la plus âgée sur l'enregistrement (fiable) était de 122, de sorte que 8 bits (maximum 127) fonctionneront pour tous les scénarios possibles jusqu'à présent. Je posterai une nouvelle réponse (ou devrais-je modifier celle-ci?) Lorsque j'aurai terminé la version 16 bits.

La version 16 bits est terminée!

Vous remarquerez quelques sections verticales du circuit. Le premier (à gauche) détermine quelle entrée est la plus grande. Les deux suivants sont des multiplexeurs, triant les entrées. J'ajoute ensuite 11111001(-7) au plus petit dans la quatrième section, et je conclus en comparant deux fois ceci à l'entrée plus grande. Si c'est moins, la relation est effrayante. Puisque je décale les bits à doubler, je dois prendre en compte le bit inutilisé de lesser-7. Si c'est un 1, alors lesser-7est négatif, et le plus jeune des deux n'a pas plus de six ans. Terrifiant. Je termine avec une porte OU, donc si l’un ou l’autre des tests de fluage revient 1, c’est l’ensemble du circuit.

Si vous regardez attentivement, vous verrez que je sept une constante s (hardcoding la 11111011et arrière 0). Je l’ai fait parce que Logisim a besoin d’au moins une valeur pour qu'une porte logique produise une sortie. Cependant, chaque fois qu'une constante est utilisée, deux portes NAND assurent une 1valeur quelle que soit la constante.

-12 portes grâce à moi !

C #, 22 octets

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

C, 29 octets

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

Comment ça fonctionne:

• #define f(a,b)définit une fonction macro fqui prend deux arguments non typés.
• a/2+7>b vérifie si le premier âge divisé par deux plus sept est supérieur au deuxième âge.
• b/2+7>a vérifie si le deuxième âge divisé par deux plus sept est plus grand que le premier âge.
• Si l'une ou l'autre des valeurs ci-dessus sont vraies, retournez 1 (effrayant). Sinon, renvoyez 0 (pas effrayant).

Essayez-le en ligne!

JavaScript (ES6), 21 octets

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

Renvoie 0 pour ne pas être effrayant, 1 pour cet effrayant.

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 octets

-1 octet grâce à @djhurio

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

Essayez-le en ligne!

Rétine , 20 octets

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

Essayez-le en ligne!

La saisie est unaire avec un saut de ligne entre les deux nombres. La sortie est 0(pas effrayant) ou 1(effrayant).

Explication

O`.+

Triez les deux nombres, nous savons donc que le plus grand est le deuxième.

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

Appelez le plus petit aet le plus grand b. Nous capturons d'abord a-7en groupe 1. Ensuite , nous essayons de correspondre 2*(a-7)+1à b, ce qui signifie b >= 2*(a-7)+1ou b >= 2*(a-7)ou b/2+7 > aqui est le critère d'une relation chair de poule.

TI-Basic, 20 10 9 octets

max(2Ans<14+max(Ans

-10 octets en utilisant une liste et une partie de la suggestion de Timtech

-1 octet en utilisant la suggestion de lirtosiast

Prend une liste de deux âges, "{40,42}: prgmNAME"

Retourne 1 pour 'creepy' et 0 pour 'pas creepy'.

GNU APL 1.2, 23 octets

Définit une fonction qui prend deux arguments et imprime 1 si effrayant, 0 sinon.

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

Explication

∇commence et finit la fonction
A f Best l'en-tête de la fonction; fonction est nommée fet prend deux arguments, Aet B(les fonctions dans APL peuvent être monadiques - prenant un argument - ou dyadiques - prenant deux arguments)
A⌊Best min(A,B)et A⌈Best max(A,B)
APL est évalué de droite à gauche, des parenthèses sont donc nécessaires pour garantir la priorité.

Les autres opérateurs s'expliquent d'eux-mêmes.

Le code pourrait être adapté au golf, je suis encore novice en code-golf.

Python 3, 74 45 octets

First Code Golf, probablement terrible.

Réduction de 29 octets par @Phoenix

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

JavaScript (ES6), 27 octets

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

Pas de currying (appelez comme f(a,b)au lieu de f(a)(b))

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

Si b > a, permutez les paramètres et réessayez. Sinon, vérifiez. Le currying ne sauve aucun octet à cause de l'appel récursif.

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 octets

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

Absolument pas original.

Essai

Essayez-le en ligne!

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 octets

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

Pas beaucoup plus court que les autres soumissions Python, mais j’ai trouvé une façon légèrement différente de vérifier la chair de poule. J'ai remarqué que la différence acceptable entre les âges est égale à min - 14 ans. Cela découle de la réorganisation algébrique de la formule.

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

Cela me permet de résoudre sans avoir besoin de deux constantes, et aussi sans avoir besoin d'utiliser à la fois max et min, au lieu d'utiliser abs (ab). Du point de vue du golf, je n'ai eu qu'un octet de moins que la solution de @ nocturama, mais j'ai utilisé une formule légèrement différente pour le faire.

Excel, 26 à 24 octets

Formule de cellule qui prend en entrée des nombres dans la plage de cellules A1:B1et génère une valeur booléenne représentant la chair de poule dans la cellule de formule

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

Ancienne version, 26 octets

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

TI-Basic, 10 9 10 octets

2min(Ans)-14≤max(Ans

Répertorie les entrées depuis Ans, les sorties 1si "effrayant" ou 0autrement.

Mathématiques , 16 octets

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

Essayez-le en ligne!

-2 octets grâce à @GregMartin

Vrai pour pas effrayant, faux pour effrayant.

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

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

Röda , 16 octets

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

Essayez-le en ligne!

Il s'agit d'une fonction anonyme qui prend en entrée deux littéraux (et non un tableau) à partir du flux d'entrée.

Explication

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

{.max/2+7>.min}

L'essayer

Étendu

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

  .max / 2 + 7
  >
  .min
}

Crystal , 44 à 27 octets

-17 de regarder la réponse de daniero dans Ruby.

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

Essayez-le en ligne!

Python 3 - 32 27 octets

Impossible de commenter, mais j'ai eu une réponse un peu plus courte que l'autre solution Python 3:

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

-5 grâce à @Cyoce!

Fourier, 37 octets

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

Essayez-le sur FourIDE!

Prend deux nombres en entrée. Will golf plus tard.

PHP, 29 octets

imprime 1 pour creepy, rien pour pas creepy

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

Essayez-le en ligne!

Japt , 11 octets

Retourne truepour "creepy" et falsepour pas.

wV /2+7>UmV

Essayez-le en ligne

Explication

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

<.<7+2%~>.

Sorties 1pour pas effrayant, 0pour effrayant

Explication

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

J-uby , 25 octets

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

Appelle comme f^[80,32]. Donne truepour pas effrayant, falsepour effrayant.

Explication

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

AWK , 26 octets

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

Essayez-le en ligne!

Sorties 1 pour "Creepy" et 0 pour "Pas Creepy". Pourrait économiser 3 octets si no-output pouvait être considéré comme une valeur de fausseté, via:

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