ठगों के साथ दोहों को बदलें

36

एक सकारात्मक पूर्णांक को देखते हुए, इसके प्रमुख गुणनखंडन को लेने के लिए कुछ कोड लिखें और इसके सभी कारकों को प्रतिस्थापित 2करें 3।

उदाहरण के लिए

12 = 2 * 2 * 3 -> 3 * 3 * 3 = 27

यह कोड-गोल्फ है इसलिए लक्ष्य आपके उत्तर की बाइट संख्या को कम करना है।

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

1 -> 1
2 -> 3
3 -> 3
4 -> 9
5 -> 5
6 -> 9
7 -> 7
8 -> 27
9 -> 9
10 -> 15
11 -> 11
12 -> 27
13 -> 13
14 -> 21
15 -> 15
16 -> 81
17 -> 17
18 -> 27
19 -> 19
20 -> 45
21 -> 21
22 -> 33
23 -> 23
24 -> 81
25 -> 25
26 -> 39
27 -> 27
28 -> 63
29 -> 29
code-golf  arithmetic  number-theory 
— गेहूं का जादूगर
स्रोत

जवाबों:

63

फ्रैक्ट्रन , 3 बाइट्स

3/2

फ्रैक्ट्रन का शाब्दिक अर्थ केवल एक बिलिन होता है, लेकिन यह वही होता है जो यह कार्य करता है। (यह भी ट्यूरिंग-पूर्ण है, अपने आप से।)

भाषा में वास्तव में एक मानकीकृत वाक्यविन्यास या दुभाषिया नहीं है। यह दुभाषिया (एक ब्लॉग पोस्ट के लिए एक टिप्पणी में - यह एक बहुत ही सरल भाषा है) यहां दिखाए गए वाक्यविन्यास को स्वीकार करेगा। (अन्य वाक्य रचनाओं के साथ अन्य फ्रैक्ट्रान व्याख्याकार हैं, उदाहरण के लिए कुछ इस प्रोग्राम को कमांड लाइन के तर्क के रूप में 3 2, या यहां तक ​​कि उपयोग 3और लिखेंगे 2, जिससे 0 + 3 बाइट्स का स्कोर होगा। मुझे संदेह है कि यह 3 से बेहतर करना संभव है। पहले से मौजूद दुभाषिया, हालांकि।)

व्याख्या

3/2
 /   Replace a factor of
  2  2
3    with 3
     {implicit: repeat until no more replacements are possible}
10
नौकरी के लिए सही टूल के बारे में बात करें ..
— केविन क्रूज़सेन
23
"केवल एक साधारण बिलिन का उपयोग करने वाले तुच्छ समाधानों को न बढ़ाएं।" ठीक है, इस मामले में: यह जानते हुए कि एक भाषा "फ्रैक्ट्रन" है, जिसमें एक एकल बिल्डिन है जो इस विशिष्ट कार्य को हल करता है अपने आप में प्रभावशाली है।
— स्टीवी ग्रिफिन
3
संबंधित एसओ कोड गोल्फ (प्री-पीपीसीजी): फ्रैक्ट्रन दुभाषिया लिखें ।
— हॉब्स
1
@AnderBiguri: संभवतः ट्यूरिंग-पूर्ण भाषा की तलाश है जो लागू करने के लिए बहुत सरल / आसान है। ट्यूरिंग टर्पिट्स जाने के दौरान फ्रैक्ट्रन वास्तव में सुरुचिपूर्ण है; अधिकांश में बहुत अधिक खुरदुरे किनारे, विशेष मामले या विवरण होते हैं जिन्हें एक बड़े अंतर के बिना बदला जा सकता है।
3
@AnderBiguri ऐसा लगता है कि यह Collatz अनुमान के अपने अध्ययन से बाहर आया; उन्होंने साबित किया कि Collatz का एक सामान्यीकरण Fractran के बराबर है और Fractran Turing-complete है, इसलिए सामान्यीकृत Collatz अनिर्दिष्ट है।
— हॉब्स
21

पायथन 2 , 28 बाइट्स

f=lambda n:n%2*n or 3*f(n/2)

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

पुन: संख्या को 2 से विभाजित करें और परिणाम को 3 से गुणा करें, जब तक कि संख्या सम हो। विषम संख्याएँ स्वयं लौटती हैं।

32 बाइट ऑल्ट:

lambda n:n*(n&-n)**0.58496250072

इसे ऑनलाइन आज़माएं । कुछ फ्लोट त्रुटि है। स्थिर है log_2(3)-1।

(n&-n)की सबसे बड़ी शक्ति -2 कारक को खोजने के लिए उपयोग करता है n, की शक्ति को बढ़ाकर परिवर्तित करता 3**kहै ।2**klog_2(3)-1

— XNOR
स्रोत
अच्छा यह मेरा समाधान बिल्कुल है!
— गेहूं जादूगर
@WheatWizard मुझे भी, आहा!
— ग्रेविटॉन
18

05AB1E , 4 बाइट्स

Ò1~P

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

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

Ò     Compute the prime factorization of the input.
 1~   Perform bitwise OR with 1, making the only even prime (2) odd (3).
   P  Take the product of the result.
— डेनिस
स्रोत
यह जेली को 1 बाइट से
— हरा देता
5
@ हैपरनेट्रिनो: मैंने यह भी देखा: "डेनिस 05AB1E का उपयोग क्यों कर रहा है? ओह, समान एल्गोरिथ्म, छोटे बिलिन नाम"। तो मुझे जाना था और एक ऐसी भाषा ढूंढनी थी, जहाँ मैं इसे और भी कम बाइट्स में कर सकता था, और भी अधिक समुचित सेटों के उपयोग के माध्यम से।
14

हास्केल, 24 23 बाइट्स

until odd$(*3).(`div`2)

हास्केल में विषम चाल तक दो से विभाजित और 3 से गुणा करें।

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

पॉइंटफ्री फ़ंक्शन के बजाय लैम्बडा के साथ और उसी बाइट काउंट के साथ वैकल्पिक:

odd`until`\x->div(x*3)2

संपादित करें: @ ais523 ने मूल संस्करण में एक बाइट को बचाया और @ Johanrjan जोहानसन को वैकल्पिक संस्करण में एक किया, इसलिए दोनों संस्करण की लंबाई अभी भी समान है। धन्यवाद!

— nimi
स्रोत
3
लैम्ब्डा संस्करण को छोटा किया जा सकता है odd`until`\x->div(x*3)2।
— अर्जन जोहान्स
2
मूल संस्करण $को कोष्ठक की एक जोड़ी को बदलने के लिए उपयोग करके एक बाइट को छोटा किया जा सकता है: इसे ऑनलाइन आज़माएं!
@ !RjanJohansen: आह, अच्छा! धन्यवाद।
— निमि
@ ais523: मैं कैसे चूक सकता है कि एक, धन्यवाद!
— निमि
2
मुझे लगता है कि आप एक जोड़ी निकालना भूल गए () लैम्ब्डा संस्करण से
— CAD97
8

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

f=x=>x%2?x:f(x*1.5)

जबकि इनपुट दो से विभाज्य है, इसे 1.5 से गुणा करें, जो 2 से विभाजित करने और 3 से गुणा करने के बराबर है।

— ETHproductions
स्रोत
2
x*3/2उसी बायटेकाउंट में
— लीकी नून
1
f=हमारे लिए js की जरूरत नहीं है।
— क्रिस्टोफ़
3
@ क्रिसहॉफ थैंक्स, लेकिन खुद को बुलाने के लिए f(x*1.5)इसका नाम होना जरूरी है f, इसलिए f=इसमें शामिल किया गया है।
— ETHproductions
@ETHproductions उह ... बिल्कुल! मैंने यह खो दिया। क्या कॉल कोड वास्तव में कैसा दिखता है, इस पर कोई मेटा है?
— क्रिस्टोफ़
2
@Christoph यहाँ प्रासंगिक मेटा पोस्ट है।
— ETHproductions
8

ब्रेन-फ्लैक , 76 बाइट्स

{{({}[()]<([({})]()<({}{})>)>)}{}([{}]()){{}((({})){}{})<>}<>}<>({}({}){}())

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

व्याख्या

यह कार्यक्रम विभाजन से संख्या को दो और तीन से विभाजित करके काम करता है जब तक कि यह विभाजन से एक शेष नहीं मिलता है। फिर यह लूपिंग और डबल्स को रोकता है और एक को अंतिम संख्या में जोड़ता है।

अधिक विस्तृत विवरण अंततः ...

— 0 '
स्रोत
> जल्द ही आ रहा है ...
— गेहूं जादूगर
7

गणितज्ञ, 22 19 बाइट्स

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

#//.x_?EvenQ:>3x/2&

शुद्ध कार्य जो बार-बार प्रतिस्थापन करता है, एक समय में 2 का एक कारक। 2 65537 से कम सभी सकारात्मक पूर्णांकों पर काम करता है ।

— ग्रेग मार्टिन
स्रोत
x_?EvenQइसके बजाय काम करेंगे x_/;EvenQ@x?
— एक पेड़ नहीं
1
आप पूरी तरह से सही हैं, धन्यवाद!
— ग्रेग मार्टिन
6

MATL , 7 , 6 बाइट्स

Yf1Z|p

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

1 बाइट ने डेनिस के प्रतिभाशाली अवलोकन के लिए धन्यवाद बचाया

इसे समझाने का सबसे अच्छा तरीका विभिन्न बिंदुओं पर स्टैक दिखाना है।

Yf  % Prime factors

[2 2 2 3]

1Z| % Bitwise OR with 1

[3 3 3 3]

p   % Product

81

वैकल्पिक समाधान:

Yfto~+p
— DJMcMayhem
स्रोत
अच्छा! मेरे पास Yf3H$X>p8 बाइट्स के लिए
— लुइस मेंडो
6

05AB1E , 6 5 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया ।

ÒDÈ+P

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

व्याख्या

Ò       # push list of prime factors of input
 D      # duplicate
  È     # check each factor for evenness (1 if true, else 0)
   +    # add list of factors and list of comparison results
    P   # product
— Emigna
स्रोत
2
ÒDÈ+Pएक बाइट बचाना चाहिए
— अदनान
@ अदनान: धन्यवाद!
— एमिगा
6

ऐलिस , 9 बाइट्स

2/S 3
o@i

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

ऐलिस के पास एक संख्या को दूसरे के साथ विभाजित करने के लिए अंतर्निहित बिल्ट-इन है। मुझे नहीं लगता था कि मैं वास्तव में इसका उपयोग इतनी जल्दी कर पाऊंगा ...

I / O के लिए वर्णों के कोड बिंदुओं का उपयोग करते हुए, यह 6 बाइट्स बन जाता है: I23SO@ :।

व्याख्या

2   Push 2 (irrelevant).
/   Reflect to SE. Switch to Ordinal.
i   Read all input as a string.
    The IP bounces up and down, hits the bottom right corner and turns around,
    bounces down again.
i   Try to read more input, but we're at EOF so this pushes an empty string.
/   Reflect to W. Switch to Cardinal.
2   Push 2.
    The IP wraps around to the last column.
3   Push 3.
S   Implicitly discard the empty string and convert the input string to the integer
    value it contains. Then replace the divisor 2 with the divisor 3 in the input.
    This works by multiplying the value by 3/2 as long as it's divisible by 2.
/   Reflect to NW. Switch to Ordinal.
    Immediately bounce off the top boundary. Move SW.   
o   Implicitly convert the result to a string and print it.
    Bounce off the bottom left corner. Move NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.
— मार्टिन एंडर
स्रोत
1
आपके जुनून की आधिकारिक पुष्टि हो गई है।
— लीक नून
4

जेली , 8 5 बाइट्स

Æf3»P

Æf3»P  Main Link, argument is z
Æf     Prime factors
  3»   Takes maximum of 3 and the value for each value in the array
    P  Takes the product of the whole thing

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

-3 बाइट्स @Dennis से एक संकेत के लिए धन्यवाद!

— HyperNeutrino
स्रोत
2
संकेत: 2 केवल और यहां तक ​​कि सबसे छोटी अभाज्य संख्या है।
— डेनिस
@ डेनिस मैं देखता हूं। हाँ, अब मिल गया। धन्यवाद! :)
— हाइपरएन्यूट्रीनो
जेली को सीखने के लिए बधाई।
— लीक नून
@LeakyNun धन्यवाद! और यह मुझे सिखाने के लिए धन्यवाद। :)
— हाइपरएन्यूट्रीनो
इस जवाब पर बधाई!
— एरिक आउटलागफर
4

पायथ - 14 10 9 बाइट्स

*^1.5/PQ2

अभाज्य गुणनखंड (/ PQ2) में 2s की संख्या गिनता है। इनपुट को 1.5 ^ (2 के #) से गुणा करता है

कोशिश करो

— मारिया
स्रोत
दिलचस्प दृष्टिकोण - बहुत बुरा यह मौजूदा पायथ समाधान के रूप में छोटा नहीं है।
— फलन
@ चैलेंजर 5 मैं यहां कोई अन्य पाइथ समाधान नहीं देख रहा हूं।
— मारिया
1
ओह फिर ठीक है। यह इस चुनौती के लिए सामान्य से अधिक दिलचस्प दृष्टिकोण है।
— फलदायी फल
4

हेक्सागोनी , 112 91 बाइट्स

ग्रिड आकार 6 (91 बाइट्स)

      ? { 2 . . <
     / = { * = \ "
    . & . . . { _ '
   . . { . . } ' * 2
  _ } { / . } & . ! "
 . > % . . < | . . @ |
  \ . . \ . | ~ . . 3
   . . " . } . " . "
    . & . \ = & / 1
     \ = { : = } .
      [ = { { { <

कॉम्पैक्ट संस्करण

?{2..</={*=\".&...{_'..{..}'*2_}{/.}&.!".>%..<|..@|\..\.|~..3..".}.".".&.\=&/1\={:=}.[={{{<

ग्रिड आकार 7 (112 बाइट्स)

       ? { 2 " ' 2 <
      / { * \ / : \ "
     . = . = . = | . 3
    / & / { . . } { . "
   . > $ } { { } / = . 1
  _ . . } . . _ . . & . {
 . > % < . . ~ & . . " . |
  | . . } - " . ' . @ | {
   . . . = & . . * ! . {
    . . . _ . . . _ . =
     > 1 . . . . . < [
      . . . . . . . .
       . . . . . . .

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

कॉम्पैक्ट संस्करण:

?{2"'2</{*\/:\".=.=.=|.3/&/{..}{.".>$}{{}/=.1_..}.._..&.{.>%<..~&..".||..}-".'.@|{...=&..*!.{..._..._.=>1.....<[

बेहतर पठनीयता के लिए अनप्लग्ड संस्करण:

Ungolfed

अनुमानित मेमोरी लेआउट

यहाँ छवि विवरण दर्ज करें

ग्रे पथ (मेमोरी आरंभीकरण)

?     Read input as integer (Input)
{     Move to memory edge "Divisor left"
2     Set current memory edge to 2 
" '   Move to memory edge "Divisor right" 
2     Set current memory edge to 2
"     Move to memory edge "Multiplier" 
3     Set current memory edge to 3
"     Move to memory edge "Temp 2" 
1     Set current memory edge to 1 
{ { { Move to memory edge "Modulo"
=     Turn memory pointer around 
[     Continue with next instruction pointer

पाश प्रवेश

%     Set "Modulo" to Input mod Divisor
<     Branch depending on result

ग्रीन पाथ (मान अभी भी 2 से विभाज्य है)

} } {     Move to memory edge "Result"
=         Turn memory pointer around 
*         Set "Result" to "Temp 2" times "Multiplier" (3) 
{ = &     Copy "Result" into "Temp2" 
{ { } } = Move to "Temp"
:         Set "Temp" to Input / Divisor (2)
{ = &     Copy "Temp" back to "Input"
"         Move back to "Modulo"

लाल पथ (मान अब 2 से विभाज्य नहीं है)

} = & " ~ & ' Drag what's left of "Input" along to "Multiplier"
*             Multiply "Multiplier" with "Temp 2"
! @           Output result, exit program
— मैनफ़्रेड रैडलीमर
स्रोत
1
PPCG में आपका स्वागत है! :)
— मार्टिन एंडर
@MartinEnder धन्यवाद, कमाल की भाषा btw। :)
— मैन्फ्रेड रद्लविमर
1
इसका उपयोग करने के लिए धन्यवाद! :) क्या आप मेमोरी लेआउट को सरल नहीं बना सकते हैं (और इस तरह आंदोलन की राशि जो आपको करने की आवश्यकता है) यदि आप गणना करते हैं %2और :2दोनों "modulo" किनारे में? (तो आप सिर्फ शीर्ष दो किनारों से छुटकारा पा सकते हैं।) और फिर, क्या आप "विभाजक" किनारे पर "मल्टीप्लायर" शाखा को "विभाजक" किनारे के बजाय संलग्न कर सकते हैं ताकि आपको प्रत्येक शाखा के बाद कम आंदोलन की आवश्यकता हो? (आप संभवतः उस अनुभाग को घुमा भी सकते हैं, ताकि "परिणाम" या "अस्थायी 2" "modulo" को छू ले, जिसका अर्थ है कि आपको केवल उत्पाद की गणना करने में सक्षम होने से पहले एक बार अंतिम परिणाम की प्रतिलिपि बनाने की आवश्यकता होगी।)
— मार्टिन एंडर
@MartinEnder उह्ह शायद। मैं अभी भी भाषा के "एगोनी" भाग के आसपास हो रहा हूं इसलिए अब तक मैं तर्क को छूने के बिना ग्रिड को छोटा करने के लिए छड़ी करूंगा। ^
— मैन्फ्रेड रद्लविमर
3

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

~×₂×₃↰|

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

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

~×₂×₃↰|      original program
?~×₂×₃↰.|?.  with implicit input (?) and output (.) added

?~×₂         input "un-multiplied" by 2
    ×₃       multiplied by 3
      ↰      recursion
       .     is the output
        |    or (in case the above fails, meaning that the input
                 cannot be "un-multiplied" by 2)
         ?.  the input is the output
— लीक नन
स्रोत
2

जे , 11 बाइट्स

[:*/q:+2=q:

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

[: टोपी (प्लेसहोल्डर को मौखिक रूप से कॉल करने के लिए अगले स्थान पर)

*/ का उत्पाद

q: प्रमुख कारक

+ प्लस (यानी जहां एक जोड़ा गया)

2 दो

= (प्रत्येक) के बराबर है

q: प्रमुख कारक

— एडम
स्रोत
मुझे लगा कि आप [:घृणित हैं।
— लीक नून
@LeakyNun मैं करता हूं, लेकिन मैं कोनोर ओ ब्रायन जितना चालाक नहीं था ।
— Adám
2

जे , 15 12 10 बाइट्स

(+2&=)&.q:

इसे ऑनलाइन आज़माएं! नीचे के समान काम करता है, बस के 2साथ प्रतिस्थापन के विषय में अलग तर्क है 3।

15 बाइट्स

(2&={,&3)"+&.q:

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

व्याख्या

(2&={,&3)"+&.q:
           &.    "under"; applies the verb on the right, then the left,
                 then the inverse of the right
             q:  prime factors
(       )"+      apply inside on each factor
     ,&3         pair with three: [factor, 3]
 2&=             equality with two: factor == 2
    {            list selection: [factor, 3][factor == 2]
                 gives us 3 for 2 and factor for anything else
           &.q:  under prime factor
— कोनोर ओ ब्रायन
स्रोत
जब आप मेरा लेखन कर रहे थे, तब आपने एल्गोरिथ्म को बंद कर दिया था। अब हम उसी का उपयोग करते हैं।
— एडम
@ अदम ओह, हाहा। अच्छा जवाब! मैं rollयहाँ उपयोग करने के अवसर का विरोध नहीं कर सका । :)
— कॉनर ओ'ब्रायन
वास्तव में मैं कुछ और बाइट्स को बचाने में सक्षम हो सकता है ... कुछ को संपादित करें : डी
— कॉनर ओ'ब्रायन
मज़ेदार आप इसे रोल कहते हैं, मैं इसे अंडर कहता हूं। जल्द ही इसे एपीएल में लाने की उम्मीद है।
— एडम
@ Adám Haha इसे वास्तव में कहा जाता है। मुझे भ्रम हुआ
— कॉनर ओ'ब्रायन
2

जाप , 19 16 10 9 7 बाइट्स

k ®w3Ã×

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

व्याख्या

 k ®   w3Ã ×
Uk mZ{Zw3} r*1
U              # (input)
 k m           # for every prime factor
    Z{Zw3}     # replace it by the maximum of itself and 3
           r*1 # output the product
— ल्यूक
स्रोत
हह, जेएस को जाप के साथ बांधा गया है। एक निश्चित संकेत है कि बहुत छोटा समाधान है ;-)
— ETHproductions
संकेत: (या सिर्फ ) के ×लिए एक शॉर्टकट है , जो काम में आ सकता है। वहाँ भी जो है । r@X*Y}1r*1XwYMath.max(X,Y)
— 21
धन्यवाद, हालांकि पुनरावर्ती समाधान वास्तव में सबसे छोटा है।
— ल्यूक
अच्छा है! मुझे लगता है कि आप k m_w3Ã×एक बाइट को बचाने के लिए कर सकते हैं । इसके अलावा, m_को छोटा किया जा सकता है ®।
— ओलिवर
2

CJam, 10 9 बाइट्स

rimf1f|:*

वास्तव में सरल।

स्पष्टीकरण:

ri  e# Read integer:         | 28
mf  e# Prime factors:        | [2 2 7]
1   e# Push 1:               | [2 2 7] 1
f|  e# Bitwise OR with each: | [3 3 7]
:*  e# Product:              | 63
— फल तोड़ना
स्रोत
2

हेक्सागोनी , 28 27 26 बाइट्स

?'2{{(\}}>='!:@=$\%<..>)"*

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

बाहर रखा हआ:

    ? ' 2 {
   { ( \ } }
  > = ' ! : @
 = $ \ % < . .
  > ) " * . .
   . . . . .
    . . . .

यह मूल रूप से चलता है:

num = input()
while num%2 == 0:
    num = (num/2)*3
print num

इस बिंदु पर यह इस बात पर एक अभ्यास है कि मैं बाइट्स को कम करने के लिए लूप पथ को कितना दर्दनाक बना सकता हूं।

— मजाक कर रहा है
स्रोत
ठीक है, मैं उस के बारे में नहीं सोचा था
— मैनड्रेड रेडलविमर
1
@ManfredRadlwimmer चिंता न करें, Hexagony में कुछ भी कोड करना अपने आप में एक उपलब्धि है
— जो राजा
1

आर, 42 बाइट्स

एक उत्तर में बाइट्स की एकमात्र सही मात्रा।

x=gmp::factorize(scan());x[x==2]=3;prod(x)

बहुत सीधा, gmpपैकेज को फैक्टराइज़ करने के लिए उपयोग करता है x, 3s द्वारा 2s को बदलता है, और उत्पाद को वापस करता है।

— JAD
स्रोत
1

Befunge-93 , 20 बाइट्स

&>:2%!#v_.@
 ^*3/2 <

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

& - take in input and add it to the stack
> - move right
: - duplicate the top of the stack
2 - add two to the stack
% - pop 2 and the input off the stack and put input%2 on the stack
! - logical not the top of the stack
# - jump over the next command
_ - horizontal if, if the top of the stack is 0 (i.e. input%2 was non zero) go 
    right, else go left

If Zero:
. - output the top of the stack
@ - end code

If Not Zero:
v - move down
< - move left
2 - add 2 the top of the stack
/ - pop top two, add var/2 to the stack
3 - add 3 to stack
* - pop top two, add var*3 to the stack
^ - move up
> - move right (and start to loop)
— bwillsh
स्रोत
— जो किंग
1

पर्ल 6 , 14 बाइट्स

{1.5**.lsb*$_}

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

say {$_*1.5**.lsb}(24);
> 81
— फिल एच
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.