सकारात्मक रन रिवर्स


22

इनपुट

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

उत्पादन

आपका आउटपुट इनपुट लिस्ट होगा, लेकिन प्रत्येक मैक्सिमम रन ऑफ नॉनजरो डिजिट्स को उलट दिया जाएगा।

उदाहरण

इनपुट पर विचार करें

95883007414830
<--->  <---->

जहाँ नॉनज़रो रन को तीर से चिह्नित किया गया है। इनमें से प्रत्येक रन को उलट कर, हम आउटपुट प्राप्त करते हैं

38859003841470

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

यह चुनौती संबंधित है, लेकिन बहुत अधिक जटिल है, क्योंकि इसमें अतिरिक्त स्ट्रिंग प्रसंस्करण शामिल है।

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

4 -> 4
00 -> 00
123 -> 321
0010 -> 0010
12000345 -> 21000543
18161604 -> 61618104
95883007414830 -> 38859003841470
010230456078912 -> 010320654021987
357509902003550 -> 575309902005530
2492882377675046 -> 5767732882942064
03026302053000357099 -> 03036202035000753099

लीडरबोर्ड

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

## Language, N bytes

आप स्ट्राइकथ्रू टैग का उपयोग करके हेडर में पुराने स्कोर रख सकते हैं: 57 के<s>57</s> रूप में दिखाई देगा ।

जवाबों:



8

आईपीओएस , 5 बाइट्स

'0!r%

%जीरो पर इनपुट स्ट्रिंग को विभाजित करता है, rप्रत्येक सबरिंग पर कमांड (रिवर्स) लागू करता है और परिणाम को शून्य पर वापस जोड़ता है।


7

रेटिना , 15 बाइट्स

S`0
O%^$`.

¶
0

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामलों को एक साथ चलाने के लिए थोड़ा संशोधित किया गया है।)

व्याख्या

S`0

0एस के चारों ओर इनपुट को विभाजित करें , गैर-शून्य अंकों के प्रत्येक (संभवतः खाली) रन को अपनी लाइन पर रखें।

O%^$`.

यह प्रत्येक पंक्ति को उलटा करता है:

  • प्रत्येक पंक्ति में व्यक्तिगत रूप से चरण को लागू करना %
  • प्रत्येक वर्ण के साथ व्यक्तिगत रूप से मिलान करना .
  • प्रतिस्थापन के परिणाम द्वारा इसे क्रमबद्ध करना ($रिक्त स्ट्रिंग (खाली दूसरी पंक्ति) के साथ ) । अर्थात, यह सभी प्रकारों को समान नहीं करता है, क्योंकि सभी प्रकार के मूल्य समान हैं।
  • फिर छांटे गए वर्णों के क्रम को उलट देता है।

आखिरकार:

¶
0

लाइनफीड्स को वापस चालू करें 0



5

जूलिया, 30 बाइट्स

s->replace(s,r"[^0]+",reverse)

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

replaceसमारोह में एक समारोह में प्रत्येक मैच के लिए लागू करने का परिणाम के साथ एक नियमित अभिव्यक्ति की मैचों की जगह करने की क्षमता प्रदान करता है। इस मामले में हम नॉनजरोज़ का उपयोग कर सकते हैं [^0]+और reverseमिलान किए गए पाठ पर लागू फ़ंक्शन के परिणाम के साथ उन रनों को बदल सकते हैं ।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें!


4

रेटिना, 25 24

O^$#`[^0](?=(.*?0)*)
$#1

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

मार्टिन को धन्यवाद दिया 1 बाइट बचाया!

शून्य क्रमांक द्वारा गैर-अक्षीय अंको को क्रम से क्रम से पालन करने वाले क्रम से क्रमबद्ध करें।

एक छोटा कार्यक्रम प्राप्त करने के लिए प्रति-पंक्ति मोड के चतुर उपयोग के लिए मार्टिन का समाधान देखें !


4

जोल्फ, 8 बाइट्स

RΜGi0λ_0

यहाँ कोशिश करो!

व्याख्या

RΜGi0λ_0
  Gi0     split input on zeroes
 Μ   λ_   map over reversal as a lambda
R      0  join by zeroes

यदि आप विखंडन करते हैं तो कोड स्पष्टीकरण एक लंबोदर की तरह दिखता है।

एक बराबर 8-बाइट उत्तर:

RΜGi0΅O0

एक ही बात है, लेकिन यह ΅Oइसके बजाय (स्ट्रिंग मिरर लैम्ब्डा) का उपयोग करता है ।


मैं कहूंगा कि जब मैं इसे देखता हूं तो यह मजाकिया रूप में कुछ पाठ जैसा दिखता है। शायद मुझे यह दूरबीन लगा देनी चाहिए।
बिल्ली

1
@cat नहीं, नहीं, इसे रखो, लेकिन जब तुम करते हो तो मेमने को देखो।
कॉनर ओ'ब्रायन


3

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

lambda x:"0".join([n[::-1] for n in x.split("0")])

एक स्ट्रिंग एक्स में ले जाता है और शून्य पर विभाजित होता है और विभाजन में प्रत्येक तत्व को उलट देता है और एक शून्य जोड़ता है और इस शून्य को अंतिम शून्य देता है।


1
PPCG में आपका स्वागत है :) आपको ऐसा करने में सक्षम होना चाहिए "0".joinऔर फिर अतिरिक्त और स्लाइस को छोड़ना चाहिए ।
FryAmTheEggman

@FryAmTheEggman टिप के लिए धन्यवाद
1232

कोई समस्या नहीं है :) आप ]और के बीच की जगह भी निकाल सकते हैं for। यदि आप चाहें, तो आप अधिक संकेत के लिए हमारे सुझाव पृष्ठ देख सकते हैं।
FryAmTheEggman

7
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp

3

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

Join@@Reverse/@#~SplitBy~Sign&

उदा Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}


2

PowerShell v2 +, 45 बाइट्स

($args-split0|%{-join$_[$_.length..0]})-join0

अंतर्निहित कास्टिंग का दुरुपयोग करना जैसे कि कल नहीं है। संभवतः बहुत कम नहीं मिल सकता है, क्योंकि रिवर्स के लिए कोई बिल्ट नहीं है जो इस अनुक्रमणिका चाल से कम है।

व्याख्या

यह कैसे काम करता है इसका एक उदाहरण - मान लीजिए 123045कि इनपुट था $args-splitचालू होने के बाद 0, पाइपलाइन में एक सरणी होगी (123,45)। पहले लूप के |%{...}पास वर्तमान तत्व के $_बराबर होता है 123, जो तब एक स्ट्रिंग के रूप में निहित होता है, फिर []अनुक्रमण के साथ उलट होता है । यह ('3','2','1')एक चार-सरणी के रूप में बनाता है । लूप -joinएक स्ट्रिंग में वापस डालता है "321"और इसे पाइप लाइन पर छोड़ देता है। अगला (अंतिम) लूप पुनरावृत्ति इनपुट को उलट देता है "54"। तो अब हमारे पाइप लाइन है "321", "54"। यह Parens में समझाया गया है । यह पाइपलाइन पर छोड़ दिया गया है और कंसोल को आउटपुट निहित है।() यह एक सरणी में सुधार है, और -joinपरिणामी उत्पादन स्ट्रिंग का उत्पादन करने के लिए शून्य के साथ फिर से एड के साथ फिर"321054"

यदि मूल इनपुट में बाद के शून्य हैं, तो सरणी शून्य तत्वों से आबाद होगी, इसलिए आउटपुट पर शून्य की सही संख्या है। उदाहरण के लिए, में 1230045-split0बदल जाता है (123,,45)और ऊपर के रूप में चीजें जारी रहती हैं।



2

फैक्टर, 35 बाइट्स

पीफॉन और क्लोजर, बोयाह!

[ "0"split [ reverse ] map "0"join ]

यह अनाम फ़ंक्शन इस पायथन उत्तर का शाब्दिक अनुवाद है ।

यह काफी सरल है, बस स्ट्रिंग को शून्य पर विभाजित करें, परिणामस्वरूप सरणी के प्रत्येक तत्व को उल्टा करें, और सभी तत्वों (शून्य-लंबाई के तारों सहित) के साथ जुड़ें "0"

यहाँ इसका एक उदाहरण सभी परीक्षण मामलों पर चल रहा है:

IN: scratchpad auto-use {
        "4"
        "00"
        "123"
        "0010"
        "12000345"
        "18161604"
        "95883007414830"
        "010230456078912"
        "357509902003550"
        "2492882377675046"
        "03026302053000357099"
        }
        [ 
          "0" split [ reverse ] map "0" join
        ]
        map .

{
    "4"
    "00"
    "321"
    "0010"
    "21000543"
    "61618104"
    "38859003841470"
    "010320654021987"
    "575309902005530"
    "5767732882942064"
    "03036202035000753099"
}

"00120"-> { "" "" "12" "" }-> { "" "" "21" "" }->"00210"


2

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

r%(0:t)=r++0:[]%t
r%(h:t)=(h:r)%t
r%_=r
([]%)

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

पहले दो कुछ कोड दोहराते हैं, लेकिन मुझे उन्हें (45 और 47 बाइट्स) संयोजित करने का एक छोटा तरीका नहीं मिला:

r%(h:t)|h<1=r++h:[]%t|1>0=(h:r)%t
r%_=r
([]%)

r%l|0:t<-l=r++0:[]%t|h:t<-l=(h:r)%t
r%_=r
([]%)

मुझे लगता है कि आप # 2 लाइन में कोष्ठक में से एक अधिक जोड़ी की जरूरत है:r%(h:t)=(h:r)%t
nimi


1

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

स्ट्रिंग संस्करण:

s=>s.replace(/[^0]+/g,r=>[...r].reverse().join``)

@ केविन लाउ के लिए एक बाइट धन्यवाद बचा लिया!

सरणी संस्करण (60 बाइट्स):

a=>a.map((n,i)=>n?a[z-i+[...a,0].indexOf(0,i)]:(z=i,0),z=-1)

1

जे, 20 18 बाइट्स

0}:@;@(<@|.;.1)@,]

इस के साथ मदद करने के लिए Zgarb के लिए धन्यवाद! एक सही तर्क के रूप में एक अंतरिक्ष-पृथक सूची लेता है।

-2 बाइट्स ज़गरब को धन्यवाद!


1

क्लोजर / क्लोजुरस्क्रिप्ट, 44 वर्ण

#(flatten(map reverse(partition-by pos? %)))

दूसरों के रूप में एक ही समाधान, लंबे समारोह के नाम के लिए बस अधिक क्रिया धन्यवाद। उस वजह से पोस्ट करने के लिए नहीं जा रहा था, लेकिन यह कुछ अन्य जवाब धड़कता है तो क्यों नहीं?

किसी भी अनुक्रम प्रकार पर काम करता है। क्लोजुरस्क्रिप्ट में, यह तार पर भी काम करता है क्योंकि तार वर्णों की सूची के रूप में प्रक्रियात्मक होते हैं, जो वास्तव में सिर्फ 1-लंबाई के तार होते हैं, जो कि चीजों की संख्या के लिए मोटे होते हैं pos?


1

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

import Data.Lists
(reverse=<<).split(oneOf"0")

प्रयोग उदाहरण: (reverse=<<).split(oneOf"0") $ "0123004500678090"->"0321005400876090"

अफसोस की बात है कि splitफ़ंक्शन को महंगे आयात की आवश्यकता होती है। हर 0, इनपुट सूची को विभाजित करेंsplit(oneOf"0") "0120030" ->["","0","12","0","","0","3","0",""] , प्रत्येक चंक को उल्टा करें और एक ही स्ट्रिंग में समतल करें।



1

जावा, 179 बाइट्स (आयात के साथ)

import java.util.*;static void r(String s){StringJoiner x= new StringJoiner("0");for(String a:s.split("0",s.length())){x.add(new StringBuilder(a).reverse());}System.out.print(x);}

एक स्ट्रिंग इनपुट में ले जाता है और वर्णों को शून्य से विभाजित करता है और फिर स्ट्रिंगरॉइनर क्लास पर ऐड मेथड को कॉल करके उन्हें वापस जोड़ता है।


1

Oracle SQL 11.2, 131 123 बाइट्स

एक्सएमएल कार्यों का दुरुपयोग।

SELECT LISTAGG(REVERSE(COLUMN_VALUE||''))WITHIN GROUP(ORDER BY rownum)FROM XMLTABLE(('"'||REPLACE(:1,'0','","0","')||'"'));

1

पर्ल, 22 बाइट्स

-pविकल्प के लिए +1 शामिल है :

s/[^0]+/reverse$&/eg

यह एक बहुत ही तुच्छ प्रतिस्थापन है - इतना उबाऊ होने के लिए क्षमा करें। ध्यान दें कि यदि आपका इनपुट न्यूलाइन-टर्मिनेटेड है (उदाहरण के लिए)perl -pe 's/[^0]+/reverse$&/eg' <<<21000543 Bash में ), तो यह न्यूलाइन को अंकों - उपयोग echo -nया उससे printfबचने के लिए पकड़ लेगा । वैकल्पिक रूप से, एक अतिरिक्त बाइट की लागत के लिए [1-9], वर्ण वर्ग को बदल कर , और आप कई इनपुट, प्रति पंक्ति प्रदान कर सकते हैं।


1

सी, 105 बाइट्स

#define x(o)for(p=s;*s&&'0'o*s;++s);for(r=s;r-->p;putchar(*r));
f(s,p,r)char*s,*p,*r;{x(^)x(==)*s&&f(s);}

कॉल fअंकों की सूची के साथ एक शून्य-समाप्त स्ट्रिंग के रूप में , और यह सही आउटपुट प्रिंट करेगा।

असंगठित और समझाया गया:

f(s,p,r)
char*s,*p,*r; // K&R style to avoid repeating `char`
{

    // x(^)x(==) expands to...

    // Find the next zero digit
    for(p = s; *s && '0' ^ *s; ++s)
        ;

    // Print that run backwards
    for(r = s; r-- > p; putchar(*r))
        ;

    // Find the next non-zero digit
    for(p = s; *s && '0' == *s; ++s)
        ;

    // Print that run backwards (no difference, it's all zeros)
    for(r = s; r-- > p; putchar(*r))
        ;

    // If there's more string, recurse
    *s && f(s);
}

इसे कोलिरु पर लाइव देखें


0

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

एक सबरूटीन:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}

-aइनपुट स्ट्रिंग के समाप्त होने पर (स्ट्रॉबेरी में कम से कम) काम नहीं करता है 0, क्योंकि split/\b/इसमें शामिल $/है 0
msh210

0

दरअसल, 22 बाइट्स

k"a%sa"%'0@s♂R'0j#pXdX

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

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

स्पष्टीकरण:

k"a%sa"%'0@s♂R'0j#pXdX
k"a%sa"%                surround input with "a" characters
        '0@s            split on 0
            ♂R          reverse each piece
              '0j       join on 0
                 #pXdX  listify, remove first and last element (the "a"s)

0

सी #, 131 बाइट्स ##

समाधान त्रुटिपूर्ण है!

string j(string i){foreach(var s in i.Split('0'))if(s!="")i=i.Replace(s,new string(s.ToCharArray().Reverse().ToArray()));return i;}

ungolfed:

string j(string input)
    {

        string[] a = input.Split('0');

        foreach (string s in a)
        {
            if (s!="")
            input=input.Replace(s, new string(s.ToCharArray().Reverse().ToArray()));
        }

        return input;
    }

1
मेरा मानना ​​है कि इस विधि में एक बग होता है जब एक स्ट्रिंग को उलटा होना एक दूसरे का सबसेट होता है। यदि इनपुट दिया जाता है 01201230, तो यह वापस आ जाएगा 02102130। ऐसा इसलिए है क्योंकि String.Replace विधि पहले स्ट्रिंग की सभी घटनाओं को दूसरे के साथ बदल देती है। यह बग तब भी होता है जब एक पैटर्न उलटा होने पर दिखाता है ( 0120210वापस आ जाएगा 0120120)।
Xynariz

मैंने ऐसा सोचा भी नहीं था ..
downrep_nation

0

सी #, 133 बाइट्स


golfed

String m(String s){for(int i=0,p=i;i<s.Length;i++){if(s[i]=='0'){p=i+1;}else{s=s.Insert(p,s[i].ToString()).Remove(i+1,1);}}return s;}

Ungolfed

String m( String s ) {
    // i = Index on the String
    // p = Pointer of the last '0' found
    for (int i = 0, p = i; i < s.Length; i++) {
        if (s[ i ] == '0') {
            // Move the 'p' pointer to the index after this '0'
            p = i + 1;
        } else {
            // Insert the Char at the Index location to the Pointer location 
            //    and remove the one at the Index Location + 1,
            //    since the String was incremented by one char due to the 'Insert()'.
            s = s.Insert( p, s[ i ].ToString() )
                 .Remove( i + 1, 1 );
        }
    }

    return s;
}

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            List<String> ls = new List<String>() {
                "4",
                "00",
                "123",
                "0010",
                "12000345",
                "18161604",
                "95883007414830",
                "010230456078912",
                "357509902003550",
                "2492882377675046",
                "03026302053000357099"
            };

            foreach (String s in ls) {
                String f = m( s );

                Console.WriteLine( String.Format( "{0,30}", s.Replace( "0", "0 " ) ) );
                Console.WriteLine( String.Format( "{0,30}", f.Replace( "0", "0 " ) ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            for (Int32 i = 0, p = i; i < s.Length; i++) {
                if (s[ i ] == '0') {
                    p = i + 1;
                } else {
                    s = s.Insert( p, s[ i ].ToString() ).Remove( i + 1, 1 );
                }
            }

            return s;
        }
    }
}

अभी देखा कि @downrep_nation ने पहले ही यहाँ C # के लिए एक समाधान पोस्ट किया था, जो कि मेरे कोड को 2 बाइट्स से हरा देता है ... (यह अधिक हो सकता है ....)
अनुमन २ a'१६ को

0

जावा, 126

a->{String r="",t[]=a.split("0");for(String s:t){r+=new StringBuilder(s).reverse()+"0";}return r.substring(0, r.length()-1);}

यदि आप sमोर्चे पर चर के साथ की घोषणा करते हैंr और t[], क्या आप sलूप के लिए प्रकार की घोषणा को छोड़ सकते हैं ?
साइओस

नहीं, मैंने इसकी जाँच की, लूप के लिए बढ़ाए गए एक नए घोषित चर की आवश्यकता है।
उम्मीद है कि

हुह। वह अजीब है। ओह अच्छी तरह से
साइओस

0

क्लोजर, 37 बाइट्स

#(mapcat reverse(partition-by #{0}%))

के #{0}बजाय का उपयोग करता है pos?(1 बाइट को समवर्ती के साथ बचाएं %) और mapcatइसके बजाय का उपयोग करें (flatten(map। अभी भी फैक्टर से ज्यादा लंबा है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.