Theo truyện tranh XKCD này , có một công thức để xác định xem khoảng cách tuổi tác trong mối quan hệ có "đáng sợ" hay không. Công thức này được định nghĩa là:

(Age/2) + 7

là độ tuổi tối thiểu của những người bạn có thể hẹn hò.

Do đó, một mối quan hệ là đáng sợ nếu một trong những người trong mối quan hệ nói trên trẻ hơn tuổi tối thiểu của người kia.

Với độ tuổi của hai người, bạn có thể đưa ra liệu mối quan hệ đó có đáng sợ hay không?

Quy tắc

1. Chương trình của bạn nên lấy hai số nguyên làm đầu vào, tuổi của cả hai người trong mối quan hệ. Đây có thể được thực hiện trong bất kỳ định dạng hợp lý.

2. Chương trình của bạn sau đó phải xuất ra một giá trị trung thực hoặc giả mạo mô tả xem mối quan hệ đó có "đáng sợ" hay không (Truthy = Creepy).

3. Sơ hở tiêu chuẩn không được phép.
4. Câu đố này là Code Golf, vì vậy câu trả lời với mã nguồn ngắn nhất tính bằng byte sẽ thắng

Các trường hợp thử nghiệm

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

Thạch , 6 byte

H+7>ṚṀ

Hãy thử trực tuyến!

Dường như thuật toán khác với đồng chí.

Python 3 , 26 byte

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

Hãy thử trực tuyến!
Đầu vào là một danh sách với cả hai lứa tuổi

05AB1E , 8 6 byte

;7+R‹Z

Hãy thử trực tuyến! hoặc Thử tất cả các bài kiểm tra

         # 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

Cổng NAND, 551

Được tạo bằng Logisim

Nguyên tắc tương tự như câu trả lời khác của tôi , nhưng có các đầu vào được ký 2 byte, vì vậy nó có thể xử lý 47, 10000. Hoạt động cho TẤT CẢ các trường hợp thử nghiệm!

Điều này không tối ưu cho các trường hợp thử nghiệm nhất định, vì 10000 có thể được biểu thị chỉ với 15 trong số 16 bit, nhưng nó hoạt động cho mọi lứa tuổi trong phạm vi [-32768, 32768). Lưu ý rằng bất kỳ tuổi tiêu cực sẽ trở lại 1.

Đầu vào bên trái (không có thứ tự cụ thể, 1 bit trên đầu). Đầu ra ở phía dưới bên phải.

Cổng NAND, 274 262

Nguyên:

Tốt hơn: Được tạo bằng Logisim

Điều này có hai đầu vào bên trái là số nguyên có chữ ký 1 byte, với 1 bit ở trên cùng. Đầu ra ở phía dưới bên trái; sự thật và falsey ở đây nên rõ ràng.

Hoạt động cho tất cả các trường hợp thử nghiệm ngoại trừ 47, 10000, vì vậy tôi đoán đây không phải là câu trả lời hợp lệ. Tuy nhiên, người lớn tuổi nhất trong hồ sơ (đáng tin cậy) là 122, vì vậy 8 bit (tối đa 127) sẽ hoạt động cho mọi kịch bản có thể xảy ra cho đến thời điểm này. Tôi sẽ đăng câu trả lời mới (hoặc tôi nên chỉnh sửa câu trả lời này?) Khi tôi hoàn thành phiên bản 16 bit.

Phiên bản 16 bit đã hoàn tất!

Bạn sẽ nhận thấy một số phần dọc của mạch. Cái đầu tiên (từ bên trái) xác định đầu vào nào lớn hơn. Hai cái tiếp theo là bộ ghép kênh, sắp xếp các đầu vào. Sau đó tôi thêm 11111001(-7) vào phần nhỏ hơn trong phần thứ tư và tôi kết luận bằng cách so sánh hai lần này với đầu vào lớn hơn. Nếu nó ít hơn, mối quan hệ là đáng sợ. Vì tôi thay đổi các bit thành gấp đôi, tôi phải tính đến bit không sử dụng lesser-7. Nếu đây là một 1, thì lesser-7là âm tính, và người trẻ hơn trong hai người không quá sáu tuổi. Rùng mình. Tôi kết thúc với một cổng OR, vì vậy nếu kiểm tra creepiness trở lại 1, toàn bộ mạch sẽ thực hiện.

Nếu bạn nhìn kỹ, bạn sẽ thấy rằng tôi đã sử dụng Bảy một hằng số s (thể xác định rõ 11111011và dấu 0). Tôi đã làm điều này bởi vì Logisim yêu cầu ít nhất một giá trị đi vào một cổng logic để tạo ra một đầu ra. Tuy nhiên, mỗi lần sử dụng một hằng số, hai cổng NAND đảm bảo một 1giá trị bất kể hằng số.

-12 cổng cảm ơn tôi !

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

Làm thế nào nó hoạt động:

• #define f(a,b)định nghĩa một hàm macro fcó hai đối số được đánh dấu.
• a/2+7>b kiểm tra xem tuổi thứ nhất chia cho hai cộng bảy có lớn hơn tuổi thứ hai không.
• b/2+7>a kiểm tra xem tuổi thứ hai chia cho hai cộng bảy có lớn hơn tuổi thứ nhất không.
• Nếu một trong các giá trị trên là đúng, trả về 1 (đáng sợ). Nếu không, trả về 0 (không đáng sợ).

Hãy thử trực tuyến!

JavaScript (ES6), 21 byte

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

Trả về 0 cho không đáng sợ, 1 cho đáng sợ.

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 nhờ @djhurio

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

Hãy thử trực tuyến!

Võng mạc , 20 byte

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

Hãy thử trực tuyến!

Đầu vào là đơn nhất với một dòng cấp giữa hai số. Đầu ra là 0(không đáng sợ) hoặc 1(đáng sợ).

Giải trình

O`.+

Sắp xếp hai số, để chúng ta biết rằng số lớn hơn là thứ hai.

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

Gọi tuổi nhỏ hơn avà tuổi lớn hơn b. Chúng tôi lần đầu tiên chụp a-7trong nhóm 1. Sau đó, chúng tôi cố gắng để phù hợp 2*(a-7)+1trong b, có nghĩa là b >= 2*(a-7)+1hay b >= 2*(a-7)hay b/2+7 > ađó là tiêu chí cho một mối quan hệ đáng sợ.

TI-Basic, 20 10 9 byte

max(2Ans<14+max(Ans

-10 byte bằng cách sử dụng danh sách và một phần đề xuất của Timtech

-1 byte sử dụng đề xuất của lirtosiast

Có một danh sách gồm hai lứa tuổi, "{40,42}: prgmNAME"

Trả về 1 cho 'đáng sợ' và 0 cho 'không đáng sợ'.

GNU APL 1.2, 23 byte

Xác định hàm có hai đối số và in 1 nếu đáng sợ, 0 nếu không.

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

Giải trình

∇bắt đầu và kết thúc chức năng
A f Blà tiêu đề chức năng; chức năng được đặt tên fvà nhận hai đối số, Avà B(chức năng trong APL có thể monadic - chụp một đối số - hoặc cặp đôi - lấy hai tham số)
A⌊Blà min(A,B)và A⌈Bđược max(A,B)
APL được đánh giá từ phải sang trái, vì vậy ngoặc là cần thiết để đảm bảo ưu tiên thích hợp

Các toán tử khác là tự giải thích.

Mã có thể là golf, tôi vẫn chưa quen với golf-code.

Python 3, 74 45 byte

Golf Code đầu tiên, có lẽ là khủng khiếp.

Giảm 29 byte bởi @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

Không có cà ri (gọi như f(a,b)thay vì f(a)(b))

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

Nếu b > a, trao đổi tham số và thử lại. Nếu không, hãy kiểm tra. Currying không lưu bất kỳ byte nào vì cuộc gọi đệ quy.

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

Hoàn toàn không phải bản gốc.

Kiểm tra

Hãy thử trực tuyến!

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

Không ngắn hơn nhiều so với các bài nộp trăn khác, nhưng tôi đã tìm thấy một cách hơi khác để kiểm tra sự đáng sợ. Tôi nhận thấy rằng sự khác biệt chấp nhận được giữa các độ tuổi bằng min - 14. Điều này xuất phát từ việc sắp xếp lại đại số công thức.

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

Điều này cho phép tôi giải quyết mà không cần hai hằng số, và cũng không cần sử dụng cả max và min, thay vào đó sử dụng abs (ab). Từ góc độ chơi gôn, tôi chỉ nhận được một byte ít hơn giải pháp của @ nocturama, nhưng tôi đã sử dụng một công thức hơi khác để làm điều đó.

Excel, 26 24 byte

Công thức ô lấy đầu vào là số từ phạm vi ô A1:B1và xuất giá trị boolean biểu thị sự đáng sợ cho ô công thức

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

Phiên bản cũ, 26 byte

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

TI-Basic, 10 9 10 byte

2min(Ans)-14≤max(Ans

Liệt kê đầu vào từ Ans, đầu ra 1nếu "đáng sợ" hoặc 0cách khác.

Toán học , 16 byte

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

Hãy thử trực tuyến!

-2 byte nhờ @GregMartin

Đúng cho không đáng sợ, sai cho đáng sợ.

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

Hãy thử trực tuyến!

Đây là một hàm ẩn danh nhận đầu vào là hai chữ (không phải là một mảng) từ luồng đầu vào.

Giải trình

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

Thử nó

Mở rộng

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

  .max / 2 + 7
  >
  .min
}

Pha lê , 44 27 byte

-17 từ việc nhìn vào câu trả lời của daniero trong Ruby.

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

Hãy thử trực tuyến!

Python 3 - 32 27 byte

Không thể nhận xét, nhưng tôi nhận được câu trả lời ngắn hơn một chút so với giải pháp Python 3 khác:

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

-5 cảm ơn @Cyoce!

Fourier, 37 byte

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

Hãy thử nó trên FourIDE!

Lấy hai số làm đầu vào. Sẽ chơi golf sau.

PHP, 29 byte

in 1 cho đáng sợ, không có gì cho Không đáng sợ

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

Hãy thử trực tuyến!

Japt , 11 byte

Trả về truecho "đáng sợ" vàfalse không.

wV /2+7>UmV

Dùng thử trực tuyến

Giải trình

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

Đầu ra 1cho không đáng sợ,0 cho đáng sợ

Giải trình

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

J-uby , 25 byte

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

Gọi như thế f^[80,32]. Cung cấp truecho không đáng sợ,false cho đáng sợ.

Giải trình

    :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

Hãy thử trực tuyến!

Đầu ra 1 cho "Creepy" và 0 cho "Không đáng sợ". Có thể lưu 3 byte nếu không có đầu ra có thể được coi là giá trị giả, thông qua:

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