क्या संख्या को 2 की शक्तियों में विभाजित किया जा सकता है?

33

कल अपने बच्चे के साथ खेलते हुए मैंने उसकी टॉय ट्रेन में नंबर देखा:

4281

तो हमारे पास जिन्हें या में विभाजित किया जा सकता है

4281
4−2−8−1
22−21−23−20

इतनी सरल चुनौती: इनपुट के रूप में एक गैर-नकारात्मक संख्या को देखते हुए, लगातार सत्य और झूठे मूल्यों को लौटाएं जो यह दर्शाते हैं कि संख्या के आधार का प्रतिनिधित्व करते हैं या नहीं (आधार 10 में और प्रमुख शून्य के बिना) किसी भी संख्या में विभाजित हो सकते हैं जो 2 की शक्तियां हैं ।

उदाहरण:

4281      truthy (4-2-8-1)
164       truthy (16-4 or 1-64)
8192      truthy (the number itself is a power of 2)
81024     truthy (8-1024 or 8-1-02-4)
101       truthy (1-01)
0         falsey (0 cannot be represented as 2^x for any x)
1         truthy
3         falsey
234789    falsey
256323    falsey (we have 256 and 32 but then 3)
8132      truthy (8-1-32)

Tests for very large numbers (not really necessary to be handled by your code):
81024256641116  truthy (8-1024-256-64-1-1-16)
64512819237913  falsey

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कोड हो सकता है!

code-golf  string  number  decision-problem 
— चार्ली
स्रोत
2
@StewieGriffin ने शुरू में एक मानक intप्रकार (4 बाइट्स) की सीमा तक इनपुट संख्या को सीमित करने के बारे में सोचा था , लेकिन वास्तव में मुझे कोई आपत्ति नहीं है यदि आपका कोड बहुत बड़ी संख्या का समर्थन नहीं करता है। बस अपने उत्तर में अपने कोड की सीमाएं बताएं।
— चार्ली
3
सुझाया गया परीक्षण मामला: 101(0 के कारण मिथ्या) ... या यह अभी भी सच होना चाहिए ( 1 - 01)?
— शायरु असाकोटो
1
@ShieruAsakoto मैं 101वर्तमान उत्तरों के साथ मामले का परीक्षण कर रहा हूं और वे सभी वापस लौट आए हैं true, क्योंकि इसमें विभाजित किया जा सकता है 1-01दोनों 2 की शक्तियां हैं, इसलिए मैं उस मामले को सत्य मानूंगा।
— चार्ली
6
बस यह सब के लिए टिप के रूप में यहाँ छोड़ रहा है। यहां यह जांचने के तीन संभावित तरीके हैं कि क्या संख्या 2: 1 की शक्ति है) अगर log2(n)अल्पविराम के बाद दशमलव अंक नहीं हैं तो जांचें । 2) जांचें कि क्या n AND (n-1) == 0। 3) वर्ग-सूची की एक सूची बनाएँ और जाँच करें कि nक्या उस सूची में है।
— केविन क्रूज़सेन
1
" स्क्वायर-एनआरएस " मेरी टिप्पणी में " 2 की शक्तियां " होनी चाहिए .. ऊपर।>>
— केविन क्रूज़सेन

जवाबों:

11

05AB1E , 9 8 बाइट्स

Ýos.œåPZ

-1 बाइट का धन्यवाद @Z (0) और 1s की सूची के लिए (अधिकतम) का उपयोग करके ( सत्य ) की नकल करने के लिए (अधिकतम) @Eignign केany लिए 1।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें । (नोट: тशीर्ष लेख में 100केवल 2 संख्याओं की शक्ति की पहली इनपुट राशि के बजाय 2 संख्याओं की पहली 100 शक्ति प्राप्त करना है। यह 2 की शक्ति की इनपुट राशि के साथ भी काम करता है, लेकिन यह बहुत अक्षम है और हो सकता है यदि इनपुट काफी बड़ा है तो TIO पर टाइमआउट करें।)

स्पष्टीकरण:

Ý            # Create a list in the range [0,n], where n is the (implicit) input
             # (or 100 in the TIO)
             #  i.e. 81024 → [0,1,2,3,...,81024]
 o           # Raise 2 to the `i`'th power for each `i` in the list
             #  → [1,2,4,8,...,451..216 (nr with 24391 digits)]
  s          # Swap to take the input
   .œ        # Create each possible partition of this input
             #  i.e. 81024 → [["8","1","0","2","4"],["8","1","0","24"],...,["8102","4"],["81024"]]
     å       # Check for each if it's in the list of powers of 2
             #  → [[1,1,0,1,1],[1,1,0,0],...,[0,1],[0]]
      P      # Check for each inner list whether all are truthy
             #  → [0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
       Z     # Take the maximum (and output implicitly)
             #  → 1 (truthy)
— केविन क्रूज़सेन
स्रोत
2
अच्छा, मेरा समाधान था .œ.²1%O0å(साथ ही 9 बाइट्स)। 0हालांकि, खदान विफल रही ।
— श्री एक्सकोडर
@ Mr.Xcoder आह, .²1%O0बहुत सुंदर के रूप में अच्छी तरह से है। मैंने log2इस तरह का उपयोग करने के बारे में सोचा था .²DïQ, लेकिन प्रत्येक नंबर के लिए ऐसा करने के लिए इसके चारों ओर एक मानचित्र की आवश्यकता होगी, और यह वास्तव में किनारे-केस के लिए काम नहीं करता था 0।
— केविन क्रूज़सेन
6

जावास्क्रिप्ट (Node.js) , 69 64 58 बाइट्स

f=(x,m=10,q=!(x%m&x%m-1|!x))=>x<m?q:q&&f(x/m|0)||f(x,10*m)

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

नंबर के रूप में इनपुट। लॉजिक वाला हिस्सा काफी जटिल है, इसलिए इसे अंदाजा लगाने और इससे छुटकारा पाने का कोई विचार नहीं है q।

-11 बाइट्स पॉवर-ऑफ -2 चेक से।

— bubbler
स्रोत
5

जेली , 9 बाइट्स

ŒṖḌl2ĊƑ€Ẹ

परीक्षण सूट की जाँच करें!

विकल्प

सटीक मुद्दों के कारण बड़े परीक्षण मामलों के लिए काम नहीं करता है।

ŒṖḌæḟƑ€2Ẹ

परीक्षण सूट की जाँच करें!

कैसे?

कार्यक्रम मैं

ŒṖḌl2ĊƑ€Ẹ     Full program. N = integer input.
ŒṖ            All possible partitions of the digits of N.
  Ḍ           Undecimal (i.e. join to numbers).
   l2         Log2. Note: returns (-inf+nanj) for 0, so it doesn't fail.
     ĊƑ€      For each, check if the logarithm equals its ceil.
        Ẹ     Any. Return 0 if there are no truthy elements, 1 otherwise.

कार्यक्रम II

ŒṖḌæḟƑ€2Ẹ     Full program. N = integer input.
ŒṖ            All possible partitions of the digits of N.
  Ḍ           Undecimal (i.e. join to numbers).
     Ƒ€       For each partition, check whether its elements are invariant under...
   æḟ  2      Flooring to the nearest power of 2.
        Ẹ     Any. Return 0 if there are no truthy elements, 1 otherwise.
— मिस्टर एक्सकोडर
स्रोत
5

जावास्क्रिप्ट, 59 बाइट्स

s=>eval(`/^(${(g=x=>x>s?1:x+'|0*'+g(x+x))(1)})+$/`).test(s)

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

/^(1|0*2|0*4|0*8|0*16|0*32|…|0*1)+$/2 की शक्तियों की तरह एक रेगेक्स बनाता है , और उस पर परीक्षण करता है s।

केवल जावास्क्रिप्ट संख्याओं की शुद्धता तक काम करता है, निश्चित रूप से: अंततः रेक्स में शब्द 1.2345678e30(या Inf) की तरह दिखाई देंगे । लेकिन चूंकि 2 की शक्तियां फ्लोटिंग-पॉइंट में सही प्रतिनिधित्व करना आसान है, वे कभी भी गलत पूर्णांक नहीं होंगे , जो अधिक अयोग्य होगा, मुझे लगता है।

@tsh ने 14 बाइट्स बचाए। Neato!

— लिन
स्रोत
— tsh
3

एपीएल (एनएआरएस), 154 चार्ट, 308 बाइट्स

∇r←f w;g;b;z;k
   g←{⍵≤0:1⋄t=⌊t←2⍟⍵}⋄→A×⍳∼w≤9⋄r←g w⋄→0
A: z←w⋄b←0⋄k←1
B: b+←k×10∣z⋄z←⌊z÷10
   →C×⍳∼g b⋄r←∇z⋄→0×⍳r
C: k×←10⋄→B×⍳z≠0
   r←0
∇
h←{⍵=0:0⋄f ⍵}

व्यायाम के लिए कार्य यह h है। एल्गोरिथ्म घातीय या भाज्य नहीं लगता ... परीक्षण:

  h¨ 4281 164 8192 81024 101 
1 1 1 1 1 
  h¨ 0 1 3 234789 256323 8132
0 1 0 0 0 1 
  h 81024256641116
1
  h 64512819237913
0
— RosLuP
स्रोत
2

PHP, 101 बाइट्स

लगता है कि यह 100 से नीचे नहीं मिलेगा; लेकिन मैं इसे प्राप्त कर सकते हैं करने के लिए 100 अगर 101एक falsy मामला था।

function f($s){for($x=.5;$s>=$x*=2;)if(preg_match("/^$x(.*)$/",$s,$m)?!~$m[1]||f(+$m[1]):0)return 1;}

NULL1

विविधताओं:

for($x=.5;$s>=$x*=2;)
while($s>=$x=1<<$i++)   # yields notices "undefined variable $i"

?!~$m[1]||f(+$m[1]):0
?~$m[1]?f(+$m[1]):1:0

PHP 5 या पुराने, 95 बाइट्स

function f($s){while($s>=$x=1<<$i++)if(ereg("^$x(.*)$",$s,$m)?$m[1]>""?f(+$m[1]):1:0)return 1;}
— टाइटस
स्रोत
2

लाल , 212 211 बाइट्स

func[n][g: func[x][(log-2 do x)% 1 = 0]repeat i 2 **((length? s: form n)- 1)[b: a:
copy[] k: i foreach c s[append b c if k % 2 = 0[alter a g rejoin b
b: copy[]]k: k / 2]append a g form c if all a[return on]]off]

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

एक और लंबी सबमिशन, लेकिन मैं कम से कम असंतुष्ट नहीं हूं, क्योंकि रेड में सभी सब्सट्रेट खोजने के लिए कोई अंतर्निहित नहीं है।

अधिक पठनीय:

f: func [ n ] [
    g: func [ x ] [ (log-2 do x) % 1 = 0 ]
    repeat i 2 ** ((length? s: form n) - 1) [
        b: a: copy []
        k: i
        foreach c s [
            append b c
            if k % 2 = 0 [ 
                append a g rejoin b
                b: copy []
            ]
            k: k / 2 
        ]
        append a g form c
        if all a[ return on ]
    ]
    off
]
— गैलेन इवानोव
स्रोत
2

Axiom, 198 बाइट्स

G(a)==(a<=1=>2>1;x:=log_2 a;x=floor x)
F(n)==(n<=9=>G n;z:=n;b:=0;k:=1;repeat(b:=b+k*(z rem 10);z:=z quo 10;if G b and F z then return 2>1;k:=k*10;z<=0=>break);1>1)
H(n:NNI):Boolean==(n=0=>1>1;F n)

ungolf and test

g(a)==(a<=1=>2>1;x:=log_2 a;x=floor x)
f(n)==
   n<=9=>g n
   z:=n;b:=0;k:=1
   repeat
      b:=b+k*(z rem 10);z:=z quo 10;
      if g b and f z then return 2>1
      k:=k*10
      z<=0=>break
   1>1
h(n:NNI):Boolean==(n=0=>1>1;f n)

(15) -> [[i,h i] for i in [4281,164,8192,81024,101]]
   (15)  [[4281,true],[164,true],[8192,true],[81024,true],[101,true]]
                                                      Type: List List Any
(16) -> [[i,h i] for i in [0,1,3,234789,256323,8132]]
   (16)  [[0,false],[1,true],[3,false],[234789,false],[256323,false],[8132,true]]
                                                      Type: List List Any
(17) -> [[i,h i] for i in [81024256641116, 64512819237913]]
   (17)  [[81024256641116,true],[64512819237913,false]]
                                                      Type: List List Any
(18) -> h 44444444444444444444444444
   (18)  true
                                                            Type: Boolean
(19) -> h 44444444444444444128444444444
   (19)  true
                                                            Type: Boolean
(20) -> h 4444444444444444412825444444444
   (20)  false
                                                            Type: Boolean
(21) -> h 2222222222222244444444444444444412822222222222210248888888888882048888888888888888
   (21)  true
                                                            Type: Boolean
(22) -> h 222222222222224444444444444444441282222222222225128888888888882048888888888888888
   (22)  true
                                                            Type: Boolean
— RosLuP
स्रोत
1

जाप -!, 12 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है।

ÊÆòXÄÃex_&ZÉ

कोशिश करो

— झबरा
स्रोत
0मामले आउटपुट trueऔर इसलिए इस तरह के रूप मामलों 1010भी उत्पादन true।
— चार्ली
1

एपीएल (एनएआरएस), 70 चार्ट, 140 बाइट्स

P←{k←↑⍴⍵⋄x←11 1‼k k⋄y←⍵⋄∪{x[⍵;]⊂y}¨⍳↑⍴x}
f←{⍵=0:0⋄∨/∧/¨y=⌊y←2⍟⍎¨¨P⍕⍵}

परीक्षा:

  f¨ 4281 164 8192 81024 101
1 1 1 1 1 
  f¨ 0 1 3 234789 256323 8132
0 1 0 0 0 1 
  f 126
0

मैं अन्य अधिक बड़ी संख्याओं को करने की कोशिश नहीं करता ... मुझे ध्यान देना है कि पी सामान्य विभाजन नहीं है, लेकिन यह एक ऐसा विभाजन है जहां सभी तत्व उपसमुच्चय हैं जो लगातार सभी सदस्य हैं, उदाहरण के लिए

  ⎕fmt P 'abc'
┌4──────────────────────────────────────────────────┐
│┌1─────┐ ┌2─────────┐ ┌2─────────┐ ┌3─────────────┐│
││┌3───┐│ │┌2──┐ ┌1─┐│ │┌1─┐ ┌2──┐│ │┌1─┐ ┌1─┐ ┌1─┐││
│││ abc││ ││ ab│ │ c││ ││ a│ │ bc││ ││ a│ │ b│ │ c│││
││└────┘2 │└───┘ └──┘2 │└──┘ └───┘2 │└──┘ └──┘ └──┘2│
│└∊─────┘ └∊─────────┘ └∊─────────┘ └∊─────────────┘3
└∊──────────────────────────────────────────────────┘

ध्यान दें कि तत्व ((एसी) (बी)) या बेहतर है, '(' एसी ')' बी 'अनुपस्थित है

  ⎕fmt ,,¨('ac')'b'
┌2─────────┐
│┌2──┐ ┌1─┐│
││ ac│ │ b││
│└───┘ └──┘2
└∊─────────┘
— RosLuP
स्रोत
1

POSIX ERE, 91 बाइट्स

(0*([1248]|16|32|64|128|256|512|1024|2048|4096|8192|16384|32768|65536|131072|262144|524288))+

यह पूरी तरह से धोखा है, पाठ बड़ी संख्या (वास्तव में आपके कोड द्वारा संभाला जाना आवश्यक नहीं) पर आधारित है ; यह सभी मूल्यों को उदाहरणों के आकार सीमा में संभालता है। स्पष्ट रूप से आकार की कीमत पर 32- या 64-बिट पूर्णांक प्रकारों की पूरी श्रृंखला तक बढ़ाया जा सकता है। मैंने मुख्य रूप से इसे एक प्रदर्शन के रूप में लिखा कि समस्या स्वाभाविक रूप से उपकरण को कैसे फिट करती है। एक मजेदार अभ्यास इसे एक कार्यक्रम के रूप में फिर से लिखना होगा जो ईआरई को मनमानी सीमा के लिए उत्पन्न करता है फिर इसके खिलाफ मैच करता है।

— आर ..
स्रोत
1

C (gcc) , -DA=asprintf(&c,+ 108 = 124 बाइट्स

p,c;f(a,i){c="^(0*(1";for(i=0;i<31;)A"%s|%d",c,1<<++i);A"%s))+$",c);regcomp(&p,c,1);a=!regexec(&p,a,0,0,0);}

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

यह 2 अप करने के लिए 2 ** 32 की शक्तियों का एक regex बनाता है, और फिर इसके खिलाफ इनपुट स्ट्रिंग से मेल खाता है।

— Logern
स्रोत
1

पॉवरशेल, 56 बाइट्स

$x=(0..63|%{1-shl$_})-join'|0*'
"$args"-match"^(0*$x)+$"

टेस्ट स्क्रिप्ट:

$f = {

    $x=(0..63|%{1-shl$_})-join'|0*'
    "$args"-match"^(0*$x)+$"

}

@(
    ,(4281            ,$true)
    ,(164             ,$true)
    ,(8192            ,$true)
    ,(81024           ,$true)
    ,(101             ,$true)
    ,(0               ,$false)
    ,(1               ,$true)
    ,(3               ,$false)
    ,(234789          ,$false)
    ,(256323          ,$false)
    ,(8132            ,$true)
    ,("81024256641116"  ,$true)
    ,("64512819237913"  ,$false)
) | % {
    $n, $expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result <- $n"
}

आउटपुट:

True: True <- 4281
True: True <- 164
True: True <- 8192
True: True <- 81024
True: True <- 101
True: False <- 0
True: True <- 1
True: False <- 3
True: False <- 234789
True: False <- 256323
True: True <- 8132
True: True <- 81024256641116
True: False <- 64512819237913

स्पष्टीकरण:

^(0*1|0*2|0*4|0*8|0*16|0*32|…)+$2 की शक्तियों की तरह एक रेगेक्स बनाता है , और तर्कों पर इसका परीक्षण करता है।

— Mazzy
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.