लक्ष्य

किसी फ़ंक्शन या प्रोग्राम को उनके द्विआधारी प्रतिनिधित्व में 1 के वर्तमान की संख्या से अवरोही क्रम में एक पूर्णांक की एक सरणी लिखें। कोई द्वितीयक प्रकार की शर्त आवश्यक नहीं है।

उदाहरण क्रमबद्ध सूची

(16-बिट पूर्णांक का उपयोग करके)

  Dec                Bin        1's
16375   0011111111110111        13
15342   0011101111101110        11
32425   0111111010101001        10
11746   0010110111100010         8
28436   0000110111110100         8
19944   0100110111101000         8
28943   0000011100011111         8
 3944   0000011111101000         7
15752   0011110110001000         7
  825   0000000011111001         6
21826   0101010101000010         6

इनपुट

32-बिट पूर्णांक की एक सरणी।

उत्पादन

समान पूर्णांकों की एक सरणी को वर्णित के अनुसार क्रमबद्ध किया गया।

स्कोरिंग

यह एक सप्ताह के समय में चुने जाने वाले कम से कम बाइट्स के लिए कोड गोल्फ है।

code-golf sorting bitwise

— हाथ-ए-खाना
स्रोत

2

आपने स्पष्ट रूप से उल्लेख नहीं किया है, लेकिन क्या इसे अवरोही क्रम में होना चाहिए?

— निक टी

3

तुम सही हो, मुझे वह याद आया। बाकी सभी लोग नीचे उतर चुके हैं, इसलिए हम उसी के साथ रहेंगे।

— हाथ-ई-फूड

मुझे लगता है कि अंतिम संख्या (21826) को गलत रूप दिया गया है। मेरे विंडोज कैलकुलेटर के अनुसार, यह 0101 0101 0100 0010 है, न कि 0010 1010 1100 0010।

— Nzall

उन सुधारों के लिए धन्यवाद। यह 21826 के बारे में अजीब है क्योंकि मैंने संख्याओं को बाइनरी में बदलने के लिए एक्सेल का उपयोग किया है। मुझे अब बाकी के बारे में आश्चर्य है।

— हैंड-ई-फूड

विधानसभा और popcount अनुदेश का उपयोग कर समाधान?

— ईयोनोहिटो

27

जे (11)

(\:+/"1@#:)

यह एक फ़ंक्शन है जो एक सूची लेता है:

     (\:+/"1@#:) 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

यदि आप इसे एक नाम देना चाहते हैं, तो इसके लिए एक अतिरिक्त चरित्र की लागत है:

     f=:\:+/"1@#:
     f 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

स्पष्टीकरण:

\:: नीचे की ओर छाँटें
+/: का योग
"1: की प्रत्येक पंक्ति
#:: बाइनरी प्रतिनिधित्व

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

5

@ ak82 यह एपीएल का एएससीआईआई संस्करण है

— जॉन ड्वोरक

3

@JDDvorak के प्रकार; काफी कुछ बदलाव हुए हैं: jsoftware.com/papers/j4apl.htm (भाषा अनुभाग देखें)।

— जेम्स वुड

3

वहाँ भी है \:1#.#:जो कुछ बाइट्स बचाता है।

— मील की दूरी पर

17

जावास्क्रिप्ट, ३ ९

अपडेट: अब रूबी से कम।

x.sort(q=(x,y)=>!x|-!y||q(x&x-1,y&y-1))

40

x.sort(q=(x,y)=>x&&y?q(x&x-1,y&y-1):x-y)

स्पष्टीकरण:

क्यू एक पुनरावर्ती कार्य है। यदि x या y 0 हैं, तो यह लौटाता है x-y(यदि x शून्य है तो एक ऋणात्मक संख्या या y शून्य है तो धनात्मक संख्या)। अन्यथा यह x&x-1x और y से सबसे कम बिट ( ) को हटाता है और दोहराता है।

पिछला संस्करण (42)

x.sort(q=(x,y)=>x^y&&!x-!y+q(x&x-1,y&y-1))

— प्रतिलिपि
स्रोत

यह वास्तव में चतुर है! मैं अभी भी अपने दिमाग को इसके चारों ओर लपेटने की कोशिश कर रहा हूं।

— mowwwalker

के ~yबजाय काम नहीं करना चाहिए -!y?

— टूथब्रश

@toothbrush अंतिम स्थिति यह है कि x या y 0 हैं, जिस स्थिति में अभिव्यक्ति !x|-!yगैर-शून्य हो जाती है। ~वास्तव में फिट नहीं है क्योंकि यह कई इनपुटों (शून्य सहित) के लिए गैर-शून्य है

— नकल करें

किसी को माध्यमिक छँटाई की आवश्यकता होने पर कृपया मेरी मदद कर सकते हैं ?

— मनुभर्गव

15

रूबी ४१

f=->a{a.sort_by{|n|-n.to_s(2).count(?1)}}

परीक्षा:

a = [28943, 825, 11746, 16375, 32425, 19944, 21826, 15752, 15342, 3944, 28436];
f[a]
=> [16375, 15342, 32425, 11746, 28436, 28943, 19944, 15752, 3944, 21826, 825]

— daniero
स्रोत

2

सरल। समझा जा सकता। कम। इस समाधान के लिए यश।

— पियरे अरलाउड

8

पायथन 3 (44):

def f(l):l.sort(lambda n:-bin(n).count('1'))

— ब्लेंडर
स्रोत

8

आम लिस्प, 35

logcountएक संख्या में 'ऑन-बिट्स' की संख्या देता है। एक सूची के लिए l, हमारे पास:

(sort l '> :key 'logcount)

CL-USER> (sort (list 16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826) '> :key 'logcount)
;=> (16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826)

एक स्टैंडअलोन फ़ंक्शन के रूप में, और मैं बाइट काउंट को आधार बनाऊंगा:

(lambda(l)(sort l'> :key'logcount))

— जोशुआ टेलर
स्रोत

7

पायथन 3, 90 77 72 67 अक्षर।

हमारा समाधान कमांड-लाइन से एक इनपुट लेता है, और अवरोही क्रम (67 वर्ण) या आरोही (66) में संख्या को प्रिंट करता है।

घटते क्रम में

print(sorted(input().split(),key=lambda x:-bin(int(x)).count("1"))) # 67

अंत में सरणी को उलटने के लिए एक स्लाइस का उपयोग करने के बजाय, इसे उलटने के लिए 1 की गिनती में माइनस का उपयोग करने के सुझाव के लिए @daniero को धन्यवाद ! इसने प्रभावी रूप से 5 वर्णों को बचाया।

बस इसे पोस्ट करने के लिए, आरोही क्रम संस्करण (जो हमने पहली बार बनाया था) एक वर्ण को कम लेगा।

आरोही क्रम :

print(sorted(input().split(),key=lambda x:bin(int(x)).count("1"))) # 66

@Bakuriu के लिए कुंजी = lambda x ... सुझाव के लिए धन्यवाद । ; D

— Jetlef
स्रोत

तो 0हमेशा अपने आउटपुट का एक हिस्सा होगा; यह सही नहीं है।

— डेनिएरो

मुझे उस प्रश्न में कुछ भी दिखाई नहीं देता है जो मुझे मूल्य डालने से रोकता है।

— जेटली

मैं करता हूं: " वर्णित के अनुसार समान पूर्णांकों की एक सरणी ।" ;) इसके अलावा, सिर्फ raw_input()कुछ पात्रों का उपयोग और ड्रॉप क्यों नहीं किया जाता है ?

— डेनिएरो

1

@daniero ने इसे ठीक किया। पायथन 3 पर स्विच करना (एक पायथन 2 उत्तर पहले से ही मौजूद था, बहुत ही रचनात्मक होगा!) मुझे इनपुट () का उपयोग करने की अनुमति देता है , जिससे दो वर्णों को बचाया जा सकता है (प्रिंट () ) द्वारा आवश्यक कोष्ठक के कारण दो जोड़े जा सकते हैं ।

— जेटली

तुम []भीतर गिरा सकते हो sorted। इसके अलावा इस प्रोग्राम का आउटपुट इनपुट सॉर्ट किए गए नंबरों में 1s की संख्या है, लेकिन आपको इनपुट में प्राप्त संख्या को आउटपुट करना चाहिए, सॉर्ट किए गए नंबर का उपयोग करके 1। कुछ इस तरह: print(sorted(input().split(), key=lambda x:bin(int(x)).count('1')))सही होगा।

— बाकुरि

7

जावास्क्रिप्ट [76 बाइट्स]

a.sort(function(x,y){r='..toString(2).split(1).length';return eval(y+r+-x+r)})

aसंख्याओं का इनपुट सरणी कहां है।

परीक्षा:

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(function(x, y) {
    r = '..toString(2).split(1).length';
    return eval(y + r + -x + r);
});

[16375, 15342, 32425, 19944, 11746, 28943, 28436, 15752, 3944, 21826, 825]

— दृष्टि
स्रोत

क्या आप बता सकते हैं कि कैसे ..काम करता है? मेरी समझ यह है कि अगर x = 5वह eval(x + r)बन जाता eval(5..toString(2).match(/1/g).length)है, तो मुझे लगता है, अमान्य है। धन्यवाद।

— गौरांग टंडन

1

@ गौरांगटंडन यह नहीं है। जैसा कि आप जानते हैं, जेएस में शाब्दिक को छोड़कर सब कुछ एक वस्तु है। और संख्या। तो सैद्धांतिक रूप से (और व्यावहारिक रूप से) आप डॉट नोटेशन के माध्यम से किसी भी गैर-शाब्दिक के गुणों या कॉल विधियों को प्राप्त कर सकते हैं, जैसा कि आप करते हैं 'string'.lengthया [1,2,3].pop()। संख्या के मामले में आप ऐसा कर सकते हैं लेकिन आपको यह ध्यान रखना चाहिए कि एक बिंदु के बाद पार्सर एक फ्लोट वैल्यू (जैसे 123.45) की अपेक्षा कर रहे संख्या के भिन्नात्मक भाग की तलाश करेगा । यदि आप एक पूर्णांक का उपयोग करते हैं, तो आपको उस पार्सर को "बताना" चाहिए जो एक भिन्नात्मक भाग खाली है, एक संपत्ति को संबोधित करने से पहले एक अतिरिक्त बिंदु सेट करना 123..method():।

— VisioN

1

आप दो बाइट्स को जीरो से हटाकर बाकी को दशमलव संख्या के रूप में मान सकते हैं। बदलें match(/1/g).lengthके साथ replace(/0/g,"")।

— डॉकमैक्स

@VisioN धन्यवाद! एक नई बात सीखी।

— गौरांग टंडन

1

a.sort(function(x,y){r='..toString(2).match(/1/g).length';return eval(y+r+-x+r)})

— l4m2

6

गणितज्ञ ३०

SortBy[#,-DigitCount[#,2,1]&]&

उपयोग:

SortBy[#,-DigitCount[#,2,1]&]&@
                           {19944,11746,15342,21826,825,28943,32425,16375,28436,3944,15752}

{16375, 15342, 32425, 11746, 19944, 28436, 28943, 3944, 15752, 825, 21826}

— डॉ। बेलिसरियस
स्रोत

6

k [15 शुल्क]

{x@|<+/'0b\:'x}

उदाहरण 1

{x@|<+/'0b\:'x}19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752

16375 15342 32425 28436 28943 11746 19944 15752 3944 825 21826

उदाहरण 2 (सभी संख्याएँ 2 ^ n -1 हैं)

{x@|<{+/0b\:x}'x}3 7 15 31 63 127

127 63 31 15 7 3

— NYI
स्रोत

5

गणितज्ञ ३ ९

IntegerDigits[#,2] 1 और 0 की सूची के लिए एक आधार 10 नंबर धर्मान्तरित।

Tr अंकों को बताता है।

f@n_:=SortBy[n,-Tr@IntegerDigits[#,2]&]

परीक्षण का मामला

f[{19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752}]

{16375, 15342, 32425, 11746, 19944, 28436, 28943, 3944, 15752, 825, 21826}

— DavidC
स्रोत

मैं उस (ab?) के शौकीन हूं, जो कि ट्रिंग [] का उपयोग गोल्फिंग कोड में करता है।

— माइकल स्टर्न

5

जावा 8 - 87/113 81/111 60/80 60/74/48 वर्ण

यह एक पूर्ण जावा कार्यक्रम नहीं है, यह सिर्फ एक फ़ंक्शन (सटीक होने के लिए एक विधि) है।

ऐसा नहीं है कि मान लिया गया है java.util.Listऔर java.lang.Long.bitCountआयात किए जाते हैं, और 60 कैरेक्टर हैं:

void s(List<Long>a){a.sort((x,y)->bitCount(x)-bitCount(y));}

यदि कोई पूर्व-आयातित सामान की अनुमति नहीं है, तो यह 74 वर्णों के साथ है:

void s(java.util.List<Long>a){a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

अधिक 7 वर्ण जोड़ें यदि यह आवश्यक होगा कि यह होना चाहिए static।

[४ साल बाद] या यदि आप चाहें, तो यह एक मेमना हो सकता है (धन्यवाद सुझाव के लिए @ केविनक्रूजसेन), ४ suggestion बाइट्स के साथ:

a->{a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

— विक्टर स्टैफ़ुसा
स्रोत

किसी भी कारण से आप ऐसा नहीं कर सकते Integer.bitCount(x)<Integer.bitCount(y)?-1:1;? क्या आपको -1,0,1व्यवहार की आवश्यकता है?

— जस्टिन

इसके अलावा, क्या <Integer>अंतरिक्ष के साथ प्रतिस्थापित करना संभव है?

— जस्टिन

आप यह भी उपयोग कर सकते हैं Long, कि कुछ जगह बचाओ :)

— RobAu

इसके अलावा a.sort((x,y)->Long.bitCount(x)-Long.bitCount(y));

— रॉबौ

1

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

— विक्टर स्टैफुसा

4

पायथन 2.x - 65 अक्षर (बाइट्स)

print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))

यह वास्तव में 66 अक्षर है, अगर हम इसे एक फ़ंक्शन बनाते हैं (तो आपको इसे कॉल करने के लिए कुछ चाहिए जो प्रस्तुत करने के लिए लामर है)।

f=lambda a:sorted(a,key=lambda x:-sum(int(d)for d in bin(x)[2:]))

बाश / सीएमडी में डेमो:

echo [16, 10, 7, 255, 65536, 5] | python -c "print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))"

— निक टी
स्रोत

आप बदल सकते हैं sum(int(d)for d in bin(x)[2:])करने के लिएsum(map(int,bin(x)[2:]))

— एलीशा

1

या यहां तक कि:print sorted(input(),key=lambda x:-bin(x).count('1'))

— एलिशा

4

मतलूब, ३४

'A' में इनपुट

[~,i]=sort(-sum(dec2bin(a)'));a(i)

नॉनगेटिव नंबर के लिए काम करता है।

— Fraktal
स्रोत

4

सी - 85 बाइट्स (108 106 बाइट्स)

GCC / Clang / जहाँ भी __builtin_popcountउपलब्ध हो पर पोर्टेबल संस्करण (106 बाइट्स):

#define p-__builtin_popcount(
c(int*a,int*b){return p*b)-p*a);}
void s(int*n,int l){qsort(n,l,sizeof l,c);}

अल्ट्रा-कंडेंस्ड, नॉन-पोर्टेबल, बमुश्किल कार्यात्मक MSVC- केवल संस्करण (85 बाइट्स):

#define p __popcnt
c(int*a,int*b){return p(*b)-p(*a);}
s(int*n,int l){qsort(n,l,4,c);}         /* or 8 as needed */

बाइट काउंट में शामिल पहली न्यूलाइन की वजह से #defineदूसरे जरूरी नहीं हैं।
कॉल करने का कार्य s(array, length)विशिष्टताओं के अनुसार है।
sizeofएक और 7 वर्णों को बचाने के लिए पोर्टेबल संस्करण में हार्डकोड कर सकता है , जैसे कुछ अन्य सी उत्तर ने किया। मुझे यकीन नहीं है कि लंबाई-प्रयोज्य अनुपात के संदर्भ में कौन सा सबसे लायक है, आप तय करते हैं।

— थॉमस
स्रोत

2

sizeof lएक बाइट बचाता है। बुरी तरह से बदसूरत #define p-__builtin_popcount(दूसरे को बचाने में मदद कर सकता है।

— बदसूरत

@ugoren सुझावों के लिए धन्यवाद! प्रीप्रोसेसर एक ऐसा हैक है, मुझे नहीं पता था कि ऐसा संभव है। अफसोस की बात है कि यह MSVC पर काम नहीं करता है, लेकिन हर बाइट मायने रखता है!

— थॉमस

4

पॉवरशेल v3, 61 58 53

$args|sort{while($_){if($_-band1){1};$_=$_-shr1}}-des

Cmdlet के लिए ScriptBlock Sort-Objectसंख्या के बाइनरी प्रतिनिधित्व में प्रत्येक 1 के लिए 1 की एक सरणी देता है। Sort-Objectप्रत्येक संख्या के लिए दी गई सरणी की लंबाई के आधार पर सूची को सॉर्ट करें।

निष्पादन हेतु:

script.ps1 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944

— Rynant
स्रोत

यही काम है। यह कैसे कार्य करता है? कैसा जादू '।' 'सरणी की लंबाई के आधार पर' आता है?

— माज़ी

''। ' इसके बाद आने वाले स्क्रिप्टब्लॉक को निष्पादित करता है। बाहरी स्क्रिप्टब्लॉक के आउटपुट के आधार पर सॉर्ट कमांड प्रकार। मुझे अब एहसास हुआ कि आंतरिक स्क्रिप्टब्लॉक की आवश्यकता नहीं है। देखें संपादित करें

— Rynant

$f={बेमानी है, while-> for, -band1-> %2, -des-> -dऔर अन्य गोल्फ चाल। यह स्पष्ट है। क्या आप बता सकते हैं कि कैसे काम करना है $args|sort{@(1,1,...,1)}? यही काम है! कैसे स्पष्ट के बिना सरणियों की तुलना करता है .Count? इसके बारे में कहां पढ़ना है? धन्यवाद!

— माज़ी

1

@ माज़ी, आप सही कह रहे हैं, मैंने अब बेमानी बिट्स को हटा दिया। यह सॉर्ट-ऑब्जेक्ट cmdlet का डिफ़ॉल्ट सॉर्टिंग है। देखें: help Sort-Object -Parameter propertyमुझे नहीं पता कि प्रकारों के लिए डिफ़ॉल्ट सॉर्टिंग संपत्ति कहाँ परिभाषित की गई है, लेकिन सरणियों के लिए यह गणना या लंबाई है।

— रयानंत

अच्छा अंदाजा। लेकिन $args|sort{while($_){if($_-band1){$_};$_=$_-shr1}}-desएक गलत परिणाम देता है। इसलिए, यह नहीं है Count। यह बहुत दिलचस्प है। एक बार फिर धन्यवाद।

— माज़ी

3

ईसीएमएस्क्रिप्ट 6, 61

मान लिया zगया इनपुट है

z.sort((a,b)=>{c=d=e=0;while(++c<32)d+=a>>c&1,e+=b>>c&1},e-d)

परीक्षण डेटा

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(
    (a,b)=>{
        c=d=e=0;
        while(++c<32)
            d+=a>>c&1,e+=b>>c&1
    },e-d
)

[16375, 15342, 32425, 11746, 19944, 28436, 28943, 15752, 3944, 21826, 825]

धन्यवाद, छोटे समाधान के लिए टूथब्रश।

— डैनी
स्रोत

1

मैंने सिर्फ आपके समाधान की कोशिश की है, लेकिन यह काम नहीं किया। यह संख्याओं को क्रमबद्ध नहीं करता है।

— टूथब्रश

@ टूथब्रश वुप्स। इसे पकड़ने के लिए धन्यवाद, अब काम करना चाहिए।

— डैनी

अच्छा कार्य! मुझें यह पसंद है।

— टूथब्रश

1

केवल 61 बाइट्स: z.sort((a,b)=>{c=d=e=0;while(++c<32)d+=a>>c&1,e+=b>>c&1},e-d)(और अप-वोट के लिए धन्यवाद)।

— टूथब्रश

1

मेरा समाधान अब आपके जैसा ही आकार का है!

— टूथब्रश

3

आर , 132 96 94 88 84 75 73 53 51 बाइट्स

-20 के जे। डो के कार्यान्वयन के लिए धन्यवाद -2 Giuseppe के लिए धन्यवाद

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

मेरी मूल पोस्ट:

pryr::f(rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))]))

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

इस परिणाम पर उतरने से पहले मैंने कई अलग-अलग तरीकों की कोशिश की।

मैट्रिक्स विधि: एक दो कॉलम मैट्रिक्स, इनपुट वेक्टर के साथ एक कॉलम, बाइनरी प्रतिनिधित्व के योग में से एक बनाया गया, फिर मैंने बाइनरी के योग पर सॉर्ट किया।

function(x){m=matrix(c(x,colSums(sapply(x,function(y){as.integer(intToBits(y))}))),nc=2,nr=length(x));m[order(m[,2],decreasing=T),]}

गैर-मैट्रिक्स: एहसास हुआ कि मैं मैट्रिक्स फ़ंक्शन को टॉस कर सकता हूं और इसके बजाय बाइनरी मानों का एक वेक्टर बना सकता हूं, उन्हें योग कर सकता हूं, उन्हें ऑर्डर कर सकता हूं, फिर इनपुट वेक्टर को फिर से व्यवस्थित करने के लिए ऑर्डर किए गए मानों का उपयोग कर सकता हूं।

function(x){m=colSums(sapply(x,function(y){as.integer(intToBits(y))}));x[order(m,decreasing=T)]}

छोटे - मोटे बदलाव

function(x){m=colSums(sapply(x,function(y)as.double(intToBits(y))));x[order(m,decreasing=T)]}

अधिक लघु परिवर्तन एक अर्धविराम द्वारा अलग किए गए दो के बजाय कोड की एक पंक्ति में पूरी चीज़ को परिवर्तित करता है।

function(x)x[order(colSums(sapply(x,function(y)as.double(intToBits(y)))),decreasing=T)]

योग विधिcolSums द्वारा बनाए गए बाइनरी मैट्रिक्स के साथ कॉलम को जोड़ने के बजाय sapply, मैंने sapply"समाप्त" से पहले कॉलम में तत्वों को जोड़ा ।

function(x)x[order(sapply(x,function(y)sum(as.double(intToBits(y)))),decreasing=T)]

रेव को घटाना मैं वास्तव में कम हो रही छोटा करने के लिए चाहता था, लेकिन मुझ पर आर squawks अगर मैं छोटा करने के लिए कोशिश decreasingमें orderसमारोह है, जो आदेश के रूप में वांछित पाने के लिए जरूरी हो गया था orderबढ़ाने के लिए चूक है, तो मुझे याद है revएक वेक्टर उल्टा करने के लिए कार्य करते हैं। यूरेका !!! अंतिम समाधान में पिछले परिवर्तन किया गया functionकरने के लिए pryr::f2 और बाइट्स को बचाने के लिए

function(x)rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))])

— Sumner18
स्रोत

1

53 बाइट्स

— जे। डिउ

1

51 बाइट्स @ जे। डो के उत्कृष्ट गोल्फ में सुधार!

— ग्यूसेप

2

हास्केल, 123 सी

import Data.List
import Data.Ord
b 0=[]
b n=mod n 2:b(div n 2)
c n=(n,(sum.b)n)
q x=map fst$sortBy(comparing snd)(map c x)

यह पहला तरीका है जिसे मैंने इसे हल करने के बारे में सोचा है, लेकिन मुझे यकीन है कि इसे करने का एक बेहतर तरीका है। इसके अलावा, अगर किसी को गोल्फिंग हास्केल आयात के तरीके के बारे में पता है, तो मुझे यह सुनने में बहुत दिलचस्पी होगी।

उदाहरण

*Main> q [4,2,15,5,3]
[4,2,5,3,15]
*Main> q [7,0,2]
[0,2,7]

असम्बद्ध संस्करण (स्पष्टीकरण के साथ)

import Data.List
import Data.Ord

-- Converts an integer into a list of its bits
binary 0 = []
binary n = mod n 2 : binary (div n 2)

-- Creates a tuple where the first element is the number and the second element
-- is the sum of its bits.
createTuple n = (n, (sum.binary) n)

-- 1) Turns the list x into tuples
-- 2) Sorts the list of tuples by its second element (bit sum)
-- 3) Pulls the original number out of each tuple
question x = map fst $ sortBy (comparing snd) (map createTuple x)

— danmcardle
स्रोत

इसके लिए इन्फ़िक्स संकेतन का उपयोग करने के लिए मददगार होगा mod, n`mod`2? इसका गुणन और विभाजन के समान पूर्वता है।

— जॉन ड्वोरक

जहाँ तक मैं देख सकता हूँ गोल्फिंग कारणों से यह बहुत उपयोगी नहीं होगा। मैं दो रिक्त स्थान खो सकता हूँ, लेकिन दो backticks प्राप्त करें, है ना?

— danmcardle

डेटा आयात करें। डेटा आयात करें। डेटा आयात करें। डेटा आयात करें; क्यू = छंटनी (पॉपकॉइन की तुलना) - 80 सी - या अपने दृष्टिकोण का उपयोग कर, आयात करें। डेटा आयात करें। डेटा आयात करें; बी 0 = 0; बीएन = (मॉड एन) 2) + b (div n 2); q = SortBy (b की तुलना) - 86C

— bazzargh

मैंने पूरी तरह से आयात से बचने की कोशिश की, सबसे अच्छा मैं प्रबंधन कर सकता था 87C गोल्फिंग एस्कॉर्ट द्वारा: b 0 = 0; bn = mod n 2 + b (div n 2); q [] = []; q (a: c) = f; (ba>)। b) c ++ a: f ((ba <=)। b) c; f = (q)। फ़िल्टर

— bazzargh

2

कॉफीस्क्रिप्ट (94)

पठनीय कोड (212):

sort_by_ones_count = (numbers) ->
  numbers.sort (a, b) ->
    a1 = a.toString(2).match(/1/g).length
    b1 = b.toString(2).match(/1/g).length
    if a1 == b1
      0
    else if a1 > b1
      1
    else
      -1

console.log sort_by_ones_count [825, 3944, 11746, 15342, 15752, 16375, 19944, 21826, 28436, 28943, 32425]

अनुकूलित (213):

count_ones = (number) -> number.toString(2).match(/1/g).length
sort_by_ones_count = (numbers) -> numbers.sort (a, b) ->
  a1 = count_ones(a)
  b1 = count_ones(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

ऑबफसकेटिंग (147):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

टर्नरी ऑपरेटर अत्यधिक लंबे होते हैं (129):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (0+(a1!=b1))*(-1)**(0+(a1>=b1))

अभी तक बहुत, कास्टिंग बंद करो (121):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (-1)**(a1>=b1)*(a1!=b1)

अंतिम (94):

c=(n)->n.toString(2).match(/1/g).length
s=(n)->n.sort((a, b)->(-1)**(c(a)>=c(b))*(c(a)!=c(b)))

— हारून जे
स्रोत

2

स्मॉलटॉक (स्मॉलटाक / एक्स), 36 (या शायद 24)

में इनपुट; विनाशकारी तरीके से एक में:

a sort:[:a :b|a bitCount>b bitCount]

कार्यात्मक संस्करण: एक नया क्रमबद्ध सरणी देता है:

a sorted:[:a :b|a bitCount>b bitCount]

24 वर्णों में एक छोटा संस्करण ( नाम या फ़ंक्शन को तर्क के रूप में पारित करना ) भी है। लेकिन (उच्छ्वास) यह उच्चतम अंतिम क्रमबद्ध होगा। जैसा कि मैंने समझा, यह नहीं पूछा गया था, इसलिए मैं इसे गोल्फ स्कोर के रूप में नहीं लेता हूं:

a sortBySelector:#bitCount

— blabla999
स्रोत

2

PHP 5.4+ 131

मुझे यह भी नहीं पता कि मैं इस मामले में PHP से परेशान क्यों हूं:

<?unset($argv[0]);usort($argv,function($a,$b){return strcmp(strtr(decbin($b),[0=>'']),strtr(decbin($a),[0=>'']));});print_r($argv);

उपयोग:

> php -f sortbybinaryones.php 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
Array
(
    [0] => 16375
    [1] => 15342
    [2] => 32425
    [3] => 28436
    [4] => 19944
    [5] => 11746
    [6] => 28943
    [7] => 3944
    [8] => 15752
    [9] => 825
    [10] => 21826
)

— निर्णायक डब्बलर
स्रोत

ठीक है, किसी को PHP

— Einacio

2

स्काला, ५,

def c(l:List[Int])=l.sortBy(-_.toBinaryString.count(_>48))

— ValarDohaeris
स्रोत

2

DFSORT (IBM मेनफ्रेम सॉर्टिंग उत्पाद) 288 (प्रत्येक स्रोत लाइन 72 वर्ण है, स्थिति एक में स्थान होना चाहिए)

 INREC IFTHEN=(WHEN=INIT,BUILD=(1,2,1,2,TRAN=BIT)), 
       IFTHEN=(WHEN=INIT,FINDREP=(STARTPOS=3,INOUT=(C'0',C'')))
 SORT FIELDS=(3,16,CH,D) 
 OUTREC BUILD=(1,2)

सिर्फ मनोरंजन के लिए, और कोई गणित नहीं।

एक फ़ाइल लेता है (पूर्णांक के साथ एक "सरणी" का उपयोग करने वाले प्रोग्राम से निष्पादित किया जा सकता है)। छँटाई करने से पहले, यह पूर्णांकों को बिट्स में (एक 16-वर्ण क्षेत्र में) अनुवादित करता है। फिर बिट्स में 0s को कुछ नहीं बदलता है। बदले हुए बिट्स के परिणाम पर उतरना। केवल पूर्णांकों के साथ क्रमबद्ध फ़ाइल बनाता है।

— बिल वुडगेर
स्रोत

2

सी

void main()
{
 int a[]={7,6,15,16};
 int b,i,n=0;
 for(i=0;i<4;i++)
 {  for(b=0,n=0;b<=sizeof(int);b++)
      (a[i]&(1<<b))?n++:n;   
    a[i]=n;
 }
 for (i = 1; i < 4; i++) 
  {   int tmp = a[i];
      for (n = i; n >= 1 && tmp < a[n-1]; n--)
         a[n] = a[n-1];
      a[n] = tmp;
  }    
}

— वेंकटेश के
स्रोत

4

चूंकि यह एक कोड गोल्फ प्रतियोगिता है, इसलिए आपको अपने कोड को छोटा करने का प्रयास करना चाहिए।

— टाइमटेक

2

सी #, 88 89

int[] b(int[] a){return a.OrderBy(i=>-Convert.ToString(i,2).Count(c=>c=='1')).ToArray();}

संपादित करें: अवरोही क्रम एक वर्ण जोड़ता है।

— रिक
स्रोत

2

जावास्क्रिप्ट 84

अन्य जावास्क्रिप्ट जवाबों से प्रेरित, लेकिन eval और regex के बिना।

var r=(x)=>(+x).toString(2).split('').reduce((p,c)=>p+ +c)
[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort((x,y)=>r(x)-r(y));

— Vittore
स्रोत

प्रश्न कोड गोल्फ है, कृपया अपने कोड को 'गोल्फ' करने का प्रयास करें: अनावश्यक व्हाट्सएप को हटा दें और अपने कोड को यथासंभव छोटा बनाने का प्रयास करें। इसके अलावा, अपने उत्तर में एक वर्ण गणना शामिल करें।

— प्रोग्रामफॉक्स

2

जावास्क्रिप्ट (82)

a.sort(function(b,c){q=0;while(b|c){b%2?c%2?0:q++:c%2?q--:0;b>>=1;c>>=1}return q})

— mowwwalker
स्रोत

2

पोस्टस्क्रिप्ट, 126

क्योंकि हमारे द्वारा सॉर्ट किए जाने वाले मानों की सूची पहले से और बहुत सीमित (32) के रूप में जानी जाती है, यह कार्य आसानी से किया जा सकता है, भले ही 1..32 के लिए मिलान मूल्यों को उठाकर, छँटाई के लिए कोई अंतर्निहित न हो। (क्या यह ओ (32 एन) है? शायद)।

प्रक्रिया ढेर पर सरणी की उम्मीद करती है और 'क्रमबद्ध' सरणी देता है।

/sort_by_bit_count {
    [ exch
    32 -1 1 {
        1 index
        {
            dup 2 32 string cvrs
            0 exch
            {48 sub add} forall
            2 index eq 
            {3 1 roll} {pop} ifelse
        } forall
        pop
    } for
    pop ]
} def

या, श्वेत स्थान और पठनीयता का संस्कार छीन लिया गया:

/s{[exch 32 -1 1{1 index{dup 2 32 string cvrs 0 exch{48 sub add}forall 2 index eq{3 1 roll}{pop}ifelse}forall pop}for pop]}def

फिर, यदि bits.psइसे सहेजा जाता है तो इसका उपयोग इस तरह किया जा सकता है:

gs -q -dBATCH bits.ps -c '[(%stdin)(r)file 1000 string readline pop cvx exec] s =='
825 3944 11746 15342 15752 16375 19944 21826 28436 28943 32425
[16375 15342 32425 11746 19944 28436 28943 3944 15752 825 21826]

मुझे लगता है कि यह प्रभावी रूप से इस पर्ल के समान है (यहां अभी तक कोई पर्ल नहीं है, भी):

sub f{map{$i=$_;grep{$i==(()=(sprintf'%b',$_)=~/1/g)}@_}reverse 1..32}

हालांकि कि , पोस्टस्क्रिप्ट के विपरीत, आसानी से golfed जा सकता है:

sub f{sort{j($b)-j($a)}@_}sub j{$_=sprintf'%b',@_;()=/1/g}

— user2846289
स्रोत

परिशिष्ट भाग! मेरा पहला प्यार, अब तक की मेरी पसंदीदा भाषा! वन ट्रू प्रोग्रामिंग लैंग्वेज में दूसरे विश्वासी को देखना अच्छा लगता है।

— AJMansfield

2

C - 124 111

एक विधि के रूप में लागू किया गया है और छँटाई के लिए मानक पुस्तकालय का उपयोग कर रहा है। सरणी और आकार के लिए एक संकेतक को पैरामीटर के रूप में पारित किया जाना चाहिए। यह केवल 32-बिट पॉइंटर्स वाले सिस्टम पर काम करेगा। 64-बिट सिस्टम पर, कुछ पात्रों को सूचक परिभाषाओं को निर्दिष्ट करने में खर्च करना पड़ता है।

पठनीयता के लिए इंडेंटेशन

c(int*a,int*b){
    int d,e,i;
    for(d=e=i=0;i-32;){
        d+=*a>>i&1;e+=*b>>i++&1;
    }
    return d>e?-1:d<e;
}
o(r,s){qsort(r,s,4,c);}

नमूना कॉल:

main() {
    static int a[] ={1, 2, 3, 4, 5, 6, 7, 8, 9};
    o(a, 9);
}

— Allbeert
स्रोत

2

जावा 8: 144

static void main(String[]a){System.out.print(Stream.of(a).mapToInt(Integer::decode).sorted(Comparable.comparing(Integer::bitCount)).toArray());}

विस्तारित रूप में:

static void main(String[] args){
    System.out.print(
        Stream.of(args).mapToInt(Integer::decode)
              .sorted(Comparable.comparing(Integer::bitCount))
              .toArray()
        );
}

जैसा कि आप देख सकते हैं, यह argsएक में कनवर्ट करके काम करता है Stream<String>, फिर फ़ंक्शन संदर्भ (कम या अधिक ) के Stream<Integer>साथ परिवर्तित करके , और फिर सॉर्ट करके , फिर इसे एक सरणी में डालकर, और इसे प्रिंट करके।Integer::decodeparseIntvalueOfInteger::bitCount

धाराएँ सब कुछ आसान बनाती हैं।

— AJMansfield
स्रोत

बाइनरी 1 की गिनती द्वारा संख्याओं को क्रमबद्ध करें

लक्ष्य

उदाहरण क्रमबद्ध सूची

इनपुट

उत्पादन

स्कोरिंग

जे (11)

जावास्क्रिप्ट, ३ ९

रूबी ४१

पायथन 3 (44):

आम लिस्प, 35

पायथन 3, 90 77 72 67 अक्षर।

जावास्क्रिप्ट [76 बाइट्स]

गणितज्ञ ३०

k [15 शुल्क]

उदाहरण 1

उदाहरण 2 (सभी संख्याएँ 2 ^ n -1 हैं)

गणितज्ञ ३ ९

जावा 8 - 87/113 81/111 60/80 60/74/48 वर्ण

पायथन 2.x - 65 अक्षर (बाइट्स)

मतलूब, ३४

सी - 85 बाइट्स (108 106 बाइट्स)

पॉवरशेल v3, 61 58 53

ईसीएमएस्क्रिप्ट 6, 61

आर , 132 96 94 88 84 75 73 53 51 बाइट्स

हास्केल, 123 सी

उदाहरण

असम्बद्ध संस्करण (स्पष्टीकरण के साथ)

कॉफीस्क्रिप्ट (94)

स्मॉलटॉक (स्मॉलटाक / एक्स), 36 (या शायद 24)

PHP 5.4+ 131

स्काला, ५,

सी

सी #, 88 89

जावास्क्रिप्ट 84

पोस्टस्क्रिप्ट, 126

C - 124 111

जावा 8: 144