একটি পূর্ণসংখ্যার বাইনারি মানতে 1 এর দীর্ঘতম সিরিজ গণনা করুন

Question

লক্ষ্য

অ-নেতিবাচক পূর্ণসংখ্যা দেওয়া, এমন একটি ফাংশন তৈরি করুন যা সেই পূর্ণসংখ্যার বাইনারি মানের মধ্যে একের পর এক বৃহত্তম সংখ্যার প্রারম্ভিক অবস্থানটি প্রদান করে।

যখন একটি ইনপুট দেওয়া 0ফিরে 0।

যদি সংখ্যার সমান দৈর্ঘ্যের একাধিক স্ট্রাইক থাকে তবে আপনাকে অবশ্যই শেষ রেখার অবস্থানটি ফিরে আসতে হবে।

ইনপুট

0 এর চেয়ে বড় বা সমান একটি পূর্ণসংখ্যা ।

আউটপুট

নীচে বর্ণিত হিসাবে পূর্ণসংখ্যা গণনা করা হয়েছে।

বিধি

• এটি কোড-গল্ফ, তাই প্রতিটি ভাষার বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।
• স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।

---

উদাহরণ এবং পরীক্ষার কেস

উদাহরণ 1

• আপনার ফাংশনটি পূর্ণসংখ্যা 142 কেটে গেছে
• 142 বাইনারি মধ্যে 10001110 এর সমান
• দীর্ঘতম ধারাবাহিকতা "১১১" (তিনটি ধারাবাহিক)
• ধারাটি 2 ^ 1 পজিশনে শুরু হয়
• আপনার ফাংশনটি ফলাফল হিসাবে 1 প্রদান করে

উদাহরণ 2

• আপনার ফাংশনটি পূর্ণসংখ্যা 48 কেটে গেছে
• 48 বাইনারি 110000 সমান
• দীর্ঘতম স্রোতটি "11" (দু'জনের একটি ধারা)
• ধারাটি 2 ^ 4 পজিশনে শুরু হয়
• আপনার ফাংশন ফলাফল হিসাবে 4 ফেরত

উদাহরণ 3

• আপনার ফাংশনটি পূর্ণসংখ্যা 750 কেটে গেছে
• বাইনারি মধ্যে 750 সমান 1011101110
• দীর্ঘতম ধারাবাহিকতা "১১১" (তিনটি ধারাবাহিক)
• যেহেতু সমান দৈর্ঘ্যের দুটি রেখা রয়েছে, আমরা পরবর্তী স্ট্রাইকটি ফিরে আসি।
• পরবর্তী ধারাবাহিকটি 2 ^ 5 পজিশনে শুরু হয়
• আপনার ফাংশন ফলাফল হিসাবে 5 ফিরে

Comments

আপনার কোড-গল্ফের

— ওকেক্স

@ ওকএক্স এটি শরীরেই উল্লেখ করা হয়েছিল তাই আমি ট্যাগটি যুক্ত করেছি।

— সম্পূর্ণরূপে

নিশ্চিত করুন লোক পরীক্ষা করুক 0। এটি একটি গুরুত্বপূর্ণ পরীক্ষার কেস।

— mbomb007

"সর্বশেষ লাইন" বা "সর্বশেষ ধারাবাহিক" পরিবর্তে আমি "বৃহত্তম স্থানের মান সহ লাইন" পরামর্শ দেব।

— aschepler

@ ওকএক্স কেন একটি বিজয়ী মানদণ্ড প্রয়োজনীয়? কেন এটি সহজ ধাঁধা হতে পারে না?

— corsiKa

Answer 1

জেলি , 10 8 বাইট

Ba\ÐƤṀċ¬

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

Ba\ÐƤṀċ¬  Main link. Argument: n


B         Binary; convert n to base 2.

   ÐƤ     Apply the link to the left to all postfixes of the binary array.
 a\         Cumulatively reduce by logical AND.

          For example, the array

          [1, 0, 1, 1, 1, 0, 1, 1, 1, 0]

          becomes the following array of arrays.

          [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0, 0, 0, 0]
                [1, 1, 1, 0, 0, 0, 0, 0]
                   [1, 1, 0, 0, 0, 0, 0]
                      [1, 0, 0, 0, 0, 0]
                         [0, 0, 0, 0, 0]
                            [1, 1, 1, 0]
                               [1, 1, 0]
                                  [1, 0]
                                     [0]

     Ṁ    Take the lexicographical maximum, i.e., the array with the most 1's at
          the beginning, breaking ties by length.

       ¬  Yield the logical NOT of n, i.e., 0 if n > 0 and 1 if n = 0.

      ċ   Count the occurrences of the result to the right in the one to the left.

Comments

অভিনন্দন!

— Defacto

Answer 2

জাভাস্ক্রিপ্ট (ES6), 41 40 36 34 বাইট

@ দ্য পাইরেটবেকে ধন্যবাদ 4 টি বাইট সংরক্ষণ করুন

f=x=>(k=x&x/2)?f(k):Math.log2(x)|0

পরীক্ষার মামলা

f=x=>(k=x&x/2)?f(k):Math.log2(x)|0

console.log(f(0))
console.log(f(142))
console.log(f(48))
console.log(f(750))

কিভাবে?

সাধারণ কেস x> 0

আমরা পুনরাবৃত্তভাবে এবং এক্স / 2 এর সাথে ইনপুট এক্স যা ক্রমানুসারে কেবলমাত্র ডানদিকের বিট অবধি অবধি ক্রমাগত সেট বিটগুলির নিদর্শনগুলি হ্রাস করে। আমরা সর্বশেষ নন-শূন্য মানের একটি অনুলিপি রাখি এবং এর বেস -২ লোগারিদমকে মেঝে গোল করে তার সর্বাধিক উল্লেখযোগ্য বিটের অবস্থান নির্ধারণ করি।

X = 750 ( বাইনারিতে 1011101110 ) এর জন্য আমরা যে পদক্ষেপগুলি দিয়েছি তার নীচে are

    1011101110 --.
,----------------'
'-> 1011101110
AND 0101110111
    ----------
=   0001100110 --.
,----------------'
'-> 0001100110
AND 0000110011
    ----------
=   0000100010 --.  --> output = position of MSB = 5  (0000100010)
,----------------'                                         ^
'-> 0000100010
AND 0000010001
    ----------
=   0000000000

এজ কেস x = 0

বিশেষ কেস x = 0অবিলম্বে বাড়ে Math.log2(0) | 0। বাইনারি বিটওয়াইজের OR এর 0মূল্যায়নের লগারিদম -Infinityবা 32-বিট সংখ্যার পূর্ণসংখ্যার জন্য জোর করে। মেনে বিমূর্ত অপারেশন স্পেসিফিকেশন ToInt32 , এই প্রত্যাশিত দেয় 0:

যদি সংখ্যা হয় NaN , +0 , -0 , + + ∞ , অথবা -∞ ফিরে +0

Comments

ইনপুটটির জন্য এই ত্রুটিগুলি 0, যা ইনপুট সীমার অংশ।

— জাস্টিন মেরিনার

@ জাস্টিনমারিনার ফিক্সড

— আর্নল্ড

এর Math.log2(k)|0বদলে কী হবে 31-Math.clz32(k)? নাকি আমি কিছু মিস করছি?

@ পাইরেটবেই Math.log2(k)|0বিশেষ ক্ষেত্রে খাটো এবং সহজ উভয়ই x=0। ধন্যবাদ। :)

— আর্নল্ড

খুব সুন্দর অ্যালগরিদম, এবং ভাল ব্যাখ্যা। আমি এটি x86 মেশিন কোডের 14 বাইটে প্রয়োগ করেছি ।

— পিটার

Answer 3

x86 মেশিন কোড, 14 বাইট

ব্যবহার @ Arnauld এর এলগরিদম এর x &= x>>1এবং ধাপে সামনে সর্বোচ্চ সেট বিট অবস্থান গ্রহণ xহয়ে 0।

unsigned longest_set(unsigned edi);X86-64 সিস্টেম ভি এবিআইতে স্বাক্ষর সহ সি / সি ++ থেকে কলযোগ্য । একই মেশিন-কোড বাইটগুলি 32-বিট মোডে একইভাবে ডিকোড করবে, তবে স্ট্যান্ডার্ড 32-বিট কলিং কনভেনশনগুলি প্রথম আরগটি রাখবে না edi। ( উইন্ডোতে ecxবা এর edxজন্য ইনপুট রেজিস্টার পরিবর্তন করা _fastcall/ _vectorcallবা gcc -mregparmকোনও কিছু না ভাঙ্গিয়েই করা যেতে পারে))

   address   machine-code
             bytes
                         global longest_set
 1                       longest_set:
 2 00000000 31C0             xor  eax, eax    ; 0 for input = 0
 3                       
 4                       .loop:               ; do{
 5 00000002 0FBDC7           bsr  eax, edi    ;  eax = position of highest set bit
 6                           ;; bsr leaves output unmodified when input = 0 (and sets ZF)
 7                           ;; AMD documents this; Intel manuals say unspecified but Intel CPUs implement it
 8 00000005 89F9             mov  ecx, edi
 9 00000007 D1E9             shr  ecx, 1
10 00000009 21CF             and  edi, ecx
11 0000000B 75F5             jnz .loop        ; } while (x &= x>>1);
12                       
13 0000000D C3               ret

এক্স 86 এর BSRনির্দেশাবলী (বিট স্ক্যান বিপরীত) এর জন্য উপযুক্ত, শীর্ষস্থানীয় শূন্যগুলি গণনা না করে সরাসরি আমাদের বিট-সূচক দেয়। ( bsrসরাসরি ইনপুট = 0 মত 0 উত্পাদন করে না 32-lzcnt(x), কিন্তু আমরা BSR দরকার নন-জিরো ইনপুট জন্য = 31 lzcnt, তাই lzcntকারণ লুপ কাজ করার আগে নির্দেশাবলী সংরক্ষণ এমনকি would যাক একা বাইট গণনা। Zeroing EAX bsr' ইনপুট শূন্য হলে গন্তব্যটি অবিস্মরণীয় রেখে দেওয়ার আধিকারিক আচরণ))

যদি আমরা দীর্ঘতম রানের এমএসবি অবস্থানটি ফিরিয়ে দিতে পারি তবে এটি আরও খাটো হবে। সেক্ষেত্রে, lea ecx, [rdi+rdi](3 বাইটস) + + কপি হবে বাম পরিবর্তে -shift mov+ + shr(4 বাইট)।

কোনও এসএম কলারের জন্য এই টিআইও লিঙ্কটি দেখুনexit(longest_set(argc-1));

শেল লুপ দিয়ে পরীক্ষা করা:

l=(); for ((i=0;i<1025;i++));do 
    ./longest-set-bitrun "${l[@]}";   # number of args = $i
    printf "$i %#x: $?\n" $i; 
    l+=($i); 
done | m

0 0: 0
1 0x1: 0
2 0x2: 1
3 0x3: 0
4 0x4: 2
5 0x5: 2
6 0x6: 1
7 0x7: 0
8 0x8: 3
9 0x9: 3
10 0xa: 3
11 0xb: 0
12 0xc: 2
13 0xd: 2
14 0xe: 1
15 0xf: 0
16 0x10: 4
17 0x11: 4
18 0x12: 4
19 0x13: 0
20 0x14: 4
21 0x15: 4

...

747 0x2eb: 5
748 0x2ec: 5
749 0x2ed: 5
750 0x2ee: 5
751 0x2ef: 0
752 0x2f0: 4
753 0x2f1: 4
754 0x2f2: 4

Comments

নিস! "বিট স্ক্যান বিপরীত", জন্য এক্স 86 BSR স্মৃতিসম্বন্ধীয় ব্রিদিং: যারা (আমার মত) অন্য সমাবেশ উপভাষা সঙ্গে আরো পরিচিত একটি নোট না "সাবরুটিন শাখা"।

— আর্নাউল্ড

@ আর্নল্ড: ভাল পয়েন্ট, মেমোনিক ডিকোড করার জন্য সম্পাদিত পাশাপাশি ইনস রেফারেন্স ম্যানুয়াল প্রবেশের লিঙ্ক থাকার জন্য।

— পিটার

Answer 4

জেলি , 19 17 11 বাইট

HÐĿ&\ḟ0ṪBL’

এটি অনলাইন চেষ্টা করুন!

-Den (!) ডেনিসের তীক্ষ্ণ পর্যবেক্ষণকে ধন্যবাদ বাইটস

কিভাবে এটা কাজ করে

HÐĿ&\ḟ0ṪBL’
HÐĿ         - halve repeatedly until reaching 0 due to rounding
   &\       - cumulative AND
     ḟ0Ṫ    - final non-zero, or 0 if all elements are 0
        BL  - length of binary representation (log base 2). 0->[0]->1
          ’ - decrement

Comments

জন্য ত্রুটি 0, যা ইনপুট পরিসীমা হয়।

— মিঃ এক্সকোডার

@ মিঃ এক্সকোডার স্থির

— অগ্নিনির্বাপক 24

আপনি ȯ-µ...

— জোনাথন অ্যালান

@ জোনাথান অ্যালান আমি বুঝতে পারি না কীভাবে ওআর-ইনিং সাহায্য করবে। আপনার কোড আছে?

— fireflame241

যেহেতু Bসর্বদা একটি 1 দিয়ে শুরু হওয়া একটি অ্যারে ফেরত দেয় , BUṪMṪ’×Ṡহয়ে যেতে পারে ṪBL’। এছাড়াও, আপনার দরকার নেই Ḟএবং ḟ0একটি বাইট ওভার সাশ্রয় করুন ¹Ðf।

— ডেনিস

Answer 5

পাইথন 2 , 45 বাইট

f=lambda x:f(x&x/2)if x&x/2else len(bin(x))-3

এটি অনলাইন চেষ্টা করুন!

ডেনিসকে প্রচুর পরিমাণে বাইট সংরক্ষণ করেছেন! ( len(bin(...))-3পরিবর্তে জন্য মাথা আপ math.frexp)

@ Xnor কে একটি বাগ খুঁজে পাওয়ার জন্য ধন্যবাদ, যা ভাগ্যক্রমে সহজেই স্থিরযোগ্য ছিল!

Comments

এটি মনে হয় যেমন ভুল উত্তর দেয় x=3কারণ আমি মনে করি কারণ and/orশর্ট সার্কিটগুলি ভুল হয়ে গেছে যখন ফাংশনটি 0 ফিরে আসে

— xnor

@ এক্সনর তা লক্ষ্য করার জন্য ধন্যবাদ! এটা ঠিক আছে।

— মিঃ এক্সকোডার

Answer 6

পার্ল 6 ,45 35 বাইট

এই অত্যন্ত উন্নত সংস্করণটি @ নয়েলহোফের সৌজন্যে।

{.msb+1-(.base(2)~~m:g/1+/).max.to}

এটি অনলাইন চেষ্টা করুন!

Comments

আপনি :gসমস্ত ম্যাচগুলি পেতে সহজেই মেলাতে পারেন । স্মার্ট-ম্যাচ অপারেটরের সাথে, আমি এটিকে 40 বাইটে নামিয়ে আনতে পারি:{sort(.base(2).flip~~m:g/1+/).tail.from}

— নবেলহোফ

এবং 35 বাইটে:{.msb+1-(.base(2)~~m:g/1+/).max.to}

— নোটহেনহফ

@ ননহ্নহোফ, আপনাকে অনেক ধন্যবাদ আমি একরকম মিস করেছি :gএবং আমি স্মার্টম্যাচ অপারেটরের সাথে কীভাবে অ্যাডভারব ব্যবহার করতে পারি তা অনুভব করিনি। এছাড়াও .msbপদ্ধতিটি এখানে বেশ সহায়ক এবং আমি এটি সম্পর্কে আগে জানতাম না।

— Ramillies

Answer 7

পাইথন 2 , 89 78 বাইট

m=t=i=j=0
for c in bin(input()):
 t=-~t*(c>'0');i+=1
 if t>m:j=i;m=t
print i-j

এটি অনলাইন চেষ্টা করুন!

সম্পাদনা: জনাব এক্সকোডারকে 11 বাইট সংরক্ষণ করা হয়েছে।

Comments

86 bytes

— Mr. Xcoder

78 bytes

— Mr. Xcoder

@Mr.Xcoder I also thought of that, though the question specifically asks to write a function.

— Jonathan Frech

@JonathanFrech I don't think the OP really meant function. Probably just a generic term.

— Mr. Xcoder

@Mr.Xcoder Please explain this. Thanks,

— lifebalance

Answer 8

05AB1E, 14 12 11 bytes

bDγàŠrkrJgα

Try it online! or run test cases.

Explanation

bDγàŠrkrJgα  Implicit input (ex: 750)
bD           Convert input to binary string and duplicate
                 '1011101110', '1011101110'
  γ          Split into groups of 1s or 0s
                 '1011101110', ['1', '0', '111', '0', '111', '0']
   à         Pull out max, parsing each as an integer
                 '1011101110', ['1', '0', '0', '111', '0'], '111'
    Šrk      Rearrange stack and get first index of max run of ones
                 ['1', '0', '0', '111', '0'], 2
       rJg   Reverse stack, join the array to a string, and get its length
                 2, 7
          α  Get absolute difference
                 5

Answer 9

J, 18 17 bytes

(#-0{#\\:#.~\)@#:

Try it online!

Explanation

(#-0{#\\:#.~\)@#:  Input: integer n
               #:  Binary
     #\            Length of each prefix
       \:          Sorted down using
         #.~\      Mixed base conversion on each prefix
   0{              Get the value at index 0
  -                Subtract from
 #                 Length

Comments

Very slick. Not sure I fully understand what's going on with the mixed base conversion though. Why does it count the number of consecutive ones at the end of the string? Also, if the bases being specified on the x of the dyad are all 0 and 1, what does that mean? A base 2 number has digits 0 and 1, so a base 1 number has digits... 0? then what does a 1 mean in that context? And is a base 0 number just always 0?

— Jonah

@Jonah It's more due to how mixed base conversion is implemented. x #. y first computes w =: */\. }. x , 1 then returns +/ w * y

— miles

so would you consider this a golf hack rather than a legitimate use of #., since you are relying on internal implementation details rather than the public api?

— Jonah

Answer 10

C# (.NET Core), 64 60 bytes

T=a=>(a&a/2)>0?T(a&a/2):Math.Log(a,2)<0?0:(int)Math.Log(a,2)

Try it online!

A C# version of @Arnauld's answer

Acknowledgements

4 bytes saved thanks to Kevin Cruijssen.

C# (.NET Core), 131 123+18=141 bytes

a=>{string s=Convert.ToString(a,2),t=s.Split('0').OrderBy(x=>x.Length).Last();return a<1?0:s.Length-s.IndexOf(t)-t.Length;}

Try it online!

+18 bytes for using System.Linq;

Acknowledgements

8 bytes saved thanks to Grzegorz Puławski.

Degolfed

a=>{
    string s=Convert.ToString(a,2),      // Convert to binary
    t=s.Split('0')                       // get largest group of 1's
       .OrderBy(x=>x.Length)
       .Last();
    return 
        a<1?0:                          // handle 0 case
        s.Length-s.IndexOf(t)-t.Length; // get position in reversed string
}

C# (.NET Core), 164 161 bytes

a=>{var s=Convert.ToString(a,2);int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;for(;i>=0;i--){if(s[i]>'0'){if(i==j||s[i+1]<'1'){p=i;c=0;}if(++c>=l){l=c;k=p;}}}return j-k;}

Try it online!

A non-Linq solution, which I'm sure could be improved, though nothing is immediately apparent.

Degolfed

a=>{
    var s=Convert.ToString(a,2); // Convert to binary
    int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;
    for(;i>=0;i--)               // Loop from end of string
    {
        if(s[i]>'0')             // if '1'
        {
            if(i==j||s[i+1]<'1') // if first digit or previous digit was '0'
            {
                p=i;             // set the position of the current group
                c=0;             // reset the count
            }
            if(++c>=l)           // if count is equal or greater than current largest count
            {
                l=c;             // update largest count
                k=p;             // store position for this group
            }
        }
    }
    return j-k;                  // as the string is reversed, return string length minus position of largest group
}

Comments

You can save 8 bytes by ditching r in the first answer: tio.run/##dY9RS8MwFIWfza/…

— Grzegorz Puławski

You can save two bytes in your port of Arnauld's like this: T=a=>{int x=(int)Math.Log(a,2);return(a&=a/2)>0?T(a):x<0?0:x;}

— Kevin Cruijssen

Or even two more bytes saved (60 bytes): T=a=>(a&a/2)>0?T(a&a/2):Math.Log(a,2)<0?0:(int)Math.Log(a,2)

— Kevin Cruijssen

Answer 11

Husk, 12 bytes

→S§-€¤≠Lo▲gḋ

Try it online!

Explanation

                 Implicit input, e.g                           750
           ḋ     Convert to binary                             [1,0,1,1,1,0,1,1,1,0]
          g      Group equal elements                          [[1],[0],[1,1,1],[0],[1,1,1],[0]]
        o▲       Maximum                                       [1,1,1]
    €            Index of that substring in the binary number  3
     ¤≠L         Absolute difference of lengths                abs (3 - 10) = 7
 S§-             Subtract the two                              7 - 3 = 4
→                Increment                                     5

Answer 12

Jelly,  14 13 12  11 bytes

Bµṣ0Ṫ$ƤMḢạL

A monadic link taking and returning non-negative integers.

Try it online! or see the test-suite.

How?

Bµṣ0Ṫ$ƤMḢạL - Main link: number, n                   e.g. 750
B           - convert to a binary list                    [1,0,1,1,1,0,1,1,1,0]
 µ          - monadic chain separation, call that b
      Ƥ     - map over prefixes:  (i.e. for [1], [1,0], [1,0,1], [1,0,1,1],...)
     $      -   last two links as a monad:                e.g.: [1,0,1,1,1,0,1,1]
   0        -     literal zero                                   0
  ṣ         -     split (prefix) at occurrences of (0)           [[1],[1,1,1],[1,1]]
    Ṫ       -     tail                                                        [1,1]
       M    - maximal indices                             [5,9]
        Ḣ   - head                                        5
          L - length (of b)                               10
         ạ  - absolute difference                         5

Comments

I had a similar solution but used ŒrṪP on the prefixes instead.

— miles

Answer 13

Jelly, 19 bytes

BŒgḄṀB
BwÇɓÇL+ɓBL_‘

Try it online!

Thanks to Jonathan Allan for saving  4  6 bytes!

I've worked too much to just abandon this, although it is kind of long. I really wanted to add a solution that literally searches for the longest substring of 1s in the binary representation...

Explanation

BŒgḄṀB  - Monadic helper link. Will be used with Ç in the next link.

B       - Binary representation.
 Œg     - Group runs of consecutive equal elements.
   Ḅ    - Convert from binary to integer.
    Ṁ   - Maximum value.
     B  - Convert from integer to binary.


BwÇɓÇL+ɓBL_‘  - Main link.

B             - Binary representation (of the input).
  Ç           - Last link as a monad. Takes the input integer.
 w            - First sublist index.
   ɓ          - Start a separate dyadic chain. Reverses the arguments.
    Ç         - Last link as a monad.
     L        - Length.
      +       - Addition
       ɓ      - Start a separate dyadic chain. Reverses the arguments.
        B     - Binary.
         L    - Length.
          _‘  - Subtract and increment the result (because Jelly uses 1-indexing).
              - Implicitly output.

Comments

Your helper link could be BŒgḄṀB instead

— Jonathan Allan

@JonathanAllan Oh wow thanks!

— Mr. Xcoder

Your main link could be BwÇɓÇL+ɓBL_‘

— Jonathan Allan

@JonathanAllan Wow, thanks again!

— Mr. Xcoder

Answer 14

Kotlin, 77 bytes

{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}

Beautified

{
    val b = it.toString(2)
    // Find the left position of the first instance of
    b.reversed().lastIndexOf(
            // The largest group of 1s
            b.split(Regex("0+")).max()!!)
}

Test

var s:(Int)->Int =
{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}
fun main(args: Array<String>) {
    r(0, 0)
    r(142, 1)
    r(48, 4)
    r(750, 5)
}

fun r(i: Int, i1: Int) {
    var v = s(i)
    println("$i -> $v [$i1] ${i1 == v}")
}

Comments

I did not test but think this works in scala too.

— V. Courtois

Answer 15

Haskell, 101 98 96 75 bytes

snd.maximum.(`zip`[0..]).c
c 0=[0]
c n|r<-c$div n 2=sum[r!!0+1|mod n 2>0]:r

Try it online! Usage: snd.maximum.(`zip`[0..]).c $ 142 yields 1.

Explanation:

• c converts the input into binary while at the same time counting the length of streaks of one, collecting the results in a list. r<-c$div n 2 recursively computes the rest r of this list, while sum[r!!0+1|mod n 2>0]:r adds the current length of the streak to r. The list comprehension checks if mod n 2>0, that is whether the current binary digit is a one, and if so, takes the length of the previous streak (the first element of r) and adds one. Otherwise the list comprehension is empty, and sum[] yields 0. For the example input, c 142 yields the list [0,3,2,1,0,0,0,1,0].

• (`zip`[0..]) adds the position to each element of the previous list as the second component of a tuple. For the example this gives [(0,0),(3,1),(2,2),(1,3),(0,4),(0,5),(0,6),(1,7),(0,8)].

• maximum finds the lexicographically maximal tuple in this list, that is the streak lengths are considered first as they are the first component, and in the event of a tie the second component, namely the larger index, decides. This yields (3,1) in the example, and snd returns the second component of the tuple.

Answer 16

Python 2 or 3, 58 bytes

import math
f=lambda x:x&x>>1and f(x&x>>1)or len(bin(x))-3

Try it online!

Answer 17

C (gcc), 81 80 bytes

i,l,c,r;f(n){for(i=l=c=r=0;n;n/=2,i++)c=n&1?c+1:c>=l?r=i-(l=c),0:0;n=c<l?r:i-c;}

Try it online!

C (gcc), 43 bytes

A C version of @Arnauld's answer

k;f(n){n=(k=n&n/2)?f(k):(k=log2(n))<0?0:k;}

Try it online!

Comments

Miss the return n; or return k; statement

— RosLuP

Suggest n<1?0:log2(n) instead of (k=log2(n))<0?0:k

— ceilingcat

Answer 18

MS SQL Server, 437 426 407 398 bytes

SQL Fiddle

I'm sure that I could remove line breaks, etc, but this is as compact as I was willing to make it:

create function j(@ int)
returns int
as BEGIN
declare @a varchar(max)='',@b int,@c int=0,@d int=0,@e int=0,@f int=0,@g int=0,@h int=0
while @>0 BEGIN SELECT @a=cast(@%2 as char(1))+@a,@=@/2
END
SET @b=len(@a)
while @<@b
BEGIN
select @c=@d,@d=cast(substring(@a,@b-@,1)as int)
IF @d=1
BEGIN IF @c=0
SELECT @e=@,@g=1
else SET @g+=1 END
IF @g>=@h BEGIN select @h=@g,@f=@e END
SET @+=1
END
return @f
END

Here's a more readable version:

create function BinaryString(@id int)
returns int
as BEGIN
  declare @bin varchar(max)
  declare @binLen int
  declare @pVal int = 0
  declare @Val int = 0
  declare @stC int = 0 --start of current string of 1s
  declare @stB int = 0 --start of biggest string of 1s
  declare @lenC int = 0 --length of current string of 1s
  declare @lenB int = 0 --length of biggest string of 1s

  set @bin = ''

    while @id>0
      BEGIN
        SET @bin = cast(@id%2 as varchar(1)) + @bin
        SET @id = @id/2
      END

    SET @binLen = len(@bin)

    while @id<@binLen
      BEGIN
        set @pVal = @Val
        set @Val = cast(substring(@bin,@binLen-@id,1) as int)
        IF @Val = 1 and @pVal = 0
          BEGIN 
            SET @stC = @id
            SET @lenC = 1
          END
        IF @Val = 1 and @pVal = 1
          BEGIN 
            SET @lenC = @lenC + 1
          END
        IF @lenC >= @lenB
          BEGIN
            set @lenB = @lenC
            set @StB = @StC
          END

        SET @id = @id + 1 
      END

  return @StB
END

The real trick is that as far as I could find, there is no native SQL functionality to convert a number from decimal to binary. As a result, I had to code the conversion to binary manually, then I could compare that as a string, one character at a time until I found the right number.

I'm sure there's a better way to do this, but I didn't see a(n) SQL answer, so I figured I'd throw it out there.

Comments

If you can golf it more, please do so. But otherwise, this is great! Welcome to PPCG!

— NoOneIsHere

@NoOneIsHere thanks! I realized I can shorten my function name too ;)

— phroureo

Answer 19

APL (Dyalog Unicode), 22 chars = 53 bytes

Requires ⎕IO←0 which is default on many systems.

⊃⌽⍸(∨⌿↑⊆⍨b)⍷⌽b←2⊥⍣¯1⊢⎕

Try it online!

⎕ prompt for input

⊢ yield that (separates ¯1 from ⎕)

2⊥⍣¯1 convert to base-2, using as many positions as needed

b← store as b (for binary)

⌽ reverse

(…) mark the starting positions of the following in that:

 ⊆⍨b self-partition b (i.e. the 1-streaks of b)

 ↑ mix (make list of lists into matrix, padding with zeros)

 ∨⌿ vertical OR reduction (yields longest streak)

⍸ ɩndices of starting positions

⌽ reverse

⊃ pick the first one (yields zero if none available)

Comments

you're missing a ∇ in the footer on tio

— ngn

@ngn Right you are.

— Adám

Answer 20

MATL, 15 bytes

`tt2/kZ&t]xBnq&

Try it online!

Uses the half and AND idea. The k is necessary only to make it terminate for 1 - for some reason, 1 AND 0.5 returns 1, causing an infinite loop.

(alternate solution: BtnwY'tYswb*&X>)- by converting to binary and run-length encoding)

Answer 21

Google Sheets, 94 bytes

=Len(Dec2Bin(A1))-Find(MAX(Split(Dec2Bin(A1),0)),Dec2Bin(A1))-Len(MAX(Split(Dec2Bin(A1),0)))+1

No, it's not very pretty. It'd be real nice to be able to store Dec2Bin(A1) as a variable for reference.

Key point: Like Excel, the Dec2Bin function has a max input value of 511. Anything larger than that returns an error, as seen below.

Answer 22

R, 117 Bytes

z=rev(Reduce(function(x,y)ifelse(y==1,x+y,y),strtoi(intToBits(scan())),,,T));ifelse(!sum(z),0,33-which.max(z)-max(z))

Comments

104 bytes! Instead of rev, use Reduce(...,T,T) to accumulate from the right (switching x,y in the function definition). Then use 1+max(z)-which.max(z) since the result is somewhat different. Use "if" instead of "ifelse" since we don't need the vectorization; aaand if you use any(z) instead of !sum(z) you drop a byte.

— Giuseppe

I think we should be able to get this to less than 100 bytes.

— Giuseppe

@giuseppe I feel somewhat a cheater for being here before you! Will do times tnx a bunch!

— Zahiro Mor

But a nice approach no ?

— Zahiro Mor

Oh, no worries, I saw this earlier but didn't feel like answering it because R is so bad at bit operations... Yeah, good work, you got my +1

— Giuseppe

Answer 23

Excel VBA, ₅₄ 44 Bytes

-10 Bytes thanks to @EngineerToast

Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window

?Instr(1,StrReverse([Dec2Bin(A1)]),1)+[A1>0]

Comments

Besides the oversight having C1 still in there instead of A1, I think you can output the Instr results directly with a little twisting for the zero input correction: ?Instr(1,StrReverse([Dec2Bin(A1)]),1)+([A1]>0) (46 bytes). True = -1 because... VBA.

— Engineer Toast

@EngineerToast - Sweet! I should have seen that; I was able to drop it down 2 bytes by bringing the >0 into the [A1] notation

— Taylor Scott

Answer 24

APL (Dyalog Classic), 24 21 bytes

63|-⊃⍒+/×\↑,⍨\⎕⊤⍨64⍴2

Try it online!

Answer 25

Pyth, 17 bytes

This is a recursive function. The link includes y in order to call the function on the given input.

L|&K.&b/b2yKsl|b1

Verify all test cases.

Pyth, 20 bytes

-lK.B|Q1+xKJeScK\0lJ

Verify all test cases.

Answer 26

R, 66 Bytes

function(i){a=rle(intToBits(i));max(0,a[[1]][which(a[[2]]==1)])}

Explanation:

function(i){
  a = rle(                  # Run-length encode
    intToBits(i)            # The bits in i
  );                        # And assign it to a.
  max(0,                    # Return the maximum of zero and
      a[[1]][               # The lengths of a,
        which(a[[2]]==1)    # But only those where the repeated bit is 1
        ])
}

Comments

This returns the length of the longest streak, not its position. Check against the test cases and the specs at the top.

— user2390246

I will change my downvote to an upvote once this answer is corrected. Also, note that you can use a$l instead of a[[1]] and a$v instead of a[[2]] to save some bytes :), as well as >0 instead of ==1.

— Giuseppe

Answer 27

Python 2, 41 bytes

f=lambda n:n/2and(n&n/2<1)+f(n&n/2or n/2)

Try it online!

Based on this solution by Mr. Xcoder.

Answer 28

Javascript, 54 chars

f=i=>i.toString(2).split(0).sort().reverse()[0].length

• i.toString(2) gets the binary string for the integer.
• The .split(0) gets each sequential ones part in an array element.
• .sort().reverse() gets us the highest value as first.
• The [0].length gives us the length of that first value.

Comments

the starting position of number of largest consecutive 1's

— L3viathan

Answer 29

Perl 5, 45 + 1 (-p)

(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'

If you write this out on the command line of most shells, you may have to type this as:

perl -pE'(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'"'"

The dance of the quotes at the end is just to get perl see a ', which would otherwise be consumed by the shell.

Answer 30

Retina, 52 43 bytes

Convert to binary, then replace with the length of what follows the largest string of ones.

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

$'¶
O`
A-3`
^1+

.

Try it online - all test cases

Saved 9 bytes thanks to Martin.

Comments

You can use $+ for ${1}. But you can save even more by replacing the last stage with a bunch of stages like this: tio.run/##K0otycxL/K/…

— Martin Ender

@MartinEnder Ok. The ${1} was copied from your tutorial on Github.

— mbomb007