স্বাক্ষরযুক্ত আনারি নম্বরগুলির তালিকা পার্স করুন

16

আনরি নম্বরগুলি সাধারণত অ-নেগেটিভ পূর্ণসংখ্যার প্রতিনিধিত্ব করে তবে আমরা নীচের মত সমস্ত পূর্ণসংখ্যার প্রতিনিধিত্ব করতে তাদের প্রসারিত করতে পারি:

  • একটি ধনাত্মক পূর্ণসংখ্যা N N এর প্রতিনিধিত্ব করে 1:5 -> 11111
  • একটি নেতিবাচক পূর্ণসংখ্যার -N 0এন 1এর দ্বারা অনুসরণ করা হিসাবে প্রদর্শিত হয় :-5 -> 011111
  • জিরো হিসাবে প্রতিনিধিত্ব করা হয় 0

এরপরে আমরা এই সংখ্যাগুলির একটি তালিকা নির্বিঘ্নভাবে উপস্থাপন করতে পারি যদি আমরা 0বিভাজক হিসাবে ব্যবহার করি :

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

আপনার কাজ: স্বাক্ষরযুক্ত আনারি সংখ্যার তালিকার প্রতিনিধিত্ব করে একটি স্ট্রিং নিন এবং এটি দশমিক সংখ্যার তালিকায় অনুবাদ করুন।

বিস্তারিত

আপনি ধরে নিতে পারেন যে ইনপুটটি স্বাক্ষরযুক্ত আনারি সংখ্যাগুলির একটি সম্পূর্ণ তালিকা। বিশেষত, আপনার প্রোগ্রামকে 1) খালি ইনপুট বা 2) ইনপুটটি কোনও বিভাজক দিয়ে শেষ হবে না handle

আপনি ধরে নিতে পারেন যে প্রতিটি সংখ্যার দৈর্ঘ্য 127 অতিক্রম করবে না maximum যে কোনো আকারের.

আপনার প্রোগ্রাম বা ফাংশন মানক কোনও উপায়ে 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, এটি প্রযুক্তিগতভাবে একরকম নয়। যদিও ভাল চ্যালেঞ্জ!
— ডিজেএমসিএমহেম
4
@ ডিজেএমসিএমহেম নিতপিক নীটপিকের কাছে: আমি প্রযুক্তিগতভাবে কখনও বলিনি যে এটি একরকম ছিল। এটি আনারির একটি এক্সটেনশন যা আমি "স্বাক্ষরিত অ্যানারি" বলছি। ;)
— DLosc
@ ডিজেএমসিএমহেম আইএমও, চ্যালেঞ্জটি বিশেষত: বিভাজক ( 0) এবং নেতিবাচক চিহ্ন উপসর্গ ( 0) একই, যদিও এটি এখনও স্পষ্ট নয়, যেহেতু আপনার সংখ্যার মাঝখানে নেতিবাচক চিহ্ন থাকতে পারে না ( 182--693-1একটি সংখ্যা? না, এবং 1111011000101111উভয়ই ঠিক একই কারণে নয়)।
— এরিক আউটগল্ফার
যদি আউটপুটযুক্ত তালিকাটি ইনপুটটির বিপরীত ক্রমে থাকে তবে তা ঠিক আছে?
— ডিজেএমসিএমহেম
প্রযুক্তিগতভাবে দশমিক দশমিক নয়, যেহেতু এটি '-' প্রতীকটি ব্যবহার করে
— আনলম্বদার

উত্তর:

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উপাদান ফিরে ।
— Mercator
সূত্র
1
পিপিসিজিতে আপনাকে স্বাগতম!
— স্টেডিবক্স
এটি সত্যিই সৃজনশীল পদ্ধতির! আপনি একটি সংক্ষিপ্ত ব্যাখ্যা যোগ করতে চাইতে পারেন যাতে যারা পাইথন কথা বলেন না তারা আপনার উত্তরটিরও প্রশংসা করতে পারেন।
— DLosc
@DLosc, ধন্যবাদ, আমি ব্যাকটিক সম্পর্কে জানতাম না। শব্দাবলীর ব্যাখ্যাও যুক্ত হয়েছে।
— মার্টারে
8

রেটিনা , 23 21 বাইট

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

এটি অনলাইন চেষ্টা করুন!

প্রথম পর্যায়ে (.)0<newline>$1<space>যেকোন চরিত্রের সাথে মিলে যায় 0। ম্যাচটি প্রথম অক্ষর দ্বারা প্রতিস্থাপিত হয় তার পরে একটি স্থান হয়। এটি পৃথক সংখ্যায় স্ট্রিংকে বিভক্ত করে।

দ্বিতীয় পর্যায়ে সাইন এর ব্লকের আগে 01<newline>-1প্রতিস্থাপন করে ।01-

শেষ পর্যায়ে 1+<newline>$.&সমস্ত ব্লকের সাথে মেলে 1এবং তাদের গ্রুপের দৈর্ঘ্যের সাথে প্রতিস্থাপন করে।

স্বতন্ত্র পর্যায়ে আউটপুট সহ এখানে একটি উদাহরণ।

— ovs
সূত্র
খুব সুন্দর - আমার সমস্ত ধারণাগুলি 24 বাইটে ঘন্টার মধ্যে মনে হচ্ছে ...
— নিল
1
আপনি দয়া করে একটি ব্যাখ্যা যোগ করতে পারেন? আমি রেটিনা কথা বলি না।
— ড্যানিয়েল
@ ডপাপ একটি ব্যাখ্যা যুক্ত করেছেন
— ovs
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খালি এই লাইনটি মোছার জন্য কল করব

— ডিজেএমসিএমহেম
সূত্র
বিতৃষ্ণা। :%s/1+$/ব্যাকস্ল্যাশ করার প্রয়োজনে না হলে আপনাকে একটি বাইট সংক্ষিপ্ত করে +
— তুলবে
@ নিডজেজকোব আমি বুঝতে পারি না যে এটি কেন কম হবে। এবং এছাড়াও, তা দিতে হবে -পরিবর্তে 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একটি (সম্ভাব্য খালি) নিম্নলিখিত তালিকায় 1s, এবং 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 বাইট।

— ডিজেএমসিএমহেম
সূত্র
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]

বিভাজন এই মত কাজ করে। ġ/উপাদানের প্রতিটি জোড়া মধ্যে যুক্তি splits a,b, যার জন্য /a bfalsy হয়। /a bউল্টানো যুক্তিগুলির সাথে বিভাজন, তাই bদ্বারা বিভক্ত a। এই প্রোগ্রামের সম্পর্কিত মানগুলি হ'ল:

  • /1 1দেয় 1(সত্যবাদী)
  • /1 0দেয় 0(মিথ্যা)
  • /0 1দেয় Inf(ইতিবাচক অনন্ত, সত্য)।
  • /0 0দেয় Any(একটি বিশেষ NaN- এর মতো মান, মিথ্যা)
— Zgarb
সূত্র
3

Acc !! , 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 মিনিট। : ^ পি

মন্তব্য সহ

আমি জানি না এই মন্তব্যগুলি কোডটি খুব ভালভাবে ব্যাখ্যা করেছে কিনা - আমি লেখার সময় এগুলি আমার নোটের উপর ভিত্তি করে তৈরি হয়, সুতরাং তারা কীভাবে অ্যাক্ট সম্পর্কে কিছুটা উপলব্ধি করে তা গ্রহণ করে !! কাজ করে। যদি কোনও বিষয়ে আরও ব্যাখ্যা প্রয়োজন হয় তবে আমাকে জানান এবং আমি এটি আরও পরিষ্কার করার চেষ্টা করব।

# 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

কিউবাসিক, 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-বাইট সংস্করণ থেকে শুরু হওয়া একাধিক সংশোধনীর ফলাফল কিউ বেসিকের সবচেয়ে অবহেলিত বিটগুলির মধ্যে একটি হয়েছিল যা আমি মনে করি যে আমি কখনও লিখেছি।(সম্পাদনা করুন: অদ্ভুতভাবে যথেষ্ট, আমি কোডটি আরও পরিষ্কার করে 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$

ব্যাখ্যা

(একে একে "কী ?? এটি এখনও কোনও অর্থবোধ করে না!")

বেস কৌশলটি এমন একটি লুপ চালানো যা INPUT$(1)প্রতিটি সময় থেকে একটি চরিত্রকে ধরে ফেলবে , তার সাথে স্টাফ করবে এবং লুপটি চালিয়ে যায় যতক্ষণ অক্ষরটির চেয়ে বেশি ASCII মান থাকে! (অর্থাত্ একটি নতুন লাইন ছিল না)।

আমরা দুটি ভেরিয়েবল ব্যবহার করে নম্বর-ইন-প্রগ্রেসের ট্র্যাক রাখি। numবর্তমান স্বাক্ষরযুক্ত আনারি সংখ্যায় (যে কোনও শূন্য শূন্য সহ) অক্ষরের সংখ্যা। signহয় 1যদি একটি শূন্য ছিল, 0যদি না। এই উভয়কেই আরম্ভ করা দরকার 0যা গল্ফযুক্ত সংস্করণের জন্য দুর্দান্ত কারণ কিউব্যাসিকের সংখ্যাসূচক ভেরিয়েবলগুলি স্বয়ংক্রিয়ভাবে এটিকে আরম্ভ করা হয় 0।

যখনই আমরা একটি অক্ষর পড়া, প্রথম জিনিস কিনা তা নির্ধারণ করতে এটা হয় 1বা 0। আমরা এই ফলাফলটি দু'বার ব্যবহার করব, তাই আমরা এটি সংরক্ষণ করব isZero। প্রযুক্তিগতভাবে, এই নামটি বিভ্রান্তিমূলক, যেহেতু অক্ষরটি একটি নতুন লাইন হলে মানটিও সত্যবাদী হবে। নোট করুন যে কিউব্যাসিকের -1সত্যতা এবং মিথ্যাটি 0।

এখন, আমরা যদি একটি সংখ্যা ( num > 0) পড়ার মাঝামাঝি হয়ে থাকি এবং আমরা শূন্য বা ইনপুট ( isZero) এর শেষ দিকে আঘাত করি তবে আমাদের কোন সংখ্যাটি পড়া শেষ হয়েছে তা গণনা করতে হবে।

  • sign0ধনাত্মক 1জন্য, নেতিবাচক জন্য স্টোর । 1ইতিবাচক এবং -1নেতিবাচক জন্য পেতে , আমাদের প্রয়োজন 1-2*sign।
  • numধনাত্মকগুলির জন্য সঠিক মাত্রা সঞ্চয় করে তবে sণাত্মকতার জন্য মাত্রার চেয়ে আরও একটি বেশি (যেহেতু এতে সাইন মার্কার অন্তর্ভুক্ত রয়েছে)। সুতরাং আমরা num-signআকার জন্য ব্যবহার করতে পারেন ।

এগুলি একসাথে গুণ এবং মুদ্রণ; তারপর রিসেট signএবং numকরতে 0আগামী সংখ্যা পড়ার জন্য প্রস্তুতি।

অন্যথায় (যদি আমরা একটি শূন্য না মারি, বা যদি আমরা একটি সংখ্যার শুরুতে একটি শূন্যকে আঘাত করি), তবে আমরা আপডেট করব signএবং numনিম্নরূপ:

  • signহয়ে 1যদি আমরা একটি শূন্য এ খুঁজছেন; অন্যথায়, যদি আমরা কোনওটির দিকে নজর রাখি তবে এটি ইতিমধ্যে যা ছিল তা থেকে যায়। গল্ফযুক্ত কোডটি s=s-zযা একই জিনিসটির সমান:
    • যদি এটি একটি নেতৃস্থানীয় শূন্য হয়, zহয় -1। যেহেতু হওয়ার sনিশ্চয়তা রয়েছে 0(কারণ এটি একটি নতুন সংখ্যার শুরু), s-zহবে 1।
    • যদি এটি এক, zহয় 0। তারপরে s-zযা কিছু sআগে মূল্য ছিল তা স্থির থাকে ।
  • num বর্ধিত হয়।

এটাই!

— DLosc
সূত্র
0

জাভাস্ক্রিপ্ট (ES6), 60 বাইট

পূর্ণসংখ্যার একটি স্থান-বিভাজিত তালিকা প্রদান করে।

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

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
0

অ্যাপ্লিকেশন Lua , 58 বাইট

(...):gsub("(0?)(1*)0?",function(s,n)print(#n-2*#s*#n)end)

এটি অনলাইন চেষ্টা করুন!

সম্পূর্ণ প্রোগ্রাম, কমান্ড লাইন থেকে ইনপুট নেয় এবং নম্বরগুলি নিউলাইন দ্বারা পৃথক স্টাডআউটে মুদ্রণ করে।

— জোনাথন এস।
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.