Cette relation est-elle effrayante?

73

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
Leo
la source
3
Comment devrait age/2être arrondi? Probablement en hausse si la moitié exacte est supposée être le minimum? 17,21ferait un bon cas de test.
Martin Ender
4
@MartinEnder La valeur est un minimum, donc ne arrondissez pas du tout. Il n'est pas nécessaire que ce soit un entier.
Leo
81
Vous pouvez aussi ajouter 13, 13 - Creepy.
Greg Martin
12
47, 10000 est une ... combinaison intéressante. Je tiens également à souligner que, selon cette formule, il est effrayant pour Doctor Who de sortir avec n'importe quel humain.
David Conrad
8
@ DavidConrad - ben ouais. c'est fondamentalement beastiality de sa part ....
Batman

Réponses:

6

Gelée , 6 octets

H+7>ṚṀ

Essayez-le en ligne!

Apparemment algorithme différent de celui de camarade.

Erik le golfeur
la source
Eh bien, c'est pareil maintenant ...; p
Draco18s
@ Draco18s C'était toujours pareil avec la précédente soumission de 05AB1E.
Erik l'Outgolfer
17

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

Barre
la source
Avait le même avant que je lis les réponses existantes. +1
ElPedro
Il semble que vous puissiez réellement supposer un tuple où il est toujours (plus jeune, plus vieux) - juste demandé à OP - se demander ce qu'il va dire.
rm-vanda
@ rm-vanda j'ai demandé plus tôt, vous ne pouvez pas supposer
Stephen
15

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
Riley
la source
3
En tant que programmeur C, je conviens que 2 est la vérité.
mardi
@gmatht Cela devrait toujours renvoyer 0 ou 1, jamais 2.
Riley
4
[13,13] est doublement effrayant.
mardi
1
@ gmatht Je suppose que ce serait le double. Je n'ai pas pensé à des chiffres aussi petits. C'est toujours la vérité cependant.
Riley
@ Riley 2n'est pas la vérité, voyez ceci .
Okx
13

Portes NAND, 551

Calculateur de fluage 16 bits 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.

Khuldraeseth na'Barya
la source
10

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 !

Khuldraeseth na'Barya
la source
Remarqué une optimisation évidente. Si vous le signalez avant la modification, je vous créditerai tout de même!
Khuldraeseth na'Barya
9

C #, 22 octets

n=>m=>n<m/2+7|m<n/2+7;
TheLethalCoder
la source
1
Je ne suis pas un grand programmeur C #, mais le dernier point-virgule est-il requis dans le cadre de la fonction?
Olivier Grégoire
1
@ OlivierGrégoire C'est une syntaxe invalide si elle est omise; c'est une fonction anonyme
chat,
8

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!

MD XF
la source
vous devez retourner la comparaison, il devrait être comme >bnon<b
Khaled.K
Citer "être l’âge minimum" signifie que vous devez vérifier si age >= min, vous avez également besoin de AND, au lieu de OU, puisque les deux parties doivent satisfaire afin que cela ne soit pas effrayant, test case "47, 10000 - Creepy"
Khaled.K
ok j'ai corrigé l'erreur, mais la logique est fausse, elle retourne vrai, tio.run
Khaled.K
1
@Tas Nope .
MD XF
1
A bientôt, merci pour le lien
Tas
7

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

Rick Hitchcock
la source
Enregistrer un octet avec currying: a=>b=>au lieu de (a,b)=>, appelez avec f(40)(40).
Stephen
@StephenS, merci, a appris quelque chose de nouveau!
Rick Hitchcock
Pas de problème, j'ai appris quand quelqu'un m'a dit la même chose :), il ne fonctionne qu'avec deux paramètres, mais après ça n'en vaut pas la peine.
Stephen
5

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.

Martin Ender
la source
5

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

pizzapants184
la source
TI-BASIC ferme-t-il automatiquement les parenthèses sur un symbole test ( < <= = != >= >)?
Zacharý
@ Zacharý Non, TI-Basic ne ferme que les parenthèses à la fin d'une ligne ou de deux points.
pizzapants184
Oh, oups j'ai oublié que l'entrée était considérée comme une liste de nombres!
Zacharý
4

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.

Arc676
la source
1
Bienvenue sur le site!
OldBunny2800
Wow, gentil, GNU APL, je ne l'ai pas vu depuis un moment.
Zacharý
En outre, il est possible de prendre les arguments comme une liste: f Xalors (⌊/X)<7+.5×⌈/X. IIRC, vous pouvez supprimer la nouvelle ligne entre les deuxième et troisième lignes.
Zacharý
@ Zacharý Oui, les lambdas anonymes sont possibles. Ils ne sont pas supportés par cette version de GNU APL et la plus récente ne compile pas sur Mac. Certaines de mes autres réponses utilisent APL 1.7 parce que je les teste sur Ubuntu. Je n'ai pas utilisé lambdas (je pourrais peut-être les réparer plus tard) car je suis encore assez novice en APL.
Arc676
Essayez ngn-apl. C'est une source ouverte comme GNU APL, mais honnêtement, c'est mieux.
Zacharý
4

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
KuanHulio
la source
Bonjour, assurez-vous de bien formater votre code en utilisant le système de démarques.
Leo
ne vous inquiétez pas, quelqu'un m'a battu à
cause
Vous pouvez vous débarrasser de certains de ces espaces :)
Beta Decay,
En outre, lambda a,b:0 if(a/2)+7>b or(b/2)+7>a else 1devrait fonctionner et est beaucoup plus courte.
Pavel
1
lambda a,b:a/2+7>b or b/2+7>a. Abandonner le fardeau de ces satanés 1s et 0s et embrasser le pouvoir de True/ False!
Value Ink
3

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

Stephen
la source
3

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");
    }
  }
}
Olivier Grégoire
la source
1
+1 pour mentionner " Absolument pas original. ". Presque personne ne le fait, alors qu'ils sont presque tous identiques. Et j'ai pris la liberté d'ajouter un lien TIO à partir de votre code de test. Vous ne savez pas pourquoi vous ajoutez toujours un code de test, mais pas un lien TIO ? .. :)
Kevin Cruijssen
1
Merci Kevin! J'en ajoute parfois un, parfois pas. Cela dépend si mon IDE est ouvert ou fermé. C'est aussi simple que ça! : P De plus, je montre le code de test pour que les gens comprennent ce qui rend ce lambda valide. :)
Olivier Grégoire
3

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.

Delya Erricson
la source
Cela échoue sûrement sur [37,53] (pas dans la suite de tests mais) dans l'esprit (x / 2) +7 de ce fairway
Alexx Roche
@AlexxRoche Nope, quand on donne [37,53] comme [a, b], le calcul devrait devenir abs(37 - 53) > min(37, 53) - 14 = abs(-16) > 37 - 14 = 16 > 23 = False Ceci est la réponse correcte, car selon (x / 2) + 7, l'âge minimum pour 53 ans est53/2 + 7 = 26.5 + 7 = 33.5
Delya Erricson
3

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)
Taylor Scott
la source
2

TI-Basic, 10 9 10 octets

2min(Ans)-14≤max(Ans

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

Timtech
la source
2

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               *)
Pavel
la source
Économisez des 2octets en prenant les âges comme une liste:Max@#/2+7<Min@#&
ngenisis
2

SAS, 77 octets

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

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
Kritixi Lithos
la source
2

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
}
Brad Gilbert b2gills
la source
2

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!

nocturama
la source
vous pouvez supprimer cet espacelambda *a
Cyoce
1

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.

Beta Decay
la source
Il n'est pas nécessaire de produire une chaîne comme ça, ça peut être vrai ou faux
Leo
Beau golf. C'était rapide.
MD XF
1

PHP, 29 octets

imprime 1 pour creepy, rien pour pas creepy

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

Essayez-le en ligne!

Jörg Hülsermann
la source
Si j'ai bien compris les règles, cela échoue le [34,19]
Alexx Roche
1

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.
Hirsute
la source
1

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
Cyoce
la source
1

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 
Cyoce
la source
C'est une belle langue. J'ai passé beaucoup de temps à essayer d'atteindre des objectifs similaires avec Ruby (je l'ai appelé "Blurb"), mais m'appuyer lourdement method_missingentraînait trop de complexité. Cette approche est propre et élégante. Félicitations!
Jordanie
@ Jordan merci! Je ne peux pas prendre tout le mérite, car cela a été fortement inspiré par J (d'où son nom). Je suis ouvert aux suggestions d'un collègue programmeur Ruby si vous en avez.
Cyoce
@ Jordan, vous devriez voir certaines des réponses plus complexes de J-uby. Ils sont tout à fait quelque chose.
Cyoce
1

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
Robert Benson
la source