ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่รับอินพุตจำนวนเต็มสองตัวiและjและเอาท์พุทตัวหารร่วมที่ยิ่งใหญ่ที่สุด คำนวณโดยใช้อัลกอริทึมแบบยุคลิด (ดูด้านล่าง)

อินพุต

อินพุตอาจถูกใช้เป็นการแทนค่าสตริงที่คั่นด้วยช่องว่างiและjหรือเป็นจำนวนเต็มสองตัวแยกกัน คุณสามารถสันนิษฐานได้ว่าจำนวนเต็มจะน้อยกว่าหรือเท่ากับ 10,000 คุณสามารถสันนิษฐานได้ว่าจำนวนเต็มอินพุทจะไม่เป็นไพรม์ต่อกัน

การสลายแบบยุคลิด

จำนวนที่มากขึ้นระหว่างiและjหารด้วยจำนวนที่น้อยกว่าให้มากที่สุด จากนั้นส่วนที่เหลือจะถูกเพิ่ม 0ขั้นตอนนี้ซ้ำกับที่เหลือและจำนวนก่อนจนเหลือจะกลายเป็น

ตัวอย่างเช่นถ้าอินพุตคือ1599 650:

1599 = (650 * 2) + 299
 650 = (299 * 2) +  52
 299 =  (52 * 5) +  39
  52 =  (39 * 1) +  13
  39 =  (13 * 3) +   0

ตัวเลขสุดท้าย13,, เป็นตัวหารร่วมมากของจำนวนเต็มสองจำนวน มันสามารถมองเห็นได้เช่นนี้

เอาท์พุต

ผลลัพธ์ของคุณจะต้องแยกตามแบบฟอร์มด้านบนตามด้วย newline และ GCD มันสามารถส่งออกผ่านสื่อใด ๆ

ตัวอย่าง

ปัจจัยการผลิต

18 27
50 20
447 501
9894 2628

เอาท์พุท

27 = (18 * 1) + 9
18 =  (9 * 2) + 0
9

50 = (20 * 2) + 10
20 = (10 * 2) +  0
10

501 = (447 * 1) + 54
447 =  (54 * 8) + 15
 54 =  (15 * 3) +  9
 15 =   (9 * 1) +  6
  9 =   (6 * 1) +  3
  6 =   (3 * 2) +  0
3

9894 = (2628 *  3) + 2010
2628 = (2010 *  1) +  618
2010 =  (618 *  3) +  156
 618 =  (156 *  3) +  150
 156 =  (150 *  1) +    6
 150 =    (6 * 25) +    0
6

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

โบนัส

หากการแสดงผลของคุณเป็นเว้นวรรคข้างต้นคุณอาจเพิ่มโบนัส -10% ให้กับคะแนนของคุณ

Pyth, 33 ไบต์

ASQWGs[H\=\(G\*/HG\)\+K%HG)A,KG)H

ลองออนไลน์: การสาธิตหรือชุดทดสอบ

คำอธิบาย:

ASQWGs[H\=\(G\*/HG\)\+K%HG)A,KG)H
  Q                                read the two numbers from input
 S                                 sort them
A                                  and assign them to G and H
   WG                              while G != 0:
                      K%HG           assign H mod G to K
     s[H\=\(G\*/HG\)\+K   )          join the following list items and print:
                                        H=(G*(H/G))+K
                           A,KG      assign K, G to G, H
                               )   end while
                                H  print H

CJam, 46 43 39 ไบต์

q~]$3*~\{N5$"=("3$:G'*3$Gmd")+"\}h]7>NG

ลองใช้ออนไลน์ในล่าม CJam

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

q~]    e# Read all input, evaluate it and wrap the results in an array.
$3*    e# Sort the array and repeat it thrice.
~\     e# Dump the array and swap its last two elements.
{      e# Do:
  N    e#   Push a linefeed.
  5$   e#   Copy the sixth topmost element from the stack.
  "=(" e#   Push that string.
  3$:G e#   Copy the fourth topmost element from the stack. Save it in G.
  '*   e#   Push that character.
  3$   e#   Copy the fourth topmost element from the stack.
  Gmd  e#   Push quotient and remainder of its division by G.
  ")+" e#   Push that string.
  \    e#   Swap the string with the remainder.
}h     e#   If the remainder is positive, repeat the loop.
]7>    e# Wrap the stack in an array and discard its first seven elements.
NG     e# Push a linefeed and G.

Python 2, 70

f=lambda a,b:b and'%d=(%d*%d)+%d\n'%(a,b,a/b,a%b)*(a>=b)+f(b,a%b)or`a`

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

การจัดรูปแบบจะกระทำผ่านการแทนที่สตริงโดยใช้การแบ่งจำนวนเต็มเพื่อรับ multiplicand

หนึ่งอาการสะอึกจำเป็นต้องเริ่มต้นด้วยจำนวนที่มากขึ้นจะถูกนำไปดัดแปลงเป็นจำนวนที่น้อยกว่า หากตัวเลขอยู่ในลำดับที่ไม่ถูกต้องขั้นตอนแรกของอัลกอริทึม Euclidian จะพลิกพวกเขา เพื่อป้องกันไม่ให้ขั้นตอนนี้จากการถูกแสดงเพียงเพิ่มบรรทัดปัจจุบันถ้าจำนวนแรกคืออย่างน้อยสอง (ความเท่าเทียมกันเป็นสิ่งจำเป็นสำหรับการพูดf(9,9))

awk, 78 77

x=$1{for(x<$2?x+=$2-(y=x):y=$2;t=y;x=t)print x"=("y"*"int(x/y)")+",y=x%y}$0=x

การเรียงลำดับอินพุตตามขนาดใช้เวลาเป็นจำนวนมาก: /
มันลงมาที่นี่:

x=$1;
if(x<$2) x+=$2-(y=x); # add $2 subtract $1 and set y to $1
else y=$2;            # set y to $2

เอาท์พุต

650 1599 (อินพุต)
1599 = (650 * 2) + 299
650 = (299 * 2) + 52
299 = (52 * 5) + 39
52 = (39 * 1) + 13
39 = (13 * 3) + 0
13

เพียงเพื่อความสนุกฉันได้สร้างเวอร์ชันที่มีระยะห่างที่เหมาะสมเช่นกันโดยให้คะแนน 233 * 0.9 == 209.7 ไบต์

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

x=$1{x<$2?x+=$2-(y=x):y=$2;a=length(x);b=length(y);for(d=length(x%y);t=y;x=t){$++i=x;$++i=y;if(c<l=length($++i=int(x/y)))c=l;$++i=y=x%y}while(j<NF)printf "%"a"d = %"b-length($(j+2))"s(%d * %"c"d) + %"d"d\n",$++j,_,$++j,$++j,$++j}$0=x

แต่ฉันก็ยังรู้สึกว่าฉันวิ่งเข้าไปในบล็อกจิตที่นั่นที่ไหนสักแห่ง ...

เอาท์พุท (gawk4 เรียกด้วยawk -M -f code.awk)

6837125332653632513763 18237983363879361 (อินพุต)
6837125332653632513763 = (18237983363879361 * 374883) + 15415252446024000
     18237983363879361 = (15415252446024000 * 1) + 2822730917855361
     15415252446024000 = (2822730917855361 * 5) + 1301597856747195
      2822730917855361 = (1301597856747195 * 2) + 219535204360971
      1301597856747195 = (219535204360971 * 5) + 203921834942340
       219535204360971 = (203921834942340 * 1) + 15613369418631
       203921834942340 = (15613369418631 * 13) + 948032500137
        15613369418631 = (948032500137 * 16) + 444849416439
          948032500137 = (444849416439 * 2) + 58333667259
          444849416439 = (58333667259 * 7) + 36513745626
           58333667259 = (36513745626 * 1) + 21819921633
           36513745626 = (21819921633 * 1) + 14693823993
           21819921633 = (14693823993 * 1) + 7126097640
           14693823993 = (7126097640 * 2) + 441628713
            7126097640 = (441628713 * 16) + 60038232
             441628713 = (60038232 * 7) + 21361089
              60038232 = (21361089 * 2) + 17316054
              21361089 = (17316054 * 1) + 4045035
              17316054 = (4045035 * 4) + 1135914
               4045035 = (1135914 * 3) + 637293
               1135914 = (637293 * 1) + 498621
                637293 = (498621 * 1) + 138672
                498621 = (138672 * 3) + 82605
                138672 = (82605 * 1) + 56067
                 82605 = (56067 * 1) + 26538
                 56067 = (26538 * 2) + 2991
                 26538 = (2991 * 8) + 2610
                  2991 = (2610 * 1) + 381
                  2610 = (381 * 6) + 324
                   381 = (324 * 1) + 57
                   324 = (57 * 5) + 39
                    57 = (39 * 1) + 18
                    39 = (18 * 2) + 3
                    18 = (3 * 6) + 0
3

เพิ่มบรรทัดใหม่และแท็บบางรายการ

x=$1{
    x<$2?x+=$2-(y=x):y=$2;
    a=length(x);
    b=length(y);
    for(d=length(x%y);t=y;x=t)
    {
        $++i=x;
        $++i=y;
        if(c<l=length($++i=int(x/y)))c=l;
        $++i=y=x%y
    }
    while(j<NF)
        printf "%"a"d = %"b-length($(j+2))"s(%d * %"c"d) + %"d"d\n",
                                               $++j,_,$++j,$++j,$++j
}$0=x

ฉันสามารถบันทึกความยาวของค่าเริ่มต้นสำหรับ x, y และ x% y ในการเริ่มต้นเพราะพวกเขาสามารถได้รับในแต่ละขั้นตอนจะสั้นลงเท่านั้น แต่สำหรับปัจจัยที่ฉันต้องกำหนดความยาวสูงสุดก่อนที่จะพิมพ์อะไรเพราะความยาวอาจแตกต่างกันไป ฉันใช้$iเป็นอาร์เรย์ที่นี่เพราะมันช่วยประหยัดอักขระสองตัวเมื่อเทียบกับการใช้ [i] ทุกครั้ง

คอมไพเลอร์ C ++, GCC, 171 ไบต์ (-10%, 154 ไบต์)

โอเคลองครั้งแรกของฉัน ..

#include<iostream>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b;
    if(a<b)
    swap(a,b);
    while(b>0)
    {
        c=a;
        cout<<a<<" = ("<<b<<" * "<<a/b<<") + "<<a%b<<endl;
        a=b;
        b=c%b;
    }
    cout<<a;
}

เคล็ดลับในการรหัสกอล์ฟชื่นชม

PS จำเป็นต้องนับไบต์ของไฟล์ส่วนหัวมาตรฐานและ int หลักในขณะที่ใช้ c ++ หรือไม่ หากไม่รวมจะช่วยลด 50 ไบต์

T-SQL (2012+), 268 ไบต์

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

CREATE FUNCTION E(@ INT,@B INT)RETURNS TABLE RETURN WITH M AS(SELECT IIF(@<@B,@B,@)A,IIF(@>@B,@B,@)B),R AS(SELECT A,B,A/B D,A%B R FROM M UNION ALL SELECT B,R,B/R,B%R FROM R WHERE 0<>R)SELECT CONCAT(A,'=(',B,'*',D,')+',R)R FROM R UNION ALL SELECT STR(B)FROM R WHERE R=0

คำอธิบายและการใช้งาน:

--Create the function
CREATE FUNCTION E(@ INT,@B INT)RETURNS TABLE RETURN
WITH
    --Order the input correctly
    M AS (
          SELECT IIF(@<@B,@B,@)A,
                 IIF(@>@B,@B,@)B
          )
    --Recursive selection
    ,R AS (
          SELECT A,B,A/B D,A%B R FROM M -- Anchor query
          UNION ALL
          SELECT B,R,B/R,B%R FROM R     -- Recurse until R = 0
          WHERE 0<>R
          )
SELECT CONCAT(A,'=(',B,'*',D,')+',R)R   -- Concat results into output string
FROM R 
UNION ALL                               -- ALL required to maintain order
SELECT STR(B)                           -- Add final number
FROM R WHERE R=0

--Function Usage
SELECT * FROM E(447,501)

R
-----------------------------------------------------
501=(447*1)+54
447=(54*8)+15
54=(15*3)+9
15=(9*1)+6
9=(6*1)+3
6=(3*2)+0
3

Rev 1: Ruby, 86

อัลกอริทึมแบบเรียกซ้ำขอบคุณด้วยเคล็ดลับจาก Doorknob

f=->i,j{j>i&&(i,j=j,i)
0<j ?(print i," = (#{j} * #{i/j}) + #{i%j}
";f[j,i%j]):puts(i)}

Rev 0: Ruby, 93

เรื่องนี้ไม่ได้ผลดีเลย ห่วงจะขึ้นตัวอักษรมากเกินไปโดยเฉพาะอย่างยิ่งกับwhile endฉันไม่เห็นวิธีการหลีกเลี่ยง การเรียกซ้ำจะต้องใช้ฟังก์ชันที่มีชื่อแทนแลมบ์ดาซึ่งจะกินอักขระจำนวนมาก

->i,j{j>i&&(i,j=j,i)
while j>0
print(i," = (#{j} * #{i/j}) + #{i%j}\n")
i,j=j,i%j
end
puts i}

เรียกว่าเป็นแบบนี้:

f=->i,j{j>i&&(i,j=j,i)
while j>0
print(i," = (#{j} * #{i/j}) + #{i%j}\n")
i,j=j,i%j
end
puts i}

I=gets.to_i
J=gets.to_i

f.call(I,J)

PowerShell, 84

บล็อกโค้ดแบบเรียกซ้ำถูกเก็บในตัวแปร เรียกใช้ด้วย& $e num1 num2เช่น:

$e={$s,$b=$args|Sort;if(!$s){$b}else{$r=$b%$s;"$b=($s*$(($b-$r)/$s))+$r";&$e $s $r}}

PS D:\> & $e 9894 2628
9894=(2628*3)+2010
2628=(2010*1)+618
2010=(618*3)+156
618=(156*3)+150
156=(150*1)+6
150=(6*25)+0
6

ในรูปแบบที่อ่านได้มากขึ้นมันทำสิ่งต่อไปนี้ (nb. สำหรับโค้ดที่ชัดเจนกว่าฉันได้ใส่ชื่อ commandlet แบบเต็มช่องว่างในสตริงมากขึ้นและทำให้คำสั่งไพพ์ไลน์เอาต์พุตชัดเจน):

function Euclid {
    $small, $big = $args|Sort-Object   #Sort argument list, assign to two vars.

    if (!$small) {                     #Recursion end, emit the last
        Write-Output $big              #number alone, for the last line.

    } else {                           #main recursive code

        $remainder = $big % $small
        Write-Output "$big = ( $small* $(($big-$remainder)/$small)) + $remainder"
        Euclid $small $remainder
    }
}

สิ่งหนึ่งที่น่ารำคาญจากมุมมอง codegolf; PoSh ไม่มีการหารจำนวนเต็ม 10/3 ส่งกลับค่า Double แต่ส่งผลลัพธ์เป็นจำนวนเต็มและไม่ปัดเศษเสมอรอบ N.5 ปัดเศษเป็นเลขคู่ที่ใกล้ที่สุด - ขึ้นหรือลง [int](99/2) == 50ดังนั้น

ที่เหลือสองทางเลือกที่น่าอึดอัดใจ:

$remainder = $x % $y
$quotient = [Math]::Floor($x/$y)

# or, worse

$remainder=$null
$quotient = [Math]::DivRem($x, $y, [ref]$remainder)

นี่คือเหตุผลที่ฉันต้องเผาอักขระบางตัวที่ทำ

$remainder = $big % $small
($big - $remainder)/$small

นอกเหนือจากนั้นก็คือจำนวน

ฉันยังมีเวอร์ชันซ้ำซึ่งค่อนข้างดีเป็น 84 ตัวอักษร:

{$r=1;while($r){$s,$b=$args|Sort;$r=$b%$s;"$b=($s*$(($b-$r)/$s))+$r";$args=$s,$r}$s}

codeblock ที่ไม่ระบุชื่อโดยสมบูรณ์ดังนั้นให้เรียกใช้ด้วย

& {*codeblock*} 1599 650

PHP, 118 ไบต์

for(list(,$n,$m)=$argv,$g=max($n,$m),$l=min($n,$m);$g;$g=$l,$l=$m)
echo$g,$l?"=($l*".($g/$l^0).")+".($m=$g%$l)."
":"";

ลองออนไลน์!

PHP, 131 ไบต์

for(list(,$n,$m)=$argv,$r=[max($n,$m),min($n,$m)];$r[+$i];)echo$g=$r[+$i],($l=$r[++$i])?"=($l*".($g/$l^0).")+".($r[]=$g%$l)."
":"";

ลองออนไลน์!

-4 ไบต์แทนที่list(,$n,$m)=$argvด้วย[,$n,$m]=$argvความต้องการ PHP> = 7.1

Japté , 43 42 41 ไบต์

"ทักษะ" ที่เพิ่งค้นพบของฉันดูเหมือนจะแย่ลงไม่ดีขึ้น!

?U>V?ßVU :[V'='(U'*V/U|0')'+V%=UR,ßVU]¬:V

ลองออนไลน์

JavaScript (ES6), 74 50 62 61 55 ไบต์

f=(x,y)=>y?y>x?y:x+`=(${y}*${x/y|0})+${x%=y}
`+f(y,x):x

• เสียสละ 12 ไบต์ทำให้จำนวนเต็มถูกส่งผ่านในลำดับใด ๆ มากกว่าที่ใหญ่ที่สุดก่อน

ลองมัน

f=(x,y)=>y?y>x?y:x+`=(${y}*${x/y|0})+${x%=y}
`+f(y,x):x
o.innerText=f(i.value=683712533265363251376,j.value=18237983363879361)
i.oninput=j.oninput=_=>o.innerText=f(+i.value,+j.value)

<input id=i type=number><input id=j type=number><pre id=o>

คำอธิบาย

f=          :Assign the function to variable f ...
(x,y)=>     :And take the two integer inputs as arguments via parameters x and y.
y?          :If y is greater than 0 then
y>x?        :    If y is greater than x then
f(y,x)      :        Call f again, with the order of the integers reversed.
            :        (This can only happen the first time the function is called.)
:           :    Else
x           :        Start building the string, beginning with the value of x.
+`=(        :        Append "=(".
${y}        :          The value of y.
*           :          "*"
${x/y|0}    :          The floored value of x divided by y
)+          :          ")+"
${x%=y}     :          The remainder of x divided by y, which is assigned to x
            :          (x%=y is the same as x=x%y.)
\n          :          A newline (a literal newline is used in the solution).
`+f(y,x)    :        Append the value f returns when y and the new value of x
            :        are passed as arguments.
:           :Else
x           :    Return the current value of x,
            :    which will be the greatest common divisor of the original two integers.

JS, 151

a=prompt("g","");b=prompt("l","");c=0;l=[a,b];for(var i=0;i<=1;i++){t=c;o=c+1;r=c+2;n=l[t]%l[o];if(n!==0){l[r]=n;c=c+1;i=0;}else{p=l[o];alert(p);i=2;}}

C, 83 ไบต์

g(x,y,z){y&&(printf("%u=(%u*%u)+%u\n",x,y,x/y,z=x%y),z)?g(y,z,0):printf("%u\n",y);}

การทดสอบและผลลัพธ์

int main()
{g(18,27,0);
 g(50,20,0);
 g(447,501,0);
 g(9894,2628,0);
}

18=(27*0)+18
27=(18*1)+9
18=(9*2)+0
9
50=(20*2)+10
20=(10*2)+0
10
447=(501*0)+447
501=(447*1)+54
447=(54*8)+15
54=(15*3)+9
15=(9*1)+6
9=(6*1)+3
6=(3*2)+0
3
9894=(2628*3)+2010
2628=(2010*1)+618
2010=(618*3)+156
618=(156*3)+150
156=(150*1)+6
150=(6*25)+0
6

Java 133

public void z(int i,int j){for(int d=1;d!=0;i=j,j=d){d=i%j;System.out.println(i+"=("+j+"*"+((i-d)/j)+")+"+d);}System.out.println(i);}

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

public void z(int i, int j)
{
    for(int d=1;d!=0;i=j,j=d)
    {
        d=i%j;
        System.out.println(i+"=("+j+"*"+((i-d)/j)+")+"+d);
    }
    System.out.println(i);
}