4chan, popüler bir oyun olsun. Sitedeki her yayın sıralı bir yayın kimliği alır. Onları etkileyemediğiniz veya belirleyemediğiniz için, insanlar kendi posta numaralarını, genellikle ilk birkaç rakamı (en azından bir kısmını) tahmin etmeye çalışırlar. Oyunun bir başka versiyonu da dubs olarak adlandırılıyor ve hedefi sayının sonunda tekrarlayan rakamları (yani 1234555) elde etmektir.

Göreviniz kabul etmek isterseniz, giriş kimliğini girdi olarak alan bir program yazmaktır (standart tamsayı, 2 ^ 32'nin altında olabilir) ve sonunda kaç tane basamak olduğunu döndürür.

kurallar

• Standart boşluklara izin verilmez .
• Program, çalıştırmak için harici sayılmamış kod / argüman gerekmediği sürece, gerçekten çalışan, bir fonksiyon, tam program, REPL komutu olabilir.
• Girdi, STDIN'den, işlev argümanlarından, komut satırı argümanından, dosyadan ve size uygun olandan gelebilir.

Test Kılıfları

Input: 14892093
Output: 1

Input: 12344444
Output: 5

Input: 112311
Output: 2

Input: 888888
Output: 6

Input: 135866667 //Post number I got on /pol/ few days ago, rip
Output: 1

Mathematica, 29 bayt

Aritmetik bir çözüme ne dersiniz?

IntegerExponent[9#+#~Mod~10]&

Bunun ileri düz Mathematica yaklaşımını geçtiğini görmek beni çok mutlu etti.

açıklama

Kodun kendisi 9 * n + n% 10 değerini hesaplar ve ardından girişi bölen en büyük 10 gücünü bulur veya diğer bir deyişle izleyen sıfırları sayar. Biz olmadığını göstermek için gereken N uçlarında k olduğu, tekrar basamak 9 * n + n% 10 vardır k sondaki sıfırlar.

Rep-basamaklar, 99999 gibi bir sayıyı ( 10 ⁵ -1 ) 9'a bölerek ve daha sonra tekrarlanan sayı ile çarparak matematiksel olarak en kolay ifade edilir . Yazabiliriz Böylece , n = m * 10 ^K + d * (10 ^k -1) / 9 , m ≢ d (mod 10) , sağlamak için , n bitmez daha fazla k tekrar basamağı. D = n% 10 olduğuna dikkat edin .

Bunu 9 * n + n% 10 formülümüze ekleyelim . 9 x m * 10 ^k + d * (10 ^k -1) + d elde ederiz . D : Biz ile sol böylece sonunda, iptal edilir * 10 9 * m ^K + d x 10 ^K = (9 x m + d) x 10 ^k . Ancak 9 ≡ -1 (mod 10) , yani 9 * m + d ≡ d - m (mod 10) . Fakat biz m ≢ d (mod 10) ve dolayısıyla d - m ≢ 0 (mod 10) olduğunu iddia ettik .

Diğer bir deyişle, söz konusu gösterdikleri 9 * m + d tarafından bölünebilir değildir , 10 ve bu yüzden, en büyük enerji 10 bu bölme 9 10 * N + n% 10 = (9 x m + d) ^k olduğu k , sondaki tekrarlanan hanelerin sayısı.

Bir bonus olarak, bu çözüm ∞giriş için doğru sonucu yazdırır 0.

Retina , 9 bayt

&`(.)\1*$

Çevrimiçi deneyin!

(.)\1*$Aynı karakter sonekine uyan bir regex olan çakışan eşleşme sayısını sayar .

Brachylog , 4 bayt

ẹḅtl

Çevrimiçi deneyin!

açıklama

ẹ       Elements: split to a list of digits
 ḅ      Blocks: group consecutive equal digits into lists
  t     Tail: take the last list
   l    Length: Output is the length of that last list

Eğer ḅtamsayılar üzerinde doğrudan çalıştık (ve bu yüzden yaptığı uygulamak vermedi neden emin değilim) gibi bu sadece 3 byte olacaktır ẹihtiyaç olmaz.

Python 2 , 47 41 bayt

lambda s:len(`s`)-len(`s`.rstrip(`s%10`))

Çevrimiçi deneyin!

36 bayt - Daha esnek bir giriş için

lambda s:len(s)-len(s.rstrip(s[-1]))

Çevrimiçi deneyin!

Javascript (ES6), 55 52 32 30 bayt

a=>a.match`(.)\\1*$`[0].length

• Regex değiştirerek @MartinEnder sayesinde 19 bayt kaydedildi
• Etiketli şablonları kullanarak @ user81655 sayesinde 2 bayt kaydedildi

Son basamağın son grubuyla eşleştirmek için bir regex kullanma

Not: İlk kez gönderme. Açıklama yapmaktan çekinmeyin.

f=a=>a.match`(.)\\1*$`[0].length


console.log(f("14892093"));//1
console.log(f("12344444"));//5
console.log(f("112311"));//2
console.log(f("888888"));//6
console.log(f("135866667 "));//1

C, 62 56 48 47 bayt

@ Steadybox sayesinde bir bayt kaydedildi!

j,k;f(n){for(k=j=n%10;j==n%10;n/=10,k++);k-=j;}

Çevrimiçi deneyin!

PHP, 47 45 40 bayt

while($argn[-++$i]==$argn[-1]);echo$i-1;

İle koş echo <n> | php -nR '<code>

Görünüşe göre bir döngü hala ilk cevabımdan daha küçük. sadece sonuncuya eşit olan karakterleri sayın. Bu, PHP 7.1'in negatif dize ofsetlerini kullanır .

-5 Titus tarafından bayt . Teşekkürler !

Eski cevap:

<?=strlen($a=$argv[1])-strlen(chop($a,$a[-1]));

en sağdaki karaktere uyan her karakter sağdan kaldırılır ve uzunluktaki farkı hesaplar.

05AB1E , 4 bayt

.¡¤g

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

.¡    # group consecutive equal elements in input
  ¤   # get the last group
   g  # push its length

CJam , 7 bayt

re`W=0=

Çevrimiçi deneyin!

açıklama

r   e# Read input.
e`  e# Run-length encode.
W=  e# Get last run.
0=  e# Get length.

Jöle , 5 bayt

DŒgṪL

Çevrimiçi deneyin!

açıklama

D      # convert from integer to decimal   
 Œg    # group runs of equal elements
   Ṫ   # tail
    L  # length

Perl 5 , 22 bayt

21 bayt kodu + -pbayrak.

/(.)\1*$/;$_=length$&

Çevrimiçi deneyin!

/(.)\1*$/Son özdeş sayıları alır ve daha sonra $_=length$&uzunluğunu atar $_, ki bu -pbayrak sayesinde dolaylı olarak basılır .

C (gcc) , 32 29 bayt

f(x){x=x%100%11?1:-~f(x/10);}

Bu bir liman Python cevabımın .

Bu gcc ile çalışır, ancak bir eksikliği return ifadenin tanımsız bir davranıştır.

Çevrimiçi deneyin!

Python 2, 51 bayt

Tamsayı giriş olarak alır. Çevrimiçi deneyin

lambda S:[x==`S`[-1]for x in`S`[::-1]+'~'].index(0)

Giriş olarak dize için 48 bayt. Çevrimiçi deneyin

lambda S:[x==S[-1]for x in S[::-1]+'~'].index(0)

C # , 63 62 bayt

golfed

i=>{int a=i.Length-1,b=a;while(a-->0&&i[a]==i[b]);return b-a;}

Ungolfed

i => {
    int a = i.Length - 1,
        b = a;

    while( a-- > 0 && i[ a ] == i[ b ] );

    return b - a;
}

Ungolfed okunabilir

i => {
    int a = i.Length - 1, // Store the length of the input
        b = a ;           // Get the position of the last char

    // Cycle through the string from the right to the left
    //   while the current char is equal to the last char
    while( a-- > 0 && i[ a ] == i[ b ] );

    // Return the difference between the last position
    //   and the last occurrence of the same char
    return b - a;
}

Tam kod

using System;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            int a = i.Length - 1, b = a;
            while( a-- > 0 && i[ a ] == i[ b ] );
            return b - a;
         };

         List<String>
            testCases = new List<String>() {
               "14892093",
               "12344444",
               "112311",
               "888888",
               "135866667"
            };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput: {f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Bültenleri

• v1.1 - - 1 byte - Kevin'ın yorumuna teşekkürler .
• v1.0 -  63 bytes- İlk çözüm.

notlar

Eklenecek bir şey yok

Python 2 , 38 32 bayt

f=lambda n:0<n%100%11or-~f(n/10)

6 bayt kaydettiğiniz için @xnor'a teşekkürler!

Çevrimiçi deneyin!

MATL , 6 5 bayt

@Luis sayesinde 1 bayt kurtarıldı

&Y'O)

MATL Online'da deneyin

açıklama

        % Implicitly grab input as a string
&Y'     % Perform run-length encoding on the string but keep only the second output
        % Which is the number of successive times an element appeared
O)      % Grab the last element from this array
        % Implicitly display

Cubix, 24 19 bayt

)uO)ABq-!wpUp)W.@;;

Not

• Aslında girişin sonunda aynı karakterlerin kaç tanesinin olduğunu sayar, bu nedenle bu gerçekten büyük tam sayılar ve gerçekten uzun karakter dizileri için de geçerlidir (sonunda aynı karakterlerin sayısı JavaScript'in maksimum hassasiyetinden küçük olduğu sürece ( 10 tabanındaki yaklaşık 15 hane).
• Giriş, giriş alanına giriyor, çıkış, çıkış alanına basılıyor

Burada dene

açıklama

İlk önce, küpü genişletelim

    ) u
    O )
A B q - ! w p U
p ) W . @ ; ; .
    . .
    . .

Uygulamadaki adımlar üç aşamada ayrılabilir:

1. Ayrıştırma girişi
2. Karakterleri karşılaştır
3. Sonucu yazdır

Faz 1: Giriş

Gerçekleştirilen ilk iki karakter Ave B. Atüm girişi okur ve karakter kodları olarak yığına iter. Bunun tersten yapıldığına dikkat edin, ilk karakter yığının en üstünde, en son da neredeyse en altta biter. En altta, dizgenin sonundaki ardışık karakterlerin miktarı için bir sayaç olarak kullanılacak olan -1( EOF) yerleştirilir. Son iki karakteri içermesi için yığının tepesine ihtiyacımız olduğundan, döngüye girmeden önce yığını tersine çeviririz. Yığının en üst kısmının artık şöyle göründüğünü unutmayın:..., C[n-1], C[n], -1 .

IP'nin küp üzerindeki yeri, Eolduğu yer ve doğru olduğunu gösteriyor. Henüz uygulanmayan tüm talimatlar no-op'larla değiştirildi (tam durak).

    . .
    . .
A B E . . . . .
. . . . . . . .
    . .
    . .

Faz 2: Karakter karşılaştırması

Yığın, kontrol edilecek ( ve ) iki karakterin eşit ..., C[a-1], C[a], counterolduğu durumlarda counterartma sayacının olduğu yerdir . IP ilk önce bu döngüye karakterden girerek sağa ilerler. Karakter IP (hakkı işaret) sona erecek pozisyonudur ve aynı değeri çıkarılarak bu araçlara sahip olmayan dan verim vermez , bu durumda aşağıdaki talimatı de atlanır (bir olan ).C[a]C[a-1]SEC[a]C[a-1]C[a]C[a-1]0!w

    . .
    . .
. S q - ! w E .
p ) W . . ; ; .
    . .
    . .

Tam bir döngü sırasında yürütülen talimatlar:

q-!;;p) # Explanation
q       # Push counter to the bottom of the stack
        #     Stack (counter, ..., C[a-1], C[a])
 -      # Subtract C[a] from C[a-1], which is 0 if both are equal
        #     Stack (counter, ..., C[a-1], C[a], C[a-1]-C[a])
  !     # Leave the loop if C[a-1]-C[a] does not equal 0
   ;;   # Remove result of subtraction and C[a] from stack
        #     Stack (counter, ..., C[a-1])
     p  # Move the bottom of the stack to the top
        #     Stack (..., C[a-1], counter)
      ) # Increment the counter
        #     Stack (..., C[a-1], counter + 1)

Ve sonra etrafında dolaşıyor.

Faz 3: Baskı sonucu

Erken döngü ayrıldığından beri, yığın görünüyor bu gibi: counter, ..., C[a-1]-C[a]. Bu sayaç yazdırmak için kolay, ama biz de saymayı başladık çünkü biz döngünün son tekrarında bunu ve bir kez daha çünkü bir kez sayacını artırmak zorunda -1yerine 0. Küp üzerindeki yol, Ssağdan işaret ederek başlayarak bu şekilde görünür . IP tarafından yürütülen iki no-op, IP yönünü gösteren oklarla değiştirilir.

    ) u
    O )
. B . . . S p U
. ) . . @ . . .
    > >
    . .

Talimatlar aşağıdaki sırayla gerçekleştirilir. B)Sonunda verilen talimatların yığını değiştirdiğini ancak programı sonlandırmayacağımızdan, programı sonlandırmayacağımıza ve yığını kullanmayacağımıza dikkat edin.

p))OB)@ # Explanation
p       # Pull the counter to the top
        #     Stack: (..., counter)
 ))     # Add two
        #     Stack: (..., counter + 2)
   O    # Output as number
    B)  # Reverse the stack and increment the top
      @ # End the program

Alea iacta est.

Toplu iş, 91 bayt

@set s=-%1
@set n=1
:l
@if %s:~-2,1%==%s:~-1% set s=%s:~,-1%&set/an+=1&goto l
@echo %n%

-Önler dize başlangıcını akıp testi.

JavaScript (ES6), 34 bayt

f=(n,p)=>n%10-p?0:1+f(n/10|0,n%10)

Regex çözümünden daha kısa değil.

Rakamları sağdan sola değerlendiren özyinelemeli fonksiyon, farklı bir rakamla karşılaşıldığında durma. Sonuç, yinelemelerin sayısıdır. polduğu undefinedanlamına gelir birinci tekrar, ilgili n%10-pdöner NaN(falsy). Bundan sonra p, bir önceki haneye eşittir n%10. Geçerli hane ( n%10) ve önceki ( p) farklı olduğunda, döngü sona erer.

Röda , 12 bayt

{count|tail}

Çevrimiçi deneyin!

Bu, giriş dizesinin her karakterinin akışa itilmesini bekleyen adsız bir işlevdir (bence bu son bir meta sorusunun ruhu için geçerlidir ).

İki yerleşik kullanır: countve tail:

1. count akıştan değerleri okur ve ardışık öğelerin sayısını akışa doğru iter.
2. tail akıştaki son değeri döndürür.

T-SQL, 238 214 Bayt

declare @ varchar(max) = '' declare @i int=0, @e int=0, @n int=right(@,1), @m int while (@i<=len(@)) begin set @m=(substring(@,len(@)-@i,1)) if (@n=@m) set @e=@e+1 else if (@i=0) set @e=1 set @i=@i+1 end select @e

Veya:

declare @ varchar(max) = '12345678999999'
declare 
    @i int = 0,
    @e int = 0,
    @n int = right(@,1),
    @m int

while (@i <= len(@))
begin
    set @m = (substring(@,len(@)-@i,1))
    if (@n = @m) set @e = @e + 1
    else
    if (@i) = 0 set @e = 1
    set @i = @i + 1
end
select @e

Java 7, 78 bayt

int c(int n){return(""+n).length()-(""+n).replaceAll("(.)\\1*$","").length();}

Burada dene.

Özyineleme veya döngü kullanarak bazı şeyler denedim, ancak ikisi de 100 bayttan fazlaydı.

Powershell, 41 Bayt

for($n="$args";$n[-1]-eq$n[-++$a]){};$a-1

Bir karakter dizedeki son karakter ile uyuşmayana kadar basit döngü, karakter karakterini -1 döndürür.

-3 @AdmBorkBork sayesinde - bir süre yerine for döngüsü kullanıyor.

Mathematica, 33 30 bayt

Greg Martin'e 3 bayt kaydettiği için teşekkürler.

Tr[1^Last@Split@Characters@#]&

Bir dize olarak girdi alır.

Ondalık basamakları (karakter biçiminde) alır, bunları özdeş öğelerin akışlarına böler, son çalışmayı alır ve uzunluğu vektörün toplamını almanın standart numarasıyla hesaplar 1^list.

Bash + Unix yardımcı programları, 34 bayt

sed s/.*[^${1: -1}].//<<<x$1|wc -c

Çevrimiçi deneyin!

JavaScript (ES6), 39 38 37 27 bayt

f=n=>n%100%11?1:1+f(n/10|0)

Belki regex tabanlı çözümden daha kısa olmasa da, tamamen aritmetik temelli bir çözüm yazmaya karşı koyamadım. Teknik, n % 100 % 11sonuç sıfır olmayana kadar art arda 10'a kadar alıp bölmek, ardından yinelemeleri saymaktır. Bu çalışır çünkü son iki hane aynıysa, n % 100 % 11aynı olacaktır 0.

Haskell , 33 bayt

f(h:t)=sum[1|all(==h)t]+f t
f _=0

Çevrimiçi deneyin!

Dize girişi alır. Arka arkaya ilk karakteri keser ve sonekteki tüm karakterler ilk karaktere eşitse 1 ekler.

R, 35 bayt

rle(rev(charToRaw(scan(,''))))$l[1]

Kısa açıklama

                  scan(,'')         # get input as a string
        charToRaw(         )        # convert to a vector of raws (splits the string)
    rev(                    )       # reverse the vector
rle(                         )$l[1] # the first length from run length encoding

Befunge-98 , 19 bayt

01g3j@.$~:01p-!j$1+

Çevrimiçi deneyin!

Yalnızca yığını kullanabilseydim bu daha kısa yapılabilirdi.

Nasıl çalışır:

01g3j@.$~:01p-!j$1+
01g                 ; Get the stored value (default: 32)                 ;
   3j               ; Skip to the ~                                      ;
        ~           ; Get the next character of input                    ;
         :01p       ; Overwrite the stored value with the new char       ;
             -!     ; Compare the old value and the new                  ;
               j$   ; Skip the $ when equal, else pop the counter        ;
                 1+ ; Increment the counter                              ;

; When the input runs out, ~ reflects the IP and we run: ;
   @.$
     $              ; Pop the extraneous value (the stored value) ;
   @.               ; Print the number and exit                   ;

Python 3 - 50 44 bayt

Tam program (Python 3'te input()giriş ne olursa olsun bir dize döndürür):

g=input();print(len(g)-len(g.rstrip(g[-1])))