ตามการ์ตูน XKCD นี้มีสูตรที่จะตัดสินว่าช่องว่างของอายุในความสัมพันธ์นั้น "น่าขนลุก" หรือไม่ สูตรนี้ถูกกำหนดเป็น:

(Age/2) + 7

เป็นอายุขั้นต่ำของคนที่คุณสามารถเดท

ดังนั้นความสัมพันธ์จึงน่าขนลุกหากคนใดคนหนึ่งในความสัมพันธ์ดังกล่าวมีอายุน้อยกว่าอายุขั้นต่ำของอีกฝ่าย

เมื่อพิจารณาถึงอายุของสองคนคุณสามารถแสดงว่าความสัมพันธ์นั้นน่าขนลุกหรือไม่?

กฎระเบียบ

1. โปรแกรมของคุณควรใช้จำนวนเต็มสองจำนวนเป็นอินพุตอายุของทั้งคู่ในความสัมพันธ์ สิ่งเหล่านี้สามารถดำเนินการในรูปแบบที่เหมาะสม

2. โปรแกรมของคุณจะต้องส่งออกค่าความจริงหรือเท็จที่อธิบายว่าความสัมพันธ์นั้นเป็น "น่าขนลุก" หรือไม่ (Truthy = Creepy)

3. ไม่อนุญาตช่องโหว่มาตรฐาน
4. ปริศนานี้เป็นรหัสกอล์ฟดังนั้นคำตอบของรหัสที่สั้นที่สุดคือหน่วยไบต์

กรณีทดสอบ

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

เยลลี่ 6 ไบต์

H+7>ṚṀ

ลองออนไลน์!

อัลกอริทึมที่ดูเหมือนจะแตกต่างจากของสหาย

Python 3 , 26 ไบต์

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

ลองออนไลน์!
อินพุตเป็นรายการที่มีทั้งช่วงอายุ

05AB1E , 8 6 ไบต์

;7+R‹Z

ลองออนไลน์! หรือลองทดสอบทั้งหมด

         # 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, 551

สร้างด้วยLogisim

หลักการเดียวกับคำตอบอื่น ๆ ของฉันแต่รับอินพุตที่มีลายเซ็น 2 ไบต์ดังนั้นจึงสามารถจัดการได้47, 10000ได้ ใช้งานได้กับทุกกรณีทดสอบ!

สิ่งนี้ไม่เหมาะสำหรับกรณีทดสอบที่ระบุเนื่องจาก 10000 สามารถแสดงได้เพียง 15 จาก 16 บิต แต่ใช้ได้กับทุกช่วงอายุในช่วง [-32768, 32768) โปรดทราบว่าอายุติดลบใด ๆ จะกลับมา1จะกลับมา

อินพุตด้านซ้าย (ไม่มีคำสั่งซื้อพิเศษ 1 บิตที่ด้านบน) เอาต์พุตที่มุมล่างขวา

ประตู NAND, 274 262

เดิม:

ดีกว่า: สร้างด้วยLogisim

วิธีนี้ใช้สองอินพุตทางซ้ายเป็นจำนวนเต็ม 1 ไบต์ที่มีการเซ็นชื่อโดยมี 1 บิตที่ด้านบน เอาต์พุตอยู่ที่ด้านล่างซ้าย ความจริงและความเท็จที่นี่ควรชัดเจน

ใช้งานได้กับทุกกรณีทดสอบยกเว้น47, 10000ดังนั้นฉันเดาว่านี่ไม่ใช่คำตอบที่ถูกต้องทางเทคนิค อย่างไรก็ตามบุคคลที่เก่าแก่ที่สุดใน (เชื่อถือได้) บันทึกเป็น 122 ดังนั้น 8 บิต (สูงสุด 127) จะทำงานกับทุกสถานการณ์ที่เป็นไปได้จนถึงจุดนี้ ฉันจะโพสต์คำตอบใหม่ (หรือฉันควรแก้ไขคำนี้) เมื่อฉันเสร็จสิ้นรุ่น 16 บิต

เวอร์ชั่น 16 บิตเสร็จแล้ว!

คุณจะสังเกตเห็นส่วนแนวตั้งบางส่วนของวงจร อันแรก (จากซ้าย) กำหนดว่าอินพุทใดจะยิ่งใหญ่กว่า สองอันถัดไปคือมัลติเพล็กเซอร์เรียงลำดับอินพุต จากนั้นฉันจะเพิ่ม11111001(-7) ให้น้อยลงในส่วนที่สี่และฉันสรุปโดยการเปรียบเทียบสองครั้งนี้กับอินพุตที่มากขึ้น ถ้ามันน้อยความสัมพันธ์ก็น่าขนลุก lesser-7ตั้งแต่ผมเปลี่ยนบิตที่สองผมจะต้องคำนึงถึงบิตที่ไม่ได้ใช้ หากนี่คือ a แสดง1ว่าlesser-7เป็นลบและน้องของทั้งสองนั้นมีอายุไม่เกินหก น่าขนลุก ฉันจบด้วยประตู OR ดังนั้นหากการทดสอบความน่ากลัวกลับมา1มาทั้งวงจรจะทำ

ถ้าคุณมองอย่างใกล้ชิดคุณจะเห็นว่าผมใช้เจ็ดหนึ่งคงs (hardcoding 11111011และต่อท้าย0) ฉันทำสิ่งนี้เพราะ Logisim ต้องการค่าอย่างน้อยหนึ่งค่าเพื่อเข้าสู่ลอจิกเกตเพื่อสร้างเอาต์พุต อย่างไรก็ตามในแต่ละครั้งที่มีการใช้ค่าคงที่ประตู NAND สองแห่งจะตรวจสอบ1ค่าโดยไม่คำนึงถึงค่าคงที่

-12 ประตูขอบคุณฉัน !

C #, 22 ไบต์

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

C, 29 ไบต์

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

มันทำงานอย่างไร:

• #define f(a,b)กำหนดฟังก์ชั่นแมโครfที่ใช้สองอาร์กิวเมนต์ที่ไม่ได้พิมพ์
• a/2+7>b ตรวจสอบว่าอายุแรกหารด้วยสองบวกเจ็ดมีขนาดใหญ่กว่าอายุที่สอง
• b/2+7>a ตรวจสอบว่าอายุที่สองหารด้วยสองบวกเจ็ดมีขนาดใหญ่กว่าอายุแรก
• ถ้าค่าใดค่าหนึ่งข้างต้นเป็นจริงให้ส่งคืน 1 (น่าขนลุก) มิฉะนั้นส่งคืน 0 (ไม่น่าขนลุก)

ลองออนไลน์!

JavaScript (ES6), 21 ไบต์

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

ส่งคืนค่า 0 สำหรับไม่น่าขนลุก 1 สำหรับความน่าขนลุก

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 ไบต์

-1 ไบต์ขอบคุณ @djhurio

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

ลองออนไลน์!

เรติน่า 20 ไบต์

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

ลองออนไลน์!

อินพุตมีค่าไม่พร้อมกันที่มีตัวป้อนบรรทัดระหว่างตัวเลขสองตัว ผลลัพธ์คือ0(ไม่น่าขนลุก) หรือ1(น่าขนลุก)

คำอธิบาย

O`.+

จัดเรียงตัวเลขสองตัวเพื่อให้เรารู้ว่าตัวเลขที่ใหญ่กว่านั้นเป็นที่สอง

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

เรียกอายุที่น้อยลงaและอายุที่bมากขึ้น เราจับครั้งแรกในกลุ่มa-7 1จากนั้นเราก็พยายามให้ตรงกับ2*(a-7)+1ในbซึ่งหมายความว่าb >= 2*(a-7)+1หรือb >= 2*(a-7)หรือb/2+7 > aซึ่งเป็นเกณฑ์สำหรับความสัมพันธ์ที่น่าขนลุก

TI-Basic, 20 10 9 ไบต์

max(2Ans<14+max(Ans

-10 ไบต์โดยใช้รายการและส่วนหนึ่งของข้อเสนอแนะของ Timtech

-1 ไบต์โดยใช้คำแนะนำของ lirtosiast

เข้าสู่รายการสองอายุ "{40,42}: prgmNAME"

ส่งคืน 1 สำหรับ 'Creepy' และ 0 สำหรับ 'Not Creepy'

GNU APL 1.2, 23 ไบต์

กำหนดฟังก์ชั่นที่รับสองอาร์กิวเมนต์และพิมพ์ 1 ถ้าน่าขนลุก 0 ถ้าไม่

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

คำอธิบาย

∇เริ่มต้นและสิ้นสุดฟังก์ชั่น
A f Bเป็นส่วนหัวของฟังก์ชั่น; ฟังก์ชั่นชื่อfและใช้เวลาสองข้อโต้แย้งAและB(ฟังก์ชั่นใน APL สามารถเป็น monadic - รับหนึ่งอาร์กิวเมนต์ - หรือ dyadic - รับสองข้อโต้แย้ง)
A⌊Bคือmin(A,B)และA⌈Bเป็นmax(A,B)
APL จะถูกประเมินจากขวาไปซ้ายดังนั้นวงเล็บจำเป็นต้องให้ความสำคัญก่อน

ผู้ประกอบการรายอื่นอธิบายตนเอง

รหัสอาจเล่นกอล์ฟได้ฉันยังใหม่กับรหัสกอล์ฟ

Python 3, 74 45 ไบต์

กอล์ฟรหัสแรกน่ากลัวมาก

ลด 29 ไบต์โดย @Phoenix

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

JavaScript (ES6), 27 ไบต์

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

ไม่มีการ currying (โทรเหมือนf(a,b)แทนf(a)(b))

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

ถ้าb > aให้สลับพารามิเตอร์แล้วลองอีกครั้ง มิฉะนั้นตรวจสอบ การปิดกั้นไม่บันทึกไบต์ใด ๆ เนื่องจากการโทรซ้ำ

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 ไบต์

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

ไม่ใช่ของแท้แน่นอน

การทดสอบ

ลองออนไลน์!

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 ไบต์

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

ไม่สั้นไปกว่าการส่งไพ ธ อนอื่น ๆ แต่ฉันพบวิธีที่แตกต่างกันเล็กน้อยเพื่อตรวจสอบความน่ากลัว ฉันสังเกตเห็นว่าความแตกต่างที่ยอมรับได้ระหว่างอายุเท่ากับขั้นต่ำ - 14 นี่เป็นผลจากการจัดเรียงสูตรทางพีชคณิตใหม่

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

ให้ฉันแก้โดยไม่ต้องมีค่าคงที่สองค่าและไม่ต้องใช้ทั้ง max และ min แทนการใช้ abs (ab) จากมุมมองของการเล่นกอล์ฟฉันได้รับเพียงหนึ่งไบต์ที่น้อยกว่าโซลูชันของ @ nocturama แต่ฉันใช้สูตรที่แตกต่างออกไปเล็กน้อย

Excel, 26 24 ไบต์

สูตรเซลล์ที่รับอินพุตเป็นตัวเลขจากช่วงเซลล์A1:B1และส่งออกค่าบูลีนที่แสดงถึงความน่ากลัวไปยังเซลล์สูตร

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

รุ่นเก่า, 26 ไบต์

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

TI-Basic, 10 9 10 ไบต์

2min(Ans)-14≤max(Ans

รายการอินพุตจากAnsเอาต์พุต1ถ้า "น่าขนลุก" หรือ0อื่น ๆ

คณิตศาสตร์ , 16 ไบต์

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

ลองออนไลน์!

-2 ไบต์ขอบคุณ@GregMartin

จริงสำหรับไม่น่าขนลุกเท็จสำหรับน่าขนลุก

            (* 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 ไบต์

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

Röda , 16 ไบต์

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

ลองออนไลน์!

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่รับอินพุตเป็นสองตัวอักษร (ไม่ใช่อาร์เรย์) จากอินพุตสตรีม

คำอธิบาย

{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 ไบต์

{.max/2+7>.min}

ลองมัน

ขยาย

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

  .max / 2 + 7
  >
  .min
}

คริสตัล , 44 27 ไบต์

-17 จากการดูคำตอบของdanieroใน Ruby

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

ลองออนไลน์!

Python 3 - 32 27 ไบต์

ไม่สามารถแสดงความคิดเห็นได้ แต่ฉันได้รับคำตอบที่สั้นกว่าโซลูชัน Python 3 อื่น ๆ เล็กน้อย:

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

-5 ขอบคุณ @Cyoce!

ฟูเรียร์, 37 ไบต์

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

ลองใช้กับ FourIDE!

ใช้ตัวเลขสองตัวเป็นอินพุต จะตีกอล์ฟทีหลัง

PHP, 29 ไบต์

พิมพ์ 1 สำหรับน่าขนลุกไม่มีอะไรสำหรับไม่น่าขนลุก

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

ลองออนไลน์!

Japt , 11 ไบต์

ผลตอบแทนtrueสำหรับ "น่าขนลุก" และfalseไม่

wV /2+7>UmV

ลองออนไลน์

คำอธิบาย

      :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 ไบต์

<.<7+2%~>.

ผลผลิต1ไม่น่าขนลุก0สำหรับน่าขนลุก

คำอธิบาย

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

J-uby , 25 ไบต์

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

f^[80,32]โทรเช่น จะช่วยให้trueไม่น่าขนลุกfalseสำหรับน่าขนลุก

คำอธิบาย

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

AWK , 26 ไบต์

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

ลองออนไลน์!

เอาต์พุต 1 สำหรับ "Creepy" และ 0 สำหรับ "Not Creepy" สามารถบันทึกได้ 3 ไบต์หากไม่มีการส่งออกอาจพิจารณาค่าที่ผิดพลาดผ่าน:

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