Trên 4chan, một trò chơi phổ biến là get. Mỗi bài đăng trên trang web sẽ nhận được một ID bài liên tiếp. Vì bạn không thể ảnh hưởng hoặc xác định chúng, mọi người cố gắng đoán (ít nhất là một phần) số bài đăng của riêng họ, thường là một vài chữ số đầu tiên. Một phiên bản khác của trò chơi được gọi là dubs và mục tiêu của nó là lấy các chữ số lặp lại ở cuối số (tức là 1234555).

Nhiệm vụ của bạn, nếu bạn muốn chấp nhận nó, là viết một chương trình lấy id bài đăng làm đầu vào (số nguyên chuẩn, bạn có thể giả sử dưới 2 ^ 32) và trả về số lượng chữ số lặp lại ở cuối.

Quy tắc

• Sơ hở tiêu chuẩn là không được phép .
• Chương trình có thể là một hàm, chương trình đầy đủ, lệnh REPL, bất cứ thứ gì hoạt động, thực sự, miễn là không cần mã / đối số không đếm được bên ngoài để chạy nó.
• Đầu vào có thể đến từ STDIN, đối số chức năng, đối số dòng lệnh, tệp, bất cứ điều gì phù hợp với bạn.

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

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

Toán học, 29 byte

Làm thế nào về một giải pháp số học?

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

Tôi rất vui khi thấy rằng điều này đánh bại cách tiếp cận Mathicala thẳng tiến.

Giải trình

Bản thân mã này tính toán 9 * n + n% 10 và sau đó tìm ra công suất lớn nhất là 10 chia cho đầu vào, hay nói cách khác, đếm các số 0 ở cuối. Chúng ta cần hiển thị nếu n kết thúc bằng k chữ số lặp lại, rằng 9 * n + n% 10 có k số 0 ở cuối.

Các chữ số lặp lại được biểu diễn dễ dàng nhất bằng toán học bằng cách chia một số như 99999 (là 10 ⁵ -1 ) cho 9 và sau đó nhân với chữ số lặp lại. Vì vậy, chúng ta có thể viết n = m * 10 ^k + d * (10 ^k -1) / 9 , trong đó m ≢ d (mod 10) , để đảm bảo rằng n không kết thúc nhiều hơn k chữ số lặp lại. Lưu ý rằng d = n% 10 .

Hãy cắm nó vào công thức của chúng tôi 9 * n + n% 10 . Ta được 9 * m * 10 ^k + d * (10 ^k -1) + d . Các d ở cuối bị hủy bỏ, vì vậy chúng tôi đang trái với: 9 * m * 10 ^k + d * 10 ^k = (9 * m + d) * 10 ^k . Nhưng 9 ≡ -1 (mod 10) , nên 9 * m + d ≡ d - m (mod 10) . Nhưng chúng tôi đã khẳng định rằng m ≢ d (mod 10) và do đó d - m 0 (mod 10) .

Nói cách khác, chúng tôi đã chỉ ra rằng 9 * m + d không chia hết cho 10 và do đó, công suất lớn nhất của 10 chia 9 * n + n% 10 = (9 * m + d) * 10 ^k là k , số lượng chữ số lặp đi lặp lại.

Như một phần thưởng, giải pháp này in kết quả chính xác ∞, cho đầu vào 0.

Võng mạc , 9 byte

&`(.)\1*$

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

Đếm số lượng các trận đấu chồng chéo trong (.)\1*$đó là một biểu thức khớp với hậu tố của các ký tự giống hệt nhau.

Brachylog , 4 byte

ẹḅtl

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

Giải trình

ẹ       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

Nếu ḅlàm việc trực tiếp trên các số nguyên (và tôi không chắc tại sao tôi không triển khai nó như vậy), thì đây chỉ là 3 byte vì ẹkhông cần thiết.

Python 2 , 47 41 byte

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

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

36 byte - Để có đầu vào linh hoạt hơn

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

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

Javascript (ES6), 55 52 32 30 byte

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

• Đã lưu 19 byte nhờ @MartinEnder bằng cách thay thế regex
• Đã lưu 2 byte nhờ @ user81655 bằng cách sử dụng các mẫu chữ được gắn thẻ

Sử dụng biểu thức chính quy để khớp với nhóm cuối cùng của chữ số cuối cùng

Lưu ý: Lần đầu tiên đăng bài. Đừng ngần ngại để nhận xét.

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 byte

Đã lưu một byte nhờ @Steadybox!

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

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

PHP, 47 45 40 byte

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

Chạy với echo <n> | php -nR '<code>

dường như một vòng lặp vẫn nhỏ hơn câu trả lời đầu tiên của tôi. chỉ đơn giản là đếm các ký tự bằng với cuối cùng. Điều này sử dụng offset chuỗi âm của PHP 7.1 .

-5 byte bởi Tít. Cảm ơn !

Câu trả lời cũ:

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

loại bỏ khỏi bên phải mọi ký tự khớp với ký tự ngoài cùng bên phải và tính toán sự khác biệt về độ dài.

05AB1E , 4 byte

.¡¤g

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

CJam , 7 byte

re`W=0=

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

Giải trình

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

Thạch , 5 byte

DŒgṪL

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

Giải trình

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

Perl 5 , 22 byte

21 byte mã + -pcờ.

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

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

/(.)\1*$/lấy các số giống hệt nhau cuối cùng, và sau đó $_=length$&gán độ dài của nó $_, được in ngầm nhờ -pcờ.

C (gcc) , 32 29 byte

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

Đây là một cổng của câu trả lời Python của tôi .

Điều này làm việc với gcc, nhưng thiếu một returntuyên bố là hành vi không xác định.

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

Python 2, 51 byte

Lấy số nguyên làm đầu vào. Dùng thử trực tuyến

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

48 byte cho chuỗi làm đầu vào. Dùng thử trực tuyến

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

C # , 63 62 byte

Chơi gôn

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

Bị đánh cắp

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

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

    return b - a;
}

Ungolfed có thể đọc được

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

Mã đầy đủ

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();
      }
   }
}

Phát hành

• v1.1 - - 1 byte - Nhờ bình luận của Kevin .
• v1.0 -  63 bytes- Giải pháp ban đầu.

Ghi chú

Không có gì để bổ sung

Python 2 , 38 32 byte

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

Cảm ơn @xnor vì đã lưu 6 byte!

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

MATL , 6 5 byte

Lưu 1 byte nhờ @Luis

&Y'O)

Dùng thử tại MATL Online

Giải trình

        % 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

Khối, 24 19 byte

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

chú thích

• Trên thực tế, có bao nhiêu ký tự giống nhau ở cuối đầu vào, do đó, nó hoạt động cho các số nguyên thực sự lớn và các chuỗi thực sự dài (miễn là số lượng các ký tự giống nhau ở cuối nhỏ hơn độ chính xác tối đa của JavaScript ( khoảng 15 chữ số trong cơ sở-10).
• Đầu vào đi vào trường đầu vào, đầu ra được in ra trường đầu ra

Hãy thử nó ở đây

Giải trình

Đầu tiên, hãy mở rộng khối

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

Các bước trong quá trình thực hiện có thể được chia thành ba giai đoạn:

1. Phân tích cú pháp
2. So sánh các nhân vật
3. Kết quả in

Giai đoạn 1: Đầu vào

Hai ký tự đầu tiên được thực thi là Avà B. Ađọc tất cả đầu vào và đẩy nó dưới dạng mã ký tự vào ngăn xếp. Lưu ý rằng điều này được thực hiện ngược lại, ký tự đầu tiên kết thúc ở trên cùng của ngăn xếp, ký tự cuối cùng gần như ở dưới cùng. Ở dưới cùng, -1( EOF) được đặt, sẽ được sử dụng làm bộ đếm cho số lượng ký tự liên tiếp ở cuối chuỗi. Vì chúng ta cần đỉnh của ngăn xếp để chứa hai ký tự cuối cùng, chúng tôi đảo ngược ngăn xếp, trước khi vào vòng lặp. Lưu ý rằng phần trên cùng của ngăn xếp bây giờ trông như sau:..., C[n-1], C[n], -1 .

Vị trí của IP trên khối lập phương là vị trí Evà nó đang chỉ đúng. Tất cả các hướng dẫn chưa được thực hiện, đã được thay thế bằng no-op (dừng hoàn toàn).

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

Giai đoạn 2: So sánh nhân vật

Ngăn xếp là ..., C[a-1], C[a], counter, nơi counterbộ đếm tăng dần khi hai ký tự kiểm tra ( C[a]và C[a-1]) bằng nhau. IP đầu tiên vào vòng lặp này tại Ský tự, di chuyển sang phải. Các Enhân vật là vị trí nơi mà các IP sẽ kết thúc (chỉ phải) khi C[a]và C[a-1]không có giá trị như nhau, có nghĩa là trừ đi C[a]từ C[a-1]không mang lại 0, trong trường hợp các hướng dẫn sau đó !sẽ bị bỏ qua (mà là một w).

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

Dưới đây là các hướng dẫn được thực hiện trong một vòng lặp đầy đủ:

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)

Và sau đó nó vòng quanh.

Giai đoạn 3: Kết quả in

Vì chúng tôi rời vòng lặp sớm, ngăn xếp trông như thế này : counter, ..., C[a-1]-C[a]. Thật dễ dàng để in bộ đếm, nhưng chúng tôi phải tăng bộ đếm một lần vì chúng tôi đã không làm điều đó trong lần lặp cuối cùng của vòng lặp và một lần nữa vì chúng tôi bắt đầu đếm -1thay vì 0. Đường dẫn trên khối lập phương trông như thế này, bắt đầu từ S, chỉ sang phải. Hai no-op được thực thi bởi IP được thay thế bằng các mũi tên chỉ theo hướng của IP.

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

Các hướng dẫn được thực hiện theo thứ tự sau đây. Lưu ý rằng các B)hướng dẫn ở cuối thay đổi ngăn xếp, nhưng không ảnh hưởng đến chương trình, vì chúng tôi sắp chấm dứt nó và chúng tôi không sử dụng ngăn xếp nữa.

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.

Mẻ, 91 byte

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

Việc -ngăn không cho kiểm tra chạy khỏi đầu chuỗi.

JavaScript (ES6), 34 byte

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

Không ngắn hơn giải pháp regex.

Hàm đệ quy đánh giá các chữ số từ phải sang trái, dừng khi gặp một chữ số khác. Kết quả là số lần lặp. plà undefinedtrên lần lặp đầu tiên, có nghĩa là n%10-ptrả về NaN(giả). Sau đó, pbằng chữ số trước với n%10. Khi chữ số hiện tại ( n%10) và trước đó ( p) khác nhau, vòng lặp kết thúc.

Röda , 12 byte

{count|tail}

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

Đây là một hàm ẩn danh hy vọng rằng mỗi ký tự của chuỗi đầu vào được đẩy vào luồng (tôi nghĩ rằng điều này là hợp lệ theo tinh thần của một câu hỏi meta gần đây ).

Nó sử dụng hai nội dung: countvà tail:

1. count đọc các giá trị từ luồng và đẩy số lượng phần tử liên tiếp vào luồng.
2. tail trả về giá trị cuối cùng trong luồng.

T-SQL, 238 214 byte

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

Hoặc là:

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 byte

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

Hãy thử nó ở đây.

Tôi đã thử một số thứ bằng cách sử dụng đệ quy hoặc một vòng lặp, nhưng cả hai đều kết thúc trên 100 byte ..

Powershell, 41 byte

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

vòng lặp đơn giản ngược về phía sau cho đến khi một char không khớp với char cuối cùng trong chuỗi, trả về chỉ mục của char -1 đó.

-3 cảm ơn @AdmBorkBork - sử dụng vòng lặp for thay vì một lúc.

Toán học, 33 30 byte

Cảm ơn Greg Martin đã tiết kiệm 3 byte.

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

Đưa đầu vào dưới dạng một chuỗi.

Lấy các chữ số thập phân (dưới dạng ký tự), chia chúng thành các phần tử giống hệt nhau, lấy lần chạy cuối cùng và tính độ dài với thủ thuật tiêu chuẩn là lấy tổng của vectơ 1^list.

Tiện ích Bash + Unix, 34 byte

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

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

JavaScript (ES6), 39 38 37 27 byte

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

Có thể không ngắn hơn giải pháp dựa trên regex, nhưng tôi không thể cưỡng lại việc viết một giải pháp hoàn toàn dựa trên số học. Kỹ thuật là lặp đi lặp lại lấy n % 100 % 11và chia cho 10 cho đến khi kết quả khác không, sau đó đếm số lần lặp. Điều này hoạt động bởi vì nếu hai chữ số cuối là như nhau, n % 100 % 11sẽ được 0.

Haskell , 33 byte

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

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

Đưa đầu vào chuỗi. Liên tục cắt bỏ ký tự đầu tiên và thêm 1 nếu tất cả các ký tự trong hậu tố bằng với ký tự đầu tiên.

R, 35 byte

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

Giải thích ngắn gọn

                  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 byte

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

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

Điều này có thể được thực hiện ngắn hơn nếu tôi quản lý chỉ sử dụng ngăn xếp.

Làm thế nào nó hoạt động:

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                   ;

Con trăn 3 - 50 44 byte

Chương trình đầy đủ (trong Python 3, input()trả về một chuỗi, bất kể đầu vào):

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