ฟังก์ชั่น (หรือโปรแกรม) ที่รับอินพุตและให้เอาท์พุทสามารถกล่าวได้ว่ามีรอบหากการเรียกใช้ฟังก์ชั่นบนเอาท์พุทของตัวเองซ้ำ ๆ จนมาถึงหมายเลขเดิม ตัวอย่างเช่นใช้ฟังก์ชันต่อไปนี้:

Input:  n    1 2 3 4 5 6
Output: f(n) 5 7 1 3 4 9

ถ้าเราเริ่มต้นด้วยn=1, f(n)=5, f(f(n))=f(5)=4, ,f(f(f(n)))=f(4)=3f(f(f(f(n))))=f(3)=1

(1 5 4 3)นี้ถูกเขียน เนื่องจากมีตัวเลขที่ไม่ซ้ำกัน 4 ตัวในลูปนี้นี่จึงเป็นวงจรของความยาว 4

ความท้าทายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่มีความยาวเท่าที่เป็นไปได้ นั่นคือจะต้องมีรอบความยาว 1, ความยาว 2 และอื่น ๆ

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

รายละเอียด: อนุญาตให้ใช้ระบบอินพุต / เอาต์พุตมาตรฐานใด ๆ รวมถึง STDIN, STDOUT, อาร์กิวเมนต์ของฟังก์ชัน, การส่งคืนและอื่น ๆ ที่ไม่อนุญาตให้มีช่องโหว่มาตรฐาน

คุณไม่จำเป็นต้องกังวลเกี่ยวกับข้อ จำกัด ของชนิดข้อมูลของคุณคุณสมบัติด้านบนจำเป็นต้องพักภายใต้สมมติฐานที่ว่าintหรือfloatสามารถเก็บค่าใด ๆ ได้

ไม่มีข้อ จำกัด เกี่ยวกับพฤติกรรมของฟังก์ชันในอินพุตซึ่งไม่ใช่จำนวนเต็มบวกและอินพุต / เอาต์พุตเหล่านั้นจะถูกละเว้น

การให้คะแนนคือโค้ดกอล์ฟในหน่วยไบต์รหัสที่สั้นที่สุดจะเป็นผู้ชนะ

Pyth, 11 8 ไบต์

.<W-0zz1

น่าเบื่อมากกว่าคำตอบก่อนหน้าของฉัน

ทุกหมายเลขที่มี 0 แผนที่หลักของตัวเอง หมายเลขอื่นใด ๆ ที่จับคู่กับตัวเลขที่มีตัวเลขหมุนเป็น 1 ดังนั้นตัวอย่างเช่น:

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

Python 2, 56 55 54 ไบต์

n=input()
a=b=1
while a+b<=n:a+=b;b+=1
print(n+~a)%b+a

นี่คือผลลัพธ์ 21 รายการแรก:

[1, 3, 2, 6, 4, 5, 10, 7, 8, 9, 15, 11, 12, 13, 14, 21, 16, 17, 18, 19, 20]

รูปแบบชัดเจนถ้าเราแบ่งรายการเป็นกลุ่มเช่น:

 1    2  3    4  5  6    7  8  9  10    11  12  13  14  15    16  17  18  19  20  21
[1]  [3, 2]  [6, 4, 5]  [10, 7, 8, 9]  [15, 11, 12, 13, 14]  [21, 16, 17, 18, 19, 20]

Pyth, 25 ไบต์

+hK/*J/h@h*8tQ2 2tJ2%-QKJ

นี่เป็นลำดับเดียวกับ @ Sp3000 แต่มีรูปแบบปิด แบบฟอร์มปิดคือ:

Python3, 40 ไบต์

n=input();print([n[1:]+n[0],n]['0'in n])

ทุกหมายเลขที่มี 0 แผนที่หลักของตัวเอง หมายเลขอื่นใด ๆ ที่จับคู่กับตัวเลขที่มีตัวเลขหมุนเป็น 1 ดังนั้นตัวอย่างเช่น:

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

ทับทิม, 22 + 1 = 23

ด้วยแฟล็กบรรทัดคำสั่ง-pให้รัน

~/(.)(.?)/
$_=$1+$'+$2

เมื่อได้รับเป็น input เป็นตัวแทนสตริงของหมายเลข (โดยไม่มีการขึ้นบรรทัดใหม่) จะช่วยให้คงหลักแรกแล้วหมุนที่เหลือที่เหลือจึงกลายเป็น12341342

สามารถลดได้ถึง 21 ตัวอักษรด้วย $_=$1+$'+$2if/(.)(.)/แต่พิมพ์คำเตือน

ทับทิม, 16 + 1 = 17

ด้วยแฟล็กบรรทัดคำสั่ง-pให้รัน

$_=$_[/.0*$/]+$`

นี่เป็นฟังก์ชั่นที่ซับซ้อนกว่าคำตอบอื่น ๆ ของฉัน แต่เกิดขึ้นว่าสามารถเล่นกอล์ฟได้มากขึ้น (และอดทนต่อการขึ้นบรรทัดใหม่) มันจะใช้ตัวเลขที่ไม่ใช่ศูนย์สุดท้ายของการป้อนข้อมูลรวมทั้งศูนย์ใด ๆ ต่อท้ายและย้ายไปที่จุดเริ่มต้นของตัวเลข ดังนั้นจะกลายเป็น9010300 3009010หมายเลขใด ๆ ที่มีตัวเลขที่ไม่ใช่ศูนย์จะเป็นส่วนหนึ่งของวงจรความยาว n

อินพุตเป็นสตริงในฐานใด ๆ ผ่าน STDIN เอาต์พุตเป็นสตริงในฐานนั้น

Python 43

ผกผันของฟังก์ชั่นของ SP3000ดำเนินการซ้ำ

f=lambda n,k=1:n>k and k+f(n-k,k+1)or n%k+1

ฟังก์ชั่นเป็นหนึ่งรอบตามด้วยสองรอบตามด้วยสามรอบ ...

(1)(2 3)(4 5 6)(7 8 9 10)(11 12 13 14 15)...

การดำเนินการn%k+1ทำหน้าที่เป็นk-cycle 1..kที่ตัวเลข เพื่อหาสิ่งที่เหมาะสมkกับการใช้งาน, การเปลี่ยนแปลงทุกอย่างลงk=1แล้วk=2และอื่น ๆ n<=kจน

Pyth, 15 ไบต์

คำตอบที่สั้นที่สุดที่ใช้การดำเนินงานที่เป็นตัวเลขมากกว่าการดำเนินการสตริง

.|.&Q_=.&_=x/Q2

    Q                input
            /Q2      input div 2
           x   Q     that XOR input
          =          assign that to Q
         _           negate that
       .&       Q    that AND Q
      =              assign that to Q
     _               negate that
  .&                 input AND that
.|               Q   that OR Q

ผลกระทบของฟังก์ชั่นนี้ในการเป็นตัวแทนไบนารีคือการขยายบล็อกขวาสุดของ 1s เป็น 0 ต่อไป; หรือหากไม่มี 0 ให้รีเซ็ตมันกลับเป็น 1 เดียว:

10010110100000 ↦  
10010110110000 ↦  
10010110111000 ↦  
10010110111100 ↦  
10010110111110 ↦  
10010110111111 ↦
10010110100000  

Pyth, 26 ไบต์, ตัวแปรสนุกสนาน

.|.&Q_h.&/Q2+Qy=.&/Q2_h.|y

    Q                           input
         /Q2                    input div 2
             Q                  input
                  /Q2           input div 2
                         yQ     twice input
                       .|  Q    that OR input
                     _h         NOT that
                .&              (input div 2) AND that
               =                assign that to Q
              y                 twice that
            +                   input plus that
       .&                       (input div 2) AND that
     _h                         NOT that
  .&                            input AND that
.|                          Q   that OR Q

ดำเนินการการดำเนินการข้างต้นพร้อมกันกับบล็อกทั้งหมดของ 1s ไม่ใช่เฉพาะที่ถูกต้องที่สุด - ยังคงใช้การดำเนินการระดับบิตและเลขคณิตเท่านั้น

1000010001001 ↦
1100011001101 ↦
1110011101001 ↦
1111010001101 ↦
1000011001001 ↦
1100011101101 ↦
1110010001001 ↦
1111011001101 ↦
1000011101001 ↦
1100010001101 ↦
1110011001001 ↦
1111011101101 ↦
1000010001001

Swift 1.2, 66 bytes

func a(b:Int){var c=0,t=1,n=b
while n>c{n-=c;t+=c++}
print(n%c+t)}

Input:  1,   2, 3,  4, 5, 6,   7, 8, 9, 10,   11, 12, 13, 14, 15
Output: 1,   3, 2,  5, 6, 4,   8, 9, 10, 7,   12, 13, 14, 15, 11

Brachylogขนาด 5 ไบต์

∋0&|↺

ลองออนไลน์!

คำตอบ Pyth ของ @ @ พอร์ตของ orlp ออกมาเรียบง่ายและเรียบร้อย:

∋0    % If input contains a 0 (since input is a single number, "contains" ∋ treats it as an array 
      %   of its digits, so this means "if any of input's digits are 0")
&     % Then output is the input
|     % Otherwise
↺     % Circularly shift the input once, and unify that with the output

ตอนแรกฉันต้องการที่จะแก้ปัญหา Python ของพอร์ต @ Sp3000 แต่นั่นก็กินเนื้อที่23 ไบต์ :

⟧∋B-₁⟦++₁A≤?;A--₁;B%;A+

ลองออนไลน์!

JavaScript (ES6), 43 ไบต์

f=(n,i=1,j=1)=>n>j?f(n,++i,j+i):n++<j?n:n-i

Matlab (189)

  function u=f(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if ~isempty(z),t=y(y~=max(y));if isempty(t),u=y(end)*2^(nnz(y)-1);else,g=max(t);e=primes(g*2);u=n/g*e(find(e==g)+1);end,end,end

• ฟังก์ชั่น:

  แผนที่จำนวนเต็มใด ๆ ตามปัจจัยเฉพาะของมันถ้าจำนวนศูนย์หรือตัวประกอบเป็น 2 หรือ 1 ตัวเลขจะถูกแมปกับตัวเองไม่เช่นนั้นเราจะเลือกตัวประกอบจำนวนที่ใหญ่ที่สุดของจำนวนนี้ ตัวประกอบที่ใหญ่กว่านั้นจนกว่าเราจะไปถึงจำนวนbiggest_prime^nซึ่งnเป็นผลรวมของเลขชี้กำลังทั้งหมดของปัจจัยทั้งหมดเมื่อเราไปถึงจำนวนนั้นเราจะหันไปหาmax_prime*2^(n-1)และเราจะสร้างวงจรเดียวกันอีกครั้ง

Matlab (137)

  function u=h(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if~isempty(z),e=nnz(y);f=nnz(z);if(~mod(e,f)&e-f)u=n/2^(e-f);else,u=u*2;end

• วิธีที่คล้ายกันเล็กน้อยทวีคูณจำนวนใด ๆ ไม่เท่ากับ {0,1,2 ^ n} 2จนกว่าเราจะสะดุดกับเลขชี้กำลัง2ซึ่งหารได้ด้วยผลรวมของเลขชี้กำลังของปัจจัยสำคัญอื่น ๆ 2^(sum of exponents of other primes)แล้วเราย้ายไปยังจุดเริ่มต้นของการแบ่งวงจรโดย ส่วนชาอื่นถูกแมปกับตัวเอง