हस्ताक्षरित यूरी संख्या की सूची को पार्स करें

16

यूनीरी नंबर आम तौर पर केवल नॉनजेटिव पूर्णांकों का प्रतिनिधित्व करते हैं, लेकिन हम उन्हें निम्नानुसार सभी पूर्णांकों का प्रतिनिधित्व करने के लिए बढ़ा सकते हैं:

  • एक सकारात्मक पूर्णांक N को N के रूप में दर्शाया गया है 1:5 -> 11111
  • एक नकारात्मक पूर्णांक -N को 0N के द्वारा अनुसरण किया जाता है 1:-5 -> 011111
  • शून्य का प्रतिनिधित्व किया जाता है 0

यदि हम 0विभाजक के रूप में उपयोग करते हैं तो हम इन नंबरों की एक सूची का प्रतिनिधित्व कर सकते हैं :

3,-2,0,1
111,011,0,1
111 0 011 0 0 0 1
11100110001

आपका कार्य: एक ऐसी संख्या पर हस्ताक्षर किए गए यूनिरी नंबर का प्रतिनिधित्व करने वाला एक स्ट्रिंग लें, और इसे दशमलव संख्याओं की सूची में अनुवाद करें।

विवरण

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

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

आपका कार्यक्रम या फ़ंक्शन किसी भी मानक तरीके से I / O प्रदर्शन कर सकता है । इनपुट एक स्ट्रिंग या पात्रों की सूची, एकल-वर्ण स्ट्रिंग्स, पूर्णांक या बूलियन हो सकता है। आप प्रतिनिधित्व करने के लिए किसी भी दो वर्णों का उपयोग कर सकते हैं 1और 0; यदि आप उपयोग नहीं करते हैं 1और 0, कृपया निर्दिष्ट करें कि आप किन वर्णों का उपयोग कर रहे हैं।

किसी भी उचित सूची प्रारूप में आउटपुट दशमलव संख्या होना चाहिए (विशेष रूप से, संख्याओं के बीच किसी प्रकार का विभाजक होना चाहिए)। ऋणात्मक संख्याओं को ऋण चिह्न के साथ इंगित किया जाना चाहिए, हालांकि यदि आपकी भाषा में नकारात्मक पूर्णांकों के लिए एक अलग प्रारूप है, तो मैं इसे भी स्वीकार करूंगा। शून्य को आउटपुट में 0या के रूप में दर्शाया जा सकता है -0।

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

1 -> 1
0 -> 0 (or -0, and similarly for the other test cases)
011 -> -2
1101 -> 2,1
1100 -> 2,0
11001 -> 2,-1
110001 -> 2,0,1
11100110001 -> 3,-2,0,1
00000001 -> 0,0,0,-1
01111011111111001111111111111110111111111111111100111111111111111111111110111111111111111111111111111111111111111111 -> -4,8,-15,16,-23,42
01111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 -> -127
code-golf  string  parsing 
— DLosc
स्रोत
2
नाइटपिक: चूंकि इसमें सम्‍मिलित है '0's, यह तकनीकी रूप से एकात्मक नहीं है। हालांकि अच्छी चुनौती!
— DJMcMayhem
4
@DJMcMayhem नाइटपिक से नाइटपिक: मैंने तकनीकी रूप से कभी नहीं कहा कि यह एकात्मक था। यह यूनरी का एक विस्तार है जिसे मैं "हस्ताक्षरित यूरी" कह रहा हूं। ;)
— डीएलओसी
@DJMcMayhem IMO, चुनौती विशेष रूप से यह है कि विभाजक ( 0) और नकारात्मक संकेत उपसर्ग ( 0) समान हैं, हालांकि यह अभी भी अस्पष्ट है, क्योंकि आप एक संख्या के बीच में नकारात्मक संकेत नहीं कर सकते हैं ( 182--693-1एक संख्या है? नहीं? और न 1111011000101111ही सटीक कारण के लिए है)।
— आउटगॉल्फ
यदि आउटपुट सूची इनपुट के रिवर्स ऑर्डर में है तो क्या यह ठीक है?
— डीजेमेकमैम
'-' चिह्न अच्छी तरह से तकनीकी रूप से दशमलव दशमलव या तो के बाद से इसे इस्तेमाल करता है नहीं है
— Unlambder

जवाबों:

10

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

एक फ़ंक्शन जो इनपुट के रूप में एक स्ट्रिंग लेता है और पायथन सूची का एक स्ट्रिंग प्रतिनिधित्व लौटाता है। शून्य का प्रतिनिधित्व किया जा सकता है ( 0और -0जब यह अंतिम हो):

lambda s:`map(len,s.split('0'))`.replace('0, ','-').replace('--','0,')

व्याख्या

  1. splitsशून्य पर इनपुट स्ट्रिंग ।
  2. परिणामी सूची (उपयोग ) में प्रत्येक स्ट्रिंग की लंबाई लें map।

हमें लंबा रास्ता तय करना है। शून्य सभी के बाद विभाजक थे। और नंबर एकात्मक थे, इसलिए lenआसानी से उन लोगों को दशमलव में परिवर्तित कर देता है। लेकिन अब हमने सभी गैर-विभाजक उपयोगों को गड़बड़ कर दिया है 0। सौभाग्य से, सभी गैर-विभाजक उपयोग अग्रणी शून्य थे इसलिए वे एक विभाजक-शून्य के बाद आए और हमें शून्य-लंबाई के तार ( '00'.split('0') == ['', '', '']) दिए। उन शून्य-लम्बाई के तार भी 0उसी के कारण बने len।

  1. सूची को एक स्ट्रिंग में बदल दें ( "रिवर्स कोट्स का उपयोग करके" ), इसलिए हम गड़बड़ को अधिक आसानी से ठीक कर सकते हैं।
  2. replaceप्रत्येक शून्य जो उस संख्या पर एक ऋणात्मक चिन्ह द्वारा दूसरे नंबर से पहले आता है। यह 0एक संकेत के रूप में उपयोग को ठीक करता है लेकिन यह शाब्दिक शून्य को तोड़ता है। शाब्दिक शून्य भी एक विभाजक से पहले थे, इसलिए वे अब अगले नंबर पर अतिरिक्त डैश के जोड़े बन गए हैं।
  3. replace"सूची" --में प्रत्येक 0तत्व में वापस ।
— मर्केटर
स्रोत
1
PPCG में आपका स्वागत है!
— स्टेडीबॉक्स
यह वास्तव में रचनात्मक दृष्टिकोण है! आप एक छोटा स्पष्टीकरण जोड़ना चाह सकते हैं ताकि जो लोग अजगर नहीं बोलते हैं वे आपके उत्तर की सराहना कर सकें।
— DLosc
@ डलास, धन्यवाद, मैं बैकटिक के बारे में नहीं जानता था। Wordy स्पष्टीकरण भी जोड़ा गया।
— मर्केटर
8

रेटिना , 23 21 बाइट्स

(.)0
$1 
01
-1
1+
$.&

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

पहला चरण (.)0<newline>$1<space>किसी भी चरित्र से मेल खाता है जिसके बाद ए 0। मैच को पहले चरित्र द्वारा प्रतिस्थापित किया जाता है और उसके बाद एक स्थान बनाया जाता है। यह अलग-अलग संख्याओं में स्ट्रिंग को विभाजित करता है।

दूसरे चरण के संकेत के एक ब्लॉक से पहले की 01<newline>-1जगह है ।01-

अंतिम चरण समूह के 1+<newline>$.&सभी खंडों से मेल खाता है 1और उन्हें समूह की लंबाई के साथ बदल देता है।

यहां व्यक्तिगत चरणों के आउटपुट के साथ एक उदाहरण दिया गया है।

— OVS
स्रोत
बहुत अच्छा - मेरे सभी विचार 24 बाइट्स में देखते हैं ...
— नील
1
क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं? मैं रेटिना नहीं बोलता।
— डैनियल
@ डोप्प्प ने स्पष्टीकरण में कहा
— १s को
7

विम, 56 बाइट्स

:s/\v(0?1*)0?/\1\r/g|%s/0/-/|%s/1*$/\=len(submatch(0))
D

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

मैंने थोड़ी देर में विम में पोस्ट नहीं किया है। मैं ज्यादातर विम का उपयोग कर रहा हूं क्योंकि वी कभी-कभी दर्द होता है। क्योंकि countकमांड, जो लाइन पर '1 की संख्या प्राप्त करने के लिए एकदम सही है, लाइन पर किसी भी' 0 को अधिलेखित कर देगा, इसलिए हम इसे बाद में नकार नहीं सकते हैं।

स्पष्टीकरण:

यह एक बाइट छोटा है तो सीधा रास्ता:

:s/\v(0?1*)0?/\1\r/g
:%s/0/-
:%s/1*$/\=len(submatch(0))
D

कमांड चेनिंग के कारण। चूँकि एक आदेशों को अलग करता है, मैं इसका उपयोग स्पष्टीकरण के लिए करूँगा।

:s/                     " Substitute
                        " Search for...
   \v                   "   Enable 'magic'. This determines whether certain atoms require a backslash or not.
                        "   Without it we would have: '\(0\?1*\)0\?', which is 2 bytes longer
      0?                "   An optional 0
        1*              "   Followed by any number of '1's
     (    )             "   (call that group 1)
           0?           "   Followed by another optional 0
             /          " Replace it with...
              \1        "   Subgroup 1
                \r      "   A newline
                  /g    " Do this for every match on the current line.

अब, प्रत्येक हस्ताक्षरित अनार्य संख्या एक व्यक्तिगत रेखा पर है एक उदाहरण के रूप में '11100110001' का उपयोग करना, इस समय हमारे पास होगा:

111
011
0
1

:%s/0   " Replace every 0
     /- " With a dash  

:%s/1*$/                    " Replace every run of 1's at the end of a line
        \=len(submatch(0))  " With the length of said run

चूंकि हमने प्रत्येक मैच के अंत में नई कड़ियाँ जोड़ी हैं, इसलिए दौड़ने से पहले हमारे पास एक खाली रेखा थी। इसे चलाने के बाद, हमारे पास एक '0' होगा (क्योंकि यह 0 '1' के रन से मेल खाता है)। तो हम सिर्फ Dइस लाइन को हटाने के लिए कॉल करते हैं, इसे खाली छोड़ देते हैं

— DJMcMayhem
स्रोत
ओह। :%s/1+$/अगर आप को +
— पीछे हटने
@NieDzejkob मुझे समझ नहीं आ रहा है कि यह छोटा क्यों होगा। और यह भी, कि देना होगा -बजाय 0या-0
— DJMcMayhem
मैं आखिरी रास्ता इस तरह से खत्म करना चाहता था: पी, कोई बात नहीं।
— निएडजेककोब
7

हास्केल , 68 66 बाइट्स

f(x:r)|(a,b)<-span(>0)r=([(0-),(1+)]!!x$sum a):[z|_:t<-[b],z<-f t]

इसे ऑनलाइन आज़माएं! शून्य और लोगों की सूची के रूप में इनपुट लेता है। उदाहरण उपयोग: f [0,0,0,1,1]पैदावार [0,-2]।

स्पष्टीकरण:

में पैटर्न मिलान f(x:r)|(a,b)<-span(>0)rबांध xइनपुट के पहले तत्व के लिए, aएक (संभावित खाली) निम्नलिखित की सूची में 1है, और bइनपुट के आराम करने के। एक इनपुट को देखते हुए [0,1,1,1,0,0,1], हम प्राप्त करते हैं x=0, a=[1,1,1]और b=[0,0,1]।

वर्तमान संख्या तब या तो aऋणात्मक राशि का योग है x=0, या aयदि एक के साथ एक का योग है x=1। इस के साथ का अनुक्रमण द्वारा हासिल की है xएक निषेध और वेतन वृद्धि समारोह युक्त एक सूची में, और की राशि के परिणामस्वरूप समारोह को लागू करने a: [(0-),(1+)]!!x$sum a।

बाकी सूची bया तो खाली है या एक अलग शून्य और अगली संख्या है। सूची की समझ पैटर्न पर [z|_:t<-[b],z<-f t]मेल खाने की कोशिश करती है , जो कि प्रमुख तत्व को भूल जाती है और बाकी सूची को बांध देती है । यदि खाली है तो यह मैच विफल हो जाता है और सूची की समझ का मूल्यांकन होता है , जो पुनरावृत्ति का आधार मामला है। अन्यथा फ़ंक्शन को पुनरावर्ती रूप से लागू कर दिया जाता है और सूची समझ के परिणाम से सभी तत्वों का मूल्यांकन होता है ।b_:ttb[]ftzf t

— Laikoni
स्रोत
3

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

StringCases[#<>"0",x_~~Shortest@y___~~"0":>(If[x=="0",-#,#+1]&)@StringLength@y]&

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

के मैकेनिक को गाली देता है StringCases, क्योंकि यह ओवरलैपिंग पैटर्न की जांच नहीं करता है। चूंकि हम ओवरलैप के बिना, बाएं से दाएं खोजते हैं, हमें हमेशा केवल पूर्णांक प्राप्त होते हैं जिनकी हमें आवश्यकता होती है।

व्याख्या

#<>"0"

अंत में एक शून्य जोड़ें

StringCases

निम्नलिखित सभी पैटर्न खोजें ...

x_~~Shortest@y___~~"0"

एक एकल चरित्र (इसे कॉल करें x), जिसके बाद सबसे कम संभव शून्य-लंबाई या लंबी स्ट्रिंग (इसे कॉल करें y), जिसके बाद एक शून्य होता है।

(If[x=="0",-#,#+1]&)@StringLength@y

मिलान पैटर्न पर लागू करें: की लंबाई लें y। यदि xशून्य है, तो मान को नकारात्मक करें। और, वेतन वृद्धि एक।

यह भी शामिल है 00, चूंकि yएक खाली स्ट्रिंग होगा, और हम गणना करेंगे -0( == 0)।

— जंगहवान मिन
स्रोत
3

ब्रेन-फ्लैक , 94 (70?) बाइट्स

([]){{}({(<()>)()}{}(<>)<>{<([{}]<>{})><>})
{{}<>([{}])(<>)}{}{}([])}{}<>([]){{}({}<>)<>([])}<>

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

यह वास्तव में आश्चर्यजनक रूप से मस्तिष्क-परत के लिए प्रवण है।

यहाँ एक टिप्पणी / पठनीय संस्करण है:

([])

{

    #Pop the Stack height
    {}

    (
        #If there isn't a leading 0, evaluate to 1...
        {
            (<()>)

            ()
        }

        #Pop the 0
        {}

        #Push a 0 onto the alternate stack
        (<>)
        <>

        #Run of '1's
        {
            #Decrement the alternate stack
            <([{}]<>{})>
            <>
        }

        #And push it here
    )

    #Was there a not leading 0?

    {
        {}

        #Invert the value on the alternate stack
        <>([{}])(<>)
    }

    #Pop 2 zeros
    {}{}


    ([])

}{}<>

#Push stack height
([])

#Reverse the stack
{

    {}

    ({}<>)

    <>([])

}<>

यदि आउटपुट रिवर्स में हो सकता है, तो हम इसके बजाय 70 के लिए कर सकते हैं:

([]){{}({(<()>)()}{}(<>)<>{<([{}]<>{})><>}){{}<>([{}])(<>)}{}{}([])}<>

मेरा यह टिप है लगभग इस स्थिति के लिए एकदम सही। लेकिन यह काफी काम नहीं करता है क्योंकि हमें ऑपरेशन करने से पहले एक 0 पुश करना है ('1' की गिनती), और ऑपरेशन एक लूप में होता है। सबसे कम मैं इस टिप का उपयोग कर सकता है:

([]){{}({(<()>)()}{}(<>)<>{<([{}]<>{})><>})
{{}<>([{}])(<>)}{}{}(<>())<>([])}{}<>{{}({}<>)<>}<>

जो कि 94 बाइट्स भी है।

— DJMcMayhem
स्रोत
3

हस्क , 20 18 17 15 14 बाइट्स

Γ~:?Σṁ_Πȯ₀tΣġ/

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

व्याख्या

Γ~:?Σṁ_Πȯ₀tΣġ/  Input is a list, say x = [0,1,1,0,0,0,1,1]
            ġ   Group by
             /  division.
                This splits x right before each 0: [[0,1,1],[0],[0],[0,1,1]]
Γ               Deconstruct into head y = [0,1,1] and tail z = [[0],[0],[0,1,1]]
   ?Σṁ_Π        Apply to y:
       Π         Product: 0
   ?Σ            If that is nonzero, take sum of y,
     ṁ_          else take sum of negated elements of y: u = -2
        ȯ₀tΣ    Apply to z:
           Σ     Concatenate: [0,0,0,1,1]
          t      Drop first element: [0,0,1,1]
         ₀       Recurse: [0,2]
 ~:             Tack u to the front: [-2,0,2]

बंटवारा इस तरह काम करता है। ġ/प्रत्येक जोड़े के बीच अपने तर्क को विभाजित करता है a,bजिसके /a bलिए मिथ्या है। /a bफ़्लिप किए गए तर्कों के साथ विभाजन होता है, इसलिए इससे bविभाजित होता है a। इस कार्यक्रम में प्रासंगिक मूल्य ये हैं:

  • /1 1देता है 1(सत्य)।
  • /1 0देता है 0(झूठा)।
  • /0 1देता है Inf(सकारात्मक अनंत, सच्चाई)।
  • /0 0देता है Any(एक विशेष NaN की तरह मूल्य, मिथ्या)।
— Zgarb
स्रोत
3

एसीसी !! , 252 237 बाइट्स

N
Count i while _/48 {
Count n while 48/_ {
Write 45
50+N
}
_+49/_*50
Count u while _%50/49 {
_+100-_%50+N
}
_/50-1
Count h while _/200 {
Write _/200+48
_%200+1
}
Count t while _/20+_%2 {
Write _/20+48
_%20-_%2
}
Write _/2+48
Write 9
N
}

उपयोग करता है -0। आउटपुट नंबर टैब वर्णों द्वारा अलग किए गए हैं, एक अनुगामी टैब के साथ। इसे ऑनलाइन आज़माएं!

वास्तविक एल्गोरिथ्म लिखने की मात्रा: 20 मिनट। मेरे दशमलव आउटपुट कोड को डिबगिंग करने की मात्रा: 45 मिनट। : ^ पी

टिप्पणियों के साथ

मुझे नहीं पता कि क्या ये टिप्पणियां कोड को बहुत अच्छी तरह से समझाती हैं - जब मैं इसे लिख रहा था, तो वे मेरे लिए अपने नोट्स पर आधारित हैं, इसलिए वे कुछ समझ लेते हैं कि कैसे Acc! काम करता है। अगर किसी चीज की अधिक व्याख्या की जरूरत है, तो मुझे बताएं और मैं इसे स्पष्ट करने की कोशिश करूंगा।

# We partition the accumulator _ as [number][flag][nextchar]
# [flag] is a 2-value slot and [nextchar] a 50-value slot
# So [nextchar] is _%50, [flag] is _/50%2, [number] is _/100
# [flag] is 1 if we're in the middle of reading a number, 0 if we're between numbers
# It is also used for outputting as decimal (see below)
# Possible input characters are 0, 1, and newline, so [nextchar] is 48, 49, or 10

# Read the first character
N
# Loop while the character we just read is 0 or 1 and not newline
Count i while _/48 {
  # What we do in the loop depends on the combination of [flag] and [nextchar]:
  # 0,48 (start of number, read 0) => write minus sign, [flag] = 1, read another char
  # _,49 (read 1) => increment [number], [flag] = 1, read another char
  # 1,48 (middle of number, read 0) => write/clear [number], status = 0, read another
  #      char
  # 1,10 (middle of number, read <cr>) => ditto; the next read will be 0 for eof, which
  #      means the acc will be less than 48 and exit the loop

  # Process leading 0, if any
  Count n while 48/_ {
    # acc is 48: i.e. [number] is 0, [flag] is 0, [nextchar] is 48 (representing a 0)
    # Output minus sign
    Write 45
    # Set [flag] to 1 (thereby exiting loop) and read [nextchar]
    50+N
  }
  # If number starts with 1, then we didn't do the previous loop and [flag] is not set
  # In this case, acc is 49, so we add (50 if acc <= 49) to set [flag]
  _+49/_*50

  # Process a run of 1's
  Count u while _%50/49 {
    # [nextchar] is 49 (representing a 1)
    # Increment [number] and read another
    _+100-_%50+N
  }

  # At this stage, we know that we're at the end of a number, so write it as decimal
  # This is "easier" (ha) because the number has at most three digits
  # We shift our partitioning to [number][flag] and set [flag] to 0
  _/50-1

  # Output hundreds digit if nonzero
  # Since [number] is _/2, the hundreds digit is _/200
  Count h while _/200 {
    Write _/200+48
    # Mod 200 leaves only tens and units; also, set [flag] to 1
    _%200+1
  }
  # Output tens digit (_/20) if nonzero OR if there was a hundreds digit
  # In the latter case, [flag] is 1
  Count t while _/20+_%2 {
    Write _/20+48
    # Mod 20 leaves only units; clear [flag] if it was set
    _%20-_%2
  }
  # Write units unconditionally
  Write _/2+48

  # Write a tab for the separator
  Write 9
  # Read another character
  N
}
— DLosc
स्रोत
2

आर , 119 बाइट्स

function(x){n=nchar
y=regmatches(x,regexec("(0?)(1*)0?([01]*)",x))[[1]]
cat((-1)^n(y[2])*n(y[3]),"")
if(y[4]>0)f(y[4])}

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

संबंधित समस्या के लिए कोड स्टैकओवरफ़्लो से इस समाधान का उपयोग करता है (विचार के लिए धन्यवाद)। आउटपुट स्टडआउट के लिए छपा हुआ एक स्पेस-अलग स्ट्रिंग है।

— NofP
स्रोत
2

जेली ,  19  18 बाइट्स

इसके लिए अवश्य ही एक बेहतर तरीका होना चाहिए...

®ḢN$Ḣ©?ṄEȧ
ṣ0L€ÇL¿

एक पूरा कार्यक्रम जो प्रत्येक संख्या को छापता है उसके बाद एक लाइनफीड।

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

कैसे?

®ḢN$Ḣ©?ṄEȧ - Link 1, print first number and yield next input: list of numbers, X
           -                              e.g. [8,0,15,16,...] or [0,4,8,0,15,16,...]
      ?    - if...
    Ḣ      - condition: yield head and modify  8([0,15,16,...])   0([4,8,0,15,16,...])  
     ©     -            (copy to register)     8                  0
®          - then: recall from the register    8
   $       - else: last two links as a monad:
 Ḣ         -         yield head and modify                        4([8,0,15,16,...])
  N                  negate                                      -4
       Ṅ   - print that and yield it           8                 -4
        E  - all equal (to get 0 to be truthy) 1                  1
         ȧ - AND the (modified) input          [0,15,16,...]      [8,0,15,16,...]
           -   (ready to be the input for the next call to this link)

ṣ0L€ÇL¿ - Main link: list e.g. [0,1,0,0,0,0,1,1]
ṣ0      - split at zeros       [[],[1],[],[],[],[1,1]
  L€    - length of €ach       [0,1,0,0,0,2]
      ¿ - while...
     L  - condition: length                           1  1  1  0  ([0,1,0,0,0,2], [0,0,0,2], [0,2], [])
    Ç   - action: call the last link (1) as a monad  -1  0 -2     ( - 1            - 0        - 2)
— जोनाथन एलन
स्रोत
1

QBasic, 88 86 बाइट्स

1u$=INPUT$(1)
z=u$<"1
IF n*z THEN?(1-2*s)*(n-s):s=0:n=0ELSE s=s-z:n=n+1
IF"!"<u$GOTO 1

यह मजेदार था। 107-बाइट संस्करण से शुरू होने वाले कई संशोधन QBasic के सबसे मोटे बिट्स में से एक के परिणामस्वरूप मुझे लगता है कि आपने कभी नहीं लिखा था। (संपादित करें: विचित्र रूप से पर्याप्त है, मैं कोड को स्पष्ट करके 2 बाइट्स गोल्फ में सक्षम था।)

नोट: यह कार्यक्रम उपयोगकर्ता इनपुट को एक बार में स्क्रीन पर गूँजने के बिना एक वर्ण पढ़ता है ( INPUT$(1)सामान्य INPUTविवरण के बजाय उपयोग करने का परिणाम )। जैसा कि आप टाइप कर रहे हैं, आपको 1 और 0 नहीं दिखाई देंगे, लेकिन दशमलव संख्याएँ गणना के अनुसार दिखाई देंगी। Enterअंतिम संख्या को देखने और कार्यक्रम को समाप्त करने के लिए इनपुट के अंत में हिट करना सुनिश्चित करें ।

अनप्लग्ड संस्करण

sign = 0
num = 0
DO
  digit$ = INPUT$(1)
  isZero = (digit$ < "1")
  IF num > 0 AND isZero THEN
    PRINT (1 - 2 * sign) * (num - sign)
    sign = 0
    num = 0
  ELSE
    IF isZero THEN sign = 1
    num = num + 1
  END IF
LOOP WHILE "!" < digit$

व्याख्या

(AKA "क्या ?? अब भी कोई मतलब नहीं है!")

आधार रणनीति एक लूप चलाने के लिए है जो INPUT$(1)प्रत्येक समय से एक चरित्र को पकड़ता है , इसके साथ सामान करता है, और जब तक चरित्र ASCII मान से अधिक होता है !(यानी, एक नई पंक्ति नहीं थी) के रूप में लंबे समय तक लूप करता रहता है ।

हम दो चर का उपयोग करके संख्या-में-प्रगति का ट्रैक रखते हैं। numवर्तमान हस्ताक्षरित अनार्य संख्या (किसी भी अग्रणी शून्य सहित) में वर्णों की संख्या है। signहै 1यदि संख्या एक अग्रणी शून्य था, 0नहीं तो। इन दोनों को आरंभीकृत करने की आवश्यकता है 0, जो कि गोल्फ संस्करण के लिए बहुत अच्छा है क्योंकि QBasic में संख्यात्मक चर स्वचालित रूप से आरंभ किए जाते हैं 0।

जब भी हम किसी पात्र को पढ़ते हैं, तो पहली बात यह निर्धारित करना है कि वह है 1या नहीं 0। हम इस परिणाम का दो बार उपयोग करेंगे, इसलिए हम इसे स्टोर करते हैं isZero। तकनीकी रूप से, यह नाम भ्रामक है, क्योंकि मूल्य भी सत्य होगा यदि चरित्र एक नई रूपरेखा है। ध्यान दें कि QBasic में -1सच्चाई है और झूठी है 0।

अब, यदि हम किसी संख्या ( num > 0) को पढ़ने के बीच में हैं और हमने एक शून्य या इनपुट के अंत ( ) को मारा है isZero, तो हमें यह गणना करने की आवश्यकता है कि हमने किस संख्या को पढ़ना समाप्त किया है।

  • sign0सकारात्मक के लिए भंडार , 1नकारात्मक के लिए। 1सकारात्मक और -1नकारात्मक के लिए पाने के लिए , हमें जरूरत है 1-2*sign।
  • numसकारात्मकता के लिए सही परिमाण को संग्रहीत करता है लेकिन नकारात्मकता के लिए परिमाण से एक अधिक (क्योंकि इसमें साइन मार्कर शामिल है)। तो हम num-signपरिमाण के लिए उपयोग कर सकते हैं ।

इन्हें एक साथ गुणा करें और प्रिंट करें; तो रीसेट signऔर numकरने के लिए 0अगले संख्या को पढ़ने के लिए तैयारी में।

अन्यथा (यदि हमने शून्य नहीं मारा है, या यदि हमने किसी संख्या की शुरुआत में शून्य मारा है), तो हम अपडेट करते हैं signऔर numनिम्नानुसार हैं:

  • sign1यदि हम एक अग्रणी शून्य को देख रहे हैं, तो वह बन जाता है; अन्यथा, यदि हम एक को देख रहे हैं, तो यह पहले से ही जो कुछ भी है, उस पर रहता है। गोल्फ कोड है s=s-z, जो एक ही बात करने के लिए राशि:
    • यदि यह एक अग्रणी शून्य है, zहै -1। चूंकि होने sकी गारंटी है 0(क्योंकि यह एक नए नंबर की शुरुआत है), s-zहोगा 1।
    • यदि यह एक है, zहै 0। फिर s-zजो भी sपहले था मूल्य पर रहता है ।
  • num बढ़ा हुआ है।

बस!

— DLosc
स्रोत
0

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

पूर्णांक की एक अलग-अलग सूची लौटाता है।

s=>(0+s).replace(/00?1*/g,s=>(l=s.length,+s[1]?l-1:2-l)+' ')

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

कोड स्निपेट दिखाएं

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