हर संभव साइकिल की लंबाई

Question

एक फ़ंक्शन (या प्रोग्राम) जो इनपुट लेता है और आउटपुट प्रदान करता है, एक चक्र कहा जा सकता है यदि फ़ंक्शन को अपने आउटपुट पर बार-बार कॉल करने से अंततः मूल संख्या तक पहुंच जाता है। उदाहरण के लिए, निम्नलिखित कार्य करें:

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)=3, f(f(f(f(n))))=f(3)=1।

यह लिखा है (1 5 4 3)। चूंकि इस लूप में 4 अद्वितीय संख्याएं हैं, इसलिए यह लंबाई 4 का एक चक्र है।

---

आपकी चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जिसमें हर संभव लंबाई के चक्र हैं। यही है, लंबाई 1 का एक चक्र होना चाहिए, लंबाई 2 का, और इसी तरह।

इसके अलावा, आपका फ़ंक्शन / प्रोग्राम पॉजिटिव पूर्णांकों से पॉजिटिव पूर्णांकों तक होना चाहिए, और यह बायजेक्टिव होना चाहिए , जिसका अर्थ है कि सभी पॉजिटिव पूर्णांकों पर हर संभव आउटपुट वैल्यू के लिए बिल्कुल एक इनपुट वैल्यू होनी चाहिए। इसे दूसरे तरीके से रखने के लिए, फ़ंक्शन / प्रोग्राम को पॉजिटिव पूर्णांकों के क्रमांकन की गणना करनी चाहिए।

---

विवरण: किसी भी मानक इनपुट / आउटपुट सिस्टम को अनुमति दी जाती है, जिसमें STDIN, STDOUT, फ़ंक्शन तर्क, रिटर्न आदि शामिल हैं। मानक कमियां निषिद्ध हैं।

आपको अपने डेटा प्रकारों की सीमाओं के बारे में चिंता करने की आवश्यकता नहीं है - उपरोक्त गुणों को केवल इस धारणा के तहत पकड़ना होगा कि intया floatउदाहरण के लिए कोई मूल्य पकड़ सकता है।

इनपुट पर फ़ंक्शन के व्यवहार पर कोई प्रतिबंध नहीं है जो सकारात्मक पूर्णांक नहीं हैं, और उन इनपुट / आउटपुट को अनदेखा किया जाएगा।

---

स्कोरिंग कोड गोल्फ है बाइट्स में, सबसे छोटा कोड जीतता है।

Comments

"लंबाई 1 का एक चक्र होना चाहिए, लंबाई 2 का, और इसी तरह" क्या इसकी व्याख्या इस रूप में की जानी चाहिए " कम से कम 1 लंबाई का चक्र होना चाहिए , कम से कम 2 लंबाई का, और इसी तरह" या "वहाँ होना चाहिए" हो बिल्कुल लंबाई 1 का एक चक्र की लंबाई 2 में से एक, और इतने पर "।

— बकुरीउ

@ बकुरीउ प्रत्येक सकारात्मक लंबाई का कम से कम एक चक्र।

— ईसैक

Answer 1

अजगर, 11 8 बाइट्स

.<W-0zz1

मेरे पिछले उत्तर की तुलना में बहुत अधिक उबाऊ।

प्रत्येक संख्या जिसमें स्वयं के लिए 0 अंक के नक्शे होते हैं। संख्या के लिए कोई अन्य संख्या मानचित्र जिसमें इसके अंक घुमाए गए हैं 1. उदाहरण के लिए:

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

Answer 2

पायथन 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]

Comments

अरे, यह वह पैटर्न है जिसके लिए मैं भी जा रहा था, लेकिन एक बंद रूप के साथ।

— orlp

रुचिकर .. A- मान अनुक्रम A000124 का पालन करते हैं । लेकिन मुझे लगता है कि आप पहले से ही जानते थे कि: P

— Kade

ध्यान दें कि यह अनुक्रम oeis.org/A066182 है ।

— orlp

Answer 3

पायथ, 25 बाइट्स

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

यह @ Sp3000 जैसा ही अनुक्रम है, लेकिन एक बंद फॉर्म के साथ। बंद फॉर्म है:

Answer 4

पायथन 3, 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

Comments

देजा वु! इसे दो भाषाओं में देखने के लिए अच्छा है!

— डेन्हम कोट

Answer 5

रूबी, 22 + 1 = 23

कमांड-लाइन ध्वज के साथ -p, चलाएँ

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

जब इनपुट के रूप में एक संख्या का स्ट्रिंग निरूपण (बिना अनुगामी न्यूलाइन के) किया जाता है, तो यह पहले अंक को स्थिर रखता है, फिर शेष बाईं ओर घूमता है, इसलिए 1234बन जाता है 1342।

इसे 21 वर्णों तक घटाया जा सकता है $_=$1+$'+$2if/(.)(.)/, लेकिन एक चेतावनी प्रिंट करता है।

Answer 6

रूबी, 16 + 1 = 17

कमांड-लाइन ध्वज के साथ -p, चलाएँ

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

यह मेरे अन्य उत्तर की तुलना में अधिक जटिल कार्य है, लेकिन अधिक गोल्फ (और अनुगामी न्यूलाइन्स के प्रति सहिष्णु) होता है। यह इनपुट के अंतिम नॉनजेरो अंक, साथ ही किसी अनुगामी शून्य को लेता है, और इसे संख्या की शुरुआत में ले जाता है। तो 9010300बन जाता है 3009010। एन नॉनजरो अंकों के साथ कोई भी संख्या एक एन-लंबाई चक्र का हिस्सा होगी।

इनपुट STDIN के माध्यम से किसी भी आधार में एक स्ट्रिंग है, आउटपुट उस आधार में एक स्ट्रिंग है।

Answer 7

पायथन, 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चक्र के रूप में कार्य करता है 1..k। kउपयोग करने के लिए उपयुक्त खोजने के लिए k=1, तब k=2तक, तब तक सब कुछ नीचे स्थानांतरित करें n<=k।

Answer 8

अजगर, 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  

अजगर, 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

1 एस के सभी ब्लॉकों के लिए एक साथ उपरोक्त ऑपरेशन करता है , न केवल सबसे सही एक - अभी भी केवल बिटवाइज़ और अंकगणितीय संचालन का उपयोग करना।

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

Answer 9

स्विफ्ट 1.2, 66 बाइट्स

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

Answer 10

ब्रेकीलॉग , 5 बाइट्स

∋0&|↺

इसे ऑनलाइन आज़माएं!

@ 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

मैं मूल रूप से @ Sp3000 के पायथन सॉल्यूशन को पोर्ट करना चाहता था, लेकिन इसमें 23 बाइट्स लगे :

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

इसे ऑनलाइन आज़माएं!

Answer 11

जावास्क्रिप्ट (ईएस 6), 43 बाइट्स

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

Answer 12

मैटलैब (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)और हम उसी चक्र को फिर से दोहराते हैं।

Answer 13

मैटलैब (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)। अन्य संख्याएँ स्वयं के लिए मैप की जाती हैं।