Auf 4chan ist ein beliebtes Spiel zu bekommen. Jeder Beitrag auf der Website erhält eine fortlaufende Beitrags-ID. Da Sie sie nicht beeinflussen oder bestimmen können, versuchen die Leute, ihre eigene Beitragsnummer (zumindest einen Teil davon) zu erraten, normalerweise die ersten Ziffern. Eine andere Version des Spiels heißt Dubs. Ziel ist es, sich wiederholende Ziffern am Ende der Zahl zu erhalten (z. B. 1234555).

Wenn Sie dies akzeptieren möchten, müssen Sie ein Programm schreiben, das eine Post-ID als Eingabe verwendet (Standard-Ganzzahl, die Sie unter 2 ^ 32 annehmen können) und zurückgibt, wie viele sich wiederholende Ziffern am Ende stehen.

Regeln

• Standardlücken sind nicht zulässig .
• Das Programm kann eine Funktion, ein vollständiges Programm, ein REPL-Befehl sein, was auch immer wirklich funktioniert, solange kein externer, nicht gezählter Code / keine nicht gezählten Argumente benötigt werden, um es auszuführen.
• Die Eingabe kann von STDIN, Funktionsargumenten, Befehlszeilenargumenten und Dateien kommen, je nachdem, was Ihnen passt.

Testfälle

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 Bytes

Wie wäre es mit einer arithmetischen Lösung?

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

Ich bin sehr erfreut zu sehen, dass dies den einfachen Mathematica-Ansatz übertrifft.

Erläuterung

Der Code selbst berechnet 9 * n + n% 10 und ermittelt dann die größte Potenz von 10 , die die Eingabe teilt, oder mit anderen Worten, die nachfolgenden Nullen zählt. Wir müssen , wenn zeigen n Ende in k wiederholt Ziffern, dass 9 * n + n% 10 hat k nacheilenden Nullen.

Wiederholungsziffern lassen sich am einfachsten mathematisch ausdrücken, indem eine Zahl wie 99999 (das sind 10 ⁵ -1 ) durch 9 geteilt und dann mit der wiederholten Ziffer multipliziert wird. Wir können also n = m * 10 ^k + d * (10 ^k -1) / 9 schreiben , wobei m ≢ d (mod 10) , um sicherzustellen, dass n nicht mit mehr als k wiederholten Ziffern endet . Beachten Sie, dass d = n% 10 .

Stecken wir das in unsere Formel 9 * n + n% 10 . Wir erhalten 9 * m * 10 ^k + d * (10 ^k -1) + d . Das d am Ende wird gestrichen, so dass wir übrig haben: 9 * m * 10 ^k + d * 10 ^k = (9 * m + d) * 10 ^k . Aber 9 ≤ -1 (mod 10) , also 9 * m + d ≤ d - m (mod 10) . Aber wir haben behauptet, dass m ≤ d (mod 10) und damit d - m ≤ 0 (mod 10) ist .

Mit anderen Worten, haben wir gezeigt , daß 9 * m + d durch nicht teilbar ist 10 , und daher die größte Leistung von 10 , dass Trennlinien 9 * n + n% 10 = (9 · m + d) * 10 ^k ist k , Die Anzahl der nachfolgenden wiederholten Ziffern.

Als Bonus druckt diese Lösung das richtige Ergebnis ∞für die Eingabe 0.

Netzhaut , 9 Bytes

&`(.)\1*$

Probieren Sie es online!

Zählt die Anzahl überlappender Übereinstimmungen, bei (.)\1*$denen es sich um eine Regex handelt, die mit einem Suffix identischer Zeichen übereinstimmt.

Brachylog , 4 Bytes

ẹḅtl

Probieren Sie es online!

Erläuterung

ẹ       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

Wenn ḅdirekt an ganzen Zahlen gearbeitet würde (und ich bin nicht sicher, warum ich es nicht implementiert habe), wären dies nur 3 Bytes, da die ẹnicht benötigt würden.

Python 2 , 47 41 Bytes

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

Probieren Sie es online!

36 Bytes - Für eine flexiblere Eingabe

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

Probieren Sie es online!

Javascript (ES6), 55 52 32 30 Bytes

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

• Gespeichert 19 Bytes dank @MartinEnder durch den Regex ersetzen
• Gespeichert 2 Bytes dank @ user81655 getaggt Vorlagen Literale mit

Verwenden Sie einen regulären Ausdruck, um mit der letzten Gruppe der letzten Ziffer übereinzustimmen

Hinweis: Erstmaliges Posten. Zögern Sie nicht, Anmerkungen zu machen.

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 Bytes

Dank @Steadybox ein Byte gespeichert!

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

Probieren Sie es online!

PHP, 47 45 40 Bytes

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

Laufen Sie mit echo <n> | php -nR '<code>

anscheinend ist eine schleife noch kleiner als meine erste antwort. Zähle einfach die Zeichen, die gleich dem letzten sind. Dies verwendet negative String-Offsets von PHP 7.1 .

-5 Bytes von Titus. Vielen Dank !

Alte Antwort:

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

Entfernt von rechts jedes Zeichen, das mit dem am weitesten rechts stehenden Zeichen übereinstimmt, und berechnet den Längenunterschied.

05AB1E , 4 Bytes

.¡¤g

Probieren Sie es online! oder als Testsuite

Erläuterung

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

CJam , 7 Bytes

re`W=0=

Probieren Sie es online!

Erläuterung

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

Gelee , 5 Bytes

DŒgṪL

Probieren Sie es online!

Erläuterung

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

Perl 5 , 22 Bytes

21 Byte Code + -pFlag.

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

Probieren Sie es online!

/(.)\1*$/Ruft die letzten identischen Zahlen ab und $_=length$&weist dann deren Länge zu $_, die dank -pflag implizit gedruckt wird .

C (GCC) , 32 29 Bytes

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

Dies ist ein Port meiner Python-Antwort .

Dies funktioniert mit gcc, aber das Fehlen einer returnAussage ist undefiniertes Verhalten.

Probieren Sie es online!

Python 2, 51 Bytes

Übernimmt eine Ganzzahl als Eingabe. Probieren Sie es online aus

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

48 Bytes für String als Eingabe. Probieren Sie es online aus

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

C # , 63 62 Bytes

Golf gespielt

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 lesbar

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

Vollständiger Code

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

Releases

• v1.1 - - 1 byte - Dank Kevins Kommentar.
• v1.0 -  63 bytes- Anfangslösung.

Anmerkungen

Nichts hinzuzufügen

Python 2 , 38 32 Bytes

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

Vielen Dank an @xnor für das Speichern von 6 Bytes!

Probieren Sie es online!

MATL , 6 5 Bytes

1 Byte gespart dank @Luis

&Y'O)

Probieren Sie es bei MATL Online aus

Erläuterung

        % 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 Bytes

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

Hinweis

• Zählt tatsächlich, wie viele der gleichen Zeichen am Ende der Eingabe stehen. Dies funktioniert also auch für sehr große Ganzzahlen und sehr lange Zeichenfolgen (sofern die Anzahl der gleichen Zeichen am Ende kleiner ist als die maximale Genauigkeit von JavaScript). etwa 15 Stellen in der Basis 10).
• Die Eingabe erfolgt in das Eingabefeld, die Ausgabe wird in das Ausgabefeld gedruckt

Probieren Sie es hier aus

Erläuterung

Erweitern wir zunächst den Cube

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

Die Schritte in der Ausführung können in drei Phasen unterteilt werden:

1. Eingaben analysieren
2. Zeichen vergleichen
3. Ergebnis drucken

Phase 1: Eingabe

Die ersten beiden Zeichen, die ausgeführt werden, sind Aund B. ALiest alle Eingaben und schiebt sie als Zeichencodes auf den Stapel. Beachten Sie, dass dies in umgekehrter Reihenfolge erfolgt. Das erste Zeichen landet oben auf dem Stapel, das letzte Zeichen fast unten. Ganz unten steht -1( EOF), das als Zähler für die Anzahl aufeinanderfolgender Zeichen am Ende der Zeichenfolge verwendet wird. Da der obere Teil des Stapels die letzten beiden Zeichen enthalten muss, kehren wir den Stapel um, bevor wir in die Schleife eintreten. Beachten Sie, dass der obere Teil des Stapels sieht nun so: ..., C[n-1], C[n], -1.

Die IP-Adresse auf dem Cube befindet sich dort, wo sie sich Ebefindet, und sie zeigt nach rechts. Alle Anweisungen, die noch nicht ausgeführt wurden, wurden durch No-Ops (Punkt) ersetzt.

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

Phase 2: Charaktervergleich

Der Stapel ist ..., C[a-1], C[a], counter, wobei counterdie Zähler zu inkrementieren , wenn die zwei Zeichen (zu überprüfen C[a]und C[a-1]) gleich sind. Die IP tritt zuerst an der Stelle in diese Schleife ein Sund bewegt sich nach rechts. Das EZeichen ist die Position , wo die IP wird am Ende (nach rechts) , wenn C[a]und C[a-1]haben nicht den gleichen Wert, was bedeutet , dass Subtrahieren C[a]von C[a-1]nicht nachgibt 0, in welchem Fall der Befehl die folgenden !wird übersprungen (die eine w).

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

Hier sind die Anweisungen, die während einer vollständigen Schleife ausgeführt werden:

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)

Und dann dreht es sich.

Phase 3: Druckergebnis

Da wir die Schleife vorzeitig verlassen, wie der Stapel sieht folgendermaßen aus : counter, ..., C[a-1]-C[a]. Es ist einfach, den Zähler auszudrucken, aber wir müssen den Zähler einmal inkrementieren, weil wir ihn in der letzten Iteration der Schleife nicht ausgeführt haben, und noch einmal, weil wir -1stattdessen mit dem Zählen begonnen haben 0. Der Pfad auf dem Würfel sieht wie folgt aus: Er beginnt bei Sund zeigt nach rechts. Die beiden No-Ops, die von der IP ausgeführt werden, werden durch Pfeile ersetzt, die in Richtung der IP zeigen.

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

Die Anweisungen werden in der folgenden Reihenfolge ausgeführt. Beachten Sie, dass die B)Anweisungen am Ende den Stapel ändern, das Programm jedoch nicht beeinflussen, da wir kurz davor stehen, ihn zu beenden, und den Stapel nicht mehr verwenden.

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.

Batch, 91 Bytes

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

Das -verhindert , dass der Test der Ausführung von dem Anfang des Strings ab.

JavaScript (ES6), 34 Byte

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

Nicht kürzer als die Regex-Lösung.

Rekursive Funktion, die die Ziffern von rechts nach links auswertet und stoppt, wenn eine andere Ziffer angetroffen wird. Das Ergebnis ist die Anzahl der Iterationen. pist undefinedbei der ersten Iteration, was bedeutet , n%10-pzurückkehrt NaN(falsy). Danach pentspricht die vorherige Ziffer mit n%10. Wenn die aktuelle Ziffer ( n%10) und die vorherige ( p) unterschiedlich sind, endet die Schleife.

Röda , 12 Bytes

{count|tail}

Probieren Sie es online!

Dies ist eine anonyme Funktion, die erwartet, dass jedes Zeichen der Eingabezeichenfolge in den Stream verschoben wird (ich denke, dies gilt im Sinne einer aktuellen Meta-Frage ).

Es werden zwei integrierte Funktionen verwendet: countund tail:

1. count Liest Werte aus dem Stream und überträgt die Anzahl aufeinanderfolgender Elemente in den Stream.
2. tail Gibt den letzten Wert im Stream zurück.

T-SQL, 238 214 Bytes

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

Oder:

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 Bytes

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

Probieren Sie es hier aus.

Ich habe einige Dinge mit Rekursion oder einer Schleife ausprobiert, aber beide endeten über 100 Bytes.

Powershell, 41 Bytes

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

Wenn ein Zeichen nicht mit dem letzten Zeichen in der Zeichenfolge übereinstimmt, geben Sie den Index dieses Zeichens -1 zurück.

-3 dank @AdmBorkBork - mit einer for-Schleife statt einer Weile.

Mathematica, 33-30 Bytes

Vielen Dank an Greg Martin für das Speichern von 3 Bytes.

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

Übernimmt die Eingabe als Zeichenfolge.

Ruft die Dezimalstellen (in Form von Zeichen) ab, teilt sie in Läufe identischer Elemente auf, ruft den letzten Lauf ab und berechnet die Länge mit dem Standardtrick der Summe des Vektors 1^list.

Bash + Unix-Dienstprogramme, 34 Byte

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

Probieren Sie es online!

JavaScript (ES6), 39 38 37 27 Bytes

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

Vielleicht nicht kürzer als die auf Regex basierende Lösung, aber ich konnte nicht widerstehen, eine Lösung zu schreiben, die ausschließlich auf Arithmetik basiert. Die Technik besteht darin, wiederholt zu nehmen n % 100 % 11und durch 10 zu dividieren, bis das Ergebnis ungleich Null ist, und dann die Iterationen zu zählen. Das funktioniert, weil wenn die letzten beiden Ziffern gleich sind, n % 100 % 11werden 0.

Haskell , 33 Bytes

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

Probieren Sie es online!

Übernimmt die Zeichenketteneingabe. Schneidet das erste Zeichen wiederholt ab und fügt 1 hinzu, wenn alle Zeichen im Suffix mit dem ersten Zeichen übereinstimmen.

R, 35 Bytes

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

Kurze Erklärung

                  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 Bytes

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

Probieren Sie es online!

Dies könnte verkürzt werden, wenn ich nur den Stack verwenden könnte.

Wie es funktioniert:

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 Bytes

Vollständiges Programm (in Python 3 wird input()unabhängig von der Eingabe ein String zurückgegeben):

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