ที่เกี่ยวข้อง แต่ต้องใช้จำนวนเต็มบวกเท่านั้นและไม่จำเป็นต้องสลับกัน

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

งานของคุณคือการออกแบบฟังก์ชั่นที่สอง: หนึ่งที่มีประสิทธิภาพและมีประสิทธิภาพอื่นX, Y -> Z ๆ Z -> X, Yนี่คือการจับ: X, Y -> Zจะต้องสลับกัน ซึ่งหมายความว่าZ -> X, Yจะไม่สามารถที่จะตรวจสอบถ้าใส่เป็นหรือX, YY, X

คำจำกัดความที่เป็นทางการของความท้าทายนี้คือ:

เลือกชุดตัวเลข S ที่ไม่มีที่สิ้นสุดนับได้
ออกแบบสองฟังก์ชั่นที่ทำงานต่อไปนี้:

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

ความต้องการ

• ผลลัพธ์ควรเหมือนกันระหว่างการวิ่ง
• {a, a} เป็นคู่ที่ไม่มีลำดับ

หมายเหตุ: คำตอบของคุณมีแนวโน้มที่จะได้รับ upvote จากฉันถ้าคุณให้หลักฐาน แต่ฉันจะทดสอบคำตอบเมื่อฉันได้รับมันและ upvote เมื่อฉันค่อนข้างแน่ใจว่ามันทำงาน

Haskell , 65 + 30 = 95 ไบต์

a#b=length.fst$span(<(max a b,min a b))[(a,b)|a<-[1..],b<-[1..a]]

ลองออนไลน์!

([(a,b)|a<-[1..],b<-[1..a]]!!)

ลองออนไลน์!

หมายเหตุ:เมื่อทั้งสองฟังก์ชั่นอาจแบ่งปันรหัสนี่เป็นเพียง 75 ไบต์:

(l!!)
a#b=length.fst$span(<(max a b,min a b))l
l=[(a,b)|a<-[1..],b<-[1..a]]

ลองออนไลน์! โดเมนเป็นจำนวนเต็มบวก ฟังก์ชั่น(#)ทำการจับคู่ฟังก์ชั่นที่(l!!)ตรงกันข้าม ตัวอย่างการใช้งาน: ทั้งสอง(#) 5 3และ(#) 3 5อัตราผลตอบแทน12และอัตราผลตอบแทน(l!!) 12(5,3)

สิ่งนี้ทำงานโดยการแสดงรายการคู่ที่เรียงลำดับทั้งหมดในรายการที่ไม่สิ้นสุดl:

l = [(1,1),(2,1),(2,2),(3,1),(3,2),(3,3),(4,1),(4,2),(4,3),(4,4),(5,1),(5,2),(5,3),(5,4),(5,5),(6,1), ...`

การเข้ารหัสนั้นเป็นเพียงดัชนีในรายการนี้

Pyth , 8 + 6 = 14 ไบต์

ij\aSQ16

    SQ   # Sort the input
 j\a     # join with "a"
i     16 # convert from base 16 to base 10

ลองออนไลน์!

c.HQ\a

 .HQ     # convert from base 10 to 16
c   \a   # split on "a"

ลองออนไลน์!
โดเมน: จำนวนเต็มบวก

เยลลี่ , 8 + 11 = 19 ไบต์

ย้อนกลับไปเนื่องจากอัลกอริทึมของ Rod ไม่ทำงาน

สิ่งนี้ใช้ได้กับโดเมนของจำนวนเต็มบวก

รับxและyโต้แย้ง 2 ครั้งไม่สำคัญว่าจะเรียงตามลำดับหรือzไม่

»’RSð+ð«

ลองออนไลน์!

รับzและส่งคืน[min(x, y), max(x, y)]

R€Ẏ,Rx`$ị@€

ลองออนไลน์!

JavaScript (ES7), 44 ไบต์

(x,y)=>x>y?x*x+y:y*y+x
z=>[x=z**.5|0,y=z-x*x]

แผนที่จากจำนวนเต็มที่ไม่เป็นลบไปยังชุดย่อยของมัน

C (gcc) , 36 + 39 = 75 ไบต์

ขอบคุณ @tsh สำหรับการบันทึกสองไบต์

โดเมนเป็นจำนวนเต็มไม่เป็นลบ

p(x,y){return y>x?p(y,x):-~x*x/2+y;}

ใช้เวลาxและผลตอบแทนyz

u(int*r){for(*r=0;r[1]>*r;r[1]-=++*r);}

รับintอาร์เรย์สององค์ประกอบ องค์ประกอบที่สองจะต้องตั้งค่าzก่อนการโทร หลังจากการโทรrมีxและyและ

ลองออนไลน์!

เยลลี่ , 13 11 ไบต์

คู่ของจำนวนเต็มบวกถึงจำนวนเต็มบวก 5 ไบต์

Ṁc2+Ṃ

ลองออนไลน์!

จำนวนเต็มบวกกับคู่ของจำนวนเต็มบวก, 6 ไบต์

ŒċṀÞị@

ลองออนไลน์!

ขั้นตอนวิธี

หากเราเรียงลำดับชุดของจำนวนเต็มบวกทั้งหมดที่ไม่เรียงลำดับตามค่าสูงสุดแล้วหารด้วยผลรวมเราจะได้ลำดับต่อไปนี้

{1,1}, {1,2}, {2,2}, {1,3}, {2,3}, {3,3}, {1,4}, {2,4}, {3 , 4}, {4,4}, {1,5}, {2,5}, {3,5}, {4,5}, {5,5}, ...

ฟังก์ชั่นแรกใช้เวลาหนึ่งคู่{x, y}และค้นหาดัชนีในลำดับนี้

ฟังก์ชันที่สองรับจำนวนเต็มบวกzและส่งคืนรายการz ^thของลำดับ

โปรดทราบว่าการทำแผนที่นี้เป็นเช่นเดียวกับใน@ EriktheOutgolfer คำตอบของวุ้น

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

Ṁc2+Ṃ   Main link. Argument: [x, y]
        Let m = max(x, y) and n = min(x, y).

Ṁ       Maximum; yield m.
 c2     2-combinations; yield mC2 = m(m-1)/2.
        Note that there's one pair with maximum 1 ({1,1}), two pairs with maximum 2
        ({1,2}, {2,2}), etc., so there are 1 + 2 + … + (m-1) = m(m-1)/2 pairs with
        maximum less than m.
    Ṃ   Minimum; yield n.
        Note that {x,y} is the n-th pair with maximum m.
   +    Add; yield mC2 + n.
        This finds {x,y}'s index in the sequence.

ŒċṀÞị@  Main link. Argument: z

Œċ      2-combinations w/replacement; yield all pairs [x, y] such that x ≤ y ≤ z.
  ṀÞ    Sort by maximum.
    ị@  Retrieve the pair at index z (1-based).

Mathematica (35 + 53) = 78 Bytes

((x=Min[#])+(y=Max[#]))(x+y+1)/2+y&

(i=Floor[(-1+Sqrt[1+8#])/2];{#-i(1+i)/2,i(3+i)/2-#})&

นี่คือฟังก์ชั่นการจับคู่สมการกำลังสองที่รู้จักกันดีสำหรับ Z <--> ZxZ รวมกับ Min และ Max เพื่อให้เป็นระเบียบ

Ruby, 66 ไบต์

f=->x,y{2**~-x|2**~-y}
g=->n{x,y=(1..n).select{|i|n[i-1]>0};[x,y||x]}

ฉันพยายามหาวิธีที่จะเลือกเซตที่ไม่มีที่สิ้นสุดเพื่อทำให้ง่ายขึ้นนี่คือสิ่งที่ดีที่สุดที่ฉันเคยได้รับ

เรากำหนด f (x, y) = 2 ^x-1บิตหรือ 2 Y-1 โดเมนประกอบด้วยชุดที่กำหนดซ้ำแบบมี 1,2 และหมายเลขทั้งหมดที่สามารถสร้างได้โดยการเรียก f บนตัวเลขในชุด (โปรดทราบว่า f (1,1) = 1 และ f (2,2) = 2 ดังนั้น 1 และ 2 จึงมีค่าผกผัน) ตัวเลขผลลัพธ์ทั้งหมดมีหนึ่งหรือสอง 1 ในการขยายไบนารีด้วยดัชนีของ 1s ที่สอดคล้องกับตัวเลขในชุด เราสามารถดึงคู่ที่ไม่มีลำดับเดิมออกมาได้โดยหาดัชนี หากมีเพียงหนึ่งเดียวนั่นหมายความว่าองค์ประกอบของคู่นั้นเท่ากัน

ตัวอย่างเช่น f (3,5) เท่ากับ 20 เพราะ 20 คือ 1,0100 ในฐาน 2 ซึ่งมี 1 วินาทีในสถานที่ที่สำคัญน้อยที่สุดอันดับ 3 และ 5

Java 8, 153 146 141 137 + 268 224 216 205 ไบต์

ฟังก์ชั่นการจับคู่

a->{String f="";for(int i=(f+a[0]).length(),c=0,j;i>0;i-=c,f+=c,c=0)for(j=1;j<10;c+=i-j++<0?0:1);return new Integer(a[0]+""+a[1]+"0"+f);}

ลองออนไลน์!

ฟังก์ชั่น Depair

r->{String a=r+"",t=a.substring(a.lastIndexOf('0')+1);int l=0,i=l,o=t.length();for(;i<o;l+=r.decode(t.charAt(i++)+""));return new int[]{r.decode(a.substring(0,l)),r.decode(a.substring(l,a.length()-o-1))};}

ลองออนไลน์!

05AB1E , 6 + 11 = 17 ไบต์

พอร์ตคำตอบของเยลลี่ของฉัน

โดเมน: จำนวนเต็มบวก

รับรายการ[x, y]เป็น input zผลตอบแทน

{`<LO+

ลองออนไลน์!

ใช้เวลาเป็นจำนวนเต็มบวกzเป็น input [min(x, y), max(x, y)]ผลตอบแทน

L2ã€{RÙR¹<è

ลองออนไลน์!

-5 ขอบคุณที่Emigna

จาวาสคริปต์, 72 ไบต์

f=a=>eval('0x'+a.sort().join`a`)
g=n=>n.toString(16).split`a`.map(x=>+x)

ใช้งานได้สำหรับจำนวนเต็มบวก (ในทางทฤษฎี) แนวคิดง่าย ๆ : เรียงลำดับเลขสองตัวในลำดับ (เวทย์มนตร์) เชื่อมต่อพวกมันเป็นสตริงด้วยตัวอักษร"a"แล้วแยกเป็นจำนวนเต็มฐานสิบหก

f=a=>eval('0x'+a.sort().join`a`)
g=n=>n.toString(16).split`a`.map(x=>+x)

<pre oninput="p.value=f([+x.value, +y.value])">
     X = <input id="x" type="number" min="0" />
     Y = <input id="y" type="number" min="0" />
 f(X,Y)= <output id="p"></output>
</pre>

<pre oninput="q.value=g(+u.value).join(', ')">
     U = <input id="u" type="number" />
   g(U)= <output id="q"></output>
</pre>

MATL, 6 + 8 = 14 ไบต์

ฟังก์ชั่นการเข้ารหัสใช้เวลาสองอินพุต n, m แสดงผลผลิตภัณฑ์ของ Prime Prime และ Prime Prime

,iYq]*

ขั้นตอน:

• , - ทำสองครั้ง
• i - อินพุตพุช
• Yq - ป๊อปอินพุทพุชดันอินพุทไพรม์
• ]* - จบทำสองครั้ง pop ทั้งช่วงเวลาและผลักดันผลิตภัณฑ์

ฟังก์ชั่นการถอดรหัสใช้เวลาหนึ่งอินพุต m ส่งออกจำนวนช่วงเวลาที่ต่ำกว่าแต่ละปัจจัยหลักของ n

iYf"@Zqn

ขั้นตอน:

• i - อินพุตพุช
• Yf - ป้อนป๊อปพุชของปัจจัยสำคัญ
• " - สำหรับ n ในอาร์เรย์
• @Zq - กดอาร์เรย์จำนวนเฉพาะด้านล่าง n
• n - ป๊อปอาร์เรย์ความยาวของอาร์เรย์

นี่คือการสับเปลี่ยนเนื่องจากการคูณนั้นสลับกันและการฉีดเนื่องจากแฟคทอเรียลที่เฉพาะเจาะจง ไม่ใช่ว่านี่ไม่ได้อยู่ในจำนวนเต็ม

Husk , 5 + 3 = 8 ไบต์

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

คู่ของจำนวนเต็มบวกเป็นจำนวนเต็มบวกเดียว:

¤*!İp

ลองออนไลน์!

มันทำงานโดยใช้ตัวเลขที่ดัชนีที่กำหนด (ดัชนี 1) จากรายการของจำนวนเฉพาะและคูณพวกเขา

ผลลัพธ์ของฟังก์ชันแรกสำหรับคู่ของจำนวนเต็มบวก:

mṗp

ลองออนไลน์!

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

ทำงานตัวอย่าง

ได้รับ(4,1)เป็นคู่เริ่มต้นที่เราใช้เวลาที่สี่และเป็นครั้งแรกตัวเลขที่สำคัญและพวกเขาคูณ→(7,2) 14การคูณนี้คือสิ่งที่ทำให้ฟังก์ชันอิสระตามลำดับของทั้งสององค์ประกอบ

เริ่มต้นจากการ14ที่เรา factorize มัน(2,7)และกลับดัชนีของ2และในรายการของตัวเลขสำคัญ→7(1,4)

C # , 80 ไบต์ (38 + 42)

ข้อมูล

Encoder

• ใส่ Int32 lตัวเลข
• ใส่ Int32 rตัวเลข
• เอาต์พุต Int64ทั้งสองรวมเข้าด้วยกัน

ถอดรหัส

• อินพุต Int32 vค่า
• เอาต์พุต Int32[]อาร์เรย์ที่มี ints ดั้งเดิมสองตัว

แข็งแรงเล่นกอล์ฟ

// Encoder
e=(l,r)=>{return(long)l<<32|(uint)r;};

// Decoder
d=v=>{return new[]{v>>32,v&0xFFFFFFFFL};};

Ungolfed

// Encoder
e = ( l, r ) => {
    return (long) l << 32 | (uint) r;
};

// Decoder
d = v => {
    return new[] {
        v >> 32,
        v & 0xFFFFFFFFL };
};

อ่านได้ไม่ดี

// Encoder
// Takes a pair of ints
e = ( l, r ) => {

    // Returns the ints fused together in a long where the first 32 bits are the first int
    // and the last 32 bits the second int
    return (long) l << 32 | (uint) r;
};

// Decoder
// Takes a long
d = v => {

    // Returns an array with the ints decoded where...
    return new[] {

        // ... the first 32 bits are the first int...
        v >> 32,

        // ... and the last 32 bits the second int
        v & 0xFFFFFFFFL };
};

รหัสเต็ม

using System;
using System.Collections.Generic;

namespace TestBench {
    public class Program {
        // Methods
        static void Main( string[] args ) {
            Func<Int32, Int32, Int64> e = ( l, r ) => {
                return(long) l << 32 | (uint) r;
            };
            Func<Int64, Int64[]> d = v => {
                return new[] { v >> 32, v & 0xFFFFFFFFL };
            };

            List<KeyValuePair<Int32, Int32>>
                testCases = new List<KeyValuePair<Int32, Int32>>() {
                    new KeyValuePair<Int32, Int32>( 13, 897 ),
                    new KeyValuePair<Int32, Int32>( 54234, 0 ),
                    new KeyValuePair<Int32, Int32>( 0, 0 ),
                    new KeyValuePair<Int32, Int32>( 1, 1 ),
                    new KeyValuePair<Int32, Int32>( 615234, 1223343 ),
                };

            foreach( KeyValuePair<Int32, Int32> testCase in testCases ) {
                Console.WriteLine( $" ENCODER: {testCase.Key}, {testCase.Value} = {e( testCase.Key, testCase.Value )}" );
                Console.Write( $"DECODING: {e( testCase.Key, testCase.Value )} = " );
                PrintArray( d( e( testCase.Key, testCase.Value ) ) );

                Console.WriteLine();
            }

            Console.ReadLine();
        }

        public static void PrintArray<TSource>( TSource[] array ) {
            PrintArray( array, o => o.ToString() );
        }
        public static void PrintArray<TSource>( TSource[] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 index = 0; index < array.Length; index++ ) {
                output.Add( valueFetcher( array[ index ] ) );
            }

            Console.WriteLine( $"[ {String.Join( ", ", output )} ]" );
        }
    }
}

ข่าว

• v1.0 - 80 bytes- โซลูชั่นเริ่มต้น

หมายเหตุ

• ไม่มี

Python: 41 + 45 = 86

เข้ารหัส: 41

e=lambda*x:int('1'*max(x)+'0'+'1'*min(x))

e(4, 3), e(3,4)

(11110111, 11110111)

ตัวถอดรหัส: 45

d=lambda z:[len(i)for i in str(z).split('0')]

d(11110111)

[4, 3]

ความพยายามที่เก่ากว่า:

Python: 114: 30 + 84

เข้ารหัส: 30

ยอมรับ 2 จำนวนเต็มส่งคืนสตริง

e=lambda*x:2**max(x)*3**min(x)

e(3, 4), e(4, 3)

(432, 432)

ถอดรหัส: 86

def d(z):
 x=y=0
 while 1-z%2:
  x+=1
  z/=2
 while 1-z%3:
  y+=1
  z/=3
 return x,y

d(432)

4, 3

decoder2: 120

ความพยายามอีกครั้งกับความเข้าใจกำเนิดและผลรวม

def d(z):
 x=sum(1 for i in range(z)if not z%(2**i))-1
 z/=2**x
 return x,sum(1 for i in range(int(z))if not z%(3**i))-1