कार्य सरल है: एक सरणी की एक पंक्ति को समेकित करें। इस सरणी को समेकित करने में निम्नलिखित शामिल हैं:

0 के सभी उदाहरणों को सरणी के अंत में ले जाने की आवश्यकता है।
गैर-शून्य पूर्णांक के बीच कोई 0s नहीं होना चाहिए।
सभी गैर-शून्य सूचकांकों को अपने आदेश को बनाए रखना चाहिए।

चुनौती

किसी सरणी को कम से कम बाइट में समेकित करें।

आप यादृच्छिक पूर्णांकों के साथ अपनी भाषा के अधिकतम आकार के साथ यादृच्छिक लंबाई की एक सरणी को समेकित कर रहे हैं। इनपुट आपकी भाषा के लिए कोई भी प्राकृतिक तरीका हो सकता है।

उदाहरण

इनपुट

0 5 8 8 3 5 1 6 8 4 0 3 7 5 6 4 4 7 5 6 7 4 4 9 1 0 5 7 9 3 0 2 2 4 3 0 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 0 5 0 6 0 3

उत्पादन

5 8 8 3 5 1 6 8 4 3 7 5 6 4 4 7 5 6 7 4 4 9 1 5 7 9 3 2 2 4 3 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 5 6 3 0 0 0 0 0 0 0 0

इनपुट

-1 -7 -6 5 1 -5 -2 7 -3 -8 0 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 0 -5 -7 3 8 1 1 3 -3 -2 -2 0 -7 0 -4 8 6 -3 6 0 5 3 2 2 2 -2 -7 -3 9 -1 6 0 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 0 3 3 7 -1 -5 1 -3 4 -7 0 3 2 -2 7 -3 0 0 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7

उत्पादन

-1 -7 -6 5 1 -5 -2 7 -3 -8 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 -5 -7 3 8 1 1 3 -3 -2 -2 -7 -4 8 6 -3 6 5 3 2 2 2 -2 -7 -3 9 -1 6 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 3 3 7 -1 -5 1 -3 4 -7 3 2 -2 7 -3 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7 0 0 0 0 0 0 0 0 0 0

उदाहरण कोड (जावा)

public class Consolidate {
    public static void main(String[] args) throws Exception {
        int[] toConsolidate = new int[args.length];
        for (int i=0; i<args.length; i++){
            toConsolidate[i]=Integer.parseInt(args[i]);
        }
        for (int i=0; i<toConsolidate.length; i++) {
            for (int k=0; k<toConsolidate.length-1; k++) {
                if (toConsolidate[k] == 0){
                    toConsolidate[k] = toConsolidate[k+1];
                    toConsolidate[k+1] = 0;
                }
            }
        }
        for (int i:toConsolidate)
            System.out.print(i+" ");
    }
}

code-golf array-manipulation

— एडिसन क्रम्प
स्रोत

किसी भी पूर्णांक या उदाहरण की तरह एकल अंक?

— edc65

@ edc65 कोई भी पूर्णांक जो आपकी भाषा का समर्थन करता है।

— Addison Crump

उदाहरण कितना जटिल हो सकता है जब सबसे छोटे उत्तर 3 वर्ण लंबे हों? क्या जावा बहुत क्रिया है?

— AL

7

"गैर-शून्य पूर्णांक के बीच कोई 0s नहीं होना चाहिए।" निरर्थक?

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

1

इस चुनौती के लिए @immibis सही भाषा नहीं हो सकती है। : P

— Addison Crump

31

अजगर, 3 बाइट्स

!DQ

स्पष्टीकरण:

  Q    Input
!D     Sort by logical NOT

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

Qकिसी भी पाइथ स्क्रिप्ट के अंत में निहित किया जा सकता है (यह एक मेमने के बाहर है, जो यह है), यह 2 बाइट्स बनाते हैं।

— hakr14

@ hakr14 यह सुविधा 2 साल पहले मौजूद नहीं थी।

— डेनिस

12

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

¬Ụị

सूची को उसके मानों के तार्किक नहीं के द्वारा सूचीबद्ध करता है। इसे ऑनलाइन आज़माएं!

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

¬Ụị    Main link. Input: A (list)

¬      Compute the logical NOT of each element of A.
 Ụ     Grade up; sort the resulting list's indices by their corresponding values.
  ị    Retrieve the elements of A at that indices.

— डेनिस
स्रोत

1

ओह हे, आधुनिक जेली एक 2-बाइट कर सकती है ¬Þ, यहां तक कि!

— लिन

10

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

@(A)[A(~~A) A(~A)]

sort()बहुत सारे बाइट्स लेता है। मैं सिर्फ तार्किक अनुक्रमण का उपयोग करूँगा।

आइडोन पर उदाहरण ।

— बीकर
स्रोत

अच्छी तरह से किया। +1।

— रायरेंग - मोनिका

वाह, मतलब में भी काम करता है! मुझे नहीं पता था कि इस तरह की अनुक्रमण संभव है

— brainkz

9

आर, 29 23 21 बाइट्स

जैसा कि MarcoBreitig द्वारा उल्लेख किया गया है, हम इसे 21 बाइट्स तक छोटा कर सकते हैं यदि हमें इसे फ़ंक्शन के रूप में प्रदान करने की आवश्यकता नहीं है:

x=scan();x[order(!x)]

पिछला संस्करण:

function(x)x[order(!x)]

फ़ंक्शन वेक्टर को इनपुट के रूप में लेता है और तार्किक वेक्टर द्वारा आदेश देता है जो इनपुट को नकारने से उत्पन्न होता है।

मूल उत्तर:

function(x)c(x[x!=0],x[x==0])

फ़ंक्शन इनपुट के रूप में एक वेक्टर लेता है और c()गैर-शून्य मान और फिर शून्य मान चलाता है।

— docendo डिस्कस
स्रोत

2

x = स्कैन (); x [क्रम (! x)] केवल २१ बाइट्स लंबा है।

— मार्को ब्रेइटिग

@MarcoBreitig, यह सही है। मैंने सोचा कि यह एक समारोह होना चाहिए (और शुरू में, आवश्यकता एक "पूर्ण विकसित कार्यक्रम" थी)। मेरे उत्तर को अपडेट करेगा

— docendo discimus

8

रेटिना , १५

सरल दोहराया regex प्रतिस्थापन:

+`\b0 (.*)
$1 0

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

— डिजिटल आघात
स्रोत

1

मैंने अपने जावा उत्तर में एक ही विधि का उपयोग किया (यदि मैं यह सही पढ़ रहा हूं)। : D

— Addison Crump

7

ईएस 6, 23 बाइट्स

a=>a.sort((x,y)=>!x-!y)

यह ऐसा मामला हुआ करता sortथा जो स्थिर नहीं था, जिस स्थिति में आपको 41 बाइट की आवश्यकता थी:

a=>a.filter(x=>x).concat(a.filter(x=>!x))

— नील
स्रोत

6

पायथन बाइट कोड (2.7.9), 252 बाइट्स, 33 ऑपकोड, 0.0228 सेकंड

यह तब बनाया गया था जब प्रतियोगिता अभी भी एक सबसे तेज़ कोड प्रतियोगिता थी

'SourceArray'उपयोग के लिए बुलाया वर्तमान निर्देशिका में एक फ़ाइल खोलता है

LOAD_CONST          ''
STORE_FAST          no_zeroes#  no_zeroes = ''

LOAD_NAME           open
LOAD_CONST          'SourceArray'
CALL_FUNCTION       0,1#  open('SourceArray')
LOAD_ATTR           read
CALL_FUNCTION       0,0#  .read()

LOAD_ATTR           split
CALL_FUNCTION       0,0#  .split()

DUP_TOP
DUP_TOP             #Start if
BUILD_LIST          0
COMPARE_OP          ==
POP_JUMP_IF_TRUE    35#  if list == [], GOTO 35
LOAD_ATTR           pop
LOAD_CONST          0
CALL_FUNCTION       0,1#  list.pop(0)
DUP_TOP
LOAD_CONST          '0'
COMPARE_OP          ==
POP_JUMP_IF_TRUE    28#  if list.pop(0) == '0', GOTO 28
PRINT_ITEM          #  print list.pop(0)
JUMP_ABSOLUTE       13

POP_TOP
LOAD_CONST          '0%_'#  '0 '
LOAD_FAST           no_zeroes
INPLACE_ADD
STORE_FAST          no_zeroes#  no_zeroes = no_zeroes + '0 '
JUMP_ABSOLUTE       13

LOAD_FAST           no_zeroes
PRINT_ITEM          #  print no_zeroes

LOAD_CONST          None
RETURN_VALUE

co_code(वास्तविक Codey बिट)

'd\x01\x00}\x00\x00\te\x00\x00\x83\x00\x00\tj\x01\x00\x83\x00\x00\t\x04\x04g\x00\x00k\x02\x00sG\x00j\x02\x00d\x02\x00\x83\x01\x00\x04d\x03\x00k\x02\x00s8\x00Gq\x15\x00\t\x01d\x04\x00|\x00\x007}\x00\x00q\x15\x00\t|\x00\x00G\td\x00\x00S'

या एक .pyc फ़ाइल संस्करण 03F3

03 F3 0D 0A 40 FD B0 56 63 00 00 00 00 01 00 00 00 03 00 00 00 00 00 00 00 73 59 00 00 00 64 01 00 7D 00 00 09 65 00 00 64 02 00 83 01 00 6A 01 00 83 00 00 09 6A 02 00 83 00 00 09 04 04 67 00 00 6B 02 00 73 50 00 6A 03 00 64 03 00 83 01 00 04 64 04 00 6B 02 00 73 41 00 47 71 1E 00 09 01 64 05 00 7C 00 00 37 7D 00 00 71 1E 00 09 7C 00 00 47 09 64 00 00 53 28 06 00 00 00 4E 74 00 00 00 00 74 0B 00 00 00 53 6F 75 72 63 65 41 72 72 61 79 69 00 00 00 00 74 01 00 00 00 30 73 02 00 00 00 30 20 28 04 00 00 00 74 04 00 00 00 6F 70 65 6E 74 04 00 00 00 72 65 61 64 74 05 00 00 00 73 70 6C 69 74 74 03 00 00 00 70 6F 70 28 01 00 00 00 74 09 00 00 00 6E 6F 5F 7A 65 72 6F 65 73 28 00 00 00 00 28 00 00 00 00 74 09 00 00 00 70 79 6B 65 5F 63 6F 64 65 52 08 00 00 00 01 00 00 00 52 00 00 00 00

आप मेरे स्रोत कोड को अपने पुस्तकालय में गीथुब पर प्रयोग करके स्वयं संकलन करने का प्रयास कर सकते हैं । मैंने अभी इसके लिए एक कमेंट पोस्ट किया है जो टिप्पणियों की अनुमति देता है इसलिए मुझे आशा है कि यह अभी भी प्रतिस्पर्धा कर रहा है जहाँ तक सबसे तेज़-कोड जाता है;)

के बराबर है

no_zeroes = ''
unamed_variable = open('SourceArray').read().split()
while unamed_variable != []:
    unamed_variable_2 = unamed_variable.pop()
    if unamed_variable_2 == '0':
        no_zeroes += '0 '
    else:
        print unamed_variable_2,
print no_zeroes,

— नीला
स्रोत

Wooow। आपने उसमें से एक टन समय काट दिया।

— एडिसन क्रम्प

@VoteTo यह है कि मेरे लैपटॉप पर चलने वाली गति लगभग 1.5x है: O किसने कहा कि पायथन इतना धीमा था ?

— ब्लू '

6

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

lambda x:sorted(x,key=0..__eq__)

तर्क को किसी भी चलने योग्य (सूची, टपल, आदि) के रूप में लेता है। मुझे एक नई चाल सिखाने के लिए @xnor को धन्यवाद!

— मेगो
स्रोत

यह उपयोग करने के लिए थोड़ा छोटा है key=0..__eq__(हाँ, दो डॉट्स)।

— xnor

@xnor यह साफ-सुथरा है ... यह कैसे काम करता है?

— मेगो

7

अधिकांश पायथन वस्तुओं में एक समानता पद्धति होती है, इसलिए उदाहरण के लिए "abc".__eq__("abc")==True। यह तब होता है जब आप कहते हैं "abc"==। कारणों से, पायथन पूर्णांकों में यह नहीं होता है, लेकिन तैरता है, और चूंकि 0. == 0, हम इसके समानता ऑपरेटर को प्रतिस्थापित कर सकते हैं, जो है 0..__eq__।

— xnor

@ एक्सनोर आह, मुझे .__eq__विधि के बारे में पता था , लेकिन डबल डॉट्स मुझे भ्रमित कर रहे थे। मैं यह नहीं पकड़ पाया कि पहले वाला फ्लोट शाब्दिक में दशमलव बिंदु था।

— मेगो

6

मतलाब: 21 बाइट्स

@(a)[a(a~=0),a(a==0)]

नॉनज़ेरो तत्वों को पहले प्रिंट करता है, फिर शून्य तत्वों के साथ जोड़ता है

@(a)____ एक इनपुट तर्क के साथ एक अनाम फ़ंक्शन बनाएं a

[___,___] कॉमा के द्वारा अलग किए गए कोष्ठक के अंदर क्षैतिज वैक्टर को समतल करता है

a(a~=0) वेक्टर के सभी nonzero तत्वों के साथ वेक्टर देता है a

a(a==0) वेक्टर के सभी शून्य तत्वों के साथ वेक्टर देता है a

— brainkz
स्रोत

5

हास्केल, 26 बाइट्स

f x=filter(/=0)x++[0|0<-x]

सभी शून्य शून्य के बाद सभी शून्य लें। 0एक सूची बोध का उपयोग करते समय स्थिरांक (यहां:) काफी कम है [0|0<-x]।

— nimi
स्रोत

5

Zsh, 22 बाइट्स

(इनपुट स्क्रिप्ट / फ़ंक्शन ( $@उर्फ $argvसरणी) के तर्क के रूप में पारित किया गया , स्टैडआउट पर स्पेस अलग सूची, न्यूलाइन टर्मिनेट के रूप में आउटपुट)

<<<${@:#0}\ ${(M)@:#0}

<<< string: यहाँ-स्ट्रिंग को $NULLCMDकमांड के लिए स्टडिन के रूप में पारित किया गया (cat डिफ़ॉल्ट रूप से)।
${@:#0} $@ सिवाय तत्वों के ०।
${(M)@:#0} ऊपर का उलटा

यह मानता है (यहाँ कई अन्य उत्तरों की तरह) कि इनपुट में शून्य सभी के रूप में व्यक्त किए गए हैं 0( 00न तो 0x0और न ही 36#0)।

— sch
स्रोत

4

जावास्क्रिप्ट, 52 54 51 बाइट्स

s=>s.replace(/\b0 /g,x=>++i&&'',i=0)+' 0'.repeat(i)

— हटा दिया
स्रोत

जब इनपुट में कोई शून्य नहीं होता है तो यह काम नहीं करता है

— rink.attenders.6 22

@ rink.attendant.6। धन्यवाद, मैंने अपडेट किया है और अभी भी कुछ बाइट्स की तलाश कर रहा हूं :)

— हटा दिया गया

4

गणितज्ञ, 14 बाइट्स

Sort[#,#!=0&]&

— alephalpha
स्रोत

3

Sort[#!=0&]पर्याप्त होगा।

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

4

एपीएल: 8 बाइट्स

(⍴a)↑a~0

एक ~ 0 से शून्य हटाएं (पढ़ें "एक बिना 0")
(originala) मूल लंबाई की (पढ़ें "" का आकार ")
एक मूल लंबाई के बिना शून्य के पैड

में कोशिश करो http://ngn.github.com/apl/web/index.html पर

टेस्ट डेटा: एक 0 1 0 1 2 3 4 0 1 0 0 0 1 2 3 4 5

— Lobachevsky
स्रोत

1

आपको या तो एक पूर्ण कार्यक्रम लिखना चाहिए और स्टड से इनपुट पढ़ना चाहिए, या एक फ़ंक्शन लिखना चाहिए और इसके मापदंडों से इनपुट पढ़ना चाहिए। लेकिन आप उपयोग कर सकते हैं ⍴↑{⍵~0}और यह छोटा भी है।

— jimmy23013

इतना शीघ्र नही। Not everywhere {⍵ ~ 0} हर जगह काम नहीं करेगा, न कि APL2000 में और न ही IBM APL2 में।

— लोबाचेवस्की

⍴ an {⍵ ~ 0} एक खाली वेक्टर लौटाएगा। ⍴⍴ one {⍵ ~ 0} एक (एक तत्व वेक्टर) शून्य है।

— लोबाचेव्स्की

4

जावा 7, 78 बाइट्स

void g(int[]a){int c=0;for(int o:a)a[o==0?c:c++]=o;for(;c<a.length;a[c++]=0);}

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

— मार्की मार्कोव
स्रोत

हे, मैंने इसका इस्तेमाल किया क्योंकि मुझे ऐसा लगता था। मुझे लगता है कि आप की घोषणा करने में सक्षम होना चाहिए oके साथ int c=0,o;for(o:a)...। आप जावा 8 लैम्ब्डा सिंटैक्स में भी कनवर्ट कर सकते हैं: a->{int c=0;for(int o:a)a[o==0?c:c++]=o;for(;c<a.length;a[c++]=0);}और यह बताता है कि यह एक इंट सरणी के रूप में इनपुट की अपेक्षा करता है।

— Addison Crump

रुको, ओ घोषणा बात खरोंच। लेकिन फिर भी, जावा 8 लंबोदर। : D

— Addison Crump

@VoteToClose मुझे लगा कि इसे आत्म-निहित होना चाहिए। अगर मैं इसे गिनने के बिना अन्य प्रकार और सामान की घोषणा कर सकता हूं, तो यह सही नहीं है।

— मार्की मार्कोव

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

— Addison Crump

3

आम लिस्प, 46 बाइट्स

(lambda(a)(stable-sort a(lambda(_ b)(= 0 b))))

सरणी को क्रमबद्ध करें ताकि प्रत्येक जोड़े के लिए (ए, बी) , हमारे पास एक बी हो अगर बी शून्य है। जब न <b> या b <a , सॉर्ट स्थिर है: तत्वों के बीच मूल क्रम बरकरार है।

मैंने समायोजन-सरणी और हटाने के साथ भी प्रयास किया , लेकिन यह बहुत लंबा था:

(lambda(a)(adjust-array(remove 0 a)(length a):initial-element 0))

— कोर निपात
स्रोत

3

PHP, 73 71 70 52 49 48 46 बाइट्स - इज़माएल मिगुएल के लिए धन्यवाद

// Assuming
$a = array(4,8,6,1,0,8,0,0,0,0,0,-4,'-5',-1,564,0);

// Produces a notice-level error
foreach($a as$v)$v?print"$v ":$b.="0 ";echo$b;

— MonkeyZeus
स्रोत

1

$v==0के साथ प्रतिस्थापित किया जा सकता है !$v, आपको 2 बाइट्स बचाकर।

— इस्माइल मिगुएल

@IsmaelMiguel धन्यवाद!

— मंकीज़ेउस

आपका स्वागत है। मुझे लगता है कि आपने एक बाइट काटने का प्रबंधन किया था। इस प्रयास करें: foreach($argv as$v)$v?$f.=" $v":$b.=" $v";echo$f.$b;। यह .... कुछ बाइट्स, मुझे नहीं पता ...

— इस्माइल मिगुएल

2

या foreach($a as$v)$v?print("$v "):$b.="$v ";echo$b;अधिक साफ-सुथरे तरीके से, जो बिल्कुल वैसा ही दिखता है

— इस्माइल मिगुएल

1

@IsmaelMiguel अच्छा लगा! मुझे रोना होगा अगर मुझे कभी किसी और के प्रोजेक्ट को चुनना पड़ा और कोड-गोल्फिंग

— लोल

3

बैश + जीएनयू उपयोगिताओं, 23

grep -v ^0 a
grep ^0 a

माना जाता है कि इनपुट एक फाइल में न्यूलाइन-सेपरेटेड एंट्रीज है a। इस फ़ाइल नाम के लिए स्कोर में +1 शामिल है।

— डिजिटल आघात
स्रोत

@ एसच हां, यह बैश होना चाहिए - फिक्स्ड।

— डिजिटल ट्रामा

@TimmyD हाँ - अनुस्मारक के लिए धन्यवाद।

— डिजिटल ट्रामा

3

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

23 प्लस तीन के लिए -an ( -Eनि: शुल्क है)

say for sort{!$a-!$b}@F

डेनिस की याद दिलाने के लिए धन्यवाद -a, दो बाइट बचाकर।

— msh210
स्रोत

2

सीजाम, 6 बाइट्स

{{!}$}

एक अनाम फ़ंक्शन। कुंजी के रूप में "तत्व शून्य है या नहीं" का उपयोग करके क्रमबद्ध करें।

— लिन
स्रोत

2

MATL , 7 बाइट्स

t~FT#S)

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

t      % input array. Duplicate
~      % logical negate: nonzero values become false, zeros become true
FT#S   % sort (false, then true) and output a vector with the indices of the sorting
)      % apply that vector of indices to original array

— लुइस मेंडो
स्रोत

2

गंभीरता से, 12 बाइट्स

4,n`Y`M@░)░+

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

स्पष्टीकरण:

4,n`Y`M@░)░+
4,n           push 4 copies of input
   `Y`M       map logical negate
       @░)    filter (take zeroes) and push to bottom of stack
          ░   filter (take non-zeroes)
           +  append zeroes

— मेगो
स्रोत

2

स्विफ्ट , 13 बाइट्स

a.sort{$1==0}

— scraplesh
स्रोत

2

पर्ल 6, 11 बाइट्स

{.sort(!*)}

एक ब्लॉक का निर्माण करता है - जिसे एक सरणी पर कहा जा सकता है:

{.sort(!*)}.([1,2,0,3]).say

हालाँकि यह लिखना अधिक स्वाभाविक (और कम) होगा:

[1,2,0,3].sort(!*).say

यह कैसे काम करता है: यदि perl6 सॉर्ट रूटीन को एक ब्लॉक के साथ कहा जाता है जो केवल एक तर्क को स्वीकार करता है, तो सूची तत्वों के अनुसार क्रमबद्ध किया जाता है by($a) cmp by($b)। इस मामले में, ब्लॉक !*यानी की एक नकार है जो भी ऑपरेटर की ।

मुझे लगता है कि:

प्रश्न में उदाहरण एक वर्ग है जो एक विधि प्रदान करता है, जिसमें पढ़ने के लिए आवश्यक बॉयलरप्लेट शामिल नहीं है
कार्य के विवरण को मुद्रण की आवश्यकता नहीं होती है, और, इस तथ्य को छोड़कर कि उदाहरण प्रिंट करता है, इसका मतलब है कि एक सरणी वापस आ सकती है

— user52889
स्रोत

2

TeX (सादा प्रारूप), 160 बाइट्स

बनाना 0चरित्र को सक्रिय करें (यानी, दुभाषिया प्रक्रिया को एक कमांड के रूप में ), फिर चरित्र को छोड़ने और काउंटर बढ़ाने के लिए उस कमांड को परिभाषित करें। स्ट्रिंग के अंत में, जितने गिने गए थे, उतने ही प्रिंट करें।

इस रूप में सहेजें zero.texऔर इस कमांड के साथ कमांड लाइन के माध्यम से इनपुट दें:

pdftex "\def\I{0 1 0 3 2 0 0 8 0 5 0 1 9 4}\input zero"

\def\I{}\newcount\Z\def\L{\loop\advance\Z by-1\ifnum\Z>00 \repeat}
\begingroup\catcode`\013 \def0{\advance\Z by1}
\scantokens\expandafter{\I\empty}\endgroup\L\bye

(स्पष्टता के लिए जोड़े गए नए समाचार)

— musarithmia
स्रोत

2

जे, 4 बाइट्स

/:0=

स्पष्टीकरण:

/:      NB. upward sort on
  0=    NB. equality to zero

जे में सॉर्ट फ़ंक्शन विनिर्देश द्वारा स्थिर होने की गारंटी है।

वैकल्पिक समाधान, 6 बाइट्स:

#{.*#+

   *#+  NB. replicate each item by its sign (removing zeroes)
#{.     NB. take as many items from this as the original list had
        NB.  (taking more items than there are in a list results in extra zeroes)

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

2

स्ट्रॉ , 30 29 बाइट्स

<:([^0 ])()/,0()/ +,+( +) /}>

CP437 एन्कोडिंग का उपयोग करें

व्याख्या

<:([^0 ])()/,0()/ +,+( +) /}>
<                             Take input
 :                            Duplicate
  ([^0 ])()/                  Remove every character that is not a 0 or a space
            ,                 Swap the two items on the top of the stack
             0()/             Remove every 0 on the top of the stack
                  +           Push a space and concatenate
                   ,          Swap
                    +         Concatenate
                     ( +) /   Remove duplicate spaces
                           }  Get the 'tail' of the string
                            > Output

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों का परीक्षण करने के लिए जोड़ा गया कोड)

— TuxCrafting
स्रोत

2

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

x=>x.sort(t=>!t)

फ़ायरफ़ॉक्स पर काम करता है

— l4m2
स्रोत

2

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

->a{a-[0]+[0]*a.count(0)}

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

— किरिल एल।
स्रोत

1

05AB1E , 15 14 बाइट्स

कोड:

ED0¢r0KR`rFZ}|

स्पष्टीकरण:

E               # Evaluate input
 D              # Duplicate top of the stack
  0¢            # Count zeroes
    r           # Reverse stack
     0K         # Delete all zeroes
       R        # Reverse top of the stack
        `       # Flatten
         r      # Reverse stack
          FZ}   # For N in range(amount zeroes): push zero
             |  # Print full stack

CP-1252 एन्कोडिंग का उपयोग करता है। इस तरह एक सरणी लेता है:

[0, 5, 8, 8, 3, 5, 1, 6, 8, 4, 0, 3, 7, 5, 6, 4, 4, 7, 5, 6, 7, 4, 4, 9, 1, 0, 5, 7, 9, 3, 0, 2, 2, 4, 3, 0, 4, 8, 7, 3, 1, 4, 7, 5, 1, 2, 1, 8, 7, 8, 7, 7, 2, 6, 3, 1, 2, 8, 5, 1, 4, 2, 0, 5, 0, 6, 0, 3]

— अदनान
स्रोत

एक सरणी को समेकित करें

चुनौती

उदाहरण

उदाहरण कोड (जावा)

अजगर, 3 बाइट्स

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

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

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

आर, 29 23 21 बाइट्स

रेटिना , १५

ईएस 6, 23 बाइट्स

पायथन बाइट कोड (2.7.9), 252 बाइट्स, 33 ऑपकोड, 0.0228 सेकंड

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

मतलाब: 21 बाइट्स

हास्केल, 26 बाइट्स

Zsh, 22 बाइट्स

जावास्क्रिप्ट, 52 54 51 बाइट्स

गणितज्ञ, 14 बाइट्स

एपीएल: 8 बाइट्स

जावा 7, 78 बाइट्स

आम लिस्प, 46 बाइट्स

PHP, 73 71 70 52 49 48 46 बाइट्स - इज़माएल मिगुएल के लिए धन्यवाद

बैश + जीएनयू उपयोगिताओं, 23

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

सीजाम, 6 बाइट्स

MATL , 7 बाइट्स

गंभीरता से, 12 बाइट्स

स्विफ्ट , 13 बाइट्स

पर्ल 6, 11 बाइट्स

TeX (सादा प्रारूप), 160 बाइट्स

जे, 4 बाइट्स

स्ट्रॉ , 30 29 बाइट्स

व्याख्या

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

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

05AB1E , 15 14 बाइट्स