26

पूर्णांक की डिजिटल कठोरता को खोजने के लिए , इसके बाइनरी प्रतिनिधित्व को लें, और गणना करें कि एक अग्रणी और अनुगामी दोनों को 1तब तक हटाया जा सकता है जब तक कि यह या तो शुरू या समाप्त नहीं होता है 0। हटाए गए बिट्स की कुल संख्या इसकी डिजिटल कठोरता है।

यह काफी चिंताजनक स्पष्टीकरण है - तो चलिए इसे एक उदाहरण के साथ तोड़ते हैं।

इस उदाहरण के लिए, हम संख्या 3167 का उपयोग करेंगे। बाइनरी में, यह है:

110001011111

(ध्यान दें कि, बाइनरी में रूपांतरण के दौरान, आपको अग्रणी शून्य को पट्टी करना सुनिश्चित करना चाहिए)

यह शुरू या समाप्त नहीं होता है 0, इसलिए हम 1 जोड़ी बिट्स निकालते हैं:

1  1000101111  1

और दुसरी:

11  00010111  11

लेकिन अब शुरुआत में 0 है, इसलिए हम अब और 1जोड़े नहीं निकाल सकते । कुल मिलाकर, 4 बिट्स हमने निकाले, और इसलिए 4 3167 की डिजिटल कठोरता है ।

हालाँकि, उन संख्याओं के लिए जिन्हें सकारात्मक n के लिए 2 ⁿ -1 के रूप में लिखा जा सकता है (अर्थात केवल बाइनरी प्रतिनिधित्व में होते हैं ), 0 कभी नहीं पहुंचेगा, और इसलिए सभी बिट्स को हटाया जा सकता है। इसका मतलब है कि कठोरता केवल पूर्णांक की लंबाई है।1

चुनौती

आप कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो एक गैर-नकारात्मक पूर्णांक दिया जाता है n >= 0, इसकी डिजिटल कठोरता को निर्धारित करता है।

आप एक पूर्ण कार्यक्रम प्रस्तुत कर सकते हैं जो I / O, या एक फ़ंक्शन करता है जो परिणाम देता है। आपका सबमिशन nआपकी भाषा के मानक पूर्णांक श्रेणी के मानों के लिए काम करना चाहिए ।

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

कृपया मुझे सूचित करें कि इनमें से कोई भी गलत है, या यदि आप जोड़ने के लिए किसी भी किनारे के मामलों का सुझाव देना चाहते हैं।

0     -> 0
1     -> 1
8     -> 0
23    -> 2
31    -> 5
103   -> 4
127   -> 7
1877  -> 2
2015  -> 10

यहाँ पर अनगुल्ड पाइथन सॉल्यूशन है जिसका उपयोग मैंने इन टेस्ट मामलों को उत्पन्न करने के लिए किया है (बग-लेस होने की गारंटी नहीं):

def hardness(num) -> int:
    binary = bin(num)[2:]

    if binary.count('0') == 0:
        return num.bit_length()

    revbin = binary[::-1]

    return min(revbin.find('0'), binary.find('0')) * 2

— FlipTack
स्रोत

1

1जब कोई उसमें नहीं 0है तो वह कैसे 1 लौटाएगा ? मेरा मतलब है, आप इसे शुरू या अंत में रखने के लिए स्ट्रिंग से पर्याप्त रूप से 1 नहीं निकाल सकते 0।

— 20

2

@busukxuan "चुनौती" शीर्षक से ठीक पहले अनुच्छेद पढ़ें: उन संख्याओं के लिए जिन्हें 2 ^ n-1 के रूप में लिखा जा सकता है (अर्थात बाइनरी प्रतिनिधित्व में केवल 1 होता है), 0 कभी भी नहीं पहुंचेगा, और इसलिए सभी बिट्स को हटाया जा सकता है । इसका मतलब है कि कठोरता केवल पूर्णांक की लंबाई है।

— 20

2

@busukxuan आप इसके बारे में सोच सकते हैं कि प्रत्येक पक्ष की संख्या के साथ गद्देदार है, इससे पहले कि जीरो पहुंच जाए।

— 20

2

डाउनवॉटर के लिए जो स्पष्ट रूप से किनारे के मामलों को पसंद नहीं करते थे: कठोरता ठोस की संख्या है (1) बिट्स जिसके साथ गद्देदार है - यदि पूरी चीज ठोस है, तो निश्चित रूप से इसमें 100% कठोरता है, इसकी पूरी लंबाई?

— FlipTack

1

@ फालतू मैं बहुत अधिक प्रभावित नहीं करना चाहता, यह आपकी चुनौती है। मैं शुरू में की अधिकतम संख्या के रूप में "कठोरता" समझा जोड़े बाहरी जो कि हटाया जा सकता है, हर तरफ से एक की। लेकिन आप सही हो सकते हैं, अगर एक भी अंत में रहता है, तो शायद इसे गिना जाना चाहिए

— लुइस मेंडो

6

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

BµQL××Ṛa\S

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

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

BµQL××Ṛa\S  Main link. Argument: n

B           Binary; convert n to base 2.
 µ          Begin a new, monadic chain. Argument: A (array of binary digits)
  Q         Unique; deduplicate the digits.
   L        Length; count the unique digits.
    ×       Multiply each digit by the result.
     ×Ṛ     Multiply the results by reversed A.
       a\   Cumulative reduce by logical AND.
            This zeroes out all elements after the first zero.
         S  Compute the sum of the result.

— डेनिस
स्रोत

8

पायथन , 76 69 68 63 62 60 57 बाइट्स

f=lambda n,k=0:n>>k&(n&n>>k>n>>k+1)and(n&n+1>0)-~f(n,k+1)

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

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

यह एक पुनरावर्ती समाधान है जो एक इनपुट n लेता है और बढ़ाता है k - 0 पर शुरू होता है - जबकि दोनों LSB _k (n) ( दाएं से इंडेक्स k पर बिट ) और MSB _k (n) ( बाएं से इंडेक्स k पर बिट ) तैयार। एक बार समाप्त होने के बाद, यह k वापस आता है यदि n के सभी बिट सेट हैं और 2k नहीं हैं तो।

चलो एक सहायक चर टी के साथ एक नामित फ़ंक्शन एफ के रूप में लंबोदा एफ को फिर से लिखना शुरू करते हैं ।

def F(n, k = 0):
    t = n >> k
    return t & (n & t > t >> 1) and (n & (n + 1) > 0) + 1 + F(n, k + 1)

में से प्रत्येक के मंगलाचरण में एफ , हम पहले थोड़ा-शिफ्ट n की कुल कश्मीर सही करने के लिए इकाइयों और में परिणाम की दुकान टी । इस तरह, LSB ₀ (t) = LSB _k (n) , इसलिए t विषम है यदि और केवल यदि LSB _k (n) सेट है।

यह निर्धारित करना कि क्या MSB _k (n) सेट है थोड़ा पेचीदा है; यह वही है जो n & t > t >> 1हासिल करता है। यह समझने के लिए कि यह कैसे काम करता है, आइए बिट 8 की पूर्णांक n = 1α bit ₂ पर विचार करें और फ़ंक्शन कॉल F (n, 3) का विश्लेषण करें , अर्थात, k = 3 ।

हम यह निर्धारित करने की कोशिश कर रहे हैं कि क्या MSB ₃ (n) = comparison की तुलना के सत्य मान (n & t> t >> 1) = (1αβγδεζη ₂ & 1αβγδ ₂ > 1αβγ ₂ ) का परीक्षण करके किया गया है । आइए शामिल पूर्णांक की जांच करें।

MSB-index  012k4567

n          1αβγδεζη
t             1αβγδ

t >> 1         1αβγ

हम दावा करते हैं कि claim = 1 यदि और केवल अगर n & t> t >> 1 ।

यदि γ = 1 , तो N & T बिट लंबाई है 5 , जबकि टी >> 1 बिट लंबाई है 4 , इसलिए n & ला> टी >> 1 ।

यह साबित करता है कि 1 = 1 का तात्पर्य n & t> t >> 1 है ।
यदि n & t> t >> 1 , दो विकल्प हैं: या तो or = 1 या t = 0 । पहले मामले में, साबित करने के लिए कुछ नहीं बचा है।

दूसरे मामले में, हमारे पास αβγδ ₂ t n & t> t >> 1 = 1αβγ _{2 है} ।

चूंकि α must ₂ > 1αβγ ₂ , हमारे पास MSB ₀ (α ) ₂ ) ≥ MSB ₀ (1α meaning ₂ ) होना चाहिए , जिसका अर्थ है कि α = 1 ।

इस तरह, 1βγδ ₂ > 11βγ ₂ , इसलिए हम होना आवश्यक है MSB ₁ (1βγδ ₂ ) ≥ MSB ₁ (11βγ ₂ ) , कि अर्थ β = 1 ।

बदले में, इसका मतलब है कि 11γδ ₂ > 111। ₂ । दूसरे मामले में उस ing = 0 को याद करते हुए, हमें असमानता 110 _{11 2} > 1110 ₂ मिलती है , जो MSB ₂ (110δ ₂ ) = 0 <1 = MSB ₂ (1110 ₂ ) के बाद से झूठी है ।

इस प्रकार, केवल पहला मामला संभव है और n & t> t >> 1 का अर्थ । = 1 है ।

सारांशित होने पर, यदि LSB _k (n) और MSB _k (n) दोनों सेट होते हैं, तो t विषम होगा और n & t> t >> 1 सही होगा , इसलिए t & (n & t> t >> 1) होगा उपज 1 । हालाँकि, यदि LSB _k (n) या MSB _k (n) परेशान है (या यदि दोनों हैं), तो t होगा या n & t> t >> 1 गलत होगा , इसलिए t & (n & t> t> > 1) 0 मिलेगा ।

एकल तर्क के साथ F को कॉल करना k = 0 को प्रारंभ करता है । जबकि जिस स्थिति पर हमने पहले चर्चा की है, उसके बाद कोड andनिष्पादित किया जाता है, जो (अन्य चीजों के अलावा) बढ़ाए गए कश्मीर के साथ एफ को पुन: कॉल करता है ।

एक बार LSB _k (n) या MSB _k (n) की शुरुआत नहीं होने पर, स्थिति विफल हो जाती है और F (n, k) रिटर्न 0 हो जाता है । पूर्ववर्ती k फ़ंक्शन कॉल में से प्रत्येक जोड़ता है (n & (n + 1)> 0) + 1 से F (n, k) = 0 , इसलिए F (n) रिटर्न ((n + (n + 1)> 0) + 1) के ।

अब, के सभी बिट्स अगर n बराबर हैं (यानी, यदि n या तो है 0 या उसके बिट्स के लिए पूरी तरह तैयार कर रहे हैं), n + 1 के साथ आम में किसी भी बिट्स की ज़रूरत नहीं होगी n , तो n & (n + 1) = 0 और F (n) रिटर्न k । हालाँकि, यदि n में सेट और अनसेट बिट्स हैं, तो n & (n + 1)> 0 और F (n) 2k लौटता है ।

— डेनिस
स्रोत

2

पायथन में पुनरावर्ती समाधान वास्तव में हाल ही में अच्छी तरह से स्कोरिंग हो रहे हैं।

— mbomb007

कम से कम पुनरावृत्तियों के साथ तुलना में, उनके पास हमेशा होता है। input(), whileऔर printपहले से ही 17 बाइट्स हैं ...

— डेनिस

हाँ, लेकिन मुझे उन्हें लिखना बहुत कठिन लगता है।

— mbomb007

1

काफी उचित। एक ही विचार का एक सीधा चलने का कार्यान्वयन केवल 5 बाइट्स लंबा होगा, हालांकि। tio.run/nexus/… 2 और बाइट्स को कुछ ट्रिक्स से बचाया जा सकता है। tio.run/nexus/python2#JY1BDsIgFAXX7SnepgUUI1BNm1K4jKVJQ/…

— डेनिस

6

MATL , 13 12 बाइट्स

Btv`6L&)}x@q

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

कोड प्रत्येक बाइनरी अंक को दोहराता है, और गिनता है कि दो बाहरी लोगों को हटाने के लिए कितनी बार संभव है।

B        % Input number (implicit). Horizontal vector of binary digits
tv       % Duplicate and concatenate vertically
`        % Do...while
  6L&)   %   Flatten the array if needed (in column-major order), and split it
         %   into two subarrays: one with the inner entries, and another
         %   with the two outer entries. The latter will be used for deciding
         %   if the loop continues or is exited
}        % Finally (execute before exiting the loop)
  x      %   Delete last subarray of inner entries
  @q     %   Push last iteration index minus 1
         % End (implicit). The next iterarion is executed if the array at the
         % top of the stack is non-empty and only contains nonzero values. 
         % Otherwise the loop is exited, executing the "finally" block first
         % Display (implicit)

— लुइस मेंडो
स्रोत

6

पायथन, 82 बाइट्स

मुझे लगता है कि यह अभी भी गोल्फ हो सकता है, लेकिन मैंने विभिन्न तरीकों की कोशिश करते हुए कुछ समय बिताया और यह सबसे छोटा था।

def f(n):b=bin(n)[2:];x=min(b.find('0'),b[::-1].find('0'));print(x<0)*len(b)or x*2

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

हालांकि यह ओपी के पायथन प्रोग्राम के समान ही काम करता है, मैंने सवाल पोस्ट किए जाने से पहले इसे बनाया था, सैंडबॉक्स में सवाल देखने के बाद, जिसमें ऐसा कोई प्रोग्राम नहीं था।

— mbomb007
स्रोत

6

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

s=bin(input())[2:].split('0')
print len(min(s[-1],s[0]))<<1%len(s)

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

— XNOR
स्रोत

चतुर, लेकिन अभी भी समझने में आसान है। मुझें यह पसंद है!

— mbomb007

5

@ mbomb007 डेनिस के :)

— xnor

3

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

$a=[convert]::ToString($args[0],2)-split0;(((($b=$a[0].length),$a[-1].length|sort)[0]*2),$b)[$a.count-eq1]

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

इनपुट लेता है $args[0], आधार के साथ convertइसे करने के लिए .NET कॉल का उपयोग करता है (यानी, इसे द्विआधारी बनाते हैं), फिर उस स्ट्रिंग को एस पर , स्टोर करता है । नोट करने के लिए महत्वपूर्ण: .NET कॉल अग्रणी शून्य वापस नहीं करता है, इसलिए पहला अंक हमेशा एक होता है ।toString2-split0$a1

इस प्रकार दो संभावनाएं हैं - बाइनरी स्ट्रिंग सभी हैं, या कम से कम एक शून्य था। हम उन लोगों के बीच अंतर करते हैं जिनके द्वारा छद्म-त्रिशूल अनुक्रमित है $a.count-eq1। यदि बाइनरी में कम से कम एक शून्य है, तो बायाँ मामला, हम एस के पहले [0]स्ट्रिंग की लंबाई 1और अंतिम [-1]स्ट्रिंग (द्वारा पाया गया |sortऔर फिर [0]) की न्यूनतम लंबाई लेते हैं । उनमें से सबसे छोटी जोड़ी है जिसे हम निकाल सकते हैं, इसलिए हम इसे गुणा करते हैं 2। ध्यान दें कि यदि मूल बाइनरी स्ट्रिंग 0इनपुट की तरह, समाप्त हो जाती है 8, तो [-1].lengthयह भी होगा 0(क्योंकि यह एक खाली स्ट्रिंग है), जिसे तब गुणा किया 2जाता है 0।

अन्यथा, बाइनरी स्ट्रिंग सभी के साथ, हम बस लेते हैं $b(जो पहले पहले [0]स्ट्रिंग की लंबाई निर्धारित की गई थी , इस मामले में, बाइनरी स्ट्रिंग की संपूर्णता)।

किसी भी स्थिति में, उस परिणाम को पाइपलाइन पर छोड़ दिया जाता है और आउटपुट निहित होता है।

— AdmBorkBork
स्रोत

3

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

f=
n=>n.toString(2).replace(/^(1*)(.*(\1))?$/,'$1$3').length

<input oninput=o.value=1/this.value?f(+this.value):''><input id=o readonly>

स्निपेट का विस्तार करें

बाइनरी लेता है और सभी को मेल करने 1sया विफल करने की कोशिश करता है कि अग्रणी और अनुगामी की एक समान संख्या 1s।

— नील
स्रोत

2

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

.+
$*
+`(1+)\1
$1o
o1
1
m(+`^1(.*)1$
xx¶$1
x|^1$

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

स्पष्टीकरण:

.+              # Convert to unary
$*
+`(1+)\1        # Convert to binary (but with `o` instead of `0` -- it's shorter)
$1o
o1
1
m(+`^1(.*)1$    # Replace pairs of surrounding ones with `xx`
xx¶$1
x|^1$,          # Count x's, including the possibility of a single remaining `1`

— mbomb007
स्रोत

2

सी #, 133 बाइट्स

क्रिया जो कठोरता लौटाती है। तर्क से पूर्णांक लेता है।

int h(int b){var n=Convert.ToString(b,2);for(b=0;;){if(n[0]+n[n.Length-1]==98)n=n.Substring(1,n.Length-2);else break;b+=2;}return b;}

खैर, आज मुझे '1' + '1' = 98C # में पता चला ।

— devRicher
स्रोत

1

ऐसा इसलिए '1'है क्योंकि ASCII char 49, और 49 + 49 = 98 है।

— FlipTack

मैंने सचमुच 10 मिनट बिताए, मुझे पता नहीं चला कि मेरे 1 + 1 = 2काम क्यों नहीं हुए। @ फीलटैक

— 21

2

सी, 89 88 85 बाइट्स

@FlipTack के कारण दो बाइट को सहेजा गया जो एक बेकार घोषणा है।

f()परीक्षण के लिए नंबर के साथ कॉल करें , आउटपुट फ़ंक्शन से वापस आ गया है।

t,h;f(l){for(t=l;t&&~t&1<<30;t*=2);for(h=0;t&1<<30&&l&1;t*=2,l/=2)++h;return h<<!!l;}

इसे आइडोन पर आज़माएं ।

— owacoder
स्रोत

2

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

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

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

कोड स्निपेट दिखाएं

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

console.log(
  [0, 1, 8, 23, 31, 103, 127, 1877, 2015].map(
    n => n + ' -> ' + f(n)
  ).join('\n')
)

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

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

Eo2
BµŒg.ịṂS×Ç

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

— लिन
स्रोत

2

सी, 137 132 122 119 117 114 98 94 92 87 85 बाइट्स

गोल्फिंग शुरू करने का समय-)

i,j;f(n){for(i=1<<30;i&~n;i/=2);for(j=0;n&i;n/=2,i/=4)j+=~n&1?i=0:2;return j-=n<1*j;}

यहाँ सबूत है

main()
{
  printf("%d %d\n", 0, f(0));
  printf("%d %d\n", 1, f(1));
  printf("%d %d\n", 8, f(8));
  printf("%d %d\n", 23, f(23));
  printf("%d %d\n", 31, f(31));
  printf("%d %d\n", 103, f(103));
  printf("%d %d\n", 127, f(127));
  printf("%d %d\n", 1877, f(1877));
  printf("%d %d\n", 2015, f(2015));
  printf("%d %d\n", 3167, f(3167));
}

और आउटपुट;

— cleblanc
स्रोत

1

जावा (ओपनजेडके) , 181 156 150 बाइट्स

n->{int i=0;String s=n.toString(n,2);if(s.matches("1*"))i=s.length();else for(;!s.matches("(.*0)|(0.*)");s=s.substring(1,s.length()-1))i+=2;return i;}

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

— पावेल
स्रोत

1

गणितज्ञ, 63 56 बाइट्स

(2-Min[l=#~IntegerDigits~2])Min[Tr/@Split[l][[{1,-1}]]]&

व्याख्या

l=#~IntegerDigits~2

एक के साथ लिपटे इनपुट के आधार -2 प्रतिनिधित्व उत्पन्न करें List। इसमें स्टोर करेंl

(2-Min[...])

यदि l1 का न्यूनतम तत्व है, तो आउटपुट 1। यदि नहीं, तो आउटपुट 2। इसे इस से गुणा करें ...

Split[l]

lरनों में विभाजित ।

... [[{1,-1}]]

पहले और आखिरी तत्व को लें।

Tr/@ ...

दोनों का कुल लो।

Min[ ... ]

दोनों के बीच छोटे का पता लगाएं।

(इस परिणाम के साथ पहला परिणाम (1 या 2) गुणा करें)।

— जंगहवान मिन
स्रोत

1

ऑक्टेव, 56 54 बाइट्स

 @(n)cummin(d=dec2bin(n)-48)*cummin(flip(d))'*2^!all(d)

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

स्पष्टीकरण:

d=dec2bin(n)-48

का द्विआधारी प्रतिनिधित्व n

cumd= cummin(d);
cumfd = cummin(flip(d));

d फ़्लिप के संचयी मिनट और संचयी मिनट लेंd

res = cumd * cumfd ';

मैट्रिक्स गुणा करें

out = res*2^!all(d)

यदि अंकों का सभी 1 है तो 2 से गुणा करें;

— rahnema1
स्रोत

@FlipTack धन्यवाद, लिंक अपडेट किया गया!

— rahnema1

1

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

?*FJjQ2lJyhSxR0_BJ

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

टेस्ट सूट (स्वरूपण के लिए पहली पंक्ति)

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

?*FJjQ2lJyhSxR0_BJ  Program. Input: Q
?                   If
  F                 reducing
    jQ2             the binary representation of Q as a list
   J                (store in J)
 *                  by multiplication is truthy:
       lJ            Yield len(J)
                    Else:
          hS         Yield the minimum
            xR0      of the first index of zero
               _BJ   in J and its reverse
         y           * 2
                    Implicitly print

— TheBikingViking
स्रोत

1

एपीएल, 26 बाइट्स

+/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢

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

      ( +/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢ ) ¨ 0 1 8 23 31 103 127 1877 2015    
0 1 0 2 5 4 7 2 10

स्पष्टीकरण:

+ / ∘ (∧ \ ≢ ↑ (ε⊢ (, ∧∧) ¨⌽)) 2⊥⍣¯1⊢

                         ⊢ इनपुट
                    21 द्विआधारी प्रतिनिधित्व में परिवर्तित
   ()
        ((On) प्रत्येक बिट के लिए और दूसरी तरफ इसके मिलान बिट के लिए
            (The) दोनों बिट्स के तार्किक और लें,
             , दोनों बिट्स की एक सूची बनाएं,
              ∧ फिर सूची के और
         । परिणामस्वरूप सरणी समतल करें
      Bits ≢ केवल पहले N बिट्स को लेते हैं, जहाँ N होता है
                                बिट्स की मूल सूची की लंबाई
    ∧ \ _ एक रनिंग लॉजिकल लें और (केवल छोड़कर)
                                शुरू करने वाले)
+ / Those राशि उन

— मारीनस
स्रोत

1

जे, 22 बाइट्स

(#<.2*(<.&(#.~)|.))@#:

यह इस चुनौती से सीखी गई साफ-सुथरी चाल पर आधारित है ।

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

व्याख्या

(#<.2*(<.&(#.~)|.))@#:  Input: integer n
                    #:  Binary digits of n
(                 )@    Operate on those digits D
               |.         Reverse D
       <.                 Take the minimum of
         &(#.~)           the "trailing truths" of D and reverse(D)
    2*                    Multiply by 2
 #                        The length of D
  <.                      Minimum of length and the previous result

— मील की दूरी पर
स्रोत

1

PHP, 83 74 बाइट्स

3 + 6 बाइट्स जोर्ग द्वारा बचाए गए

<?=(~$s=decbin($argn))[$a=strspn($s,1)]?min($a,strspn(strrev($s),1))*2:$a;

STDIN से इनपुट लेता है; साथ चलाना -nR।

टूट - फूट

<?=                     # print ...
(~
    $s=decbin($argn)        # $s = binary representation of input
)[
    $a=strspn($s,1)         # $a = number of leading `1`s
]                           # if $s has more than $a digits,
?   min($a,                     # 2. minimum of $a and
        strspn(strrev($s),1)    # 1. number of trailing `1`s
    )*2                         # 3. *2
:   $a                      # else $a (==strlen)

— टाइटस
स्रोत

1

<?=~($s=decbin($argn))[$a=strspn($s,1)]?2*min($a,strspn(strrev($s),1)):$a;

— जोर्ग हल्सरमैन

0

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

f=x=>(y=x.toString(2),y.match(/^1*$/)?y:([s,e]=y.match(/^1*|1*$/g),s<e?s:e)).length

Ungolfed:

function f(n) {
    var binStr = n.toString(2);
    if(binStr.match(/^1*$/)) {
        // If binary representation is all 1s, return length of binary
        return binStr.length;
    } else {
        // Grab the starting and ending 1s in the binary representation
        var [start1s, end1s] = binStr.match(/^1*|1*$/g);
        var startHardness = start1s.length;
        var endHardness = end1s.length;
        return Math.min(startHardness, endHardness);
    }
}

— जोशुआ डेविड
स्रोत

0

मैथमेटिका, 62 बाइट्स

(h=0;#~IntegerDigits~2//.{{1,m___,1}:>(h+=2;{m}),{1}:>h++};h)&

शुद्ध कार्य जहां #पहले तर्क का प्रतिनिधित्व करता है।

(h=0;...;h)&सेट h=0करता है ..., सामान का एक गुच्छा करता है , फिर रिटर्न h(कठोरता) देता है। आइए सामान का गुच्छा देखें:

#~IntegerDigits~2                                     Binary representation of the input
                 //.                                  Apply the following list of rules repeatedly until there is no change
                    {                                 Start of the list of rules
                     {1,m___,1}                       If you see a list starting and ending with 1 with the sequence m (possibly empty) in between
                               :>(h+=2;{m}),            replace it with just {m} after incrementing h twice.
                                            {1}       If you see the singleton list {1}
                                               :>h++    replace it with h, then increment h.
                                                    } End of the list of rules

इस ट्रिक से मुझे परिचित कराने के लिए ग्रेग मार्टिन का धन्यवाद ।

— ngenisis
स्रोत

0

हास्केल , 94 92 बाइट्स

b 0=[]
b n=mod n 2:b(div n 2)
h n|(c,_:_)<-span(>0)$zipWith(*)n$reverse n=c++c|1<3=n
sum.h.b

इसे ऑनलाइन आज़माएं! उपयोग:

Prelude> sum.h.b $ 3167
4

स्पष्टीकरण:
b किसी संख्या को बाइनरी में कनवर्ट करता है और शून्य की सूची देता है और सबसे कम महत्वपूर्ण बिट के साथ पहले। में h, इस सूची में उलट है और तत्व के लिहाज से मूल सूची के साथ गुणा, तो span(>0)प्रारंभिक के बाद विभाजन 1रों:

       b 3167 = [1,1,1,1,1,0,1,0,0,0,1,1] = n
    reverse n = [1,1,0,0,0,1,0,1,1,1,1,1] = m
zipWith(*)n m = [1,1,0,0,0,0,0,0,0,0,1,1] = z
   span(>0) z = ([1,1],[0,0,0,0,0,0,0,0,1,1])

परिणामस्वरूप ट्यूपल पैटर्न से मेल खाता है (c,_:_)जहां _:_किसी भी गैर-रिक्त सूची से मेल खाता है, इसलिए c = [1,1]। क्योंकि बाइट्स को आगे और पीछे हटा दिया जाता है, c++c = [1,1,1,1]लौटा दिया जाता है और अंत में डिजिटल कठोरता प्राप्त करने के लिए सारांशित किया जाता है ।

यदि टपल की दूसरी सूची खाली है, तो बाइनरी प्रतिनिधित्व में केवल वही शामिल हैं, और उनमें से संख्या डिजिटल कठोरता है। पैटर्न के मिलान के साथ ही hरिटर्न में विफल रहा है n, जिसे फिर से सारांशित किया गया है।

— Laikoni
स्रोत

0

पर्ल, 61 बाइट्स

sub f{$_=sprintf('%b',pop);length(/0/?/^(1+).*\1$/&&$1x2:$_)}

इस का दिल regex है /^(1+).*\1$/जहां 2 बार लंबाई $1जवाब है। बाकी कोड ओवरहेड है और सभी 1 विशेष मामले के साथ काम कर रहा है।

— cdlane
स्रोत

आप कोष्ठकों को sprintfतर्कों के आसपास छोड़ सकते हैं । इसके अलावा, -pध्वज का उपयोग करने से आपको एक पूर्ण प्रोग्राम लिखने की अनुमति मिलेगी जो आपके फ़ंक्शन से कम होगा क्योंकि आप छोड़ sub f{...}देंगे (इसके बजाय आपको समाप्त होना होगा $_=...लेकिन यह अभी भी 4 बाइट्स सुधार है)। अंत में, आपके बजाय length(...), आप कर सकते हैं /0/&&s/^(1+).*\1$/$1$1/;$_=y///c। यह आपको 51 बाइट्स के लिए मिलना चाहिए।

— दादा

0

PHP, 65 बाइट्स

<?=strlen(preg_filter('#^(1*)(.*(\1))?$#',"$1$3",decbin($argn)));

ऑनलाइन संस्करण

— जार्ग हुल्सरमन
स्रोत

0

CJam, 14 बाइट्स

ri2b_0#\W%0#e<

स्पष्टीकरण:

ri e# Read integer:      | 3167
2b e# Convert to binary: | [1 1 0 0 0 1 0 1 1 1 1 1]
_  e# Duplicate:         | [1 1 0 0 0 1 0 1 1 1 1 1] [1 1 0 0 0 1 0 1 1 1 1 1]
0# e# Index of first 0:  | [1 1 0 0 0 1 0 1 1 1 1 1] 2
\  e# Swap:              | 2 [1 1 0 0 0 1 0 1 1 1 1 1]
W% e# Reverse:           | 2 [1 1 1 1 1 0 1 0 0 0 1 1]
0# e# Index of first 0:  | 2 5
e< e# Minimum:           | 2

— फल तोड़ना
स्रोत

इंटीग्रर्स की डिजिटल हार्डनेस

चुनौती

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

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

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

पायथन , 76 69 68 63 62 60 57 बाइट्स

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

MATL , 13 12 बाइट्स

व्याख्या

पायथन, 82 बाइट्स

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

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

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

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

स्पष्टीकरण:

सी #, 133 बाइट्स

सी, 89 88 85 बाइट्स

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

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

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

सी, 137 132 122 119 117 114 98 94 92 87 85 बाइट्स

जावा (ओपनजेडके) , 181 156 150 बाइट्स

गणितज्ञ, 63 56 बाइट्स

ऑक्टेव, 56 54 बाइट्स

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

एपीएल, 26 बाइट्स

जे, 22 बाइट्स

व्याख्या

PHP, 83 74 बाइट्स

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

मैथमेटिका, 62 बाइट्स

हास्केल , 94 92 बाइट्स

पर्ल, 61 बाइट्स

PHP, 65 बाइट्स

CJam, 14 बाइट्स