"बिट्टेस्ट" संख्या खोजें [बंद]

Dec 20 2020

चुनौती

पूर्णांक की एक सूची को देखते हुए, उनमें से "बिट्टिएस्ट" संख्या सबसे अधिक बिट्स के साथ एक है - अर्थात, बिट्स की सबसे बड़ी राशि जो 1 पर सेट है।

एक फ़ंक्शन (या एक प्रोग्राम) लिखें जो इनपुट के रूप में 32-बिट हस्ताक्षरित पूर्णांकों की एक सूची के रूप में लेता है और उनके बीच "बिटिएस्ट" नंबर आउटपुट के रूप में देता है।

आप मान सकते हैं कि सूची में कम से कम एक आइटम है।

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

इनपुट: 1, 2, 3, 4

आउटपुट: 3

इनपुट: 123, 64, 0, -4

आउटपुट: -4

इनपुट: 7, 11

आउटपुट: या तो 7या 11(लेकिन दोनों)

इनपुट: 1073741824, 1073741823

आउटपुट: 1073741823

शुभ लाभ

यह कोड गोल्फ है, इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

स्पष्टता

यदि आपकी भाषा 32-बिट हस्ताक्षरित पूर्णांक का समर्थन नहीं करती है, तो आप किसी भी अन्य संख्यात्मक (पढ़ें: पाठ नहीं) प्रतिनिधित्व का उपयोग कर सकते हैं, जब तक कि यह सभी पूर्णांकों -2^31को 2^31 - 1समावेशी से, नकारात्मक के लिए दो के पूरक का उपयोग करके प्रतिनिधित्व कर सकता है ।

जवाब

10 GioD Dec 21 2020 at 13:54

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

%Ø%B§µÞṪ

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

स्पष्टीकरण

     µÞ  | sort input by
%Ø%      | modulo by 2^32 (Ø% is a quick for 2^32)
   B     | converted to binary
    §    | sum
       Ṫ | get the last

संपादित करें: मेरे पहले प्रश्न के लिए इस तरह की प्रतिक्रिया के लिए आप सभी को धन्यवाद! मुझे लगता है कि मैंने इसे अब ठीक कर लिया है, यह सभी परीक्षण मामलों के लिए काम करता है।

मूल कोड

2*31
B%¢S€iṀị
26 CodyGray Dec 20 2020 at 18:26

x86 मशीन भाषा, 18 बाइट्स

31 D2 AD F3 0F B8 F8 39 FA 77 03 87 FA 93 E2 F2 93 C3 

उपरोक्त बाइट्स एक फ़ंक्शन को परिभाषित करता है जो esiरजिस्टर में सरणी के पते और रजिस्टर में सरणी में तत्वों की संख्या को स्वीकार करता है ecx, और रजिस्टर में सरणी में "बिटटेस्ट" नंबर देता है eax

ध्यान दें कि यह एक कस्टम कॉलिंग कन्वेंशन है जो में ecxऔर esiरजिस्टरों में तर्कों को स्वीकार करता है , लेकिन यह अन्यथा एक सी फ़ंक्शन की तरह है जो एरे की लंबाई और एक पॉइंटर को अपने दो तर्कों के रूप में ले लेता है। यह कस्टम कॉलिंग कन्वेंशन सभी रजिस्टरों को कॉलर-सेव के रूप में मानता है, जिसमें शामिल हैं ebx

इस फ़ंक्शन का कार्यान्वयन कुछ गंदी चालें खींचता है, जो यह मानते हैं कि सरणी में कम से कम 1 तत्व है, जैसा कि चुनौती में प्रदान किया गया है। यह भी मानता है कि दिशा ध्वज ( DF) स्पष्ट है ( 0), जो सभी कॉलिंग सम्मेलनों में मानक है, जिनके बारे में मुझे पता है।

असंगठित असेंबली-भाषा में भाषाविज्ञान:

; ecx = length of array
; esi = address of first element in array
Find:
    31 D2          xor    edx, edx                ; start with max bit count set to 0
Next:
    AD             lods   eax, DWORD PTR [esi]    ; load the next value from the array, and
                                                  ;   increment ptr by element size
    F3 0F B8 F8    popcnt edi, eax                ; count # of set bits in value
    39 FA          cmp    edx, edi                ; if # of set bits in value is less than
    77 03          ja     SHORT Skip              ;   the running maximum, skip next 2 insns
    87 FA          xchg   edx, edi                ; save current # of set bits (for comparisons)
    93             xchg   eax, ebx                ; save current array value (for comparisons)
Skip:
    E2 F2          loop   SHORT Next              ; decrement element count, looping until it is 0
    93             xchg   eax, ebx                ; move running maximum value to eax
    C3             ret                            ; return, with result in eax

इस कोड की मुख्य विशेषता, निश्चित रूप से, x86 popcntनिर्देश है, जो एक पूर्णांक में सेट बिट्स की संख्या को गिनता है। यह इनपुट सरणी के माध्यम से पुनरावृत्त करता है, अधिकतम तत्व के मूल्य और सेट बिट्स की संख्या पर नज़र रखता है। यह सरणी में प्रत्येक मान की जांच करता है कि यह देखने के लिए कि सेट बिट्स की संख्या पहले देखे गए किसी मूल्य से अधिक है या नहीं। यदि हां, तो यह ट्रैकिंग मूल्यों को अपडेट करता है; यदि नहीं, तो यह इस कदम को छोड़ देता है।

popcntअनुदेश एक बड़े (4 बाइट) अनुदेश है, लेकिन वहाँ कुछ भी नहीं है कि उस से बचने के लिए किया जा सकता है है। हालाँकि, बहुत कम (1-बाइट) lodsनिर्देश का उपयोग सरणी से मानों को लोड करने के लिए किया गया है, साथ ही साथ पॉइंटर को बढ़ाते हुए, loopलूप नियंत्रण के लिए शॉर्ट (2-बाइट) निर्देश का उपयोग किया गया है (स्वचालित रूप से तत्व काउंटर और लूपिंग को लंबे समय तक घटाते हुए) के रूप में वहाँ से गुजरने के लिए और अधिक तत्व शेष हैं), और बहुत ही कम (1-बाइट) xchgनिर्देश का उपयोग किया गया है।

निर्देश के xchgउपयोग को सक्षम करने के लिए अंत में एक अतिरिक्त का उपयोग करना पड़ता था lods, जो हमेशाeax रजिस्टर में लोड होता है , लेकिन यह व्यापार-मूल्य इसके मुकाबले अधिक है।

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

मेरा पहला प्रयास 20-बाइट फ़ंक्शन था। अब तक, 18 बाइट्स सर्वश्रेष्ठ हैं, जिनके साथ मैं आ सका हूं। मैं यह देखने के लिए उत्सुक हूं कि क्या कोई और इस स्कोर को हरा सकता है!

सुधार का एकमात्र मार्ग जो मुझे दिखाई LOOPAदेता है यदि कोई निर्देश मौजूद होता है। दुर्भाग्य से, यह नहीं है - / और / द्वारा समर्थित केवल शर्त कोड LOOPहैं । लेकिन हो सकता है कि कोई और मेरे दिमाग को मुझसे आगे बढ़ा सके!EZNENZ

18 Arnauld Dec 20 2020 at 03:58

जावास्क्रिप्ट (ईएस 6),  49 48 47  45 बाइट्स

सहेजे गए 2 बाइट @ user81655 की बदौलत

a=>a.sort(g=(p,q)=>!p|-!q||g(p&p-1,q&q-1))[0]

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

कैसे?

हम .sort()एक पुनरावर्ती फ़ंक्शन के साथ इनपुट सूची देते हैं, जो दिए गए pऔर q, प्रत्येक चर में कम से कम महत्वपूर्ण बिट सेट को साफ करता है जब तक कि उनमें से एक 0 (या दोनों एक साथ) के बराबर नहीं होता है। यह सबसे कम से कम बिट सेट से सूची को ऑर्डर करने की अनुमति देता है। हम फिर पहली प्रविष्टि, यानी "बिटटेस्ट" एक लौटाते हैं।

टिप्पणी की

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      !p | -!q       //     -> +1 if p = 0 and q ≠ 0,
                     //     or -1 if q = 0,
      ||             //     or  0 if p ≠ 0 and q ≠ 0, in which case ...
        g(           //     ... we do a recursive call:
          p & p - 1, //       clear the least significant bit set in p
          q & q - 1  //       clear the least significant bit set in q
        )            //     end of recursive call
  )[0]               // end of sort(); return the first entry
9 KamilaSzewczyk Dec 20 2020 at 03:45

एपीएल (डायलॉग यूनिकोड) , 15 बाइट्स

एडम और ngn के लिए धन्यवाद कई बाइट्स बचा लिया।

{⊃⍒+⌿⍵⊤⍨32⍴2}⊃⊢

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

8 Noodle9 Dec 20 2020 at 09:07

सी (जीसीसी) , 80 77 बाइट्स

सहेजी गयी 3 करने के लिए धन्यवाद बाइट्स att !!!

#define b __builtin_popcount(f(n,l
f(n,l)int*l;{n=--n?f(n,l+(b))<b+1)))):*l;}

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

7 Zaiborg Dec 21 2020 at 22:41

सी ++ (जीसीसी) , 145 141 140 135 134 133 130 128 116 बाइट्स

145-> 141 उपयोगकर्ता के लिए धन्यवाद
128-> 116 सीलिंगकैट के लिए धन्यवाद

#import<bits/stdc++.h>
int i,b,v,c;main(){for(;std::cin>>i;b<c?b=c,v=i:0)c=std::bitset<32>(i).count();std::cout<<v;}

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

6 pavi2410 Dec 21 2020 at 23:13

कोटलिन , 41 38 29 बाइट्स

बहुत कम बाइट्स के साथ सही कोड :) {धन्यवाद @vrintle}

{it.maxBy{it.countOneBits()}}

कोटलिन खेल का मैदान


{it.maxBy{it.toByte().countOneBits()}}

कोटलिन खेल का मैदान


{it.maxBy{it.toString(2).count{it=='1'}}}

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

6 Makonede Dec 21 2020 at 01:44

05AB1E , 9 बाइट्स

ΣžJ%b1¢}θ

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

ΣžJ%b1¢}θ  # full program
        θ  # last element of...
           # implicit input...
Σ          # sorted in increasing order by...
      ¢    # number of...
     1     # ones...
      ¢    # in...
           # (implicit) current element in list...
   %       # modulo...
 žJ        # 4294967296...
    b      # in binary
           # implicit output
4 Giuseppe Dec 20 2020 at 05:32

आर , 58 55 54 बाइट्स

function(x)x[order(colSums(sapply(x,intToBits)<1))][1]

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

-2 रॉबिन राइडर को धन्यवाद

-1 डोमिनिक वैन एसेन को धन्यवाद।

4 Razetime Dec 20 2020 at 10:30

स्टेक्स , 18 बाइट्स

é·║⌂╞8Q⌡ë♀NM╟¥É▌╦!

इसे चलाएं और डीबग करें

सही प्रतिनिधित्व प्राप्त करने के लिए 1s / 0s के साथ मैन्युअल रूप से पैड।

प्रत्येक टेस्टकेस के लिए एक एकल संख्या प्रदर्शित करता है।

4 GalenIvanov Dec 21 2020 at 15:02

के (ngn / k) , 11 बाइट्स

{*x@>+/2\x}

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

4 Danis Dec 20 2020 at 19:02

पायथन 3 , 52 बाइट्स

lambda l:max(l,key=lambda n:bin(n%2**31).count("1"))

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

n%2**31- चूंकि अजगर पूर्णांक अनंत हैं, इसलिए ऋणात्मक संख्याओं को बदलना होगा। उदाहरण के लिए -4बन जाता है2147483644

bin(...) - द्विआधारी प्रारूप में अनुवाद

count("1") - इकाइयों की संख्या गिनें


पायथन 3 , 50 बाइट्स

lambda n:n and n%2+z(n//b)
f=lambda l:max(l,key=z)

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

दो बाइट्स छोटे, लेकिन नकारात्मक संख्याओं के साथ काम नहीं करते हैं

4 Gabber Dec 22 2020 at 00:56

स्काला , 54 42 40 36 बाइट्स

कुछ बाइट्स को caird coinheringaahing, didymus, उपयोगकर्ता और कुछ युक्तियों के लिए धन्यवाद

_.maxBy(_.toBinaryString.count(48<))

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

3 DominicvanEssen Dec 20 2020 at 15:17

भूसी , 17 16 13 बाइट्स

संपादित करें: -1 रेज़टाइम के लिए बाइट का धन्यवाद, और फिर लियो को -3 बाइट्स का धन्यवाद

►(ΣḋΩ≥0+^32 2

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

हस्क मूल रूप से मनमाने ढंग से सटीक पूर्णांक का उपयोग करता है, और इसलिए नकारात्मक 4-बाइट हस्ताक्षरित पूर्णांक का प्रतिनिधित्व करने के लिए 32-बिट 2 के पूरक की कोई धारणा नहीं है: परिणामस्वरूप, 'बाइनरी अंक प्राप्त करें' फ़ंक्शन - - नकारात्मक इनपुट के लिए यहां दुखद बेकार है।
इसलिए हमें हाथ से '2 के पूरक बिटकॉइन' की गणना करने की आवश्यकता है।

यहाँ के उपयोग के लिए लियो से भूसी की मदद के लिए धन्यवाद ।Ω

►                       # element of input that maximises result of:
 (Σḋ                    # sum of binary digits of
    Ω                   # repeat until result is
     ≥0                 # greater than or equal to zero:
       +^32 2           # add 2^32
3 KevinCruijssen Dec 21 2020 at 22:13

जावा 10, 73 बाइट्स

a->{int r=0,m=0,t;for(var i:a)if((t=i.bitCount(i))>m){m=t;r=i;}return r;}

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

स्पष्टीकरण:

a->{                     // Method with Integer-array parameter and int return-type
  int r=0,               //  Result-integer, starting at 0
      m=0,               //  Maximum bit-count integer, starting at 0
      t;                 //  Temp integer, uninitialized
  for(var i:a)           //  Loop over each Integer in the input-array:
    if((t=i.bitCount(i)) //   If its amount of 1s in the binary representation
       >m){              //   is larger than the current maximum:
      m=t;               //    Update the maximum with this bit-count
      r=i;}              //    And update the result with this integer
  return r;}             //  After the loop, return the resulting integer
3 xigoi Dec 21 2020 at 20:53

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

%Ø%BSƲÞṪ

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

(अधिकतम) के Þबजाय (सॉर्ट) का उपयोग करके -1 बाइट ÐṀ। यह जियो डी के जवाब से प्रेरित था और उनके और मेरे संपादन के बाद, दोनों समाधान बहुत समान हैं।

स्पष्टीकरण

%Ø%BSƲÞṪ   Main monadic link
      Þ    Sort by
     Ʋ     (
%            Modulo
 Ø%            2^32
   B         Binary
    S        Sum
     Ʋ     )
       Ṫ   Last item
3 Shaggy Dec 21 2020 at 17:11

जाप -h , 10 बाइट्स

ñÈu2pH)¤¬x

इसे अजमाएं

ñÈu2pH)¤¬x     :Implicit input of array
ñ              :Sort by
 È             :Passing each element through the following function
  u            :Positive modulo
   2p          :  2 raised to the power of
     H         :  32
      )        :End modulo
       ¤       :To binary string
        ¬      :Split
         x     :Reduce by addition
               :Implicit output of last element
2 Xcali Dec 20 2020 at 06:47

पर्ल 5 , 54 बाइट्स

sub f{(sprintf"%b",@_)=~y/1//}($_)=sort{f($b)<=>f$a}@F

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

2 vrintle Dec 20 2020 at 10:55

रूबी 2.7 , 36 33 34 बाइट्स

एक विशेष मामले के लिए मेरे कोड को सही करने के लिए डिंगस के लिए धन्यवाद ! :)

p$*.max_by{("%034b"%_1)[2,32].sum}

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

इनपुट के लिए कमांड-लाइन आर्ग्स का उपयोग करता है, एक स्ट्रिंग के रूप में बिटिएस्ट नंबर को आउटपुट करता है । TIO रूबी के एक पुराने संस्करण का उपयोग करता है, जबकि Ruby 2.7 में, हमने गिने हुए पैरामीटर हैं, जो दो बाइट्स बचाता है।

2 user Dec 21 2020 at 22:25

जावा (JDK) , 44 बाइट्स

a->a.max((x,y)->x.bitCount(x)-x.bitCount(y))

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

यह एक तरह का धोखा है, क्योंकि यह एक Stream<Integer>इनपुट के रूप में स्वीकार करता है और एक रिटर्न देता है Optional<Int>

2 user Dec 22 2020 at 04:21

स्काला , 24 बाइट्स

_ maxBy Integer.bitCount

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

से अलग हो गई Gabber के महान पहले उत्तर ।

2 didymus Dec 22 2020 at 03:29

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 71 58 बाइट्स

l=>l.OrderBy(r=>Convert.ToString(r,2).Sum(c=>c-48)).Last()

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

  • टिप्पणियों में @user द्वारा सुझाए गए लंबोदर का उपयोग करने के लिए फिर से तैयार किया गया
1 Neil Dec 20 2020 at 04:34

चारकोल , 22 बाइट्स

≔EθΣ⍘﹪ιX²¦³²¦²ηI§θ⌕η⌈η

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔EθΣ⍘﹪ιX²¦³²¦²η

सूची में प्रत्येक संख्या के लिए, इसे 32-बिट अहस्ताक्षरित संख्या में डालें, इसे बाइनरी में कनवर्ट करें और बिट्स को योग करें।

I§θ⌕η⌈η

उच्चतम बिट गणना की स्थिति में संख्या को आउटपुट करें।

1 ChrisLoonam Dec 20 2020 at 13:14

SystemVerilog, 66 बाइट्स

जैसा कि मैं अपने फोन से पोस्ट कर रहा हूं, यह एक अपूर्ण उत्तर होगा, लेकिन एसवी का $countones()कार्य यहां सही है।

function m(int q[$]);
m=q.max with ($countones(item));
endfunction
1 att Dec 21 2020 at 04:29

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 39 बाइट्स

Last@*SortBy[Mod[#,2^32]~DigitCount~2&]

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

1 ZaelinGoodman Dec 21 2020 at 03:32

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

+5 बाइट्स क्योंकि यह नकारात्मक को ठीक से नहीं संभालता है
-2 बाइट्स mazzy के लिए धन्यवाद

$args|sort{$v=$_;0..31|%{$o+=!!(1-shl$_-band$v)};$o}-b 1
1 xigoi Dec 21 2020 at 21:20

निम , 75 बाइट्स

import algorithm,bitops
func b(n:seq):int=n.sortedByIt(it.countSetBits)[^1]

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

1 roblogic Dec 22 2020 at 05:17

Zsh, 85 बाइट्स

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

for i;{c=${#${(M)${(s::)$((i<0?[##2]2**32+i:[##2]i))}#1}}
((c>d))&&j=$i&&d=$c;}
<<<$j

बड़ी चुनौती, कुछ अजीब Zshयोगों की आवश्यकता! स्पष्टीकरण:
for i;{... सभी तर्कों पर निहितार्थ
$((i<0?[##2]2**32+i:[##2]i))... i32-बिट प्रारूप में कनवर्ट करें, दो के पूरक चाल का उपयोग करते हुए यदि i<0
${#${(M)${(s::) //expression// }#1}}... स्ट्रिंग को सरणी में विस्तारित करें, तत्वों की गणना करें जो (एम) atch हैं 1
((c>d))&&j=$i&&d=$c... किस इनपुट iका ट्रैक रखें गिनती के अनुसार "बिटियास्ट" c
<<<$j... विजेता को आउटपुट देता है

1 wroth Dec 22 2020 at 08:54

जे , 20 बाइट्स

{.@\:[:+/"1(32$2)&#:

जैसा कि लिखा गया है, जब कई समान रूप से, अधिकतम रूप से बिट्टी संख्या दी जाती है, तो सरणी में पहला रिटर्न देता है। यदि {.\:इसे बदल दिया जाता है {:/:, तो यह अंतिम देता है। इसे ऑनलाइन आज़माएं!

1 EasyasPi Dec 23 2020 at 12:09

AArch64, 48 44 बाइट्स

कच्चा निर्देश (32-बिट थोड़ा एंडियन हेक्स):

1e2703e4 bc404400 0e205801 2e303821
0ea43c23 2ea31c02 2ea31c24 f1000421
54ffff21 1e260040 d65f03c0

असंबद्ध विधानसभा:

        .globl bittiest
bittiest:
        fmov    s4, #0
.Lloop:
        ldr     s0, [x0], #4
        cnt     v1.8b, v0.8b
        uaddlv  h1, v1.8b
        cmge    v3.2s, v1.2s, v4.2s
        bit     v2.8b, v0.8b, v3.8b
        bit     v4.8b, v1.8b, v3.8b
        subs    x1, x1, #1
        bne     .Lloop
        fmov    w0, s2
        ret

स्पष्टीकरण

सी फ़ंक्शन हस्ताक्षर:

int32_t bittiest(int32_t *words, size_t len);

छद्म-सी:

int32_t bittiest(int32_t *words, size_t len)
{
    int32_t maxcount = 0;
    int32_t maxvalue;
    do {
        int32_t value = *words++;
        int8_t counts[4] = popcount8x4((int8_t *)&value);
        int32_t count = counts[0] + counts[1] + counts[2] + counts[3];
        if (count >= maxcount) {
            maxvalue = value;
            maxcount = count;
        }
    } while (--len);
    return maxvalue;
}

AArch64 की जनसंख्या गणना निर्देश NEON (SIMD / फ्लोटिंग पॉइंट इंस्ट्रक्शन सेट) में है, और यह प्रत्येक बाइट को अलग-अलग गिनता है। इसलिए, यहां स्केलर के साथ काम करना थोड़ा अजीब है इसलिए हम नीयन में सब कुछ करते हैं।

v4 अधिकतम जनसंख्या गणना है (v4, s4, h4 और d4 सभी एक ही रजिस्टर को संदर्भित करते हैं)। इसे 0 पर सेट करें।

        fmov    s4, #0

अगले int32 शब्द को v0, और वृद्धिशील शब्दों (x0) को 4 से लोड करें।

        ldr     s0, [x0], #4

V0 में प्रत्येक बाइट की जनसंख्या गणना को v1 में संगत बाइट में स्टोर करें।

        cnt     v1.8b, v0.8b

पूरी आबादी की संख्या प्राप्त करने के लिए v1 में सभी 8-बिट लेन को एक साथ जोड़ें, और फिर से v1 में स्टोर करें।

        uaddlv  h1, v1.8b

इस शब्द की जनसंख्या संख्या की अधिकतम से तुलना करें। यदि यह बड़ा या बराबर है, तो v3 सभी 1 बिट्स (सत्य) होगा, अन्यथा यह सभी 0 बिट्स (झूठे) होंगे।

        cmge    v3.2s, v1.2s, v4.2s

यदि v3 सत्य है, तो अधिकतम शब्द (v2) को वर्तमान शब्द पर सेट करें। अधिकतम को पहले पुनरावृत्ति पर आरंभीकृत नहीं किया जाता है, लेकिन यह हमेशा सेट किया जाएगा क्योंकि जनसंख्या की संख्या हमेशा> = 0 होगी।

        bit     v2.8b, v0.8b, v3.8b

वही, लेकिन नई अधिकतम जनसंख्या की गणना के लिए।

        bit     v4.8b, v1.8b, v3.8b

अगर यह शून्य नहीं है, तो गिरावट लेन (एक्स 1), और लूप

        subs    x1, x1, #1
        bne     .Lloop

लूप का अंत: NEON रजिस्टर से रिटर्न रजिस्टर (w0), और वापसी के लिए अधिकतम मूल्य ले जाएँ।

        fmov    w0, s2
        ret

11 निर्देश = 44 बाइट्स