รับค่าเป็นจำนวนเต็มบวกเป็นอินพุตงานของคุณคือส่งออกค่าจริงถ้าจำนวนหารด้วยผลรวมของตัวเลขสองหลักและค่าเท็จเป็นอย่างอื่น ( OEIS A134516 ) ในคำอื่น ๆ :

(sum_of_digits)*2 | number

• แทนค่าความจริง / เท็จสำหรับกรณีจริงและเท็จคุณอาจระบุชุดของค่า จำกัด สำหรับกรณีจริง / เท็จและเติมเต็มค่าอื่น ๆ สำหรับตัวอย่างง่ายๆคุณสามารถใช้0สำหรับกรณีจริงและตัวเลขอื่น ๆ ทั้งหมดสำหรับคดีเท็จ (หรือกลับกันหากคุณต้องการ)

• ใช้กฎอินพุตและเอาต์พุตมาตรฐาน ช่องโหว่เริ่มต้นยังใช้

• คุณสามารถรับอินพุตเป็นจำนวนเต็มหรือแทนสตริงของจำนวนเต็มนั้นได้

• นี่คือcode-golfดังนั้นโค้ดที่สั้นที่สุดในหน่วยไบต์ชนะ!

• ฉันใหม่สำหรับ PPCG ดังนั้นฉันต้องการให้คุณโพสต์คำอธิบายหากเป็นไปได้

กรณีทดสอบ

อินพุต - เอาต์พุต - (เหตุผล)

80 - Truthy - (16 หาร 80)
100 - ความจริง - (2 หาร 100)
60 - ความจริง - (12 หาร 60)
18 - Truthy - (18 แบ่ง 18)
12 - ความจริง - (6 แบ่ง 12)

4 - Falsy - (8 ไม่แบ่ง 4)
8 - Falsy - (16 ไม่แบ่ง 8)
16 - ความผิดพลาด - (14 ไม่ได้แบ่ง 16)
21 - เท็จ - (6 ไม่แบ่ง 21)
78 - เท็จ - (30 ไม่แบ่ง 78)
110 - เป็นเท็จ - (4 ไม่ได้ลดราคา 110)
111 - เท็จ - (6 ไม่แบ่ง 111)
390 - เท็จ - (24 ไม่แบ่ง 390)

Neim , 3 ไบต์

𝐬ᚫ𝕞

คำอธิบาย:

𝐬      Implicitly convert to int array and sum the digits
 ᚫ     Double
  𝕞   Is it a divisor of the input?

ลองออนไลน์!

รุ่นโดยละเอียด

JavaScript (ES6), 31 29 27 ไบต์

รับอินพุตเป็นสตริง ส่งกลับค่าศูนย์สำหรับความจริงและไม่ใช่ศูนย์สำหรับความเท็จ

n=>n%eval([...n+n].join`+`)

แสดงความคิดเห็น

n => n % eval([...n + n].join`+`)
n =>                                   // take input string n  -> e.g. "80"
                  n + n                // double the input     -> "8080"
              [...     ]               // split                -> ["8", "0", "8", "0"]
                        .join`+`       // join with '+'        -> "8+0+8+0"
         eval(                  )      // evaluate as JS       -> 16
     n %                               // compute n % result   -> 80 % 16 -> 0

กรณีทดสอบ

let f =

n=>n%eval([...n+n].join`+`)

console.log('[Truthy]');
console.log(f("80"))
console.log(f("100"))
console.log(f("60"))
console.log(f("18"))
console.log(f("12"))

console.log('[Falsy]');
console.log(f("4"))
console.log(f("8"))
console.log(f("16"))
console.log(f("21"))
console.log(f("78"))
console.log(f("110"))
console.log(f("111"))
console.log(f("390"))

C #, 46 ไบต์

using System.Linq;n=>n%(n+"").Sum(c=>c-48)*2<1

เวอร์ชันเต็ม / ฟอร์แมต:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<int, bool> f = n => n % (n + "").Sum(c => c - 48) * 2 < 1;

        Console.WriteLine(f(80));
        Console.WriteLine(f(100));
        Console.WriteLine(f(60));

        Console.WriteLine();

        Console.WriteLine(f(16));
        Console.WriteLine(f(78));
        Console.WriteLine(f(390));

        Console.ReadLine();
    }
}

เรติน่า , 38 27 ไบต์

-11 ไบต์และแก้ไขข้อผิดพลาดด้วยรหัสขอบคุณ @MartinEnder

$
$_¶$_
.+$|.
$*
^(.+)¶\1+$

ลองออนไลน์!

พิมพ์ 1 ถ้าหารด้วย 0 มิฉะนั้น

คำอธิบาย (หวังว่าฉันจะได้รับสิทธินี้)

$
$_¶$_

ต่อท้ายอินพุตทั้งหมดบวกกับบรรทัดใหม่บวกอินพุตอีกครั้ง

.+$|.
$*

แปลงแต่ละการแข่งขันให้เป็นคู่ (ทั้งบรรทัดที่สองซึ่งเป็นอินพุตต้นฉบับหรือแต่ละหลักในบรรทัดแรก)

^(.+)¶\1+$

ตรวจสอบว่าบรรทัดแรก (ผลรวมหลักสองเท่า) เป็นตัวหารของบรรทัดที่สอง

MATL , 7 ไบต์

tV!UsE\

ส่งออก0ถ้าหารด้วยจำนวนเต็มบวก โดยเฉพาะมันจะเอาท์พุทที่เหลือของการหารตัวเลขด้วยผลรวมของตัวเลขสองเท่า

ลองออนไลน์!

คำอธิบาย

t   % Implicit input. Duplicate
V!U % Convert to string, transpose, convert to number: gives column vector of digits
s   % Sum
E   % Times 2
\   % Modulus. Implicit display

05AB1E , 5 4 ไบต์

-1 ไบต์ต้องขอบคุณOkx

SO·Ö

ลองออนไลน์!

คุณยังสามารถลบÖล่าสุดเพื่อรับ 0 สำหรับความจริงและอย่างอื่นสำหรับความเท็จทำให้มีเพียง 3 ไบต์ แต่สำหรับฉันที่ดูเหมือนจะไม่พอดีกับคำจำกัดความที่เหมาะสม

คำอธิบาย

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?

x86-64 รหัสเครื่อง 24 ไบต์

6A 0A 5E 31 C9 89 F8 99 F7 F6 01 D1 85 C0 75 F7 8D 04 09 99 F7 F7 92 C3

รหัสด้านบนจะกำหนดฟังก์ชั่นในรหัสเครื่อง 64 บิต x86 ที่กำหนดว่าค่าอินพุตถูกหารด้วยผลรวมของตัวเลขสองหลักหรือไม่ ฟังก์ชั่นนี้เป็นไปตามข้อกำหนดการเรียกใช้ System V AMD64 เพื่อให้สามารถเรียกใช้ได้จากแทบทุกภาษาเหมือนกับว่าเป็นฟังก์ชัน C

ใช้พารามิเตอร์เดียวเป็นอินพุตผ่านEDIregister ซึ่งเป็นไปตามระเบียบการเรียกซึ่งเป็นจำนวนเต็มเพื่อทดสอบ (นี่จะถือว่าเป็นจำนวนเต็มบวกสอดคล้องกับกฎท้าทายและจำเป็นสำหรับCDQคำสั่งที่เราใช้ในการทำงานอย่างถูกต้อง)

มันจะส่งคืนผลลัพธ์ในEAXรีจิสเตอร์อีกครั้งตามระเบียบการโทร ผลลัพธ์จะเป็น 0 หากค่าอินพุตถูกหารด้วยผลรวมของตัวเลขและไม่ใช่ศูนย์มิฉะนั้น (โดยทั่วไปแล้วบูลีนผกผันเหมือนกับตัวอย่างที่ให้ไว้ในกฎการท้าทาย)

ต้นแบบ C มันจะเป็น:

int DivisibleByDoubleSumOfDigits(int value);

ต่อไปนี้เป็นคำแนะนำภาษาแอสเซมบลีที่ไม่ได้รับการบันทึกประกอบคำอธิบายโดยย่อเกี่ยวกับวัตถุประสงค์ของการเรียนการสอนแต่ละคำ:

; EDI == input value
DivisibleByDoubleSumOfDigits:
   push 10
   pop  rsi             ; ESI <= 10
   xor  ecx, ecx        ; ECX <= 0
   mov  eax, edi        ; EAX <= EDI (make copy of input)

SumDigits:
   cdq                  ; EDX <= 0
   div  esi             ; EDX:EAX / 10
   add  ecx, edx        ; ECX += remainder (EDX)
   test eax, eax
   jnz  SumDigits       ; loop while EAX != 0

   lea  eax, [rcx+rcx]  ; EAX <= (ECX * 2)
   cdq                  ; EDX <= 0
   div  edi             ; EDX:EAX / input
   xchg edx, eax        ; put remainder (EDX) in EAX
   ret                  ; return, with result in EAX

ในบล็อกแรกเราทำการเริ่มต้นเบื้องต้นของการลงทะเบียน:

• PUSH+ POPคำสั่งถูกใช้เป็นวิธีที่ช้า แต่สั้น ๆ ในการเริ่มต้นESIถึง 10 สิ่งนี้เป็นสิ่งจำเป็นเนื่องจากDIVคำสั่งใน x86 ต้องการตัวถูกดำเนินการลงทะเบียน (ไม่มีรูปแบบที่หารด้วยค่าทันทีคือ, พูด, 10. )
• XORใช้เป็นวิธีสั้นและรวดเร็วในการล้างข้อมูลการECXลงทะเบียน การลงทะเบียนนี้จะทำหน้าที่เป็น "ตัวสะสม" ภายในวงที่กำลังจะมาถึง
• ในที่สุดก็มีการทำสำเนาของค่าอินพุต (จากEDI) และเก็บไว้ในEAXซึ่งจะถูกอุดตันเมื่อเราผ่านลูป

จากนั้นเราเริ่มวนซ้ำและสรุปตัวเลขในค่าอินพุต นี้จะขึ้นอยู่กับ x86 DIVคำแนะนำซึ่งแบ่งEDX:EAXโดยถูกดำเนินการและผลตอบแทนที่ฉลาดในและที่เหลือในEAX EDXสิ่งที่เราจะทำที่นี่คือหารค่าอินพุตด้วย 10 ส่วนที่เหลือคือตัวเลขในตำแหน่งสุดท้าย (ซึ่งเราจะเพิ่มในการลงทะเบียนแอECXคคิวมูเลเตอร์ของเรา) และผลหารคือตัวเลขที่เหลือ

• CDQการเรียนการสอนเป็นวิธีที่สั้น ๆ ของการตั้งค่าEDXเป็น 0 มันจริงลงชื่อเข้าใช้ขยายค่าในEAXการEDX:EAXซึ่งเป็นสิ่งที่DIVใช้เป็นเงินปันผล เราไม่ต้องการส่วนขยายสัญญาณที่นี่จริง ๆ เนื่องจากค่าอินพุตนั้นไม่ได้ลงนาม แต่CDQเป็น 1 ไบต์ซึ่งต่างจากการใช้XORเพื่อล้างEDXซึ่งจะเป็น 2 ไบต์
• แล้วเราDIVide EDX:EAXโดยESI(10)
• ส่วนที่เหลือ ( EDX) ถูกเพิ่มเข้าไปในแอคคิวมูเลเตอร์ ( ECX)
• EAXทะเบียน (ความฉลาด) มีการทดสอบเพื่อดูว่ามันจะมีค่าเท่ากับ 0 ถ้าเช่นนั้นเราได้ทำให้มันผ่านทั้งหมดของตัวเลขและเราตกผ่าน ถ้าไม่เรายังคงมีจำนวนผลรวมมากกว่าดังนั้นเรากลับไปที่ด้านบนของลูป

ในที่สุดหลังจากลูปเสร็จสิ้นเราจะใช้number % ((sum_of_digits)*2):

• LEAการเรียนการสอนจะใช้เป็นวิธีที่สั้นคูณECX2 (หรือเท่ากันเพิ่มECXกับตัวเอง) และจัดเก็บผลในการลงทะเบียนที่แตกต่างกัน (ในกรณีนี้EAX)

  ^{(เราสามารถทำadd ecx, ecx+ ได้xchg ecx, eaxทั้งสองมี 3 ไบต์ แต่LEAคำสั่งนั้นเร็วกว่าและทั่วไปกว่า)}

• จากนั้นเราทำCDQอีกครั้งเพื่อเตรียมพร้อมสำหรับการหาร เนื่องจากEAXจะเป็นค่าบวก (กล่าวคือไม่ได้ลงนาม) สิ่งนี้มีผลของการEDXเป็นศูนย์เหมือนเมื่อก่อน
• ถัดไปคือการหารคราวนี้หารEDX:EAXด้วยค่าอินพุต (สำเนาที่ไม่ได้ทำลายซึ่งยังคงอยู่EDI) EDXนี้จะเทียบเท่ากับโมดูโลกับที่เหลือใน (ความฉลาดยังใส่อยู่EAXแต่เราไม่ต้องการ)
• สุดท้ายเราXCHG(แลกเปลี่ยน) เนื้อหาของและEAX EDXโดยปกติคุณจะทำMOVที่นี่ แต่XCHGเพียง 1 ไบต์ (แม้ว่าช้ากว่า) เนื่องจากEDXมีส่วนที่เหลือหลังการหารมันจะเป็น 0 ถ้าค่านั้นหารได้อย่างสม่ำเสมอหรือไม่เป็นศูนย์ ดังนั้นเมื่อเราRETโกศEAX(ผลลัพธ์) คือ 0 ถ้าค่าอินพุตถูกหารด้วยสองผลรวมของตัวเลขหรือไม่ใช่ศูนย์มิฉะนั้น

หวังว่าพอเพียงสำหรับคำอธิบาย
นี่ไม่ใช่รายการที่สั้นที่สุด แต่เดี๋ยวก่อนดูเหมือนว่ามันจะเป็นภาษาที่ไม่ใช่กอล์ฟเกือบทั้งหมด! :-)

Japtap , 7 4 ไบต์

รับอินพุตเป็นสตริง ขาออก0สำหรับtrueหรือมากกว่าจำนวนกว่า0สำหรับfalseซึ่งจากการแก้ปัญหาอื่น ๆ จะปรากฏเป็นที่ถูกต้อง ถ้าไม่บอกให้ฉันรู้แล้วฉันจะย้อนกลับ

%²¬x

ทดสอบมัน

คำอธิบาย

Uการป้อนข้อมูลโดยนัยของสตริง
"390"

²

ทำซ้ำUสองครั้ง
"390390"

¬

แยกเป็นอาร์เรย์ของอักขระแต่ละตัว
["3","9","0","3","9","0"]

x

ลดโดยการรวมแล้วหล่ออักขระแต่ละตัวให้เป็นจำนวนเต็มในกระบวนการโดยอัตโนมัติ
24

%

รับส่วนที่เหลือของการหารUด้วยผลลัพธ์ยังชี้ขาดUเป็นจำนวนเต็มในกระบวนการโดยอัตโนมัติ ส่งออกจำนวนเต็มผลลัพธ์โดยปริยาย
6 (=false)

C89, 55 53 ไบต์

^{(ขอบคุณ Steadybox!}

s,t;f(x){for(t=x,s=0;t;t/=10)s+=t%10;return x%(s*2);}

มันใช้เวลาอินพุตเดียวxซึ่งเป็นค่าที่จะทดสอบ มันจะคืนค่า 0 หากxแบ่งเท่า ๆ กันด้วยผลรวมของตัวเลขสองหลักหรือไม่ใช่ศูนย์

ลองออนไลน์!

Ungolfed:

/* int */ s, t;
/*int */ f(/* int */ x)
{
    for (t = x, s = 0; t /* != 0 */; t /= 10)
        s += (t % 10);
    return x % (s * 2);
}

อย่างที่คุณเห็นนี่เป็นข้อได้เปรียบของกฎเกณฑ์นัยโดยนัยของ C89 ตัวแปรโกลบอลsและtถูกประกาศโดยนัยว่าints (พวกมันกำลังเริ่มต้นโดยปริยายเป็น 0 เพราะมันเป็นทรงกลม แต่เราไม่สามารถใช้ประโยชน์จากสิ่งนี้ได้ถ้าเราต้องการให้ฟังก์ชั่นสามารถเรียกได้หลายครั้ง)

ในทำนองเดียวกันฟังก์ชั่นที่fใช้พารามิเตอร์เดียวx,ซึ่งเป็นปริยายและจะส่งกลับintint

โค้ดภายในฟังก์ชั่นนั้นค่อนข้างตรงไปตรงมาแม้ว่าforลูปจะดูแปลกมากหากคุณไม่คุ้นเคยกับไวยากรณ์ โดยทั่วไปforส่วนหัววนใน C ประกอบด้วยสามส่วน:

for (initialization; loop condition; increment)

ในส่วน "การเริ่มต้น" เราได้เริ่มต้นตัวแปรทั่วโลกของเรา สิ่งนี้จะทำงานหนึ่งครั้งก่อนที่จะวนซ้ำ

ในส่วน "เงื่อนไขลูป" เราได้ระบุไว้ในเงื่อนไขที่ลูปควรดำเนินการต่อ สิ่งนี้น่าจะชัดเจน

ในส่วน "การเพิ่มขึ้น" เราจะใส่รหัสโดยพลการเนื่องจากสิ่งนี้จะทำงานในตอนท้ายของทุกลูป

sวัตถุประสงค์ขนาดใหญ่ของวงคือการย้ำผ่านแต่ละหลักในมูลค่าใส่เพิ่มให้ ในที่สุดหลังจากวนรอบเสร็จแล้วsจะเพิ่มเป็นสองเท่าและถ่ายโมดูโลxเพื่อดูว่ามันหารได้อย่างเท่าเทียมกันหรือไม่ (คำอธิบายที่ดีกว่าและมีรายละเอียดเพิ่มเติมเกี่ยวกับตรรกะที่นี่สามารถพบได้ในคำตอบอื่น ๆ ของฉันซึ่งคำตอบนี้ขึ้นอยู่)

รุ่นที่มนุษย์อ่านได้:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}

Brachylogขนาด 8 ไบต์

ẹ+×₂;I×?

ลองออนไลน์!

คำอธิบาย

ẹ+           Sum the digits
  ×₂         Double
    ;I×?     There is an integer I such that I×(double of the sum) = Input

Python 2 , 34 32 ไบต์

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

lambda n:n%sum(map(int,`n`)*2)<1

ลองออนไลน์!

Mathematica ขนาด 26 ไบต์

(2Tr@IntegerDigits@#)∣#&

ไม่มีเงื่อนงำทำไม∣มีความสำคัญสูงกว่าการคูณ ...

PHP , 41 ไบต์

พิมพ์ศูนย์ถ้าหารด้วยจำนวนเต็มบวก

<?=$argn%(2*array_sum(str_split($argn)));

ลองออนไลน์!

Excel, 63 ไบต์

=MOD(A1,2*SUMPRODUCT(--MID(A1,ROW(OFFSET(A$1,,,LEN(A1))),1)))=0

ข้อสรุปตัวเลขคือบิตที่มีความยาว

Perl 6 , 19 ไบต์

{$_%%(2*.comb.sum)}

ลองออนไลน์!

Husk , 9 8 ไบต์

ขอบคุณ Leo ที่ช่วยประหยัด 1 ไบต์

Ṡ¦ȯ*2ṁis

ลองออนไลน์!

คำอธิบาย

Ṡ¦ȯ         Test whether f(x) divides x, where f is the function obtained by
            composing the next 4 functions.
       s    Convert x to a string.
     ṁi     Convert each character to an integer and sum the result.
   *2       Double the result.

Haskell , 38 37 42 ไบต์

ขอบคุณ Zgarb สำหรับการเล่นกอล์ฟ 1 ไบต์

f x=read x`mod`foldr((+).(*2).read.pure)0x

ลองออนไลน์!

รับอินพุตเป็นสตริง ส่งกลับค่า 0 ถ้าหารได้และไม่ใช่ศูนย์

Python 3, 35 ไบต์

lambda a:a%(sum(map(int,str(a)))*2)

TI-BASIC, 27 26 21 ไบต์

-5 ขอบคุณ@Oki

:fPart(Ans/sum(2int(10fPart(Ans10^(~randIntNoRep(1,1+int(log(Ans

นี้จะทำพลิกแพลงจากข้อเท็จจริงที่ว่าไม่มีวิธีที่รัดกุมเพื่อสรุปตัวเลขจำนวนเต็มในTI-BASIC ผลตอบแทน0สำหรับและจำนวนที่แตกต่างกันสำหรับTrueFalse

คำอธิบาย:

:fPart(Ans/sum(2int(10fPart(Ans10^(-randIntNoRep(1,1+int(log(Ans
                               10^(-randIntNoRep(1,1+int(log(Ans #Create a list of negative powers of ten, based off the length of the input, i.e. {1,0.1,0.01}
                            Ans                                  #Scalar multiply the input into the list
                    10fPart(                                     #Remove everything left of the decimal point and multiply by 10
               2int(                                             #Remove everything right of the decimal point and multiply by 2
           sum(                                                  #Sum the resulting list
       Ans/                                                      #Divide the input by the sum
:fPart(                                                          #Remove everything left of the decimal, implicit print

Braingolf , 13 12 ไบต์

VR.Mvd&+2*c%

ลองออนไลน์!

เอาต์พุต 0 สำหรับความจริง, หมายเลขอื่นใดสำหรับความเท็จ

คำอธิบาย

VR.Mvd&+2*c%  Implicit input from command-line args
VR            Create stack2, return to stack1
  .M          Duplicate input to stack2
    vd        Switch to stack2, split into digits
      &+      Sum up all digits
        2*    Double
          c   Collapse stack2 back into stack1
           %  Modulus
              Implicit output of last item on stack

Japtap , 7 ไบต์

vUì x*2

ส่งคืน1สำหรับtrue, 0สำหรับfalse

ลองออนไลน์!

คำอธิบาย

vUì x*2
v        // Return 1 if the input is divisible by:
 Uì      //   Input split into a base-10 array
    x    //   Sum the array
     *2  //   While mapped by *2

Haskell , 49 ไบต์

f x=(==) 0.mod x.(*)2.sum.map(read.return).show$x

การใช้

f 80

ลองออนไลน์!

Java , 66 ไบต์

-1 ไบต์ต้องขอบคุณ Olivier

a->{int i=0;for(int b:(""+a).getBytes())i+=b-48;return a%(i*2)<1;}

Ungolfed & คำอธิบาย:

a -> {
    int i = 0;

    for(int b : (""+a).getBytes()) { // Loop through each byte of the input converted to a string
        i += b-48; // Subtract 48 from the byte and add it to i
    }

    return a % (i*2) < 1 // Check if a % (i*2) is equal to one
    // I use <1 here for golfing, as the result of a modulus operation should never be less than 0
}

J, 15 ไบต์

0 หมายถึงความจริงไม่ใช่ศูนย์หมายถึงเท็จ

|~[:+/2#"."0@":

คำอธิบาย

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?

โอห์ม 5 ไบต์

D}Σd¥

ลองออนไลน์!

tcl, 45

puts [expr 1>$n%(2*([join [split $n ""] +]))]

การสาธิต

Haskell , 35 34 ไบต์

f x=mod x$2*sum[read[c]|c<-show x]

ลองออนไลน์!

ส่งคืน '0' ในกรณีจริงส่วนที่เหลือเป็นอย่างอื่น

Haskellรุ่น pointfree โดย nimi ขนาด 34 ไบต์

mod<*>(2*).sum.map(read.pure).show

ลองออนไลน์!

PHP, 44 ไบต์

for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;

ทำงานแบบนี้:

echo 80 | php -nR 'for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;'

คำอธิบาย

วนซ้ำตัวเลขเพื่อคำนวณผลรวมแล้วส่งเอาต์พุตโมดูโลเหมือนคำตอบส่วนใหญ่

Java (OpenJDK 8) , 55 53 ไบต์

a->{int i=0,x=a;for(;x>0;x/=10)i+=x%10*2;return a%i;}

ลองออนไลน์!

มูลค่าส่งคืนของ0หมายถึงความจริงสิ่งอื่นใดหมายถึงเท็จ

เนื่องจากความคิดเห็นของฉันในคำตอบของ Okx ไม่ได้ทำให้กระเพื่อมฉันลบมันและโพสต์มันเป็นคำตอบนี้ golfed อีกเล็กน้อย

การเล่นกอล์ฟเพิ่มเติมด้วย @KrzysztofCichocki และ @Laikoni ที่แสดงให้ฉันอย่างถูกต้องฉันไม่จำเป็นต้องตอบความจริง / เท็จตามตัวอักษร แต่มีค่าตราบเท่าที่ฉันอธิบายผล

Mini-Flak, 296 292 ไบต์

({}((()[()]))){(({}[((((()()()){}){}){}){}])({}(((({})){}){}{}){})[({})])(({}({})))({}(({}[{}]))[{}])({}[({})](({}{})(({}({})))({}(({}[{}]))[{}])({}[({})]))[{}])(({}({})))({}(({}[{}]))[{}])({}[({})])}{}({}(((({}){})))[{}]){({}((({}[()]))([{(({})[{}])()}{}]()){{}{}(({}))(()[()])}{})[{}][()])}

ลองออนไลน์!

ลิงก์ TIO มีความคิดเห็นเพิ่มเติมจากฉันดังนั้นจึงง่ายต่อการอ่านบางส่วน

Truthy / Falsey: Truthy (หารได้) ถ้าจำนวนที่สองเท่ากับจำนวนที่สามหรือเป็นอย่างอื่น ดังนั้นทั้งชุดความจริงและความเท็จเป็นอนันต์ แต่ฉันคิดว่าควรได้รับอนุญาต +10 ไบต์ถ้าไม่ใช่

หมายเหตุ: ไม่อนุญาตให้ป้อนบรรทัดใหม่ / นำหน้า / ช่องว่างต่อท้ายในช่องป้อนข้อมูล