Bugünkü göreviniz, bir dizi tamsayı alan ve soldan sağa doğru okuyarak, değerin değiştiği sayıları sayan bir program veya işlev yazmaktır. Bir örnekle bunu göstermek daha kolaydır:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

Test durumu:

Input           |   Output
[]              |   0
[0]             |   0
[0 1]           |   1
[0 0]           |   0
[1 2 3 17]      |   3
[1 1 1 2 2 3]   |   2
[-3 3 3 -3 0]   |   3

Bu kod golf , en az bayt kazanır!

MATL , 2 bayt

dz

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

     % Implicit input
d    % Consecutive differences
z    % Number of nonzeros
     % Implicit display

Python 3 , 38 bayt

f=lambda x=0,*y:y>()and(x!=y[0])+f(*y)

Çevrimiçi deneyin!

Haskell , 33 bayt

f(a:b:r)=sum[1|a/=b]+f(b:r)
f _=0

Çevrimiçi deneyin!

Bonus: Biraz meraklı noktasız aritmetik versiyon (44 bayt)

sum.(tail>>=zipWith((((0^).(0^).abs).).(-)))

Çevrimiçi deneyin!

Bir giriş göz önüne alındığında [1,1,4,3,3,3], ilk bitişik girişleri (farkını alır [0,3,-1,0,0]), sonra abs: olute değer [0,3,1,0,0]. Her elemanın gücüne sıfır almak ilk kez sonuç verir [1,0,0,1,1]ve ikinci kez listeyi tersine çevirir: [0,1,1,0,0]( (1-)yerine burada da çalışır (0^)). Sonunda almak için sumlisteyi alıyoruz 2.

Python 2 , 42 bayt

lambda a:sum(x!=y for x,y in zip(a,a[1:]))

Çevrimiçi deneyin!

Brain-Flak , 50 bayt

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

Çevrimiçi deneyin!

Brain-flak'ta eşdeğer olan 0 için hiçbir şey çıktılamaz. Bu kabul edilebilir değilse, +4bayt için bunu ekleyin :({})

Açıklama:

#Push stack-height-1
([][()])

#While true:
{

    #Pop the stack-height-1 off
    {}

    #If 'a' is the element on top of the stack, and 'b' is the element underneath it, then
    #Pop 'a' off, and push (a - b)
    ({}[({})])

    #If (a-b) is not 0...
    {
        #Pop (a-b) off
        {}

        #Switch stacks
        <>

        #Increment the value on the other stack
        ({}())

        #Push a 0 back to the main stack
        (<>)

    #Endif
    }

    #Pop either (a-b) or the 0 we pushed
    {}

    #Push stack-height-1
    ([][()])

#Endwhile
}

#Toggle to the alternate stack and display the counter
<>

Brain-Flak , 50 bayt

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

Çevrimiçi deneyin!

# Get ready to push the answer
(

# Push stack height - 1
([][()])

# Loop until 0 (until the stack has a height of 1)
{

  # Pop the old stack height and subtract it 
  #(cancels the loop counter from the final answer)
  [{}]

  # Pop the top of the stack and subtract the next element from that
  # Don't include this in the final answer
  <({}[({})])>

  # If not 0
  {

    # Pop the difference between the last two numbers
    # Don't include this in the final answer
    (<{}>)

    # Add 1 to the final answer
    ()

  # End if
  }{}

  # Push stack height - 1
  ([][()])

# End while
}

# Switch to the off stack so we don't print anything extra
<>

# Push the total sum. This is the number of times the if was true
)

Haskell , 35 bayt

H.PWiz sayesinde -8 bayt.

Özyinelemeli bir sürümle golf . Haskell neredeyse özyineleme en iyisidir ve özledim. > _ <

f l=sum[1|x<-zipWith(/=)l$tail l,x]

Çevrimiçi deneyin!

Herkes istihdam nasıl anladım eğer müthiş olurdu bu ipucunu .

Alternatif çözüm, 36 bayt

f l=sum[1|True<-zipWith(/=)l$tail l]

Çevrimiçi deneyin!

Java (OpenJDK 8) , 65 bayt

İstediğim kadar kısa değil, ama bu sadece sizin için Java.

Diziyi virgülle ayrılmış bir liste olarak geçirerek test edin.

a->{int s=0,i=1;for(;i<a.length;s+=a[i-1]!=a[i++]?1:0);return s;}

Çevrimiçi deneyin!

Kabuk , 3 bayt

Ltg

Çevrimiçi deneyin!

açıklama

Ltg    Input: [1,1,1,2,2,3]
  g    Group equal elements together: [[1,1,1],[2,2],[3]]
 t     Drop the first group (if any): [[2,2],[3]]
L      Return the length of the list: 2

Ohm v2 , 3 bayt

ΔyΣ

Çevrimiçi deneyin!

açıklama

Δ     absolute differences between consecutive elements
 y    sign: 1 if positive, -1 if negative, 0 if zero
  Σ   sum

Wolfram Dili (Mathematica) , 2324 26 29 bayt

Length@Split@#~Max~1-1&

Çevrimiçi deneyin!

• Martin Ender sayesinde -1 bayt!
• JungHwan Min sayesinde -2 bayt! güzel kullanımı Split[].
• Tamamen insanlık sayesinde -3 byte!

biraz açıklama:

Splitbir diziyi bir liste listesine (aynı öğelerin), yani dönüştürülecek şekilde {1, 2, 2, 3, 1, 1}böler {{1}, {2, 2}, {3}, {1, 1}}. Yani, Length@Split@#ardışık segmentlerin miktarı. girdi Max[*****-1, 0]ile uğraşmak için kullanılır {}.

Retina , 24 21 16 bayt

@MartinEnder'e -3 bayt için teşekkürler ve bir hata
-1 bayt fark ederek @tsh
-4 bayt @Leo sayesinde

m`^(\S+)¶(?!\1$)

Çevrimiçi deneyin!

Sembolik Python , 120 117 bayt

+Sayaç değişkeni için tamsayıya (unary kullanılarak ) açık bir kademe kaldırarak 3 bayt golf - bu, dizide herhangi bir değişiklik olmazsa çıktının Falseyerine izin verileceği0 , ancak metaya izin verildiği anlamına gelir .

___=-~(_==_)
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___)
_=___

Çevrimiçi deneyin!

# LINE 1: Generate value '2' for utility
___=-~(_==_)

# LINE 2: Get len(input) - 1
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
   '___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)'     # Generate string '___=~-len(_)'
            `_>_`[___::___]                       #    'le' spliced from 'False'
                           +`__`[-~___]           #    'n' indexed from '<function ...>'
   '___=~-'+                           +'(_)'     #    Remaining characters in plaintext
__(                                          )    # Execute this to get len(input) - 1

# LINE 3: Main calculation loop
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___) 
__(                                               ) # Execute:
   '__=___=_>_'                                     #   Set var1, var2 to 0
               +';                           '*___  #   len(input) - 1 times do:
                       _[__]!=_[-~__]               #   Compare input[var1, var1 + 1]
                  ___+=              ;              #   Add this to var2
                                      __=-~__       #   Increment var1

# LINE 4: Set output variable ('_') to the result calculated.
_=___                                       

Jöle , 3 bayt

ITL

Çevrimiçi deneyin!

Nasıl çalışır

ITL - Tam program.

I - Artışlar (deltalar).
 T - Doğru değerlerin indekslerini alın (0 olmayan elemanların indekslerini alır).
  L - Uzunluk.

K (oK) , 8 bayt

Çözüm:

+/1_~~':

Çevrimiçi deneyin!

Örnekler:

+/1_~~':1 1 1 2 2 5 5 5 5 17 3
4
+/1_~~':()
0
+/1_~~':-3 3 3 -3 0
3

Açıklama:

Sağdan sola yorumlandı:

+/1_~~': / the solution
     ~': / equal each-previous
    ~    / not (ie differ)
  1_     / 1 drop, remove first as this is different to null
+/       / sum up trues

05AB1E , 3 bayt

¥ĀO

Çevrimiçi deneyin!

Kabuk , 4 bayt

#IẊ≠

Çevrimiçi deneyin!

R , 24 bayt

cat(sum(!!diff(scan())))

Çevrimiçi deneyin!

MATL cevabı ile aynı, sadece sum(!!diff))olmadığı için kullanılır nnz.

Cubix , 24 bayt

UpO@0I>I!^-u>q.uvv$!^;)p

Çevrimiçi deneyin

Cubix'in başka girdi olmadığını belirtmek için 0 kullandığını unutmayın, bu nedenle 0 listede olamaz.

açıklama

Kırımsız:

    U p
    O @
0 I > I ! ^ - u
> q . u v v $ !
    ^ ;
    ) p

0Sayaç (ile başlatıldı 0) ve ilk girişi ( I) yığına iterek başlıyoruz .

Sonra döngüye giriyoruz. Döngünün her yinelemesinde, bir sonraki girdiyi alırız I. 0 ise, girişlerimiz tükenmiştir, bu nedenle sayacı üste ( p), Output ve exit ( @) konumuna döndürürüz .

Aksi takdirde, ilk iki elementin farkını alırız. Sıfır değilse, sayacı tepeye döndürür, arttırır ve ile tekrar tabana döndürürüz p)q. Daha sonra bir ;sonraki yinelemeye geçmeden önce farkı fark ederiz .

Burada belirtilmeyen tüm karakterler sadece kontrol akışıdır. Cubix programlarında birçoğu var.

Brain-Flak , 50 bayt

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

Çevrimiçi deneyin!

Herkes 50 baytlık çözümlerini burada paylaştığım için benim ( 48 baytlık bir tane var ama DjMcMayhem'in basit bir modifikasyonuydu, bu yüzden göndermeye değer hissettim)

açıklama

Bu cevap, değer iptal etmeyi yoğun olarak kullanmaktadır.

Golf oynanmamış gibi görünüyor

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

Burada, yığında bir öğe kalıncaya kadar deltayı hesaplıyoruz, eğer delta sıfır değilse, iç döngüden her bir değer biriktirdiğimizde.

Bu, bunu yapmanın oldukça basit bir yoludur.

Bu golf yapmak için değer iptal etmeye başlıyoruz. Birincisi ve herhangi bir sertleştirilmiş beyin-flak golfçüsü için açık olması gereken, yığın yüksekliğidir. İyi bilinen bir gerçektir

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

aynıdır

(([]){[{}]...([])}{})

Değerler bir değiştirildiği zaman aynı kalır. Bu bize

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

Bunun bizi bayt tasarruf etmediğini fark edebilirsiniz, ancak devam ettikçe daha kullanışlı hale geleceğinden korkmayın.

Bir ifade görürseniz başka bir indirim yapabiliriz

<(...)>{<{}> ...

bunu aslında

[(...)]{{} ...

Bu eserler biz döngüye girmesine çünkü eğer [(...)]ve {}iptal edecek ve biz değil değerini yaparsanız [(...)]zaten ilk etapta sıfırdı ve iptal edilmesi gerekmez. Kodumuzda bu paternin ortaya çıkması nedeniyle onu azaltabiliriz.

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

Bu bize 2 bayt kurtardı ama aynı zamanda yan yana iki hata koydu. Bunlar bizi başka 2 kurtarmak için birleştirilebilir.

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

Ve bu bizim kodumuz.

Perl 6 , 18 bayt

{sum $_ Z!= .skip}

Dene

Expanded:

{ # bare block lambda with implicit parameter ｢$_｣

  sum         # count the number of True values

      $_      # the input
    Z!=       # zip using &infix:«!=»
      .skip   # the input, but starting from the second value
              # (implicit method call on ｢$_｣
}

Gaia , 2 bayt

ėl

Çevrimiçi deneyin!

Bu, Gaia'nın bir hatasını (veya özelliğini?) Kötüye kullanır, çalışma uzunluğu kodlamasının, öğelerin son çalışmasını dikkate almaz. Çift kontrol ettiğimi, tüm test senaryolarında işe yaradığını unutmayın.

• ė - Çalışma uzunluğu kodlaması (yukarıda açıklanan hata ile).
• l - Uzunluk.

JavaScript (ES6), 35 bayt

a=>a.filter((e,i)=>e-a[i+1]).length

Pyth, 5 bayt

l #.+

Test odası.

Açıklama:

   .+  Deltas
  #    Filter on identity (space)
l      Get length 

APL (Dyalog) , 8 bayt

+/2≠/⊃,⊢

Çevrimiçi deneyin!

Nasıl?

⊃,⊢ - tek eleman durumunda ilk değer tekrarlanan liste

2≠/ - değişiklik listesi, her 2 öğe için eşit değil

+/ - toplam

Perl 5 , 37 + 2 ( -ap) = 39 bayt

$\+=$F[$_]!=$F[$_-1]for 1..$#F}{$\|=0

Çevrimiçi deneyin!

J, 10 bayt

[:+/2~:/\]

Uzunluk 2 ekleri ... eşit değil mi? 2 ~:/\ ]

Ortaya çıkan 0s ve 1s listelerini toplayın:+/

Çevrimiçi deneyin!

Ruby , 31 bayt

->a{a.chunk{|x|x}.drop(1).size}

Çevrimiçi deneyin!

C (gcc 5.4.0), 61 bayt

f(c,v)int*v;{int*p=v,s=0;for(;p<v+c-1;s+=*p++!=*p);return s;}

Çevrimiçi deneyin!

f dizinin uzunluğunu ve dizinin ilk öğesine bir işaretçi alan ve dizideki değişiklik sayısını döndüren bir işlevdir;

Bu gönderim *p++!=*p, makinemde (gcc 5.4.0) ve TIO'da çalışan, ancak diğer uygulamalar veya sürümlerde çalışmayabilen tanımlanmamış davranış (( p değiştirildiği bir ifadede iki kez kullanılır) kullanır .

Açıklama:

f(c,v)int*v;{ // old-style declaration for v, and implicit-int for c and return value
    int*p=v,s=0; // p is a pointer to the current item, s is the number of changes
    for(;p<v+c-1;s+=*p++!=*p); // for each consecutive pair of integers, if they are different, add one to the number of changes
    return s; // return the number of changes
}

05AB1E , 3 bayt

γ¦g

Çevrimiçi deneyin!

Erik'in cevabına bir alternatif.

Fullg ~ Tam program.

Eşit bitişik elemanların çalışma gruplandırın.
 Group ~ İlk grubu çıkarın (varsa).
  g ~ Uzunluk.