21

सकारात्मक पूर्णांकों की सूची को देखते हुए, हम उन्हें [2, 6, 9, 4]उदाहरण के तौर पर एक दूसरे के ऊपर लिख सकते हैं :

हम इसे एक दीवार के रूप में कल्पना कर सकते हैं:

..#.
.##.
#..#
.#..

हालांकि, यह एक बहुत कमजोर दीवार है, और यह ढह गई है! प्रत्येक 1( #) नीचे गिर जाता है जब तक कि यह "ग्राउंड" या अन्य 1( #) को हिट नहीं करता है । 0S ( .रों) स्पॉट ले जाई गईं द्वारा छोड़ा में मौजूद हैं 1रों।

यह निम्नलिखित हो जाता है:

....
....
.##.
####

जो वापस अनुवाद करता है:

जो, संख्याओं की सूची के रूप में है [0, 0, 6, 15]।

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

[10, 17, 19, 23]

यह बन जाता है:

जो बन जाता है:

अनुवाद करने के लिए वापस:

[0, 19, 19, 31]

चुनौती

सकारात्मक पूर्णांक की एक सूची को देखते हुए, इस परिवर्तन को सूची में लागू करें। किसी भी उचित प्रारूप में सकारात्मक पूर्णांक की सूची के रूप में इनपुट / आउटपुट। मानक खामियां लागू होती हैं।

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

— HyperNeutrino
स्रोत

सैंडबॉक्स पोस्ट

— हाइपरनेत्रिनो

1

अधिक टेस्टेसिस? तुम्हें पता है, गैर-स्क्वायर टेस्टकेस अच्छा होगा।

— लीक नन

@LeakyNun ज़रूर। वह में स्वयं कर लूँगा।

— हाइपरनेत्रिनो

यह बिट सरणियों के लिए सिर्फ एक छँटाई समस्या है।

— मार्कस मूलर

@ MarcusMüller आप सही हैं - मुझे एहसास हुआ कि MATL जवाब के बाद: P

— HyperNeutrino

29

MATL , 4 बाइट्स

BSXB

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

व्याख्या

    % Implicitly grab input as an array 
    %   STACK: [10, 17, 19, 23]
B   % Convert each element to binary where each decimal number results in a row
    %   STACK: [0 1 0 1 0;
    %           1 0 0 0 1;
    %           1 0 0 1 1;
    %           1 0 1 1 1]
S   % Sort each column, placing all of the 1's at the bottom of each column
    %   STACK: [0 0 0 0 0;
    %           1 0 0 1 1;
    %           1 0 0 1 1;
    %           1 1 1 1 1] 
XB  % Convert each row from its binary representation to its decimal number
    %   STACK: [0, 19, 19, 31]
    % Implicitly display the result

— Suever
स्रोत

o_O यह कैसे काम करता है: o

— हाइपरनेत्रिनो

1

क्या MATL सिर्फ 4 बाइट्स से गोल्फ जेली करता है ? o_O

— बिलकुल अमानवीय

5 बाइट्स अब :

— लीक नून

मैंने कभी नहीं सोचा था कि लोगों को नीचे की ओर ले जाने के लिए एक बिल्ट-इन xD +1 होगा

— HyperNeutrino

1

@totallyhuman अच्छी तरह से, डेनिस के आने तक प्रतीक्षा करें

— जंगवान मिन

5

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

f=lambda a:a and[x|y&a[0]for x,y in zip([0]+f(a[1:]),f(a[1:])+[-1])]

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

— एंडर्स कसीगोर
स्रोत

5

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

f=a=>a.map(_=>a.map((e,i)=>a[a[i]|=a[--i],i]&=e))&&a

व्याख्या: मान लीजिए कि दीवार की दो पंक्तियाँ इस तरह थीं:

0011
0101

परिणाम यह होना चाहिए:

0001
0111

दूसरे शब्दों में, पहली पंक्ति दो पंक्तियों की AND बन जाती है और दूसरी पंक्ति OR की दो पंक्तियों की बन जाती है। यह बस सभी बिट्स के तल पर गिरने के लिए पर्याप्त समय दोहराया जाना चाहिए।

— नील
स्रोत

4

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

BUz0Ṣ€ZUḄ

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

— लीक नन
स्रोत

2

जाप , 16 बाइट्स

m¤z3 ®¬n qÃz mn2

इसे ऑनलाइन आज़माएं! -Qसरणी परिणाम को प्रारूपित करने के लिए ध्वज का उपयोग करना ।

व्याख्या

m¤z3 ®¬n qÃz mn2    Implicit: U = input array.
                        [10, 17, 19, 23]
m¤z3                Map U to binary strings and rotate the array left 90°
                         1010       0111
                        10001   ->  1011
                        10011       0001
                        10111       1000
                                     111
®¬n qÃ              Sort each binary string, putting 0s and spaces at the start
                        0111
                        0111
                        0001
                        0001
                         111
z mn2               Rotate right 90° and convert each back to a number
                         0000       0
                        10011   ->  19
                        10011       19
                        11111       31
                    Implicit output of resulting array

— जस्टिन मेरिनर
स्रोत

मैं लगता है कि आप के साथ एक बाइट बचा सकता हैmì2 z3 mn z mì2

— ETHproductions

@ETHproductions यह 2 डी सरणी को घुमाता हुआ प्रतीत होता है, इसके बजाय स्ट्रिंग्स के सरणी को घुमाते हुए, प्रत्येक आंतरिक सरणी nullको रिक्त स्थान के बजाय पैड के साथ घुमाएं । तो यह काम करने के लिए प्रतीत नहीं होता है। और रिक्त स्थान के विपरीत, एस nullके दाईं ओर क्रमबद्ध है 1, जो बाईं ओर क्रमबद्ध हैं।

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

2

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

#~FromDigits~2&/@(Sort/@(PadLeft[#~IntegerDigits~2&/@#]))&

 है \[Transpose]

यह इनपुट (संख्याओं की एक सूची) को अंकों की सूची की सूची में परिवर्तित करता है, इसे एक वर्ग मैट्रिक्स होने के लिए पैड करता है, इसे स्थानांतरित करता है, पंक्तियों को नीचे की ओर 1 "गिरता" है, वापस स्थानांतरित करता है, फिर संख्याओं में परिवर्तित करता है। ।

— DanTheMan
स्रोत

2

पायथन 3.5 , 60 बाइट्स

def f(a,*t):
 if t:b,*r=f(*t);t=f(a|b,*r);a&=b
 return(a,*t)

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

जैसे इनपुट लेता है f(2, 6, 9, 4)। माना जाता है कि इनपुट गैर-रिक्त है। बहुत सारे टपल अनपैकिंग का उपयोग करता है ।

— XNOR
स्रोत

2

ऑक्टेव, 29 25 बाइट्स

4 बाइट्स @Stewie की बदौलत बच गए

@(x)bi2de(sort(de2bi(x)))

— Suever
स्रोत

de2bi/bi2deऑक्टेव में 4 बाइट बचाता है। Octave-online.net पर काम करता है।

— स्टिव ग्रिफ़िन

@StewieGriffin धन्यवाद!

— स्वेवर

1

जे , 13 बाइट्स

/:~"1&.|:&.#:

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

व्याख्या

/:~"1&.|:&.#:  Input: array M
           #:  Convert each in M to binary with left-padding
       |:&     Transpose
/:~"1&         Sort each row
     &.|:      Inverse of transpose (which is just transpose)
         &.#:  Inverse of converting to binary

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

बाइनरी ले-पेडिंग फिर से, +1 है। और यह भी, क्या आप बता सकते हैं कि आपको ट्रांसपोज़ के व्युत्क्रम का उपयोग करने की आवश्यकता क्यों है, क्योंकि यह सिर्फ ट्रांसपोज़ है?

— Zacharý

@ Zacharý व्युत्क्रमों का उपयोग प्रत्येक पंक्ति को छाँटने से पहले उपयोग किए गए कार्यों को पूर्ववत करने के लिए किया जाता है। यह सही है कि ट्रांसवर्स का उलटा सिर्फ ट्रांसपोज़ होता है, लेकिन इसे देखने का एक और तरीका यह है <convert from binary> <transpose> <sort each row> <transpose> <convert to binary> M, जहां पहले दो फंक्शंस सिर्फ पिछले दो के व्युत्क्रम हैं।

— मील

1

05AB1E , 9 बाइट्स

bí0ζR€{øC

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

जादू से अलग एल्गोरिथ्म Kinda।

— आउटगोल्फर को एरिक करें
स्रोत

ζ, लानत है। हटा दिया मेरा, ले मेरे +1।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn आपने अपना डिलीट क्यों किया? कोई आवश्यता नहीं।

— निकोलग्राफ जूल

यह वास्तव में बहुत अलग नहीं है (एल्गोरिथम के संदर्भ में) और यह 25% बेहतर था।

— मैजिक ऑक्टोपस Urn

1

दिल्लोग एपीएल, 24 21 19 बाइट्स

2⊥↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⎕

इसे ऑनलाइन आज़माएं! (संशोधित तो TryAPL इसे मान्य के रूप में स्वीकार करता है)

कैसे?

⎕ मूल्यांकन किया गया इनपुट (सरणियाँ अंतरिक्ष अलग हैं)
2⊥⍣¯1⊢ प्रत्येक तर्क को बाइनरी में कनवर्ट करता है (प्रश्न में क्या है इसका ट्रांसपोज़्ड)
↓ वैक्टर के वेक्टर में एक 2 डी सरणी बदल जाता है
{⍵[⍋⍵]}¨ वेक्टर के तत्वों में से प्रत्येक को सॉर्ट करें
↑ वेक्टर के वेक्टर को फिर से एक 2 डी सरणी में बदल देता है
2⊥ बाइनरी से कन्वर्ट (चूंकि यह इसे स्थानांतरित करता है, हम सही परिणाम पर पहुंचते हैं)

— जाकारी
स्रोत

1

दिल्लोग एपीएल (23 अक्षर)

{2⊥¨↓⍉↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⍵}

एक बाइनरी मैट्रिक्स में इनपुट तर्कों को परिवर्तित करें
मैट्रिक्स को कॉलम में विभाजित करें
स्तंभों को आरोही क्रम में क्रमबद्ध करें
दशमलव में छंटनी पंक्तियों को वापस कन्वर्ट करें

उदाहरण

  {2⊥¨↓⍉↑{⍵[⍋⍵]}¨↓2⊥⍣¯1⊢⍵}10 17 19 23
      0 19 19 31

मुझे इस पर सही करने के लिए Zacharý का धन्यवाद।

— जेम्स हेस्लिप
स्रोत

आप के साथ की जगह ले सकता (⊥⍣¯1)⍵साथ ⊥⍣¯1⊢⍵। इसके अलावा, मुझे नहीं लगता कि आपको विभाजन ( ↓[1]=> ↓) पर अक्ष विनिर्देश की आवश्यकता है ।

— जकार्इ

ओह, और आप इसे वापस एक सूची में बदलने वाले हैं!

— जकार्इ

यह अमान्य है।

— ज़ाचरी

धन्यवाद, Zacharý, मैं कल देर रात इस पर काम कर रहा था और मुझे लगता है कि मैंने इस समस्या को गलत बताया। मैंने अपना समाधान संशोधित कर लिया है।

— जेम्स हेस्लिप

1

अच्छा, अच्छा काम! ( ⊥⍣¯1वास्तव में एक बिलियन होने की जरूरत है)। और वास्तव में मेरा उपयोगकर्ता नाम सही पाने के लिए धन्यवाद।

— ज़चारि

0

जावास्क्रिप्ट, 127 125 बाइट्स

a=>a[m='map'](_=>b[m]((n,i)=>n&&(b[i]--,d|=1<<i),d=0)&&d,b=[...Array(32)][m]((_,c)=>a[m](e=>d+=!!(2**c&e),d=0)&&d)).reverse()

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

-2 बाइट्स गायों को धन्यवाद

(1<<c)&eबन सकते हैं2**c&e

— क्रिति लिथोस

0

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

... और अभी भी गोल्फ ... उम्मीद है कि किसी भी मदद की सराहना की!

def c(l):b=[bin(n)[2:]for n in l];print[int(n,2)for n in map(''.join,zip(*map(sorted,zip(*['0'*(len(max(b,key=len))-len(x))+x for x in b]))))]

इसका एक बड़ा हिस्सा शून्य के साथ संख्याओं को रखने के लिए है।

अधिक पठनीय:

def collapse(nums):
    bins = [bin(n)[2:] for n in nums]
    bins = [('0'*(len(max(bins, key = len)) - len(x))) + x for x in bins]
    print [int(n, 2) for n in map(''.join, zip(*map(sorted, zip(*bins))))]

यह बाइनरी स्ट्रिंग प्रतिनिधित्व का एक सरणी बनाता है, इसे पैड करता है, इसे 90º दक्षिणावर्त घुमाता है, प्रत्येक पंक्ति को सॉर्ट करता है, इसे 90 then पर वापस घुमाता है, और फिर प्रत्येक पंक्ति से पूर्णांक बनाता है।

— डैनियल
स्रोत

142 बाइट्स , आपके पास कुछ निरर्थक कोष्ठक हैं।

— मिस्टर एक्सकोडर

@ Mr.Xcoder, ओह हाँ जो मूर्खतापूर्ण था

— डैनियल

कमजोर बाइनरी दीवारें

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

चुनौती

MATL , 4 बाइट्स

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

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

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

जाप , 16 बाइट्स

व्याख्या

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

पायथन 3.5 , 60 बाइट्स

ऑक्टेव, 29 25 बाइट्स

जे , 13 बाइट्स

व्याख्या

05AB1E , 9 बाइट्स

दिल्लोग एपीएल, 24 21 19 बाइट्स

कैसे?

दिल्लोग एपीएल (23 अक्षर)

उदाहरण

जावास्क्रिप्ट, 127 125 बाइट्स

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