Tekli sayılar genellikle yalnızca negatif olmayan tam sayıları temsil eder, ancak bunları aşağıdaki gibi tam sayıları temsil edecek şekilde genişletebiliriz:

• Pozitif bir N tamsayısı N 'olarak temsil edilir 1:5 -> 11111
• Negatif bir tamsayı -N, 0bunu N 1' ile temsil eder :-5 -> 011111
• Sıfır, şu şekilde temsil edilir: 0

Daha sonra 0, ayırıcı olarak kullanırsak bu numaraların bir listesini net bir şekilde temsil edebiliriz :

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

Göreviniz: imzalanmış tekli numaraların bir listesini temsil eden bir dize alın ve ondalık sayılar listesine dönüştürün.

ayrıntılar

Girişin, imzalı tek sayıların eksiksiz bir listesi olduğunu varsayabilirsiniz. Özellikle, programınızın bir ayırıcı ile biten 1) boş girişi veya 2) girişi işlemesi gerekmez.

Her bir sayının büyüklüğünün 127'yi geçmeyeceğini varsayabilirsiniz. Maksimum dize veya liste boyutlarına sahip diller için, giriş ve çıktının dilinizin veri yapılarına sığacağını varsayabilirsiniz, ancak algoritmanız teorik olarak herhangi beden.

Programınız veya işleviniz standart yollardan herhangi birinde G / Ç gerçekleştirebilir . Girdi, bir dize veya bir karakter listesi, tek karakterli dizeler, tamsayılar veya booleans olabilir. Sen temsil etmek herhangi iki karakter kullanabilir 1ve 0; kullanmazsanız 1ve 0lütfen hangi karakterleri kullandığınızı belirtin.

Çıktı herhangi bir makul liste formatında ondalık sayılar olmalıdır (özellikle sayılar arasında bir tür ayırıcı olmalıdır). Negatif sayılar eksi işareti ile belirtilmelidir, ancak diliniz negatif tamsayılar için farklı bir biçime sahipse bunu da kabul edeceğim. Sıfır, çıktıda 0veya olarak temsil edilebilir -0.

Test senaryoları

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 bayt

Bir dizeyi girdi olarak alan ve bir Python listesinin dize olarak temsilini döndüren bir işlev. Sıfır hem temsil edilebilir 0ve -0(son geldiğinde):

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

açıklama

1. splitgiriş dizgisi ssıfırda.
2. Sonuç listesindeki her dizenin uzunluğunu alın (kullanarak map).

Bu bizi çok uzun sürüyor. Sonuçta sıfırlar ayırıcılardı. Ve sayılar tekliydi, bu yüzden bunları lenuygun şekilde ondalık sayıya dönüştürür. Ama şimdi ayırıcı olmayan tüm kullanımlarını berbat ettik 0. Neyse ki, tüm ayırıcı olmayan kullanımlar önde gelen sıfırlardı, bu nedenle ayırıcı-sıfırdan sonra geldiler ve bize sıfır uzunlukta dizeler verdi ( '00'.split('0') == ['', '', '']). Bu sıfır uzunluklu dizeler de 0nedeniyle oldu len.

3. Listeyi bir dizeye dönüştürün ( "ters tırnaklar" kullanarak ), karışıklığı daha kolay düzeltebiliriz.
4. replacebunun yerine başka bir sayıdan önce gelen her sıfır, o sayı üzerinde negatif bir işaret ile gösterilir. Bu 0bir işaret olarak kullanımını düzeltir ancak gerçek sıfırları kırar. Değişmez sıfırlardan önce bir ayırıcı da vardı, bu yüzden şimdi bir sonraki sayıda ekstra tire çiftleri haline geldiler.
5. replaceher biri "listedeki" --bir 0öğeye geri döner .

Retina , 23 21 bayt

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

Çevrimiçi deneyin!

İlk aşama (.)0<newline>$1<space>herhangi bir karakterle ve ardından a ile eşleşir 0. Eşleşme, ilk karakter ve ardından bir boşluk ile değiştirilir. Bu, dizeyi ayrı ayrı numaralara böler.

İkinci aşama 01<newline>-1yerini alacaktır 0'bir blok önce ler 1' için s -işaret.

Son aşama 1+<newline>$.&tüm blokları ile eşleşir 1ve bunları grubun uzunluğu ile değiştirir.

İşte bireysel aşamaların çıktısı ile bir örnek.

Vim, 56 bayt

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

Çevrimiçi deneyin!

Bir süredir vim yazmadım. Çoğunlukla vim kullanıyorum çünkü V bazen bir acıdır. Çünkü countsatırdaki '1'lerin sayısını elde etmek için mükemmel olan komut satırdaki' 0'ların üzerine yazacaktır, bu yüzden daha sonra bunu reddedemeyiz.

Açıklama:

Bu, basit yoldan bir bayt daha kısa:

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

komut zincirleme nedeniyle. Bu komutları ayırdığından, açıklama için kullanacağım.

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

Şimdi, imzalı her bir tekli numara ayrı bir satırdadır. Örnek olarak '11100110001'i kullanarak şu noktada sahip olacağız:

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

Her maçın sonuna yeni satırlar eklediğimiz için, bunu çalıştırmadan önce boş bir satırımız vardı. Bunu çalıştırdıktan sonra, bir '0' olacak (çünkü 0 '1'lerin koşusuyla eşleşti). Bu nedenle D, bu satırı silmek için çağırıyoruz , boş bırakıyoruz

Haskell , 68 66 bayt

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

Çevrimiçi deneyin! Girdileri sıfırlar ve birler listesi olarak alır. Örnek kullanım: f [0,0,0,1,1]verim [0,-2].

Açıklama:

Desen eşleştirme f(x:r)|(a,b)<-span(>0)rbağlar xgirişinin birinci elemana, aaşağıdakilerin bir (potansiyel olarak boş) listesine 1ler ve bgiriş geri kalanına. Bir giriş Verilen [0,1,1,1,0,0,1]biz almak x=0, a=[1,1,1]ve b=[0,0,1].

Geçerli sayı, aeğer x=0ya reddedilirse toplamı ya da aartı bir toplamıdır x=1. Bu sahip endekslenmesi ile elde edilir x, bir olumsuzluk ve artım fonksiyonu içeren bir liste halinde ve toplamına elde edilen fonksiyonun uygulanması a: [(0-),(1+)]!!x$sum a.

Kalan liste bboş veya ayırıcı sıfır ve sonraki sayı içeriyor. Liste kavraması kalıp üzerinde [z|_:t<-[b],z<-f t]eşleşmeye çalışır , yani başlık elemanını unutur ve listenin geri kalanını buna bağlar . Eğer başarısız bu maçı ve liste anlama değerlendirir boş olan yineleme için temel durumdur. Aksi takdirde işlev özyinelemeli olarak uygulanır ve liste kavranması sonucunun tüm öğelerini değerlendirir .b_:ttb[]ftzf t

Wolfram Dili (Mathematica) , 80 bayt

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

Çevrimiçi deneyin!

Üst StringCasesüste binen desenleri kontrol etmediği için tamircisini kötüye kullanır . Soldan sağa, çakışma olmadan arama yaptığımızdan, her zaman sadece ihtiyacımız olan tam sayıları alırız.

açıklama

#<>"0"

Sonuna sıfır ekle

StringCases

Aşağıdaki modelin tümünü bulun ...

x_~~Shortest@y___~~"0"

Tek bir karakter (ara x), ardından mümkün olan en kısa sıfır uzunluklu veya daha uzun bir dize (ara y), ardından sıfır gelir.

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

Eşleşen desene uygula: uzunluğunu al y. Eğer xsıfır, o zaman değerinin tersini. Başka, bir artırın.

Boş bir dize olacağı için 00bu yda kapsamaktadır ve compute -0( == 0) yöntemini kullanırız .

Brain-Flak , 94 (70?) Bayt

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

Çevrimiçi deneyin!

Bu aslında beyin flakı için şaşırtıcı bir şekilde kısadır.

İşte yorumlanmış / okunabilir versiyon:

([])

{

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

    {}

    ({}<>)

    <>([])

}<>

Çıktı tersine gelebiliyorsa, bunu 70 için yapabiliriz:

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

Benim bir ucu olan neredeyse bu durum için mükemmel. Ancak, işlem yapmadan önce 0'a basmamız gerektiğinden ('1'leri sayıyoruz) ve işlem bir döngüde gerçekleştiği için pek işe yaramaz. Bu ipucunu kullanarak karşılaşabileceğim en kısa şey:

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

bu da 94 bayt.

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

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

Çevrimiçi deneyin!

Kabuk , 20 18 17 15 14 bayt

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

Çevrimiçi deneyin!

açıklama

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

Yarma böyle çalışır. ġ/argümanını , falsili a,bolan her bir öğe çifti arasında böler /a b. /a bters çevrilmiş argümanlarla bölünme, böylece bbölünür a. Bu programdaki ilgili değerler şunlardır:

• /1 1verir 1.
• /1 0verir 0(falsy).
• /0 1verir Inf(pozitif sonsuzluk, doğruluk).
• /0 0verir Any(özel bir değer NaN benzeri falsy).

Acc !! , 252 237 bayt

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
}

Kullanır -0. Sayıları, sondaki sekmeyle sekme karakterleriyle ayırarak verir. Çevrimiçi deneyin!

^{Gerçek algoritmayı yazma süresi: 20 dakika. Ondalık çıkış kodumda hata ayıklama süresi: 45 dakika. : ^ P}

Yorumlarla

Bu yorumların kodu çok iyi açıklayıp açıklamadığını bilmiyorum - yazarken kendime notlarıma dayanıyorlar, bu yüzden Acc'in nasıl anlaşıldığını varsayıyorlar ! İşler. Bir şeyin daha fazla açıklamaya ihtiyacı varsa, bana bildirin, daha açık hale getirmeye çalışacağım.

# 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 , 9692 bayt

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

Çevrimiçi deneyin!

Her biri 2 bayt için ox ve DLosc.

R , 119 bayt

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

Çevrimiçi deneyin!

Kod, ilgili bir sorun için stackoverflow bu çözümü kullanır (Fikir için jeales sayesinde). Çıktı, stdout'a yazdırılmış, boşlukla ayrılmış bir dizedir.

Jöle ,  19  18 bayt

^{Daha iyi bir yol olmalı ...}

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

Her numarayı izleyen tam program ve ardından satır besleme.

Çevrimiçi deneyin!

Nası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)

QBasic, 88 86 bayt

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

Bu komikti. 107 baytlık bir sürümden başlayan birden fazla düzeltme, QBasic'in en gizli parçalarından biri ile sonuçlandığını düşünüyorum.(Düzenleme: Garibi, kodu daha net hale getirerek 2 bayt golf başardı.)

Not: Bu program, ekrana girmeden kullanıcı girişini bir kerede bir karakter okur ( INPUT$(1)normal INPUTifade yerine kullanmanın bir sonucu olarak ). Yazarken, 1 ve 0'ları görmezsiniz, ancak ondalık sayılar hesaplandıkça görünür. Vurduğunuzdan emin olunEnterSon sayıyı görmek ve programı sonlandırmak için girişin sonundan .

Ungolfed sürümü

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$

açıklama

(AKA "Ne? Bu hala mantıklı değil!")

Temel strateji, INPUT$(1)her seferinde bir karakter yakalayan , onunla bir şeyler yapan ve karakterin ASCII değerinden daha yüksek olduğu sürece !(yani bir satırsonu olmayan) bir döngü çalıştırmaktır .

Devam eden sayıları iki değişken kullanarak takip ediyoruz. numgeçerli imzalı tek sayıdaki karakter sayısıdır (baştaki sıfır dahil). signolan 1sayı lider sıfır olsaydı,0 değilse. Bunların her ikisinin de0 , bu QBasic'deki sayısal değişkenler otomatik olarak başlatıldığından, golf edilmiş sürüm için harikadır 0.

Biz bir karakter okumak zaman, ilk şey olup olmadığını belirlemektir 1veya 0. Bu sonucu iki kez kullanacağız, bu yüzden saklıyoruz isZero. Teknik olarak, bu isim yanıltıcıdır, çünkü karakter bir satırsonu ise değer de doğrudur. QBasic'teki gerçeğin-1 ve Falsey olduğunu0 .

Şimdi, bir sayıyı ( num > 0) okumanın ortasındaysak ve sıfırdan veya girişin ( isZero) sonuna ulaşırsak, okumayı bitirdiğimiz sayıyı hesaplamamız gerekir.

• sign0pozitif, 1negatif için depolar . Almak için 1pozitifliği ve -1negatif için ihtiyacımız 1-2*sign.
• numpozitifler için doğru büyüklüğü, ancak negatifler için büyüklükten bir tane daha saklar (işaret işaretini içerdiği için). Böylece num-signbüyüklük için kullanabiliriz .

Bunları bir araya getirin ve yazdırın; Daha sonra sıfırlamak signve numhiç0 bir sonraki numarayı okumak için hazırlık.

Aksi takdirde (sıfıra ulaşmazsak veya bir sayının başında sıfıra ulaşırsak), günceller signve numaşağıdaki gibi:

• signbaştaki 1sıfıra baktığımızda olur; Aksi halde, birine bakarsak, zaten ne olursa olsun kalır. Golfçü kod s=s-zaynı şeydir:
  • Bu önde gelen sıfır ise, zolur -1. Yana solması sağlanır 0(bu yeni sayının başlangıç olduğu için), s-zolacaktır 1.
  • Eğer bu bir zise 0. Sonra daha önce sahip s-zolunan değerde kalır s.
• num artırılır.

Bu kadar!

JavaScript (ES6), 60 bayt

Boşlukla ayrılmış bir tamsayı listesi döndürür.

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

Test senaryoları

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 bayt

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

Çevrimiçi deneyin!

Tam program, komut satırından girdi alır ve yeni satırlarla ayrılmış sayıları stdout'a yazdırır.