बाजीगर अनुक्रम का उत्पादन

Question

बाजीगर अनुक्रम इस प्रकार वर्णन किया गया है। एक इनपुट के साथ शुरुआत एक ₁ , अगले अवधि आवर्तन संबंध द्वारा परिभाषित किया गया है

अनुक्रम समाप्त हो जाता है जब यह 1 तक पहुंचता है, जैसा कि बाद के सभी शब्दों में तब 1 होगा।

कार्य

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

परीक्षण के मामलों

Input: output
2: 2, 1
3: 3, 5, 11, 36, 6, 2, 1
4: 4, 2, 1
5: 5, 11, 36, 6, 2, 1

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

Comments

मुझे थोड़ा नीरज मिला और पहले ~5.6*10^7मूल्यों के लिए कदमों की संख्या की गणना की (वे सभी अब तक रुक गए)।

— माइकल क्लिन

मुझे Collatz अनुमान की याद दिलाता है (अभी भी अनसुलझा)

— wim

@ हाँ, यह बहुत हद तक वैसा ही है।

— सेडरस

Answer 1

जेली , 12 11 10 बाइट्स

*BṪ×½Ḟµ’п

1 बाइट को बंद करने के लिए @ Sp3000 को धन्यवाद!

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

यह काम किस प्रकार करता है

*BṪ×½Ḟµ’п    Main link. Input: n

*B            Elevate n to all of its digits in base 2.
  Ṫ           Extract the last power.
              This yields n ** (n % 2).
   ×½         Multiply with sqrt(n). This yields n ** (n % 2 + 0.5).
     Ḟ        Floor.

      µ       Push the previous chain on the stack and begin a new, monadic chain.
        п    Repeat the previous chain while...
       ’        n - 1 is non-zero.
              Collect all intermediate results in an array.

Comments

मुझे पूछने से लगभग डर लगता है, क्योंकि पोस्टर में 87k प्रतिष्ठा है, लेकिन क्या 10 बाइट्स में इसका प्रतिनिधित्व करना वास्तव में संभव है? आप 10 वर्णों का उपयोग कर रहे हैं, लेकिन क्या आप वास्तव में इन सभी गूढ़ वर्णों को केवल 256 संयोजनों में फिट कर सकते हैं? Ḟ, Ḟ, add मेरे वर्णमाला में जोड़ने के लिए वर्णों के लिए मेरी पहली पसंद नहीं होगी, यह देखते हुए कि मेरे पास भरने के लिए केवल 256 स्थान हैं ...

— अनाउंसर

@Annonymus जेली एक कस्टम कोड पेज का उपयोग करता है, जो प्रत्येक 256 अक्षरों को समझता है जो प्रत्येक को सिनलेट बाइट के रूप में समझता है।

— डेनिस

समझा! धन्यवाद। Btw, मुझे आपकी तालिका में एक बग मिला, वर्ण 20 (मैं मान रहा हूं कि यह एक स्थान है, अगर यह "बग" नहीं है कि यह अस्पष्ट है) क्योंकि यह एक अकेला स्थान है, इसे हटा दिया जाता है, तो आपको & nbsp का उपयोग करना चाहिए; बजाय।

— बेनामी

@ अननोनमस हां, जो थोड़ा अजीब लग रहा था। मैं NBSP का उपयोग नहीं करना चाहता था क्योंकि तालिका को कॉपी करने का कोई भी प्रयास टूट जाएगा, लेकिन <code> </code>इसके बजाय backticks एक वास्तविक एसपी चरित्र प्रदर्शित करता है। यह बात बताने के लिए धन्यवाद।

— डेनिस

Answer 2

जूलिया, 64 50 48 42 32 30 बाइट्स

g(x)=[x;x<3||g(x^(x%2+.5)÷1)]

यह एक पुनरावर्ती कार्य है जो एक पूर्णांक को स्वीकार करता है और एक फ्लोट सरणी देता है।

हम अनुक्रम की अगली अवधि के साथ इनपुट को समवर्ती करके एक सरणी बनाते हैं, इसकी समता प्लस 1/2 की शक्ति के रूप में x के रूप में गणना की जाती है । यह हमें x ^1/2 या x ^{1 + 1/2} = x ^{3/2 देता है} । 1 से पूर्णांक विभाजन को मंजिल मिलती है। जब स्थिति x <3 सही है, तो अंतिम तत्व एक संख्यात्मक मान के बजाय एक बूलियन होगा, लेकिन चूंकि सरणी प्रकार की नहीं है Any, इसलिए यह बाकी सरणी के समान प्रकार का है।

डेनिस के लिए धन्यवाद 14 बाइट्स सहेजे गए!

Comments

क्या जूलिया दुभाषिया आईएसओ 8859-1 में सोर्स कोड संभाल सकती है? तब पूर्णांक विभाजन केवल एक बाइट होगा।

— मार्टिन एंडर

@ मार्टिनबटनर नहीं, मैंने पहले भी इसकी कोशिश की है और यह बहुत पागल हो गया है। जूलिया का पार्सर UTF-8 मानता है।

— एलेक्स ए।

Answer 3

जावास्क्रिप्ट (ईएस 7), 45 33 बाइट्स

f=n=>n<2?n:n+","+f(n**(.5+n%2)|0)

व्याख्या

पुनरावर्ती दृष्टिकोण। संख्याओं के अल्पविराम से अलग स्ट्रिंग लौटाता है।

f=n=>
  n<2?n:          // stop when n == 1
  n               // return n at the start of the list
  +","+f(         // add the rest of the sequence to the list
    n**(.5+n%2)|0 // juggler algorithm
  )

परीक्षा

** ब्राउज़र संगतता के लिए परीक्षण में उपयोग नहीं किया गया।

f=n=>n<2?n:n+","+f(Math.pow(n,.5+n%2)|0)

<input type="number" oninput="result.textContent=f(+this.value)" />
<pre id="result"></pre>

Comments

मुझे यकीन है कि **सभी ब्राउज़रों में इच्छा का समर्थन किया गया था।

— ETHproductions

@ETHproductions मुझे यकीन है कि ** C # में इच्छा का समर्थन किया गया था।

— aloisdg का कहना है कि Monica

Answer 4

गणितज्ञ, 40 39 बाइट्स

1 बाइट बचाने के लिए मार्टिन ब्यूटनर को धन्यवाद।

NestWhileList[⌊#^.5#^#~Mod~2⌋&,#,#>1&]&

परीक्षण का मामला

%[5]
(* {5,11,36,6,2,1} *)

Answer 5

Pyth, 14 12 बाइट्स

.us@*B@N2NNQ

प्रदर्शन

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

फ़ंक्शन पिछले मान को लेता है N। यह इसके वर्गमूल को साथ लेकर शुरू होता है @N2। इसके बाद, यह गुणन के Nसाथ उस मान को द्विभाजित करता है *B ... N। यह सूची बनाता है [N ** .5, (N ** .5) * N], सम और विषम मामलों के लिए निष्फल परिणाम। इसके बाद, सूची में अनुक्रमण करके उचित अप्रतिबंधित परिणाम का चयन किया जाता है @ ... N। चूंकि पायथ में मॉड्यूलर इंडेक्सिंग है, इसलिए कोई आउट-ऑफ-बाउंड त्रुटियां नहीं डाली गई हैं। अंत में, परिणाम के साथ तैर रहा है s।

Answer 6

MATL, 13 12 बाइट्स

`tt2\.5+^ktq

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

व्याख्या

`     % do...while loop
tt   % duplicate top of stack twice, takes implicit input on first iteration
2\    % take a_k mod 2
.5+^  % adds 0.5, to give 1.5 if odd, 0.5 if even, and takes a_k^(0.5 or 1.5)
kt    % Rounds down, and duplicates
q     % Decrement by 1 and use for termination condition---if it is 0, loop will finish

धन्यवाद लुइस एक बाइट बचाने के लिए!

Comments

floorकार्य करने के लिए बदल दिया गया है k, तो आप उपयोग कर सकते हैं के बजाय Zo1 बाइट को बचाने के लिए। (इन बदलावों के लिए क्षमा करें; आप यहां रिलीज़ सारांश देख सकते हैं )

— लुइस मेंडो

ओह अच्छा, मुझे बताने के लिए धन्यवाद!

— डेविड

Answer 7

मिन्कोलांग 0.15 , 25 बाइट्स

ndN(d$7;r2%2*1+;YdNd1=,).

यहाँ कोशिश करो!

व्याख्या

n                            Take number from input => n
 dN                          Duplicate and output as number
   (                         Open while loop
    d                        Duplicate top of stack => n, n
     $7                      Push 0.5
       ;                     Pop b,a and push a**b => n, sqrt(n)
        r                    Reverse stack => sqrt(n), n
         2%                  Modulo by 2
           2*                Multiply by 2
             1+              Add 1 => sqrt(n), [1 if even, 3 if odd]
               ;             Pop b,a and push a**b => sqrt(n)**{1,3}
                Y            Floor top of stack
                 dN          Duplicate and output as number
                   d1=,      Duplicate and => 0 if 1, 1 otherwise
                       ).    Pop top of stack and end while loop if 0, then stop.

Answer 8

TSQL, 89 बाइट्स

इनपुट इस प्रकार है @N:

DECLARE @N INT = 5;

कोड:

WITH N AS(SELECT @N N UNION ALL SELECT POWER(N,N%2+.5) N FROM N WHERE N>1)SELECT * FROM N

Answer 9

एपीएल, 28 24 16 बाइट्स

{⌊⍵*.5+2|⎕←⍵}⍣=⎕

यह एक प्रोग्राम है जो एक पूर्णांक को स्वीकार करता है और अलग-अलग लाइनों पर क्रमिक आउटपुट को प्रिंट करता है।

स्पष्टीकरण:

{           }⍣=⎕   ⍝ Apply the function until the result is the input
 ⌊⍵*.5+2|⎕←⍵       ⍝ Print the input, compute floor(input^(input % 2 + 0.5))

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

डेनिस की बदौलत बची 8 बाइट्स!

Answer 10

जावा 7, 83 71 बाइट्स

void g(int a){System.out.println(a);if(a>1)g((int)Math.pow(a,a%2+.5));}

मैंने मूल रूप से एक ठेठ forलूप का उपयोग किया था, लेकिन मुझे इसे सही काम करने के लिए हुप्स के माध्यम से कूदना पड़ा। बाद चोरी उधार user81655 के विचार के बजाय recurse करने, मैं इसे बारह बाइट्स नीचे मिला है।

Answer 11

हास्केल, 70 बाइट्स

हास्केल में पूर्णांक sqrtअंतर्निहित नहीं है , लेकिन मुझे लगता है कि इससे कुछ कम हो सकता है floor.sqrt.fromInteger।

s=floor.sqrt.fromInteger
f n|odd n=s$n^3|1<2=s n
g 1=[1]
g n=n:g(f n) 

Answer 12

ओरेकल SQL 11.2, 128 बाइट्स

WITH v(i)AS(SELECT :1 FROM DUAL UNION ALL SELECT FLOOR(DECODE(MOD(i,2),0,SQRT(i),POWER(i,1.5)))FROM v WHERE i>1)SELECT i FROM v;

संयुक्त राष्ट्र के golfed

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
--  SELECT FLOOR(POWER(i,0.5+MOD(i,2))) FROM v WHERE i>1
  SELECT FLOOR(DECODE(MOD(i,2),0,SQRT(i),POWER(i,1.5))) FROM v WHERE i>1 
)
SELECT * FROM v;

MOD। (I, 2) को .5 में जोड़ना छोटा है लेकिन POWER (2, .5) के साथ एक बग है।

SELECT POWER(4,.5), FLOOR(POWER(4,.5)), TO_CHAR(POWER(4,.5)) FROM DUAL

देता है

2   1   1,99999999999999999999999999999999999999

Answer 13

आर, 54 51 बाइट्स

z=n=scan();while(n>1){n=n^(.5+n%%2)%/%1;z=c(z,n)};z

3 बाइट्स को प्लेनैपस के लिए धन्यवाद।

Comments

यह देखते हुए सभी n सकारात्मक रहे हैं कि, एक छोटा कर सकते हैं floor(n^(.5+n%%2))करने के लिए n^(.5+n%%2)%/%1मुझे लगता है। फिर भी।

— प्लेनैपस

Answer 14

सीजेएम, 18 बाइट्स

ri{__2%.5+#i_(}g]p

इसका परीक्षण यहां करें

डेविड के MATL उत्तर के समान ।

Answer 15

पायथन 3, 57 , 45 , 43 , 41 बाइट्स

@Mathmandan से सुझाव के साथ बेहतर समाधान

def a(n):print(n);n<2or a(n**(.5+n%2)//1)

यह विधि प्रत्येक संख्या को एक नई लाइन पर प्रिंट करेगी

पिछला समाधान: xnor की सिफारिश के बाद 43 बाइट्स में कटौती करें

a=lambda n:[n][:n<2]or[n]+a(n**(n%2+.5)//1)

आप a(10)जो रिटर्न करते हैं, उसे ऊपर करके कॉल कर सकते हैं[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

ऊपर मानों को फ्लोट के रूप में आउटपुट करेगा। यदि आप उन्हें पूर्णांक के रूप में चाहते हैं, तो हम 43 बाइट्स के लिए अतिरिक्त 2 बाइट्स जोड़ सकते हैं:

def a(n):print(n);n<2or a(int(n**(.5+n%2)))

Comments

बेस केस को करने के लिए [n][:n<2]or, या 1/n*[n]orपूर्णांक मामले के लिए यह थोड़ा कम है ।

— xnor

पायथन 2 का उपयोग करके, आप इसे 41 बाइट्स के साथ नीचे ला सकते हैं def j(n):print n;n-1and j(n**(.5+n%2)//1)। (या पायथन 3 में, def j(n):print(n);n-1and j(n**(.5+n%2)//1)42 बाइट्स है।) यह एक सूची में शब्द एकत्र करने के बजाय शब्द द्वारा अनुक्रम शब्द प्रिंट करेगा।

— गणितमण्डल

मैं एक और बाइट भी हटा सकता हूं जो कि करने के n<2orबजायn-1and

— कैमरन एविक

Answer 16

टीआई-बेसिक, 30 बाइट्स

Prompt A
Repeat A=1
Disp A
int(A^(remainder(A,2)+.5->A
End
1

Comments

22 बाइट्स यदि आप Ans से इनपुट लेते हैं, तो प्रतिस्थापित Repeat Ans=1करें While log(Ans, और उपयोग करें √(Ans)Ans^remainder(Ans,2।

— lirtosiast

Answer 17

जावास्क्रिप्ट ईएस 6, 109 102 बाइट्स

s=>(f=n=>n==1?n:n%2?Math.pow(n,3/2)|0:Math.sqrt(n)|0,a=[s],eval("while(f(s)-1)a.push(s=f(s))"),a+",1")

मुझे पता है कि यह गोल्फ हो सकता है। अल्पविराम से अलग किए गए नंबरों की एक स्ट्रिंग देता है।

Answer 18

सी ++, 122 बाइट्स

#include <iostream>
void f(int n){int i;while(n^1){std::cout<<n<<',';for(i=n*n;i*i>(n%2?n*n*n:n);i--);n=i;}std::cout<<1;}

Answer 19

सी #, 62 बाइट्स

string f(int n)=>n+(n<2?"":","+f((int)Math.Pow(n,.5+n%2)));

@ User81655 और @Alex A. से प्रेरित होकर, मैंने पुनरावर्तन का उपयोग किया।

Answer 20

रेटिना, 144 बाइट्स

इनपुट और आउटपुट एकात्मक हैं।

2-से-अंतिम पंक्ति में एक स्थान होता है, और दो मध्य रेखा और अंतिम पंक्ति रिक्त होती है।

{`(\b|)11+$
$&¶$&
m-1=`^(?=^(11)*(1?)).*$
$&,$2
(1+),1$
$1;,
1(?=1*;)
$%_
1+;
$%_
;|,

m-1=`^
1:
+`(1+):(11\1)
1 $2:
1+:$|:1+

-1=`(1+\b)
$#1

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

व्याख्या

{`(\b|)11+$                 # Loop, Duplicate last line
$&¶$&
m-1=`^(?=^(11)*(1?)).*$     # Append ,n%2 to that line (number modulo 2)
$&,$2
(1+),1$                     # Cube that number if odd
$1;,
1(?=1*;)
$%_
1+;
$%_
;|,                         # (Last stage of cubing number)

m-1=`^                      # Integer square root of that number, 
1:                          #   borrowed and modified from another user's answer
+`(1+):(11\1)
1 $2:
1+:$|:1+

-1=`(1+\b)
$#1

रेटिना में इंटेगर स्क्वायर रूट , डिजिटल ट्रॉमा द्वारा

Answer 21

सी, 64 63 61 बाइट्स

t;q(n){for(;!t;n=pow(n,.5+n%2))printf("%d%c ",n,n^1?44:t++);}

Comments

आप ( या यदि C इसे अनुमति देता है) के n%2?1.5:0.5साथ बदल सकते हैं । अगर यह सच है, तो 1 है, अन्यथा 0.n%2+0.5.5+n%2n%2n%2

— अलोएडग का कहना है कि मोनिका जूल

Answer 22

टीआई बेसिक, 43 बाइट्स

मैं थॉमस क्वा को खींच रहा हूं और अपने मोबाइल पर इसका उत्तर दे रहा हूं।

Input N
Repeat N=1
Disp N
remainder(N,2->B
If not(B:int(sqrt(N->N
If B:int(N^1.5->N
End
1

sqrtअपने कैलकुलेटर पर वास्तविक प्रतीक के साथ बदलें । संख्याओं की एक अलग सूची को प्रदर्शित करता है, जो एक उचित प्रारूप है।

Comments

आप इसे और अधिक गोल्फ कर सकते हैं।

— lirtosiast

@ThomasKwa हाँ, आप शायद सही हैं। मैं इसके बारे में थोड़ा सोचूंगा।

— कॉनर ओ'ब्रायन

Answer 23

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

नाम का एक जनरेटर है j। उपयोग करने के लिए, सेट करें a = j(<your value>);। अनुक्रम में अगला मान देखने के लिए, दर्ज करें a.next().value।

function*j(N){for(yield N;N-1;)yield N=(N%2?Math.pow(N,3/2):Math.sqrt(N))|0}

Ungolfed:

function* juggler(N){
    yield N;
    while(N!=1){
        N = Math.floor(N % 2 ? Math.pow(N,3/2) : Math.sqrt(N));
        yield N;
    }
}

Answer 24

एफ # 77 बाइट्स

1 पर समाप्त नहीं होता है, लेकिन चलता रहता है।

let j=Seq.unfold(fun x->Some(x,floor(match x%2. with 0.->x**0.5|1.->x**1.5)))

उपयोग:

j 3.;;
> val it : seq<float> = seq [3.0; 5.0; 11.0; 36.0; ...]

संस्करण जो वास्तव में 1, 100 बाइट्स पर समाप्त होता है

let j=Seq.unfold(fun x->if x=1. then None else Some(x,floor(match x%2. with 0.->x**0.5|1.->x**1.5)))

Ungolfed

let juggle input =
    let next x = 
        floor
            (match x % 2. with 
                | 0. -> x ** 0.5
                | 1. -> x ** 1.5
                | _ -> failwith "this should never happen") // addressing a compiler warning
    Seq.unfold (fun x -> if x = 1. then None else Some(x, next x)) input

Answer 25

पर्ल 5, 34 बाइट्स

-pEइसके बजाय 33, प्लस 1-e

say;($_=int$_**($_%2+.5))-1&&redo

व्याख्या

सबसे पहले, स्टड से इनपुट के बराबर -pचर सेट करता है $_। फिर हम कोड का एक ब्लॉक शुरू करते हैं:

1. sayप्रिंट करता है $_।
2. $_=int$_**($_%2+.5)संचालन के आदेश के जादू ( ऑपरेटर पूर्वता ) के कारण {{ modulo 2} + 0.5}} की शक्ति के $_पूर्णांक भाग के बराबर सेट । यह असाइनमेंट , और का नया मान लौटाता है$_$_$_
3. (...)-1&&redoमान लौटाए गए परीक्षण, माइनस 1. यदि अंतर 0 है, तो कुछ भी न करें; अन्यथा, इस ब्लॉक को फिर से करें।

अंत में, -pप्रिंट करता है $_।

बराबर लंबाई का

का भी उपयोग करता है -p।

say()-($_=int$_**($_%2+.5))&&redo

यह: प्रिंट $_; ऊपर बताए अनुसार कार्य करता है; परीक्षण करता है कि क्या रिटर्न मान say(जो 1 है), का नया मान शून्य है $_, 0 है, और यदि ऐसा है तो ब्लॉक को फिर से लोड करता है; फिर $_अंत में प्रिंट करता है।

Answer 26

डीसी, 22 21 बाइट्स

[pd2%2*1+^vd1<F]dsFxn

व्याख्या की:

[                # Begin macro definition
 p               # Peek at top of stack (print without popping, followed by newline)
 d               # Duplicate top of stack
 2%              # Mod 2: If even, 0; if odd, 1
 2*1+            # If even: 0*2+1==1; if odd: 1*2+1==3
 ^v              # Raise, then square root: equivalent to `^(0.5)' or `^(1.5)'
 d1<F            # If result is not 1, run macro again
]dsFx            # Duplicate macro, store as `F', execute
n                # Print the final "1"

एक बग है: जब इनपुट होता है 1, तो आउटपुट में दो 1एस होते हैं ।