在4chan上，流行游戏获得了。网站上的每个帖子都会获得一个顺序的帖子ID。由于您无法影响或确定它们，因此人们会尝试猜测（至少是一部分）他们自己的帖子编号，通常是前几位数。游戏的另一个版本称为配音，其目标是在数字的末尾（例如1234555）获得重复的数字。

您的任务（如果希望接受）是编写一个程序，该程序将帖子ID作为输入（标准整数，可以假设在2 ^ 32以下），并返回最后有多少个重复数字。

规则

• 不允许出现标准漏洞。
• 该程序可以是一个函数，完整程序，REPL命令，实际上可以执行任何操作，只要运行它不需要外部未计数的代码/参数即可。
• 输入可以来自STDIN，函数参数，命令行参数，文件，任何适合您的输入。

测试用例

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个字节

算术解决方案怎么样？

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

我很高兴看到这优于简单的Mathematica方法。

说明

该代码本身计算9 * n + n％10，然后找到将输入除以10的最大幂，换句话说，对尾随的零进行计数。我们需要显示n是否以k个重复数字结尾，则9 * n + n％10具有k个尾随零。

Rep-数字最容易用数学方式表示，例如将99999（即10 ⁵ -1）除以9，然后再乘以重复的数字。因此，我们可以写N = M * 10 ^ķ + d *（10 ^ķ -1）/ 9，其中米≢d（MOD 10） ，以确保Ñ不结束更多比ķ反复位数。注意，d ＝ n％10。

让我们将其插入公式9 * n + n％10。我们得到9 * m * 10 ^k + d *（10 ^k -1）+ d。最后的d被取消，所以我们剩下：9 * m * 10 ^k + d * 10 ^k =（9 * m + d）* 10 ^k。但是9 -1 -1（mod 10），所以9 * m + d d-m（mod 10）。但是我们断言m d（mod 10），因此d-m≢0（mod 10）。

换句话说，我们已经证明9 * m + d无法被10整除，因此，将9 * n + n％10 =（9 * m + d）* 10 ^k除以10的最大幂就是k。尾随重复数字的数量。

作为奖励，此解决方案∞将为输入输出正确的结果0。

视网膜，9字节

&`(.)\1*$

在线尝试！

计算重叠匹配项的数量，(.)\1*$该匹配项是匹配后缀相同字符的正则表达式。

Brachylog，4个字节

ẹḅtl

在线尝试！

说明

ẹ       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

如果ḅ直接在整数上工作（我不确定为什么我没有实现它，以至于不能这样做），那么这将只有3个字节，因为ẹ不需要。

Python 2中，47 41个字节

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

在线尝试！

36个字节-输入更灵活

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

在线尝试！

Javascript（ES6），55 52 32 30字节

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

• @MartinEnder通过替换正则表达式节省了19个字节
• @ user81655使用标记的模板文字节省了2个字节

使用正则表达式匹配最后一位的最后一组

注意：首次发布。请不要犹豫。

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字节

感谢@Steadybox，节省了一个字节！

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

在线尝试！

PHP，47 45 40字节

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

与运行 echo <n> | php -nR '<code>

似乎循环仍比我的第一个答案小。只需计算等于最后一个的字符数即可。这使用PHP 7.1的负字符串偏移量。

Titus -5个字节。谢谢 ！

旧答案：

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

从右边删除与最右边的字符匹配的每个字符，并计算长度差。

05AB1E，4个字节

.¡¤g

在线尝试！ 或作为测试套件

说明

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

CJam，7个字节

re`W=0=

在线尝试！

说明

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

果冻，5个字节

DŒgṪL

在线尝试！

说明

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

Perl 5个字节

21个字节的代码+ -p标志。

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

在线尝试！

/(.)\1*$/获取最后一个相同的数字，然后$_=length$&将其长度分配给$_，这要归功于-pflag 隐式打印。

C（gcc）， 32 29字节

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

这是一个港口 我的Python回答的一部分。

可以与gcc一起使用，但是缺少 return语句是未定义的行为。

在线尝试！

Python 2，51字节

以整数作为输入。在线尝试

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

48个字节的字符串作为输入。在线尝试

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

C＃，63 62字节

打高尔夫球

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

不打高尔夫球

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

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

    return b - a;
}

非高尔夫可读

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

完整代码

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

发布

• V1.1 - - 1 byte -感谢凯文的意见。
• 1.0 -  63 bytes-初始溶液。

笔记

没有补充

Python 2中，38 32个字节

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

感谢@xnor节省了6个字节！

在线尝试！

MATL，6 5字节

@Luis节省了1个字节

&Y'O)

在MATL Online上尝试

说明

        % 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字节

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

注意

• 实际上会计算输入末尾有多少个相同字符，因此这对于很大的整数和非常长的字符串也适用（只要末尾相同字符的数量小于JavaScript的最大精度（以10为基数的15位数字左右）。
• 输入进入输入字段，输出打印到输出字段

在这里尝试

说明

首先，让我们扩展多维数据集

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

执行步骤可分为三个阶段：

1. 解析输入
2. 比较字符
3. 打印结果

阶段1：输入

执行的前两个字符是A和B。A读取所有输入并将其作为字符代码压入堆栈。请注意，这是相反的操作，第一个字符结束于堆栈的顶部，最后一个字符几乎位于底部。最底部放置-1（EOF），它将用作字符串末尾连续字符数量的计数器。由于我们需要堆栈的顶部包含最后两个字符，因此我们在进入循环之前反转堆栈。请注意，堆栈的顶部现在看起来像：..., C[n-1], C[n], -1。

IP在多维数据集上的位置就是当前位置E，并且指向正确的位置。所有尚未执行的指令均由无操作（句号）代替。

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

阶段2：字符比较

堆栈是..., C[a-1], C[a], counter，其中counter是要检查的两个字符（C[a]和C[a-1]）相等时要增加的计数器。IP首先在S字符处进入此循环，向右移动。的E字符是其中IP将结束（指向右侧）时的位置C[a]和C[a-1]不具有相同的值，这意味着减去C[a]从C[a-1]不能产生0，在这种情况下，跟随该指令!将被跳过（这是一个w）。

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

以下是在完整循环中执行的指令：

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)

然后循环。

阶段3：打印结果

由于我们提早退出循环，因此堆栈看起来像这样：counter, ..., C[a-1]-C[a]。打印计数器很容易，但由于在循环的最后一次迭代中未进行计数，因此我们不得不对计数器进行一次递增，而由于我们开始于-1而不是进行计数，因此必须再次增加计数器0。多维数据集上的路径看起来像这样，从处开始S，指向右边。IP执行的两个无操作被指向IP方向的箭头替换。

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

这些指令按以下顺序执行。请注意，最后的B)指令会更改堆栈，但不会影响程序，因为我们即将终止该程序，并且不再使用堆栈。

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。

批处理，91字节

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

这样-可以防止测试从字符串的开头开始。

JavaScript（ES6），34个字节

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

不小于正则表达式解决方案。

递归函数，从右到左评估数字，遇到其他数字时停止。结果是迭代次数。p是undefined在第一次迭代，这意味着n%10-p返回NaN（falsy）。之后，用p等于前一位n%10。当前数字（n%10）和上一个数字（）p不同时，循环结束。

Röda，12个字节

{count|tail}

在线尝试！

这是一个匿名函数，期望将输入字符串的每个字符都推送到流中（我认为这在最近的meta问题的意义上是有效的）。

它使用两个内置函数：count和tail：

1. count 从流中读取值，并将连续元素的数量推入流中。
2. tail 返回流中的最后一个值。

T-SQL，238214字节

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

要么：

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字节

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

在这里尝试。

我尝试使用递归或循环进行一些操作，但最终都超过了100个字节。

Powershell，41字节

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

向后直接循环，直到一个char与字符串中的最后一个char不匹配，返回该char -1的索引。

-3感谢@AdmBorkBork-使用for循环而不是一会儿。

Mathematica，33个 30字节

感谢Greg Martin节省了3个字节。

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

将输入作为字符串。

获取十进制数字（以字符形式），将其拆分为相同元素的游程，获取最后一个游程，并使用取向量之和的标准技巧来计算长度1^list。

Bash + Unix实用程序，34个字节

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

在线尝试！

JavaScript（ES6），39 38 37 27字节

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

也许不短于基于正则表达式的解决方案，但是我无法抗拒完全基于算术编写解决方案。该技术是反复取n % 100 % 11除以10，直到结果为非零，然后计算迭代次数。之所以有效，是因为如果后两位相同，n % 100 % 11则将为0。

Haskell，33个字节

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

在线尝试！

接受字符串输入。重复截断第一个字符，如果后缀中的所有字符都等于第一个字符，则加1。

R，35个字节

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

简要说明

                  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个字节

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

在线尝试！

如果我仅使用堆栈，则可以将其缩短。

怎么运行的：

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个字节

完整程序（在Python 3中，input()无论输入如何，都返回一个字符串）：

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