इसमें से एक बाइट लें!

Question

आपका कार्य है, एक अहस्ताक्षरित पूर्णांक दिया गया है, nसबसे बड़ी संख्या ज्ञात करें जो डेटा की एकल बाइट (लगातार 8 बिट्स) को हटाकर बनाई जा सकती है।

---

उदाहरण

संख्या को देखते हुए 7831, हम पहले इसे बाइनरी में बदलते हैं (किसी भी अग्रणी शून्य को हटाते हुए):

1111010010111

हम फिर 8 बिट्स के निरंतर समूह को खोजते हैं, जिसे हटाए जाने पर, सबसे बड़ा नया परिणाम प्राप्त होगा। इस मामले में, नीचे दिए गए 3 समाधान हैं

1111010010111
  ^      ^       
   ^      ^
    ^      ^

इनमें से किसी भी पैदावार को हटाकर 11111, जिसे हम 31उत्तर के लिए उसके दशमलव मान में बदल देते हैं।

---

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

256        ->   1
999        ->   3
7831       ->   31
131585     ->   515
7854621    ->   31261
4294967295 ->   16777215 (if your language can handle 32 bit integers)

---

नियम

• यह गारंटी दी जाती है कि बिट की लंबाई n8 से बड़ी होगी।
• आपका समाधान करना चाहिए सैद्धांतिक रूप से किसी बिट लंबाई के लिए काम करते n8 की तुलना में बड़ा है, लेकिन व्यवहार में, पूर्णांकों के लिए केवल काम करने की जरूरत 255 <n <2 ¹⁶
• इनपुट / आउटपुट दशमलव में होना चाहिए।
• आप एक पूर्ण कार्यक्रम या एक समारोह प्रस्तुत कर सकते हैं।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है!

Comments

मुझे समझ नहीं आता कि लोग चुनौती के शीर्षकों में विस्मयादिबोधक बिंदु क्यों डालते हैं! मुझे लगता है कि यह एक चरित्र सीमा की बात हो सकती है! हो सकता है कि सिर्फ लोग चुनौती को नोटिस करें!

— dkudriavtsev

@Mendeleev यह एक अनिवार्य वाक्य है। जिन्हें आमतौर पर विस्मयादिबोधक बिंदुओं के साथ समाप्त किया जाता है। यह केवल सही विराम चिह्न है, यह आपको परेशान क्यों करता है?

— आर्थर

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

— जन्म

@ मेंडेलीव क्योंकि यह एक बुरा वाक्य है ...

— बजे

@bornfromanegg मुझे ऐसा लगता है कि लोग इस वाक्य को नोटिस करेंगे

— dkudriavtsev

Answer 1

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

BḄ-8ƤṀ

एक मोनडिक लिंक एक नंबर ले रहा है और एक नंबर लौटा रहा है।

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

कैसे?

मील की दूरी पर विकसित , एक अच्छा त्वरित उपयोग करता है ...Ƥ

BḄ-8ƤṀ - Link: number
B      - convert to a binary list
    Ƥ  - for loop over some slices to be determined...
  -8   - this is a negative nilad, therefore: use overlapping outfixes of length 8
       -   (exactly what the specification asks us to inspect)
 Ḅ     -   convert from a binary list to an integer (vectorises)
     Ṁ - maximum

Comments

> _> ... वाह आपने मेरी 10 बाइट्स से

— बाजी मार ली

Answer 2

जे , 12 बाइट्स

[:>./8#.\.#:

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

          #:     to binary
     8  \.       remove consecutive groups of eight
      #.         convert each result to decimal
  >./            maximum
[:               do nothing, this lets me avoid parentheses

Comments

आप वहाँ क्या निफ्टी एल्गोरिथ्म है? क्या आप एक स्पष्टीकरण जोड़ सकते हैं?

— श्री एक्सकोडर

@श्री। Xcoder FrownyFrog संख्या को बाइनरी अंकों (#:) की सूची में परिवर्तित करता है, फिर सभी 8-आउटफ़िक्स को कनवर्ट करता है, या लगातार 8-बिट infixes वाली सूची दशमलव संख्या प्रणाली (8 #। \) पर वापस हटा दी जाती है और अंत में ले जाती है। बड़ा पत्थर। [: बस दो पिछले क्रियाओं का कैप बनाकर,> ./ को वैधानिक रूप से (केवल सही तर्क के साथ) निष्पादित करने के लिए

— गैलेन इवानोव

आपने मुझे आज के समय के बारे में सिखाया है, इसके लिए धन्यवाद! यह शर्म की बात है कि यह कम से कम उपयोग के लिए प्रकट नहीं होता है &.; यह इसके लिए एकदम सही तरह की समस्या है।

— कोल

Answer 3

अजगर २ , 41 बाइट्स

f=lambda n:n>>8and max(n>>8,2*f(n/2)+n%2)

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

Answer 4

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

f=(n,v=n>>8,b=1,m=0)=>b>v?m:f(n,(v^n)&b^v,b+b,v>m?v:m)

<input type=number min=256 max=2147483647 oninput=o.textContent=f(this.value)><pre id=o>

2 ** 31-1 तक काम करता है। क्योंकि किसी ने थोड़ा-सा जवाब देने के लिए कहा ...

Answer 5

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

L&K.>b8eS,K+*2y/b2%b2

यह एक पुनरावर्ती कार्य है ( yलिंक के साथ कॉल किया जाना चाहिए , या लिंक देखें)।

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

Answer 6

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

Max@Array[Drop[#&@@s,#;;#+7]~FromDigits~2&,Last[s=#~RealDigits~2]-7]&

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

यह समाधान बड़ी संख्या में काम करता है इसे ऑनलाइन आज़माएं!

केलीलॉयर से -3 बाइट्स

Comments

3 और बाइट्स बचाएं:Max[c=#~RealDigits~2;Array[Drop[c[[1]],#;;#+7]~FromDigits~2&,Last@c-7]]&

— केली लोडर

@ केलीलौड अच्छा है! मैंने आपका समाधान थोड़ा और

— बढ़ाया

Answer 7

पायथन 3 , 68 66 60 बाइट्स

^{-2 बाइट्स मिस्टर एक्सकोडर की बदौलत!}

^{-4 बाइट्स ओव्स के लिए धन्यवाद !}

^{-2 बाइट्स आउट्रिकोलर को धन्यवाद !}

lambda n:max(n%2**i|n>>i+8<<i for i in range(len(bin(n))-9))

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

Comments

66 बाइट्स । n.bit_length()-8के बराबर है len(bin(n))-10।

— श्री एक्सकोडर

62 बाइट्स

— ओव्स

61 बाइट्स

— को आउटगोल्फर

Answer 8

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

Floor@If[#<256,0,Max[#/256,2#0[#/2]+#~Mod~2]]&

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

यह संस्करण केवल 2 ⁵¹⁸ तक इनपुट संभाल सकता है -1 , अन्यथा हम Mathematica के स्टैक आकार सीमा में चलते हैं। (माथेमैटिक इंस्टॉलेशन के बीच सीमा भिन्न हो सकती है।) इस उत्तर में दूसरा समाधान इससे बचा जाता है।

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

निम्नलिखित तर्क के आधार पर एक पुनरावर्ती दृष्टिकोण:

• अधिकतम मान 0किसी भी इनपुट से कम होना चाहिए256 , क्योंकि संख्या से एक बाइट लेने पर पूरी संख्या खाती है। यह हमारा आधार मामला है, यही वजह है कि इसे शामिल किया गया है भले ही चश्मा वादा करता है कि हमें ऐसे इनपुट को संभालना नहीं होगा।
• अन्यथा, हम Maxदो विकल्पों में से एक लेते हैं: सबसे कम बाइट खाते हैं (हमें इनपुट विभाजित करके देते हैं 256) या सबसे कम बिट को काट लें, शेष पूर्णांक पर पुनरावृत्ति करें, और जब हम पूर्ण होते हैं तो सबसे कम बिट वापस जोड़ते हैं।

वोल्फ्राम भाषा (गणितज्ञ) , 55 बाइट्स

Max@Table[Mod[#,m=2^k]+Floor[#/m/2^8]m,{k,0,Log2@#-8}]&

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

एक वैकल्पिक संस्करण जो पुनरावृत्ति के बजाय एक तालिका बनाता है, इसलिए यह किसी भी आकार की संख्याओं के लिए काम करता है जिसे गणितज्ञ संभाल सकता है।

Comments

पुनरावृत्ति की गहराई 10 ^ 160 से बड़ी संख्याओं से अधिक है, हालांकि गणितज्ञ बड़ी संख्या को संभाल सकते हैं। लेकिन मुझे लगता है कि ओपी इसके साथ ठीक है

— J42161217

Answer 9

रेटिना , 71 67 64 बाइट्स

.+
$*
+`(1+)\1
$+0
01
1
.
$`_$'¶
_.{7}

A`_
O^`
1G`
+1`\B
:$`:
1

इसे ऑनलाइन आज़माएं! लिंक में केवल तेज परीक्षण मामले शामिल हैं, ताकि डेनिस के सर्वर को अधिभारित न किया जा सके। संपादित करें: @MartinEnder के लिए 3 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
$*
+`(1+)\1
$+0
01
1

दशमलव से बाइनरी में परिवर्तित करें।

.
$`_$'¶
_.{7}

A`_

सभी संभव तरीकों से लगातार 8 अंक हटाकर प्राप्त स्ट्रिंग्स की एक सूची बनाएं।

O^`
1G`

उन्हें उल्टे क्रम में क्रमबद्ध करें और पहले (सबसे बड़ा) लें।

+1`\B
:$`:
1

वापस दशमलव में परिवर्तित करें। (देखें @ मार्टिनएंडर की व्याख्या ।)

Comments

मैं थोड़ी देर पहले इस छोटे बाइनरी के साथ दशमलव रूपांतरण के लिए आया था। मैंने बताया है कि इस उत्तर में यह कैसे काम करता है ।

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

Answer 10

जावा (ओपनजेडके 8) , 138 134 बाइट्स

i->{int l=0,m=0,x;String y=i.toString(i,2);for(;l<y.length()-7;m=x>m?x:m)x=i.valueOf(y.substring(0,l)+y.substring(l+++8),2);return m;}

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

Comments

i.toBinaryString(i)हो सकता है i.toString(i,2)।

— केविन क्रूज़सेन

Answer 11

ReRegex , 294 275 बाइट्स

बेहतर 'फ़ंक्शन' परिभाषाओं का उपयोग करके 19 बाइट्स सहेजे गए

मैं कहूंगा कि यह केवल एक रेगेक्स भाषा के लिए बहुत अच्छा है।

बेस लिबर यूनरी और डेसीमल के बीच रूपांतरण की अनुमति देता है (जिसे चुनौती के रूप में स्पष्ट रूप से दशमलव के रूप में आवश्यक है), लेकिन बाइनरी का समर्थन नहीं करता है; इसलिए मुझे यह लिखना पड़ा कि स्क्रिप्ट के हिस्से के रूप में इसमें 120 बाइट्स जोड़े गए।

#import base
b(\d*):(_*)\2_b/b1$1:$2b/b(\d*):(_+)\2b/b0$1:$2b/b(\d+):b/$1/b:b/0/B(_*):1/B$1$1_:/B(_*):0/B$1$1:/B(_*):B/$1/j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/j(\d*),\1\d{0,7}:,?(.*)/,$2,/,((_+)_+),(\2),/,$1,/,(_+),(\1_*),/,$2,/^,(_*),$/d<$1>/j,b:u<(?#input)>b:

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

अलग-अलग Regexes द्वारा।

#import base
b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/
B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/
j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/
,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/
^,(_*),$/d<$1>/
j,b:u<(?#input)>b:

कदम

सबसे पहले, हम 'बेस' लाइब्रेरी को आयात करते हैं, जो दो रेगीक्स देता है। एक जो एकता u<numbers>में परिवर्तित होती है। और एक जो d<unary_underlines>दशमलव में वापस परिवर्तित होता है । ऐसा इसलिए है क्योंकि चुनौती को बेस 10 में आईओ की आवश्यकता होती है।

फिर हम मुट्ठी भर रीजैक्स को परिभाषित करते हैं जो अनरी को बाइनरी में बदलते हैं।

b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/

इनमें से सबसे पहले, कुछ द्विआधारी अंकों के बाद वैकल्पिक रूप से b(\d*):(_*)\2_b/b1$1:$2b/खोज की bजाती है, फिर एक :, फिर किसी भी राशि को रेखांकित किया जाता है, उसके बाद एक ही राशि के अंडरलाइन प्लस एक, और अंत में दूसराb ।

उसके बाद हम b1पहले से बाइनरी अंकों :और उसके बाद अंडरस्कोर के पहले हाफ को प्रतिस्थापित करते हैं , और अंत में अंतिमb ।

इसलिए यह जाँच करता है कि यदि यूनरी दो से विभाज्य नहीं है, और यदि ऐसा है, तो 1 से यह द्विआधारी अंक का संकेत देता है, फिर इसे दो से एक घटाता है।

दूसरा एक, b(\d*):(_+)\2b/b0$1:$2b/लगभग वैचारिक है, हालांकि एक अतिरिक्त के लिए जाँच नहीं करता है _, जिसका अर्थ है कि यह केवल मेल खाता है यदि यह दो से विभाज्य है, और इस मामले में प्रीपेन्ड करता है0 इसके बजाय ।

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

पिछले एक चेक अगर कोई बाइनरी अंकों की आपूर्ति नहीं होती है, और उस स्थिति में बस निकल जाती है 0 ।

रेगेक्स के अगले समूह को हम बाइनरी को वापस एकता में बदलने के लिए परिभाषित करते हैं, और थोड़ा और अधिक सरल हैं।

B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/

इस समूह में से सबसे पहले, B(_*):1/B$1$1_:/इसके प्रतिपक्षी की तरह, एक का पता लगाता है B, उसके बाद किसी भी मात्रा में यूनरी अंक, तब :1। यह मिलान के लिए जाँच नहीं करता हैB इस मामले में , क्योंकि यह केवल एक समय में एक अंक की खोज कर रहा है। यदि यह मिलान किया जाता है, तो यह पहले से मिलान किए गए अंकों की संयुक्त राशि को दोगुना कर देता है और एक को जोड़ता है, फिर एक को हटा देता है।

दूसरा, B(_*):0/B$1$1:/पहले के मुकाबले मैच के 0बजाय लगभग वैचारिक है1 , और एक अतिरिक्त गैरी अंक नहीं जोड़ता है।

इनमें से अंतिम B(_*):B/$1/, यह जांचता है कि क्या कोई बाइनरी अंक नहीं हैं, और यदि ऐसा नहीं है तो यूनरी को खोल देता है। इसके विपरीत के विपरीत, इसके लिए विशेष 0 मामले की आवश्यकता नहीं है।

आगे हम jरेगीज़ को परिभाषित करते हैं , जो एक विभाजन कार्य के रूप में कार्य करता है।

j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/

सबसे पहले, j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/सबसे भारी उठाने का काम करता है। यह खोज करता है j, वैकल्पिक रूप से द्विआधारी अंकों के बाद जो कि "इंक्रीमेंटर" है, फिर एक अल्पविराम के बाद इंक्रीमेंटर और उसके बाद बाइनरी नंबर के बाद 8 बाइनरी अंक, फिर ए :। 8 अंकों में से पहला वृद्धिशील से जुड़ा होता है, इस प्रकार इसे बढ़ाता है, फिर सब कुछ लेकिन बाइनरी इनपुट से उन 8 अंकों को :निम्नलिखित के बाद जोड़ दिया जाता है ,। तो (अगर हम 8 के बजाय 2 अंकों का उपयोग कर रहे थे) j,1001:बन जाएगा j1:1001:,01तो j10:1001,01,11। इसके अतिरिक्त, संलग्न सरणी तत्व एस में लिपटे हुए हैं B, उन्हें वापस एकात्मक में बदलने के लिए।

अन्य, j(\d*),\1\d{0,7}:,?(.*)/,$2,/जाँचता है कि वृद्धिशील के बाद जाँच करने के लिए 8 से कम बाइनरी अंक हैं या नहीं, और यदि ऐसा है, तो ,एस में लिपटे सरणी के अलावा सब कुछ हटा देता है । उदाहरण के लिए।,_,___,

सरणी के निर्माण के दौरान और बाद में हम तुलना करने वाले अवशेषों को परिभाषित करते हैं।

,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/

इनमें से पहला, ,((_+)_+),(\2),/,$1,/अल्पविराम की कुछ राशि की जाँच करता है, फिर कुछ अल्पांश की, फिर एक अल्पविराम की, फिर एक अल्पविराम की, पहली अल्पविराम की मात्रा। इसके बाद इसे ,एस से घिरे पहले तत्व में अंडरस्कोर की कुल मात्रा के साथ बदल देता है ।

बाद वाला, ,(_+),(\1_*),/,$2,/अल्पविराम की जाँच करता है, जिसके बाद कुछ राशि अंडरस्कोर होती है, उसके बाद एक अन्य अल्पविराम, फिर वही राशि या अधिक अंडरस्कोर, और एक अंतिम अल्पविराम। इसके बजाय सही तत्व छोड़ देंगे।

अंत में, जब इस प्रकार मेल खाते हुए तत्व बचे होते हैं ^,(_*),$, तो हम आस-पास के अल्पविरामों को हटाते हैं और वापस दशमलव के माध्यम से परिवर्तित करते हैं d<>। फिर कोई और अधिक रेगीक्स आग लगा सकता है और आउटपुट प्रस्तुत किया जाता है।

इनपुट को शुरू में टेम्प्लेट में रखा जाता है j,b:u<(?#input)>b:, जो पहले दशमलव इनपुट को unary में परिवर्तित करता है, जैसे 5-> j,b:_____b:, फिर परिणामी unary to बाइनरी, j,101:फिर बाइनरी को विभाजित करता है (जो उदाहरण के लिए काम नहीं करता है), सबसे बड़ा तत्व प्राप्त करता है, कनवर्ट करता है वापस दशमलव में, और किया।

Answer 12

सी (जीसीसी), 91 बाइट्स

j;m;t;f(x){for(j=m=0;t=x>>j+8;m<t?m=t:j++)t=t<<j|x%(1<<j);return m;}

-23 कोलरा सु से बाइट्स

तक का समर्थन करता है 2**31-1

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

कम 8 बिट्स के साथ शुरू होता है (j=0), फिर ऊपर जाता है, आउटपुट बदलता है यदि बिट्स के साथ [j,j+8)कट आउट संख्या हमारी वर्तमान से बड़ी है, और तब तक जारी रहती है जब तक कि एक्स के ऊपर बिट्स न हों।j+8

Comments

स्टोर x>>j+8और x>>j+8<<j|x%(1<<j)एक चर में (कोष्ठकों निकाला गया) के लिए यह कम हो जाएगा 68 बाइट्स ।

— कोलेरा सु

Answer 13

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

BJṡ8ḟ@€ƊịBḄṀ

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

जोनाथन एलन को धन्यवाद बाइट्स बचा लिया !

Comments

एक "फिल्टर आउट सब्लिस्ट्स तब इंडेक्स में" संस्करण 13 बाइट्स

— जोनाथन एलन

Answer 14

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

-3 बाइट्स जस्टिन मार्नर को धन्यवाद

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

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

मेरा समाधान पुनरावर्ती स्ट्रिंग से 8-बिट चंक पकड़ लेता है, जो अधिकतम मूल्य प्राप्त होता है।

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

console.log(f(256));
console.log(f(999));
console.log(f(7831));
console.log(f(131585));
console.log(f(7854621));
console.log(f(4294967295));

Comments

मुझे लगता है कि आप एक नंबर पर +(...)धर्मान्तरित '0b'+c[1]+c[2]को छोड़ सकते हैं , क्योंकि Math.maxपहले से ही ऐसा है। इसे ऑनलाइन आज़माएं! ( भविष्य में संदर्भ के लिए कल्पना )

— जस्टिन मैरिनर

@JustinMariner, मिठाई, धन्यवाद!

— रिक हिचकॉक

Answer 15

C # (.NET Core) , 122 + 13 = 135 120 + 13 = 133 बाइट्स

n=>{int m=0,i=0,t;for(var b=Convert.ToString(n,2);i<b.Length-7;m=t>m?t:m)t=Convert.ToInt32(b.Remove(i++,8),2);return m;}

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

+13 के लिए using System;

मुझे लगता है कि बाहर का उपयोग करने के साथ ऐसा करने का एक तरीका है Convert । किसी भी तरह से, मुझे यकीन है कि इसे कम किया जा सकता है।

स्वीकृतियाँ

-2 बाइट्स केविन क्रूज़सेन की बदौलत

UnGolfed

n=>{
    int m=0,
        i=0,
        t;

    // convert n to a binary string,
    // go through removing each possible byte,
    // check if this is the biggest int so far
    for (var b=Convert.ToString(n,2); i<b.Length-7; m=t>m?t:m)
        t=Convert.ToInt32(b.Remove(i++,8),2); // remove 8 bits from position i, then convert from binary string to int

    return m;
}

Comments

आप को बदलने के द्वारा एक बाइट बचा सकते हैं whileकरने के लिए forऔर डाल var bउस में:for(var b=Convert.ToString(n,2);i<b.Length-7;)

— केविन Cruijssen

और आप एक नया इंट वैरिएबल जोड़कर ,tऔर उपयोग न करके 1 और बाइट बचा सकते हैं Math.Max, लेकिन इसके बजाय एक मैनुअल चेक करें: n=>{int m=0,i=0,t;for(var b=Convert.ToString(n,2);i<b.Length-7;m=t>m?t:m)t=Convert.ToInt32(b.Remove(i++,8),2);return m;}( 120 + 13 बाइट्स )

— केविन क्रूज़सेन

Answer 16

PHP, 67 + 1 बाइट्स

do$r=max($r,$argn&($x=2**$i++-1)|$z=$argn>>8&~$x);while($z);echo$r;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Answer 17

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

eSmi.>>.<.BQd8d2a6l

वैकल्पिक उत्तर:

eSmi.<<8.>.BQdd2a6l

स्पष्टीकरण:

eSmi.>>.<.BQd8d2a6lQ | Implicit Q at the end, where Q = input
  m             a6lQ | Map the over [0, 1, 2, ... , floor(log base 2 of Q) - 7]
         .BQ         |  Convert Q to binary string
       .<   d        |  Cyclically rotate left by d
      >      8       |  Get string from position 8 to end.
    .>        d      |  Cyclically rotate right by d
   i           2     |  Convert from binary string to integer
eS                   | Find the last element of sorted list (maximum value)

अन्य उत्तर एक समान दृष्टिकोण का उपयोग करता है, सिवाय इसके कि यह पहले घूमता है, और अंतिम 8 को छोड़कर सभी बिट्स प्राप्त करता है।

Answer 18

MATL , 23 21 बाइट्स

Bn8-:"GB[]@8:q+(XBvX>

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

B                       % Implicitly grab input, convert to binary
 n8-:                   % Create list of 1,2,... n-8, with n the size of the binary string
     "                  % Loop over this list
      GB                % Grab the input again, convert to binary once more.
        @8:q+           % Create indices of a slice of length 8
             [](        % Index into binary string, delete the slice
                XB    % Convert the remainder from binary to integer
                  vX> % Get the maximum number so far.

अफसोस की बात है, Bn8-:8:!+q&)केवल हटाए जाने वाले स्लाइस का उत्पादन करता है, शेष नहीं जिसे हम रखना चाहते हैं।

Comments

: यह बाइट्स के एक जोड़े की बचत होती है Bn8-:"GB[]@8:q+(XBvX>(असाइन []साथ (उपयोग करने के बजाए &), और की जगह &:से :और इसके अलावा)

— लुइस Mendo

@LuisMendo धन्यवाद। मैंने डॉक्स को गलत बताया है, जिसमें कहीं कहा गया है कि आप केवल अशक्त असाइनमेंट के लिए एक इंडेक्स का उपयोग कर सकते हैं, लेकिन एक अलग स्थिति के लिए।

— Sanchises

Answer 19

जावा (ओपनजेडके 8) , 73 बाइट्स

n->{int m=0,i=1;for(;i<n>>7;i*=2)m=Math.max(m,n&~-i|(n>>8&-i));return m;}

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

Answer 20

ऑक्टेव , 81 80 बाइट्स

@(x)max(bin2dec(dec2bin(x*(c=2.^(0:(b=nextpow2(x+1)-8))))(:,[1:b b+9:end]))'./c)

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

यह मेरे मूल प्रयास का एक अलग समाधान है, एक और 14 बाइट्स को बचाता है।

कोड निम्नानुसार टूट गया है:

@(x)max(                                                                       )
        bin2dec(                                                          )'./c
                                                         (:,[1:b b+9:end])
                dec2bin(x*(                            ))
                           c=2.^(0:                   )
                                   (b=nextpow2(x+1)-8)

छठी पंक्ति पर समूहों की संख्या की गणना इनपुट की तुलना में दो (इनपुट संख्या में बिट्स) की अगली शक्ति के प्रतिपादक को खोजने के द्वारा की जाती है, और 7 को घटाते हुए जैसे हम प्रत्येक समूह से 8 बिट निकाल रहे हैं - परिणामी संख्या है संग्रहित किया है b बाद के लिए

फिर हम पांचवीं पंक्ति पर दो की शक्तियों की एक सरणी की गणना करते हैं जो सभी संभावित समूहों के लिए पर्याप्त बड़ी है जिन्हें हटाया जा सकता है। हम इसे वेरिएबल में सेव करते हैंc बाद ।

अगली पंक्ति ऊपर (अगली पंक्ति) पर, हम इनपुट को दो की शक्तियों के सरणी से गुणा करते हैं (अनिवार्य रूप से प्रत्येक संख्या को थोड़ा स्थानांतरित करते हुए), और परिणाम को द्विआधारी में बदलते हैं। यदि हम 7831 का उदाहरण लेते हैं, तो 2 डी सरणी में यह परिणाम होता है:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

अगर हम केंद्र 8 बिट्स को काटते हैं, तो वह 8 बिट्स के प्रत्येक समूह को निकालने के बराबर है। यह तीसरी पंक्ति द्वारा किया जाता है।

परिणामी सरणी दूसरी रेखा पर दशमलव में वापस बदल जाती है। हमें भी विभाजित करना होगाc शुरुआत में प्रत्येक समूह को किए गए स्केलिंग को पूर्ववत् करना होगा।

अंत में पहली पंक्ति में एक अनाम फ़ंक्शन घोषित किया जाता है, और सभी समूहों से अधिकतम मूल्य की गणना की जाती है।

---

• के nextpow2(x+1)बजाय का उपयोग करके 1 बाइट बचाओnnz(bin2dec(x))

---

---

मूल प्रयास - 120 98 95 बाइट्स

@(x)max(bin2dec(reshape(repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(d(255*2.^(0:b-1))'<49),[],b)'))

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

कोड निम्नानुसार विभाजित है:

@(x)max(                                                                                      )
        bin2dec(                                                                             )
                reshape(                                                              ,[],b)'
                        repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(                     )
                                                                d(255*2.^(0:b-1))'<49

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

लाइन द्वारा काम करने वाली रेखा, पांचवीं पंक्ति उन समूहों की गणना करती है जिन्हें हटाया जा सकता है। उदाहरण के लिए, 7831 को लीजिए। यह एक 13 बिट संख्या है, जो समूह दे रही है:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

पांचवीं पंक्ति का परिणाम एक 2D तार्किक सरणी है जिसका उपयोग अनुक्रमण के लिए किया जा सकता है।

कोड की चौथी पंक्ति इनपुट को बिट्स के एक सरणी में बदल देती है (वर्णों के रूप में '0' और '1' का प्रतिनिधित्व करती है), और फिर इसे n-7 बार (जहां ) दोहराता हैn बिट्स की संख्या में) प्रत्येक संभावित समूह के लिए एक लाइन देता है। उपरोक्त समूह मास्क का उपयोग प्रत्येक संभावित समूहों को निकालने के लिए किया जाता है।

तीसरी पंक्ति में, परिणाम को अवांछित रूप से सपाट करने के लिए फिर से आकार दिया जाता है, जिसके परिणामस्वरूप समूह मुखौटा लागू होता है। दूसरी पंक्ति परिणामी दशमलव संख्याओं की एक सरणी में वापस परिवर्तित हो जाती है। और पहली पंक्ति गुमनाम फ़ंक्शन को संभावित समूहों के सरणी का अधिकतम मूल्य निर्धारित करती है।

---

• गणित का उपयोग करके समूहों के मैट्रिक्स को उत्पन्न करके 22 बाइट्स बचाए।
• बाइनरी स्ट्रिंग्स से तार्किक समूह मास्क में रूपांतरण में 3 बाइट्स सहेजे गए।

Answer 21

पर्ल 5 , 78 + 1 ( -p) = 79 बाइट्स

map{$\=$"if($"=oct$s=~s/.{$_}\K.{8}//r)>$\}2..length($s=sprintf'0b%b',$_)-10}{

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

Answer 22

रूबी , 55 बाइट्स

->n{(8../$/=~"%b"%n).map{|r|n>>8&(a=-1<<r-8)|n&~a}.max}

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

Answer 23

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

( use 5.10.1 लंबन को लेनुगेज स्तर 5.10.1 पर लाने के लिए स्वतंत्र है)

STDIN पर इनपुट नंबर दें। बड़ी संख्या के लिए मेमोरी से बाहर चला जाएगा, लेकिन इनपुट में 32-बिट संख्या अभी तक कोई समस्या नहीं है

#!/usr/bin/perl
use 5.10.1;
$_=sprintf"%b",<>;/.{8}(?{\$F[oct"0b$`$'"]})^/;say$#F