คำอธิบาย:

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

ตัวอย่าง ขอโทษสำหรับภาพที่พร่ามัวมันเป็นสิ่งที่ดีที่สุดที่ฉันหาได้ ยังไม่สนใจตัวเลขในฟองอากาศด้านบนของเพชรคือผลิตภัณฑ์ด้านล่างคือผลรวมด้านขวาและซ้ายเป็นตัวเลขสองตัว คำตอบมีดังนี้: (นี่เป็นกรณีทดสอบของคุณด้วย)

1. 9, -7
2. -2, -1
3. 5, 8
4. -9, -9

กฎ:

• คุณไม่สามารถใช้ฟังก์ชั่นหรือคลาสที่กำหนดไว้ล่วงหน้าซึ่งจะทำให้สิ่งนี้สำเร็จสำหรับคุณ
• รหัสของคุณจะต้องเป็นโปรแกรมที่สมบูรณ์หรือฟังก์ชั่นที่ส่งคืนหรือพิมพ์คำตอบเมื่อพบพวกเขา
• อินพุตคือผลรวมและผลิตภัณฑ์ซึ่งถูกป้อนเข้าเป็นพารามิเตอร์ฟังก์ชันหรืออินพุตของผู้ใช้

ข้อมูลจำเพาะ:

• สมมติว่าตัวเลขสองตัวคือผลรวมและผลิตภัณฑ์จะเป็นจำนวนเต็มเสมอ
• คำตอบทั้งสองจะอยู่ระหว่าง -127 ถึง 127
• ข้อมูลที่คุณป้อนจะเป็นจำนวนเต็มสองจำนวน (รวมกับผลิตภัณฑ์)

โปรดจำไว้ว่านี่คือรหัสกอล์ฟดังนั้นจำนวนไบต์ที่สั้นที่สุดจึงชนะ โปรดตั้งชื่อคำตอบของคุณด้วยชื่อภาษามาตรฐาน ## จำนวนไบต์

แก้ไข: นอกจากนี้ Doorknob ยังชี้ให้เห็นว่านี่เป็น "ปัจจัยที่เป็นกำลังสองของรูปแบบ x ^ 2 + bx + c," นั่นเป็นอีกวิธีหนึ่งในการคิดและจัดการกับความท้าทายนี้ : D

เยลลี่ , 15 11 10 ไบต์

Hð+,_ðH²_½

ลองออนไลน์!

รหัสเลขฐานสองต่อไปนี้ใช้งานได้กับล่าม Jelly รุ่นนี้

0000000: 48 98 2b 2c 5f 98 48 8a 5f 90  H.+,_.H._.

ความคิด

นี่คือความจริงที่ว่า

รหัส

Hð+,_ðH²_½    Left input: s -- Right input: p

 ð   ð        This is a link fork. We define three links, call the left and right
              link with the input as arguments, then the middle link with the
              results as arguments.

H             Left link, dyadic. Arguments: s p

H             Halve the left input.

     ðH²_½    Right link, dyadic. Arguments: s p

      H       Halve the left input.
       ²      Square the result.
        _     Hook; subtract the right input from the result.
         ½    Apply square root to the difference.

 ð+,_         Middle link, dyadic. Arguments: (results of the previous links)

  +           Compute the sum of the results.
    _         Compute the difference of the results.
   ,          Pair.

ยูนิคอร์น , 4650 2982 1874 1546

[ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 ( 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( ) ) 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 2 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨ 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 4 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 ( ) ) 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈 🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤🌤 ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ ]

ขณะนี้มีแพะสายรุ้งและประกายไฟ!

หวังว่าจะสั้นกว่า Java

ใช้การเข้ารหัสที่กำหนดเองซึ่งสามารถใช้กับApplyEncoding

คำอธิบาย

มันทำงานยังไง ??? ด้วยความมหัศจรรย์ของยูนิคอร์น (และรหัสน้อย)

ยูนิคอร์นถูกรวบรวมเป็น JavaScript

แต่ละส่วนถูกคั่นด้วยช่องว่างและแต่ละส่วนแสดงถึงอักขระในรหัส JavaScript

หากส่วนนั้นมียูนิคอร์นตัวละครในส่วนนั้นจะเป็นความยาวของส่วนแปลงเป็นรหัสถ่าน (เช่น 32 ยูนิคอร์นจะเป็นช่องว่าง)

หากส่วนนั้นมีแพะความยาวของส่วนนั้นจะเพิ่มเป็นสองเท่าจากนั้นแปลงเป็นรหัสถ่าน

หากตัวอักษรพิเศษของโปรแกรมไม่แสดงนี่คือรูปภาพ:

นี่ไม่ใช่การแข่งขันเพราะยูนิคอร์นถูกสร้างขึ้นหลังจากมีการโพสต์ความท้าทายนี้

JavaScript ES6, 45 39 37 ^*ไบต์

(q,p)=>[x=p/2+Math.sqrt(p*p/4-q),p-x]

^{* ขอบคุณเดนนิส!}

TeaScript, 22 ไบต์30 31

[d=y/2+$s(y*y/4-x),y-d

ไม่ได้ว่าไม่ดี จะสั้นกว่านี้มากหากฉันสามารถเล่นกอล์ฟบางส่วนที่เสร็จสิ้นก่อนหน้านี้เช่นยูนิคอร์นช็อตคัทลัดยูนิคอร์น

ลองออนไลน์

MATL , 33 ไบต์

-100:100t!2$t+i=bb*i=&2#2$1fv101-

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

ตัวอย่าง

ต่อไปนี้ถูกเรียกใช้ใน Octave ด้วยGitHub ปัจจุบันคอมมิตของคอมไพเลอร์

>> matl -r '-100:100t!2$t+i=bb*i=&2#2$1fv101-'
> 2
> -63
 9
-7

คำอธิบาย

-100:100           % row vector -100, -99, ..., 100
t!                 % duplicate and transpose into column vector
2$t                % duplicate the two vectors
+                  % sum with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
bb                 % move the two vectors to top
*                  % multiply with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
&                  % logical "and"
2#2$1f             % find row and column of the first "true" value in logical matrix
v101-              % concatenate vertically and subtract 101

Julia, 46 44 32 ไบต์

f(b,c)=(x=b+√(b^2-4c))/2,b-x/2

ฟังก์ชั่น f ที่รับผลรวมแล้วเป็นผลิตภัณฑ์

จูเลียคำตอบแรกของฉัน @AlexA. คุณควรภูมิใจในตัวฉัน

ขอบคุณ @Dennis และ @Alex A. สำหรับความช่วยเหลือทั้งหมด ฉันต้องข้ามไป 44: P

dc, 16

?ddd*?4*-v+2/p-p

อ่านผลรวมแล้วผลิตภัณฑ์จากบรรทัดแยกของ STDIN หมายเลข -ve ต้องป้อนด้วยเครื่องหมายขีดล่างแทนเครื่องหมายลบ เช่น

$ { echo 2; echo _63; } | dc -e'?ddd*?4*-v+2/p-p'
9
-7
$ 

คำอธิบาย:

เดียวกันวิธีการแก้สมการกำลังสองขั้นพื้นฐานสำหรับการและsum = a + b product = a * bวิธีนี้จะคำนวณวิธีแก้ปัญหาaดังนี้

a = [ sum + √( sum² - 4 * product ) ] / 2

และคำนวณวิธีแก้ปัญหาbเป็น:

b = sum - a

ขยาย:

?                   # push sum to stack
 ddd                # duplicate 3 times (total 4 copies)
    *               # sum squared
     ?              # push product to stack
      4*            # multiply by 4
        -           # subtract (4 * product) from (sum squared)
         v          # take square root of (sum squared) - (4 * product)
          +         # add sum to square root of (sum squared) - (4 * product)
           2/       # divide by 2 to give solution a
             p      # print with newline and without pop
              -     # subtract solution a from sum to give solution b
               p    # print with newline and without pop

การหารด้วย 2 เสร็จสิ้นเพื่อป้องกันความแม่นยำในการสูญเสีย เป็นไปได้ที่จะหารด้วย 2 ก่อนหน้านี้ แต่ต้องมีความแม่นยำเป็นเศษส่วนซึ่งต้องการอักขระมากขึ้น

Pyth, 21 18 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @Dennis

,J/+@-^Q2*4E2Q2-QJ

ชุดทดสอบ

โปรแกรม Pyth ครั้งที่สองของฉันตลอดกาลดังนั้นจึงสามารถเล่นกอล์ฟในตัว ข้อเสนอแนะยินดีต้อนรับ!

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

,J/+@-^Q2*4E2Q2-QJ   Implicit: Q = first line of input
,                    Create and output a list of these items:
 J                     Set variable J to the result of these operations:
      ^Q2                Square Q.
     -   *4E             Subtract 4*(next line of input).
    @       2            Take the square root.
   +         Q           Add Q.
  /           2          Divide by 2.
                       The list is currently [J].
               -QJ     Push Q-J; the list is now [J, Q-J].
                     EOF; list is sent to output.

(คำอธิบายนี้อาจไม่ถูกต้อง 100% แต่ฉันไม่คุ้นเคยกับ Pyth มาก)

โปรดทราบว่าการ/แบ่งจำนวนเต็ม ด้วยการแทนที่ด้วยcเราสามารถทำให้การทำงานนี้มีอินพุตที่ไม่ใช่จำนวนเต็มเช่นกัน

Java, 82 (69 λ) ไบต์พร้อมสูตรกำลังสอง (127 (114 λ) ไบต์กำลังดุร้าย)

Brute-Force: (วานิลลา, Java 7)

int[] n(int s,int p){for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

ปรับปรุงλ: (Java 8)

(s,p)->{for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

แลมบ์ดามอบหมายให้และโทรjava.util.function.BiFunction<Integer, Integer, int[]>apply()

วิธีการบังคับสัตว์เดรัจฉานธรรมดา ฟังก์ชั่นการทำงานอยู่ที่นี่และเนื่องจาก Java ไม่สามารถคืนค่าได้หลายค่าเราจึงส่งกลับintอาร์เรย์2 องค์ประกอบพร้อมตัวเลขที่ต้องการ

โปรแกรมที่ใช้วิธีการเดรัจฉานบังคับเต็มรูปแบบสามารถพบได้ที่นี่ใน ideone.comด้วยรุ่น here ที่นี่

การเล่นกอล์ฟเกี่ยวข้องกับการลบวงเล็บปีกกาที่ไม่จำเป็นทั้งหมด

Ungolfed:

int[] n(int s,int p){//sum and product as function parameters,in that order
    for(int a=-100;a<=100;a++){//iterate first no. from -100 to 100
        for(int b=-100;b<=100;b++){//iterate second no. from -100 to 100
            //if the 2 nos. satisfy the diamond-puzzle condition, 
            //pack them in an int array and return them
            if(a+b==s&&a*b==p)return new int[]{a,b};}
     }//if no such pair exists, return null
return null;}

วิธีกำลังสอง: (วานิลลา, Java 7)

int[] n(int s,int p){int x=s+(int)Math.sqrt(s*s-4*p);return new int[]{x/2,s-x/2};}

λ-enhanced: (Java 8) (s, p) -> {int x = s + (int) Math.sqrt (s * s-4 * p); ส่งคืน int ใหม่ [] {x / 2, sx / 2} ;}

(การใช้งานสำหรับแรงเดรัจฉานλด้านบน)

พารามิเตอร์และเกณฑ์การส่งคืนจะเหมือนกับโซลูชัน brute-force ด้านบน

ใช้สูตรสมการกำลังสองที่ดีที่ใช้โดยคำตอบอื่น ๆ เกือบทั้งหมดที่นี่และไม่สามารถลงไปไกลกว่านี้ได้นอกจากมีคนช่วยฉันที่นี่ มันค่อนข้างชัดเจนดังนั้นฉันจึงไม่รวมเวอร์ชันที่ไม่น่ารังเกียจ

โปรแกรมที่ใช้วิธีกำลังสองเต็มรูปแบบอยู่ที่นี่บนideone.comโดยมีรุ่นλที่นี่

Japt , 28 22 21 20 ไบต์

[X=V/2+(V²/4-U ¬V-X]

-63 2การป้อนข้อมูลจะทำในรูปแบบของ

คำอธิบาย:

• U และ Vเป็นอินพุตทั้งสอง ( -63และ2ในกรณีแรก)
• ² กำลังสองจำนวน
• q แยกรากที่สอง

APL, 27 21 ไบต์

h(+,-).5*⍨⊣-⍨h×h←.5×⊢

นี่คือการฝึกอบรมฟังก์ชั่น dyadic ที่รับจำนวนเต็มทางด้านขวาและซ้ายแล้วส่งกลับอาร์เรย์ หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

Ungolfed:

                h←.5×⊢       ⍝ Define a train h for halving the input
              h×             ⍝ b^2/4
          ⊣-⍨                ⍝ b^2/4 - c
      .5*⍨                   ⍝ sqrt(b^2/4 - c)
h(+,-)                       ⍝ Return the halved pair

ลองออนไลน์

บันทึก 6 ไบต์ขอบคุณ Dennis!

CJam, 18 ไบต์

q~2d/_2#@-mq_2$+p-

ลองออนไลน์!

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

q~                  e# Read an evaluate all input. STACK: product sum
  2d/               e# Divide the sum by 2.0.
     _              e# Push a copy of the result.
      2#            e# Square the copy.
        @-          e# Rotate the product on top and subtract it from the square.
          mq        e# Apply square root.
            _2$     e# Push copies of the root and the halved sum.
               +p   e# Add and print.
                 -  e# Subtract the originals.

Python 3, 49 44 ไบต์

อาจมีบางวิธีในการตีกอล์ฟให้ดียิ่งขึ้นไปอีก แต่นี่ก็ดูดีพอ ๆ

def f(s,p):s/=2;d=(s*s-p)**.5;return s+d,s-d

MathCAD 15. 38 ไบต์

ด้วยสูตรทางคณิตศาสตร์การเขียนโปรแกรมใน MathCAD นั้นง่ายมาก ภาษาได้รับการออกแบบมาเพื่อจัดการกับตัวเลขที่ซับซ้อนได้อย่างง่ายดาย อย่างไรก็ตามมีภาษาที่สั้นกว่าที่สามารถแก้ปัญหาได้

𝔼𝕊𝕄𝕚𝕟, 21 ตัวอักษร / 30 ไบต์

[x=í/2+√ í²/4-î⦆,í-x]

Try it here (Firefox only).

Meh นี่ควรจะเป็นภาพที่เห็นได้พอสำหรับคุณ อย่างไรก็ตามถ้าคุณต้องî = input1, í = input2แต่ถ้าคุณต้อง

PHP, 62 ไบต์

<?=($x=($p=$_GET[p])/2+sqrt($p*$p/4-$q=$_GET[q]))." ".($p-$x);

นี่อาจเป็นเวลานานพอสมควร แต่การใช้งาน PHP แบบเต็มรูปแบบ "โปรแกรม" ยอมรับข้อโต้แย้งผ่านคำขอ "รับ"

การสาธิต

TI-BASIC, 20 ไบต์

ใช้เวลาQจากAnsและจากP โทรเช่นPromptP:prgmNAME

Prompt P
P/2+√(P²/4-Ans
{Ans,P-Ans