Nach diesem XKCD-Comic gibt es eine Formel, um festzustellen, ob der Altersunterschied in einer Beziehung "gruselig" ist oder nicht. Diese Formel ist definiert als:

(Age/2) + 7

als das Mindestalter von Menschen, die Sie datieren können.

Daher ist eine Beziehung gruselig, wenn eine der Personen in dieser Beziehung jünger als das Mindestalter der anderen ist.

Können Sie angesichts des Alters von zwei Personen ausgeben, ob diese Beziehung gruselig ist oder nicht?

Regeln

1. Ihr Programm sollte zwei Ganzzahlen als Eingabe verwenden, das Alter beider Personen in der Beziehung. Diese können in jedem vernünftigen Format genommen werden.

2. Ihr Programm muss dann einen wahrheitsgemäßen oder falschen Wert ausgeben, der beschreibt, ob die Beziehung "gruselig" ist oder nicht (Truthy = Creepy).

3. Standardlücken sind nicht erlaubt.
4. Dieses Puzzle ist Code Golf, also gewinnt die Antwort mit dem kürzesten Quellcode in Bytes

Testfälle

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

Gelee , 6 Bytes

H+7>ṚṀ

Probieren Sie es online!

Ein scheinbar anderer Algorithmus als der des Genossen.

Python 3 , 26 Bytes

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

Probieren Sie es online!
Die Eingabe ist eine Liste mit beiden Altersgruppen

05AB1E , 8 6 Bytes

;7+R‹Z

Probieren Sie es online! oder Alle testen

         # 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

NAND-Tore, 551

Erstellt mit Logisim

Das gleiche Prinzip wie bei meiner anderen Antwort , es werden jedoch 2-Byte-signierte Eingaben verwendet, damit es funktioniert 47, 10000. Funktioniert für ALLE Testfälle!

Dies ist für die gegebenen Testfälle nicht optimal, da 10000 nur mit 15 der 16 Bits ausgedrückt werden kann, aber es funktioniert für jedes Alter im Bereich [-32768, 32768]. Beachten Sie, dass jedes negative Alter zurückkehrt 1.

Eingänge links (keine bestimmte Reihenfolge, 1 Bit oben). Ausgabe unten rechts.

NAND-Gatter, 274 262

Original:

Besser: Erstellt mit Logisim

Hierfür werden links zwei Eingänge als 1-Byte-Ganzzahlen mit Vorzeichen verwendet, wobei sich das 1-Bit oben befindet. Die Ausgabe erfolgt unten links. Die Wahrheit und Falschheit hier sollte offensichtlich sein.

Funktioniert mit Ausnahme von allen Testfällen. 47, 10000Ich denke, dies ist technisch keine gültige Antwort. Die älteste Person in der (zuverlässigen) Aufzeichnung war jedoch 122, sodass 8 Bits (maximal 127) für jedes Szenario funktionieren, das bis zu diesem Zeitpunkt jemals möglich war. Ich werde eine neue Antwort veröffentlichen (oder sollte ich diese bearbeiten?), Wenn ich die 16-Bit-Version fertiggestellt habe.

16-Bit-Version ist fertig!

Sie werden einige vertikale Abschnitte der Rennstrecke bemerken. Der erste (von links) bestimmt, welcher Eingang größer ist. Die nächsten beiden sind Multiplexer, die die Eingänge sortieren. Ich füge dann 11111001im vierten Abschnitt (-7) zu dem kleineren hinzu und vergleiche abschließend das Doppelte mit dem größeren Input. Wenn es weniger ist, ist die Beziehung gruselig. Da ich die Bits auf das Doppelte verschiebe, muss ich das nicht verwendete Bit von berücksichtigen lesser-7. Wenn dies a ist 1, lesser-7ist es negativ und der jüngere der beiden ist nicht älter als sechs. Gruselig. Ich beende mit einem ODER-Gatter, also, wenn irgendein Gruseltest zurückkommt 1, tut der gesamte Stromkreis.

Wenn Sie genau hinschauen, werden Sie feststellen, dass ich sieben Ein-Konstanten- s verwendet habe (Hardcodierung von 11111011und nach 0). Ich habe dies getan, weil Logisim mindestens einen Wert benötigt, damit ein Logikgatter eine Ausgabe erzeugt. Bei jeder Verwendung einer Konstante stellen jedoch zwei NAND-Gatter 1unabhängig von der Konstanten einen Wert sicher .

-12 Tore danke an mich !

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

Wie es funktioniert:

• #define f(a,b)Definiert eine Makrofunktion f, die zwei untypisierte Argumente akzeptiert.
• a/2+7>b prüft, ob das erste Alter geteilt durch zwei plus sieben größer ist als das zweite Alter.
• b/2+7>a prüft, ob das zweite Alter geteilt durch zwei plus sieben größer ist als das erste Alter.
• Wenn einer der obigen Werte wahr ist, geben Sie 1 zurück (gruselig). Andernfalls geben Sie 0 zurück (nicht gruselig).

Probieren Sie es online!

JavaScript (ES6), 21 Byte

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

Liefert 0 für nicht gruselig, 1 für gruselig.

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 danke an @djhurio

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

Probieren Sie es online!

Netzhaut , 20 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt unärmig mit einem Zeilenvorschub zwischen den beiden Zahlen. Die Ausgabe ist 0(nicht gruselig) oder 1(gruselig).

Erläuterung

O`.+

Sortieren Sie die beiden Zahlen, damit wir wissen, dass die größere die zweite ist.

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

Nenne das kleinere aund das größere Alter b. Wir erfassen zuerst a-7in der Gruppe 1. Dann versuchen wir , passen 2*(a-7)+1in b, was bedeutet , b >= 2*(a-7)+1oder b >= 2*(a-7)oder b/2+7 > awas das Kriterium für eine gruselige Beziehung.

TI-Basic, 20 10 9 Bytes

max(2Ans<14+max(Ans

-10 Bytes anhand einer Liste und eines Teils von Timtechs Vorschlag

-1 Byte mit dem Vorschlag von Lirtosiast

Nimmt eine Liste mit zwei Altersgruppen auf: "{40,42}: prgmNAME"

Gibt 1 für 'gruselig' und 0 für 'nicht gruselig' zurück.

GNU APL 1.2, 23 Bytes

Definiert eine Funktion, die zwei Argumente akzeptiert und 1 ausgibt, wenn sie gruselig ist, und 0, wenn nicht.

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

Erläuterung

∇beginnt und endet die Funktion
A f Bist der Funktionsheader; Funktion wird benannt fund nimmt zwei Argumente, Aund B(Funktionen in APL kann monadischen sein - ein Argument nehmen - oder Dyade - unter zwei Argumenten)
A⌊Bist min(A,B)und A⌈Bwird max(A,B)
wird APL von rechts nach links ausgewertet, so Klammern benötigt werden richtigen Vorrang , um sicherzustellen ,

Die anderen Operatoren sind selbsterklärend.

Code könnte golffähig sein, ich bin noch neu im Code-Golf.

Python 3, 74 45 Bytes

Erster Code Golf, wahrscheinlich schrecklich.

29-Byte-Reduzierung durch @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

Kein Curry (anrufen wie f(a,b)statt f(a)(b))

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

Wenn b > aja, tauschen Sie die Parameter aus und versuchen Sie es erneut. Andernfalls überprüfen. Durch das Ausführen werden aufgrund des rekursiven Aufrufs keine Bytes gespeichert.

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

Absolut nicht original.

Testen

Probieren Sie es 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

Nicht viel kürzer als die anderen Python-Einreichungen, aber ich habe einen etwas anderen Weg gefunden, um auf Gruseligkeit zu prüfen. Ich habe festgestellt, dass der akzeptable Unterschied zwischen den Altersstufen min - 14 beträgt. Dies ergibt sich aus der algebraischen Neuordnung der Formel.

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

Dadurch kann ich lösen, ohne zwei Konstanten zu benötigen und ohne sowohl max als auch min zu verwenden, anstatt abs (ab) zu verwenden. Aus Golfsicht habe ich nur ein Byte weniger als die Lösung von @ nocturama, aber ich habe eine etwas andere Formel verwendet, um dies zu tun.

Excel, 26 24 Bytes

Zellformel, die Eingaben als Zahlen aus dem Zellbereich A1:B1annimmt und einen booleschen Wert ausgibt, der die Gruseligkeit in der Formelzelle darstellt

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

Alte Version, 26 Bytes

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

TI-Basic, 10 9 10 Bytes

2min(Ans)-14≤max(Ans

Listeneingabe von Ans, gibt aus , 1ob "gruselig" oder 0anders.

Mathematik , 16 Bytes

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

Probieren Sie es online!

-2 Bytes dank @GregMartin

Richtig für nicht gruselig, falsch für gruselig.

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

Probieren Sie es online!

Dies ist eine anonyme Funktion, bei der die Eingabe als zwei Literale (kein Array) aus dem Eingabestream übernommen wird.

Erläuterung

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

Versuch es

Erweitert

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

  .max / 2 + 7
  >
  .min
}

Kristall , 44 27 Bytes

-17 von danieros antwort in ruby.

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

Probieren Sie es online!

Python 3 - 32 27 Bytes

Kann nicht kommentieren, aber ich habe eine etwas kürzere Antwort als die andere Python 3-Lösung:

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

-5 danke an @Cyoce!

Fourier, 37 Bytes

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

Probieren Sie es auf FourIDE!

Nimmt zwei Zahlen als Eingabe. Wird später Golf spielen.

PHP, 29 Bytes

druckt 1 für gruselig, nichts für nicht gruselig

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

Probieren Sie es online!

Japt , 11 Bytes

Gibt truefür "gruselig" und falsefür nicht zurück.

wV /2+7>UmV

Probieren Sie es online aus

Erläuterung

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

Ausgänge 1für nicht gruselig, 0für gruselig

Erläuterung

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

J-uby , 25 Bytes

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

Rufen Sie gerne an f^[80,32]. Gibt truefür nicht gruselig, falsefür gruselig.

Erläuterung

    :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

Probieren Sie es online!

Ausgänge 1 für "Creepy" und 0 für "Not Creepy". Könnte 3 Bytes einsparen, wenn keine Ausgabe als falscher Wert angesehen werden könnte, über:

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