Các số đơn nguyên thường chỉ đại diện cho các số nguyên không âm, nhưng chúng ta có thể mở rộng chúng để biểu diễn tất cả các số nguyên như sau:

• Một số nguyên dương N được biểu diễn dưới dạng N 1's:5 -> 11111
• Một số nguyên âm -N được biểu diễn 0theo sau bởi N 1's:-5 -> 011111
• Không được đại diện là 0

Sau đó, chúng ta có thể trình bày một danh sách các số này một cách rõ ràng nếu chúng ta sử dụng 0làm dấu phân cách:

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

Nhiệm vụ của bạn: lấy một chuỗi biểu thị một danh sách các số đơn nguyên đã ký và dịch nó thành một danh sách các số thập phân.

Chi tiết

Bạn có thể giả định rằng đầu vào là một danh sách đầy đủ các số đơn nguyên đã ký. Cụ thể, chương trình của bạn sẽ không phải xử lý 1) đầu vào trống hoặc 2) đầu vào kết thúc bằng dấu phân cách.

Bạn có thể giả sử rằng độ lớn của mỗi số sẽ không vượt quá 127. Đối với các ngôn ngữ có kích thước chuỗi hoặc danh sách tối đa, bạn có thể cho rằng đầu vào và đầu ra sẽ phù hợp với cấu trúc dữ liệu của ngôn ngữ của bạn, nhưng về mặt lý thuyết thuật toán của bạn sẽ hoạt động theo danh sách bất cứ kích thước nào.

Chương trình hoặc chức năng của bạn có thể thực hiện I / O theo bất kỳ cách tiêu chuẩn nào . Đầu vào có thể là một chuỗi hoặc một danh sách các ký tự, chuỗi ký tự đơn, số nguyên hoặc booleans. Bạn có thể sử dụng bất kỳ hai ký tự để đại diện 1và 0; nếu bạn không sử dụng 1và 0, vui lòng chỉ định những ký tự bạn đang sử dụng.

Đầu ra phải là số thập phân ở bất kỳ định dạng danh sách hợp lý nào (đặc biệt, phải có một loại dấu tách giữa các số). Số âm nên được biểu thị bằng dấu trừ, mặc dù nếu ngôn ngữ của bạn có định dạng khác cho số nguyên âm, tôi cũng sẽ chấp nhận điều đó. Không có thể được biểu diễn trong đầu ra là 0hoặc -0.

Các trường hợp thử nghiệm

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

Python 2 , 73 70 byte

Một hàm lấy một chuỗi làm đầu vào và trả về một chuỗi đại diện của danh sách Python. Không có thể được biểu diễn cả bởi 0và -0(khi nó đến cuối cùng):

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

Giải trình

1. splitchuỗi đầu vào strên số không.
2. Lấy độ dài của mỗi chuỗi trong danh sách kết quả (sử dụng map).

Điều đó đưa chúng ta một chặng đường dài. Zeroes là dải phân cách sau tất cả. Và các con số là đơn nhất, do đó lenthuận tiện chuyển đổi chúng thành số thập phân. Nhưng bây giờ chúng tôi đã làm rối tung tất cả các cách sử dụng không phân cách 0. May mắn thay, tất cả các sử dụng không phân tách là các số 0 đứng đầu, vì vậy chúng xuất hiện sau một dấu phân cách bằng 0 và cho chúng ta các chuỗi có độ dài bằng không ( '00'.split('0') == ['', '', '']). Những chuỗi có độ dài bằng không sau đó cũng trở thành 0vì len.

3. Biến danh sách thành một chuỗi ( sử dụng "trích dẫn ngược" ), để chúng tôi có thể sửa chữa mớ hỗn độn dễ dàng hơn.
4. replacethay vào đó, mỗi số 0 đứng trước một số khác bằng dấu âm trên số đó. Điều đó sửa chữa việc sử dụng 0như một dấu hiệu nhưng nó phá vỡ các số 0 theo nghĩa đen. Các số 0 theo nghĩa đen cũng được phân tách bằng dấu phân cách, vì vậy giờ đây chúng trở thành các cặp dấu gạch ngang phụ trên số tiếp theo.
5. replacemỗi --trở lại thành một 0yếu tố trong "danh sách".

Võng mạc , 23 21 byte

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

Hãy thử trực tuyến!

Giai đoạn đầu tiên (.)0<newline>$1<space>phù hợp với bất kỳ nhân vật theo sau bởi a 0. Trận đấu được thay thế bằng ký tự đầu tiên theo sau là khoảng trắng. Điều này chia chuỗi trong các số riêng lẻ.

Giai đoạn thứ hai 01<newline>-1thay thế 0trước một khối 1thành -dấu hiệu.

Giai đoạn cuối 1+<newline>$.&phù hợp với tất cả các khối 1và thay thế chúng bằng chiều dài của nhóm.

Dưới đây là một ví dụ với đầu ra của các giai đoạn riêng lẻ.

Vim, 56 byte

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

Hãy thử trực tuyến!

Tôi đã không đăng trong vim trong một thời gian. Tôi chủ yếu sử dụng vim vì V đôi khi là một nỗi đau. Bởi vì countlệnh hoàn hảo để lấy số '1 trên dòng sẽ ghi đè lên bất kỳ số 0 nào trên dòng, vì vậy chúng tôi không thể phủ nhận nó sau đó.

Giải trình:

Đây là một byte ngắn hơn theo cách đơn giản:

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

do lệnh xích. Vì người ta tách các lệnh, tôi sẽ sử dụng nó để giải thích.

: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.

Bây giờ, mỗi số đơn được ký là trên một dòng riêng. Sử dụng '11100110001' làm ví dụ, tại thời điểm này, chúng tôi sẽ có:

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

Vì chúng tôi đã thêm các dòng mới vào cuối mỗi trận đấu, chúng tôi đã có một dòng trống trước khi chạy nó. Sau khi chạy nó, chúng ta sẽ có '0' (vì nó khớp với 0 '1'). Vì vậy, chúng tôi chỉ cần gọi Dđể xóa dòng này, để trống

Haskell , 68 66 byte

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

Hãy thử trực tuyến! Lấy đầu vào là một danh sách các số không và số. Ví dụ sử dụng: f [0,0,0,1,1]sản lượng [0,-2].

Giải trình:

Mẫu phù hợp trong f(x:r)|(a,b)<-span(>0)rliên kết xvới phần tử đầu tiên của đầu vào, avới danh sách (có khả năng trống) của các 1s sau và bvới phần còn lại của đầu vào. Đưa ra một đầu vào [0,1,1,1,0,0,1], chúng tôi nhận được x=0, a=[1,1,1]và b=[0,0,1].

Số hiện tại sau đó là tổng của aphủ định nếu x=0hoặc tổng acộng một nếu x=1. Điều này đạt được bằng cách lập chỉ mục với xmột danh sách chứa hàm phủ định và hàm tăng và áp dụng hàm kết quả cho tổng a: [(0-),(1+)]!!x$sum a.

Danh sách còn lại btrống hoặc chứa số 0 và số tiếp theo. Việc hiểu danh sách [z|_:t<-[b],z<-f t]cố gắng khớp với bmẫu _:t, đó là quên phần tử head và liên kết phần còn lại của danh sách với t. Nếu btrống, trận đấu này không thành công và việc hiểu danh sách []sẽ là trường hợp cơ bản cho phép đệ quy. Mặt khác, hàm fđược áp dụng đệ quy tvà mức độ hiểu danh sách đánh giá tất cả các yếu tố ztừ kết quả của f t.

Ngôn ngữ Wolfram (Mathicala) , 80 byte

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

Hãy thử trực tuyến!

Lạm dụng cơ chế của StringCases, vì nó không kiểm tra các mẫu chồng chéo. Vì chúng tôi tìm kiếm từ trái sang phải, không trùng lặp, chúng tôi luôn chỉ nhận được các số nguyên mà chúng tôi cần.

Giải trình

#<>"0"

Nối số 0 ở cuối

StringCases

Tìm tất cả các mẫu sau ...

x_~~Shortest@y___~~"0"

Một ký tự đơn (gọi nó x), theo sau là chuỗi có độ dài ngắn nhất hoặc dài hơn có thể (gọi nó y), theo sau là số không.

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

Áp dụng cho mẫu phù hợp: lấy chiều dài của y. Nếu xbằng 0 thì phủ định giá trị. Khác, tăng một.

Điều này cũng bao gồm 00, vì ysẽ là một chuỗi rỗng và chúng tôi sẽ tính toán -0( == 0).

Brain-Flak , 94 (70?) Byte

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

Hãy thử trực tuyến!

Điều này thực sự đáng kinh ngạc cho flak não.

Đây là một phiên bản nhận xét / dễ đọc:

([])

{

    #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
{

    {}

    ({}<>)

    <>([])

}<>

Nếu đầu ra có thể đảo ngược, chúng ta có thể làm điều này trong 70 thay thế:

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

Mẹo này của tôi là gần như hoàn hảo cho tình huống này. Nhưng nó không hoạt động tốt vì chúng ta phải đẩy 0 trước khi thực hiện thao tác (đếm số 1) và hoạt động diễn ra theo vòng lặp. Thời gian ngắn nhất tôi có thể nghĩ ra bằng cách sử dụng mẹo này là:

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

đó cũng là 94 byte.

Perl 5 , 40 + 1 ( -n) = 41 byte

print'-'x/00/.y/1//.$"for"0$_"=~/00?1*/g

Hãy thử trực tuyến!

Husk , 20 18 17 15 14 byte

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

Hãy thử trực tuyến!

Giải trình

Γ~:?Σṁ_Πȯ₀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]

Việc chia tách hoạt động như thế này. ġ/chia tách đối số của nó giữa mỗi cặp của các yếu tố a,bmà /a blà falsy. /a blà phân chia với các đối số lật, do đó bchia cho a. Các giá trị liên quan trong chương trình này là:

• /1 1cho 1(sự thật).
• /1 0cho 0(giả).
• /0 1cho Inf(vô cùng tích cực, trung thực).
• /0 0cho Any(một giá trị đặc biệt giống NaN, giả).

Acc !! , 252 237 byte

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
}

Công dụng -0. Xuất ra các số được phân tách bằng các ký tự tab, với một tab trailing. Hãy thử trực tuyến!

^{Lượng thời gian viết thuật toán thực tế: 20 phút. Lượng thời gian gỡ lỗi mã đầu ra thập phân của tôi: 45 phút. : ^ P}

Với nhận xét

Tôi không biết những bình luận này có giải thích mã rất tốt hay không - chúng dựa trên các ghi chú của tôi cho chính tôi khi tôi đang viết nó, vì vậy họ cho rằng một số hiểu biết về cách Acc !! làm. Nếu có bất cứ điều gì cần giải thích thêm, hãy cho tôi biết và tôi sẽ cố gắng làm cho nó rõ ràng hơn.

# 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
}

Python 2 , 96 92 byte

lambda s:[[len(t),-len(t)+1]['1'>t]for t in s.replace('10','1 ').replace('00','0 ').split()]

Hãy thử trực tuyến!

Thx đến ovs và DLosc cho mỗi 2 byte.

R , 119 byte

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])}

Hãy thử trực tuyến!

Mã sử ​​dụng giải pháp này từ stackoverflow cho một vấn đề liên quan (Nhờ ghen tị với ý tưởng). Đầu ra là một chuỗi được phân tách bằng dấu cách được in ra thiết bị xuất chuẩn.

Thạch ,  19  18 byte

^{Phải có cách tốt hơn...}

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

Một chương trình đầy đủ in mỗi số theo sau là một dòng.

Hãy thử trực tuyến!

Làm sao?

®Ḣ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)

QBasic, 88 86 byte

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

Đây là niềm vui Nhiều bản sửa đổi bắt đầu từ phiên bản 107 byte dẫn đến một trong những bit QBasic khó hiểu nhất mà tôi nghĩ tôi đã từng viết. (Chỉnh sửa: Thật kỳ lạ, tôi đã có thể đánh gôn 2 byte bằng cách làm cho mã rõ ràng hơn.)

Lưu ý: chương trình này đọc người dùng nhập một ký tự một lần mà không lặp lại màn hình (kết quả của việc sử dụng INPUT$(1) thay vì INPUTcâu lệnh thông thường ). Vì vậy, khi bạn nhập, bạn sẽ không thấy số 1 và 0, nhưng các số thập phân sẽ xuất hiện khi chúng được tính toán. Đảm bảo nhấn Entervào cuối đầu vào để xem số cuối cùng và kết thúc chương trình.

Phiên bản ung dung

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$

Giải trình

(AKA "Cái gì ?? Điều đó vẫn vô nghĩa!")

Chiến lược cơ bản là chạy một vòng lặp lấy một ký tự từ INPUT$(1)mỗi lần, thực hiện công việc với nó và tiếp tục lặp miễn là ký tự đó có giá trị ASCII lớn hơn! (nghĩa là không phải là một dòng mới).

Chúng tôi theo dõi các con số đang tiến hành bằng cách sử dụng hai biến. numlà số lượng ký tự trong số đơn nguyên được ký hiện tại (bao gồm mọi số 0 đứng đầu). signlà 1nếu số có số 0 đứng đầu, 0nếu không. Cả hai thứ này đều cần được khởi tạo 0, rất phù hợp với phiên bản golf vì các biến số trong QBasic được tự động khởi tạo 0.

Bất cứ khi nào chúng ta đọc một ký tự, điều đầu tiên là xác định xem nó 1hay 0. Chúng tôi sẽ sử dụng kết quả này hai lần, vì vậy chúng tôi lưu trữ nó isZero. Về mặt kỹ thuật, tên đó là sai lệch, vì giá trị cũng sẽ là sự thật nếu nhân vật là một dòng mới. Lưu ý rằng sự thật trong QBasic là -1và falsey là 0.

Bây giờ, nếu chúng ta đang ở giữa đọc một số ( num > 0) và chúng ta đạt đến 0 hoặc hết đầu vào ( isZero), chúng ta cần tính toán số nào chúng ta đã đọc xong.

• signcửa hàng 0cho tích cực, 1cho tiêu cực. Để có được 1cho tích cực và -1tiêu cực, chúng ta cần 1-2*sign.
• numlưu trữ độ lớn chính xác cho dương, nhưng nhiều hơn độ lớn cho âm (vì nó bao gồm dấu hiệu). Vì vậy, chúng ta có thể sử dụng num-signcho độ lớn.

Nhân các số này với nhau và in; sau đó thiết lập lại signvà numđể 0chuẩn bị đọc số tiếp theo.

Mặt khác (nếu chúng tôi không đạt 0 hoặc nếu chúng tôi đạt 0 ở đầu số), chúng tôi sẽ cập nhật signvà numnhư sau:

• signtrở thành 1nếu chúng ta đang nhìn vào một số 0 hàng đầu; mặt khác, nếu chúng ta đang nhìn vào một cái, nó vẫn ở bất cứ thứ gì nó đã có. Mã đánh gôn là s=s-zsố tiền tương tự:
  • Nếu đây là một số không hàng đầu, zlà -1. Vì sđược đảm bảo là 0(vì đây là sự khởi đầu của một số mới), s-zsẽ được 1.
  • Nếu đây là một, zlà 0. Sau đó s-zở lại bất cứ giá trị nào strước đây.
• num được tăng lên.

Đó là nó!

JavaScript (ES6), 60 byte

Trả về một danh sách các số nguyên được phân tách bằng dấu cách.

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

Các trường hợp thử nghiệm

let f =

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

console.log(f("1")) // 1
console.log(f("0")) // 0
console.log(f("011")) // -2
console.log(f("1101")) // 2,1
console.log(f("1100")) // 2,0
console.log(f("11001")) // 2,-1
console.log(f("110001")) // 2,0,1
console.log(f("11100110001")) // 3,-2,0,1
console.log(f("00000001")) // 0,0,0,-1
console.log(f("01111011111111001111111111111110111111111111111100111111111111111111111110111111111111111111111111111111111111111111")) // -4,8,-15,16,-23,42
console.log(f("01111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111")) // -127

Lua , 58 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ, lấy đầu vào từ dòng lệnh và in các số thành thiết bị xuất chuẩn được phân tách bằng dòng mới.