จำนวนเต็ม Gaussianเป็นตัวเลขที่ซับซ้อนของรูปแบบa+biที่aและbเป็นจำนวนเต็มทั้งสอง ในฐาน -1 + i จำนวนเต็ม Gaussian ทั้งหมดสามารถแสดงโดยใช้ตัวเลข0และ1ไม่จำเป็นต้องใช้สัญลักษณ์เพื่อแสดงเครื่องหมาย

ตัวอย่างเช่น1100ในฐาน -1 + i หมายถึงจำนวนทศนิยม 2 ตั้งแต่

1*(-1+i)^3 + 1*(-1+i)^2 + 0*(-1+i)^1 + 0*(-1+i)^0
= (2+2i) + (-2i) + 0 + 0
= 2

การป้อนข้อมูลจะมีสองจำนวนเต็มเสียนในฐาน -1 + i 01ใช้แทนตัวเลข สิ่งนี้สามารถใช้หนึ่งในรูปแบบต่อไปนี้:

• สองสายแยกหลัก
• เลขจำนวนเต็มฐานสิบสองจำนวนประกอบด้วย01ตัวเลขฐาน -1 + i (เช่น11002 ในฐาน -1 + i)
• เลขจำนวนเต็มไบนารีสองตัวแทนตัวเลขฐาน -1 + i (เช่นทศนิยม12หรือ0b11002 ในฐาน -1 + i)
• สตริงเดี่ยวที่แยกสตริงสองหลัก / จำนวนเต็มแบบไบนารีโดยตัวคั่นที่ไม่ใช่ตัวอักษรและตัวเลข (เช่น1100 1100หรือ12,12สำหรับ 2 + 2)

เอาท์พุทผลรวมของจำนวนเต็ม Gaussian จำนวนสองตัวเช่นกันในฐาน -1 + i และแสดงการใช้ตัวเลข01(หนึ่งในรูปแบบที่อนุญาตให้ใช้เป็นอินพุตไม่จำเป็นต้องเป็นตัวเลือกเดียวกัน) การส่งออกได้รับอนุญาตให้มีจำนวน จำกัด เป็นศูนย์นำ

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

ชี้แจงเพิ่มเติม

• คุณอาจคิดว่าอินพุตไม่มีศูนย์นำหน้าที่ไม่เกี่ยวข้อง สำหรับกรณีพิเศษ 0 คุณสามารถเลือกอย่างใดอย่างหนึ่ง0หรือสตริงที่ว่างเปล่าเป็นตัวแทน

กรณีทดสอบ

0, 0 => 0                                      # 0 + 0 = 0
0, 1 => 1                                      # 0 + 1 = 1
1, 1 => 1100                                   # 1 + 1 = 2
1100, 1100 => 111010000                        # 2 + 2 = 4
1101, 1101 => 111011100                        # 3 + 3 = 6
110111001100, 1110011011100 => 0               # 42 + (-42) = 0
11, 111 => 0                                   # i + (-i) = 0
11, 110 => 11101                               # i + (-1-i) = -1
10101, 11011 => 10010                          # (-3-2i) + (-2+3i) = (-5+i)
1010100101, 111101 => 1110100000100            # (-19+2i) + (3-4i) = (-16-2i)

กรณีทดสอบอีกต่อไป:

11011011010110101110010001001, 111100010100101001001010010101 => 0
111111111111111111111111111111, 111111111111111111111111111111 => 100100100100100100100100100100
101101110111011101110111011101, 101101110111011101110111011101 => 11101001010001000100010001000100011100
100100010101001101010110101010, 100010011101001011111110101000 => 110000110010101100001100111100010

Python 2, 98 97 91 84 ไบต์

s=input();L=1
for _ in`s`*8:s+=1098*int(str(s).translate('0011'*64));L*=10
print s%L

นี่คือ I / O เป็นทศนิยม +จำนวนเต็มจะต้องมีการแยกจากกันโดยตัวละครที่ไม่ใช่ตัวเลข

ขอบคุณ @xnor สำหรับการเล่นกอล์ฟ 2 ไบต์!

ลองบนIdeone

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

ในทางคณิตศาสตร์ในฐานคอมเพล็กซ์ , ผู้เขียนแสดงให้เห็นถึงวิธีการเพิ่มและคูณตัวเลขที่ซับซ้อนในฐานของรูปแบบ-n + i

สำหรับฐาน-1 + i การเติมจะทำในลักษณะเดียวกับการเติมแบบไบนารีและแบบพกพาซึ่งมีความแตกต่างกันสองประการ:

• แทนที่จะถือ1ไปยังตำแหน่งที่สูงกว่าต่อไปเราจะดำเนินการ110ถึงสามตำแหน่งถัดไป

• ตัวเลขนำติดตัวสามารถเผยแพร่ไปเรื่อย ๆ อย่างไรก็ตามหากไม่มีศูนย์นำหน้าผลรวม+ bจะมีตัวเลขได้ไม่เกินแปดหลักมากกว่าaและbสูงสุด

เราดำเนินการดังนี้

1. ก่อนอื่นเราเพิ่มaและbราวกับว่าตัวเลขเป็นทศนิยม

   สำหรับA = 10101และข = 11011นี้จะช่วยให้21112

2. ต่อไปเราในรูปแบบหมายเลขใหม่โดยการเปลี่ยนตัวเลขขนาดใหญ่กว่า1มี1คนอื่น ๆ ด้วย0 ¹

   สำหรับผลรวม21,112นี้จะช่วยให้10001

3. สำหรับแต่ละหลักที่มีขนาดใหญ่กว่า1เราจะต้องลบ2จากหลักนั้นและนำ110ไปสู่ตำแหน่งที่สูงขึ้นสามตำแหน่งถัดไป ตั้งแต่1098 = 10 * 110 - 2เราสามารถทำสิ่งนี้ได้โดยการคูณผลลัพธ์จากขั้นตอนที่ 2 ด้วย1,098แล้วเพิ่มผลิตภัณฑ์นั้นลงในผลรวม ²

   สำหรับผลรวม21,112นี้จะช่วยให้21112 + 1098 * 10001 = 21112 + 10981098 = 11002210

4. เราทำซ้ำขั้นตอนที่ 2และ3รวมd * 8ครั้งที่dคือจำนวนตัวเลขของA + B ³

   สำหรับผลรวมเริ่มต้น21112ผลลัพธ์จะเป็น

                         11002210
                         12210010
                       1220010010
                     122000010010
                   12200000010010
                 1220000000010010
               122000000000010010
             12200000000000010010
           1220000000000000010010
         122000000000000000010010
       12200000000000000000010010
     1220000000000000000000010010
   122000000000000000000000010010
                                .
                                .
                                .
   

5. เราใช้โมดูโลผลรวมสุดท้าย10 ^{d + 8} , ทิ้งทั้งหมดยกเว้นd + 8หลักสุดท้าย

   สำหรับผลรวมเริ่มต้น21,112ผลสุดท้ายคือ10010

¹ _{นี้จะประสบความสำเร็จกับการแปล การทำซ้ำสตริง0011 64 ครั้งทำให้เกิดการซ้ำซ้อนหนึ่งรายการพร้อมลำดับอักขระ ASCII 0123เพื่อให้ได้การแทนที่ที่ต้องการ}

² _{ทราบว่าตัวเลขของจำนวนนี้จะต้องไม่เกิน3 (ค่าเริ่มต้น1บวกสอง1 's จากดำเนินการ)}

³ _{สิ่งนี้เกิดขึ้นกับd = 1และd * 8> d + 8 เป็นอย่างอื่น รหัสอาจทำซ้ำขั้นตอน(d + 1) * 8ครั้งเนื่องจากsมีLต่อท้ายหากsเป็นจำนวนเต็มแบบยาว}

Pyth, 34 ไบต์

_shM.u,%J/eMeN\12-+PMeNm.B6/J2k,kQ

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

คำอธิบาย:

อัลกอริทึมของฉันนั้นเป็นการใช้งานนอกเหนือจากการพกพา แต่แทนที่จะถือ1ฉันต้องแบก110( 1100ในฐาน-1+iเหมือน2ในฐาน-1+i) วิธีนี้ใช้งานได้ดีส่วนใหญ่ แต่คุณสามารถติดอยู่ในศูนย์การพิมพ์วนวนไม่สิ้นสุด ตัวอย่างเช่นถ้าคุณกำลังเพิ่ม1ด้วยและในปัจจุบันมีพก11 110โดยทั่วไปแล้วฉันจะเพิ่มจนกว่าฉันจะติดอยู่ในวงแล้วหยุด ฉันคิดว่าการวนซ้ำที่การวนซ้ำจะพิมพ์เลขศูนย์เสมอและนี่ควรจะใช้ได้

_shM.u,%J/eMeN\12-+PMeNm.B6/J2k,kQ   implicit: Q = input list of strings
                               ,kQ   create the pair ["", Q]
    .u                               modify the pair N (^) until loop:
      ,                                replace N with a new pair containing:
            eN                           N[1] (the remaining summand)
          eM                             take the last digits of each summand
         /    \1                         count the ones
        J                                store the count in J
       %J       2                        J % 2 (this is the first element of the new pair)
                   PMeN                  remove the last digit of each summand
                  +    m   /J2           and add J / 2 new summand:
                        .B6                 with the value "110" (binary of 6)
                 -            k          remove empty summand
    .u                               returns all intermediate results
  hM                                 extract the digits
 s                                   sum them up to a long string
_                                    reverse

Python 2, 69 67 ไบต์

f=lambda a,b:a*a+b*b^58and 2*f(a*b%2*6,f(a/2,b/2))|a+b&1if a else b

I / O เสร็จสิ้นด้วยเลขฐาน 2

-2 ขอบคุณ @Dennis

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

r+`(.*)(\d|(?!\4))( .*)(.?)
$2$4:$1$3
T` 0
+`1:11(1*:1*)11
:$1
^:*
:::
}`:(1*:1*:)11
1:1$1
(1)*:
$#1

การดำเนินการนี้จะแยกอินพุตด้วยเครื่องหมายจุลภาค ผลลัพธ์เริ่มต้นด้วยศูนย์นำสามเสมอ

ลองออนไลน์!

ฉันสงสัยจริงๆว่ามีวิธีแก้ปัญหาที่สั้นกว่าสำหรับด่านแรกหรือไม่ ...

เยลลี่, 29 28 26 24 21 20 ไบต์

DBḅ1100ḌµDL+8µ¡Dṣ2ṪḌ

นี่คือ I / O เป็นทศนิยม +จำนวนเต็มจะต้องมีการแยกจากกันโดยตัวละครที่ไม่ใช่ตัวเลข

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

พื้นหลัง

ในทางคณิตศาสตร์ในฐานคอมเพล็กซ์ , ผู้เขียนแสดงให้เห็นถึงวิธีการเพิ่มและคูณตัวเลขที่ซับซ้อนในฐานของรูปแบบ-n + i

สำหรับฐาน-1 + i การเติมจะทำในลักษณะเดียวกับการเติมแบบไบนารีและแบบพกพาซึ่งมีความแตกต่างกันสองประการ:

• แทนที่จะถือ1ไปยังตำแหน่งที่สูงกว่าต่อไปเราจะดำเนินการ110ถึงสามตำแหน่งถัดไป

• ตัวเลขนำติดตัวสามารถเผยแพร่ไปเรื่อย ๆ อย่างไรก็ตามหากไม่มีศูนย์นำหน้าผลรวม+ bจะมีตัวเลขได้ไม่เกินแปดหลักมากกว่าaและbสูงสุด

เราดำเนินการดังนี้

1. ก่อนอื่นเราเพิ่มaและbราวกับว่าตัวเลขเป็นทศนิยม

   สำหรับA = 10101และข = 11011นี้จะช่วยให้21112

2. สำหรับแต่ละหลักที่มีขนาดใหญ่กว่า1เราจะต้องลบ2จากหลักนั้นและนำ110ไปสู่ตำแหน่งที่สูงขึ้นสามตำแหน่งถัดไป เราสามารถทำสิ่งนี้ได้โดยการแปลงตัวเลขทศนิยมแต่ละตัวให้เป็นเลขฐานสองผลอาร์เรย์แบบไบนารีจากฐาน1100เป็นจำนวนเต็มและตีความรายการผลลัพธ์ของ0 , 1 , 1100 , 1100และ1101เป็นฐานที่ไม่ใช่แบบบัญญัติ10จำนวน. ¹

   สำหรับผลรวม21,112นี้จะช่วยให้21112 + 1098 * 10001 = 21112 + 10981098 = 11002210

3. เราทำซ้ำขั้นตอนที่ 2รวมเป็นD + 8ครั้งที่dคือจำนวนตัวเลขของA + B

   สำหรับผลรวมเริ่มต้น21112ผลลัพธ์จะเป็น

                         11002210
                         12210010
                       1220010010
                     122000010010
                   12200000010010
                 1220000000010010
               122000000000010010
             12200000000000010010
           1220000000000000010010
         122000000000000000010010
       12200000000000000000010010
     1220000000000000000000010010
   122000000000000000000000010010
   

4. เราละทิ้งทั้งหมดยกเว้นตัวเลขd + 8หลักสุดท้ายจากผลลัพธ์สุดท้าย นี่คือความสำเร็จโดยการทิ้งทุกอย่างหลังจากสุดท้าย2 ²

   สำหรับผลรวมเริ่มต้น21,112ผลสุดท้ายคือ10010

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

DBḅ1100ḌµDL+8µ¡Dṣ2ṪḌ  Main link. Argument: a + b (implicit sum)

        µ    µ¡       Execute the chain before the first µ n times, where n is
                      the result of executing the chain before the second µ.
         D            Convert a + b to base 10.
          L           Length; count the decimal digits.
           +8         Add 8 to the number of digits.
D                     Convert the initial/previous sum to base 10.
 B                    Convert each digit (0 - 3) to binary.
  ḅ1100               Convert each binary array from base 1100 to integer.
       Ḍ              Interpret the resulting list as a base 10 number.
               D      Convert the final sum to base 10.
                ṣ2    Split at occurrences of 2.
                  Ṫ   Select the last chunk.
                   Ḍ  Convert from base 10 to integer.

¹ _{โปรดสังเกตว่าตัวเลขของจำนวนนี้จะต้องไม่เกิน3 (ค่าเริ่มต้น1บวกสอง1 's จากดำเนินการ)}

^{2 ใช้} _{งานได้เพราะเลขหลักสุดท้ายที่จะยกเลิกไม่สามารถเป็น3ได้}

Python 3, 289 ไบต์

การดำเนินการนี้เป็นการเพิ่มแบบดิจิทัลจากน้อยไปหามากที่สุดที่สำคัญที่สุด (กล่าวอีกนัยหนึ่งคืออัลกอริทึมแบบเดียวกันกับที่คุณสอนในโรงเรียนประถม) ความแตกต่างคือว่า (ก) มันอยู่ในไบนารีไม่ทศนิยมเพื่อให้คุณดำเนินการเมื่อใดก็ตามที่หลักคือ 2 หรือมากกว่าและ (ข) ไม่1 + 1 = 110010

ที่จริงแล้วมันก็จำเป็นที่จะต้องทราบว่า11 + 111 = 0มิฉะนั้นผลรวมที่ควรเป็นศูนย์จะไม่สิ้นสุด

from collections import*
def a(*s,p=0):
 r=defaultdict(int,{0:0})
 for S in s:
  n=0
  for d in S[::-1]:r[n]+=d=='1';n+=1
 while p<=max(r):
  while r[p]>1:
   r[p]-=2
   if r[p+1]>1<=r[p+2]:r[p+1]-=2;r[p+2]-=1
   else:r[p+2]+=1;r[p+3]+=1
  p+=1
 return str([*map(r.get,sorted(r))])[-2::-3]

กอล์ฟมากขึ้นเป็นไปได้อย่างแน่นอน

จอประสาทตา, 157 151 134 133 124 123 ไบต์

1 ไบต์ต้องขอบคุณ Martin Büttner

(.+),(.+)
$.1$*0$2,$.2$*0$1,
1
0x
+`(0x*)(,.*)0(x*),
$2,$1$3
{`,

(^|0x0xx0xx)
000
(0x*)(0x*)(0x*0)xx
$1x$2x$3
)`^0+
0
0x
1

ลองออนไลน์!

แปลงเป็น unary จากนั้นทำซ้ำการแทนที่ต่อไปนี้ (แสดงที่นี่เป็นทศนิยม):

122 -> 000
0002 -> 1100 (this can also be 0012 -> 1110 and 1112 -> 2210 or even 2222 -> 3320 or even 3333 -> 4431)

โดยทั่วไปเมื่อมีขนาดใหญ่กว่าสอง: นำออกไปสองไม่เพิ่มอะไรในหลักก่อนหน้าเพิ่มหนึ่งหลักก่อนหน้าแล้วเพิ่มหนึ่งหลักก่อนหน้า

ใน pseudocode:

if(a[n]>2):
    a[n] -= 2;
    a[n-2] += 1;
    a[n-3] += 1;

การใช้งานแบบเอกนารี:

แต่ละหลัก (เช่น3) จะแสดงเป็นจำนวนxs (เช่นxxx) จากนั้นนำหน้าด้วย0แล้วนำหน้าด้วย

ยกตัวอย่างเช่นจะแสดงเป็น12340x0xx0xxx0xxxx

ใบนี้0ไม่เปลี่ยนแปลงขณะที่จะได้รับการแสดงโดย1010x00x

ตั้งแต่ครั้งแรกและครั้งสุดท้ายมีเพียง0และ1การแปลงสามารถทำได้อย่างง่ายดายโดย1->0xและ0x->1และ

คลิกที่นี่เพื่อดูทุกขั้นตอน

JavaScript (ES6), 146 126 ไบต์

r=n=>n&&n%2-r(n>>=1)-i(n)
i=n=>n&&r(n>>=1)-i(n)
g=(x,y,b=(x^y)&1)=>x|y&&b+2*g(b-x+y>>1,b-x-y>>1)
(x,y)=>g(r(x)+r(y),i(x)+i(y))

gแปลงจำนวนเต็ม Gaussian (ส่วนจริงและจินตภาพ) เป็นฐานi-1ในขณะที่rและiแปลงฐานi-1จำนวนเต็มเป็นจำนวนเต็ม Gaussian (ส่วนจริงและจำนวนจินตภาพตามลำดับ) เมื่อมีการแปลงแล้วฉันต้องทำเลขคณิต

แก้ไข: บันทึก 20 ไบต์โดยการคำนวณชิ้นส่วนจริงและจินตภาพแยกต่างหาก

C ++ 416 ไบต์บวก#include <vector>\n#include <algorithm>\n(อีก 40)

using I=int;using v=std::vector<I>;void r(v&x){v r{rbegin(x),rend(x)};x=r;}v a(v L,v R){r(L);r(R);L.resize(std::max(L.size(),R.size()));for(int&r:R)L[&r-R.data()]+=r;while(1){L.resize(L.size()+3);auto it=find(rbegin(L),rend(L),2);if(it==rend(L))break;I i=-1+it.base()-begin(L);i&&L[i+1]&&L[i-1]/2?L[i+1]=L[i]=L[i-1]=0:(++L[i+2],++L[i+3],L[i]=0);}L.erase( std::find(rbegin(L),rend(L),1).base(),end(L));r(L);return L;}

หรือด้วยช่องว่างเพิ่มเติม:

using I=int;
using v=std::vector<I>;

void r(v&x){v r{rbegin(x),rend(x)};x=r;}
v a(v L,v R) {
  r(L);r(R);
  L.resize(std::max(L.size(),R.size()));
  for(int&r:R)
    L[&r-R.data()]+=r;
  while(1) {
    L.resize(L.size()+3);
    auto it=find(rbegin(L), rend(L), 2);
    if(it==rend(L)) break;
    I i=-1+it.base()-begin(L);
    i&&L[i+1]&&L[i-1]/2?
      L[i+1]=L[i]=L[i-1]=0
    :
      (++L[i+2],++L[i+3],L[i]=0);
  }
  L.erase( std::find(rbegin(L),rend(L),1).base(), end(L));
  r(L);
  return L;
}

แทบกอล์ฟ มันใช้อินพุตเป็นเวกเตอร์ของ ints และส่งกลับเวกเตอร์ของ ints

ตัวอย่างสด