Definieren wir die a-Funktion für natürliche Zahlen $n$ , die als 10-stellige Basis $d_k\; d_{k-1}\; \dotsc\; d_1\; d_0$ wie folgt:

Solange es gleiche benachbarte Ziffern $d_i\;d_{i-1}$ , ersetzen Sie sie durch ihre Summe$d_i+d_{i-1}$ von links nach rechts. Wenn solche Ziffern vorhanden sind, wiederholen Sie das gleiche Verfahren.

Mit anderen Worten, wir nehmen in jeder Iteration gierig alle Paare gleicher benachbarter Ziffern und ersetzen sie gleichzeitig durch ihre Summe (wobei wir das am weitesten links stehende Paar verwenden, wenn sie sich überlappen).

Beispiel

Nehmen wir zum Beispiel $\texttt{9988}$ :

1. Die ersten benachbarten Ziffern, die gleich sind, sind die beiden $\texttt{9}$
2. Also ersetzen wir sie durch $\texttt{9 + 9} = \texttt{18}$ , was uns $\texttt{1888}$
3. Da wir noch in dem ersten Links-Rechts - Traversal und es gab noch zwei sind $\texttt{8}$ s müssen wir zuerst diese ersetzen
4. So bekommen wir $\texttt{1816}$
5. Etwas hat sich geändert, also müssen wir eine weitere Iteration durchführen
6. Aber es gibt keine solchen Ziffern, also hören wir auf

Deshalb ist die $9988^\text{th}$ Zahl in dieser Folge ist $1816$ .

Herausforderung

Die ersten 200 Begriffe sind:

0,1,2,3,4,5,6,7,8,9,10,2,12,13,14,15,16,17,18,19,20,21,4,23,24,25,26,27,28,29,30,31,32,6,34,35,36,37,38,39,40,41,42,43,8,45,46,47,48,49,50,51,52,53,54,10,56,57,58,59,60,61,62,63,64,65,12,67,68,69,70,71,72,73,74,75,76,14,78,79,80,81,82,83,84,85,86,87,16,89,90,91,92,93,94,95,96,97,98,18,10,101,102,103,104,105,106,107,108,109,20,21,4,23,24,25,26,27,28,29,120,121,14,123,124,125,126,127,128,129,130,131,132,16,134,135,136,137,138,139,140,141,142,143,18,145,146,147,148,149,150,151,152,153,154,20,156,157,158,159,160,161,162,163,164,165,4,167,168,169,170,171,172,173,174,175,176,24,178,179,180,181,182,183,184,185,186,187,26,189,190,191,192,193,194,195,196,197,198,28

Ihre Aufgabe ist es auch, diese Sequenz zu generieren

• gegeben $n$ , kehrt die $n^\text{th}$ Nummer in dieser Reihenfolge,
• Mit $n$ werden die ersten $n$ Zahlen in dieser Reihenfolge zurückgegeben
• oder generieren Sie die Sequenz auf unbestimmte Zeit.

Sie können wählen, ob Sie eine $0$ oder eine $1$ Indizierung verwenden möchten. Bitte geben Sie jedoch an, welche.

Testfälle

Sie können die oben angegebenen Begriffe verwenden, hier sind jedoch einige größere:

222 -> 42
1633 -> 4
4488 -> 816
15519 -> 2019
19988 -> 2816
99999 -> 18189
119988 -> 21816
100001 -> 101
999999 -> 181818

Python 3 , 128 Bytes

def t(z):j=z and(z[0]==z[1:2])+1;return[str(int(z[0])*j),*t(z[j:])]if j else''
def c(n):r="".join(t(n));return r!=n and c(r)or r

Probieren Sie es online!

Python 2 , 97 96 93 Bytes

def f(n):r=re.sub(r'(.)\1',lambda m:`int(m.group(1))*2`,n);return r!=n and f(r)or r
import re

Probieren Sie es online!

Nicht reguläre Version:

Python 2 , 133 130 122 112 98 Bytes

def f(n):
 r='';s=n
 while s:a=1+(s[0]==s[1:2]);r+=`int(s[0])*a`;s=s[a:]
 return r!=n and f(r)or r

Probieren Sie es online!

Jelly , 11 Bytes

DŒg+2/€FVµ¡

Dies ist ein unnötig langsames, vollständiges Programm.

Probieren Sie es online!

Alternative Version, 12 Bytes

DŒg+2/€FVµƬṪ

Ein Byte länger, aber viel schneller. Arbeitet als Programm oder Funktion.

Probieren Sie es online!

Wie es funktioniert

DŒg+2/€FVµƬṪ  Main link. Argument: n (integer)

         µ    Combine the previous links into a chain. Begin a new one.
D               Decimal; yield n's digit array in base 10.
 Œg             Group adjacent, identical digits into subarrays.
   +2/€         Map non-overlapping, pairwise sum over the subarrays.
                If there is an odd number of digits in a subarray, the
                last digit will remain untouched.
       F        Flatten; dump all sums and digits into a single array.
        V       Eval; turn the result into an integer.
          Ƭ   Execute the chain 'til the results are no longer unique.
              Return all unique results.
           Ṫ  Tail; extract the last result.

Die 11-Byte-Version macht dasselbe, außer dass sie den Link n- mal für den Eingang n aufruft, anstatt ihn aufzurufen, bis ein fester Punkt erreicht ist.

Haskell, 70 Bytes

until((==)=<<f)f
f(a:b:c)|a==b=show(2*read[a])++f c|1<2=a:f(b:c)
f a=a

Die Eingabe wird als Zeichenfolge verwendet.

Probieren Sie es online!

JavaScript, 48 47 46 Bytes

Eingabe und Ausgabe als Zeichenketten. Gibt den nthTerm der Sequenz zurück.

f=s=>s-(s=s.replace(/(.)\1/g,x=>x/5.5))?f(s):s

Probieren Sie es online aus

• 1 Byte gespart dank Arnauld
• 1 Byte gespart dank tsh

Perl 6 , 37 Bytes

{($_,{S:g[(\d)$0]=2*$0}...*==*)[*-1]}

Probieren Sie es online!

Dies ist eine Funktion, die den n-ten Term der Sequenz generiert, wobei n als Argument angegeben wird.

($_, { ... } ... * == *)ist die Folge aufeinanderfolgender Änderungen an der Eingabenummer, die durch den in Klammern gesetzten Ausdruck (eine einfache Regex-Ersetzung) generiert wird und anhält * == *, wenn die letzten beiden Zahlen in der Folge gleich sind. Dann [*-1]nimmt the nur das letzte Element dieser Sequenz als Rückgabewert.

Netzhaut , 16 Bytes

+`(.)\1
$.(2*$1*

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

+`

Wiederholen, bis sich der Eingang nicht mehr ändert.

(.)\1

Ersetzen Sie Paare benachbarter Ziffern ...

$.(2*$1*

... mit der doppelten Ziffer. ( $1*Erzeugt eine Folge von $1 _s, 2*dupliziert diese und $.(nimmt die Länge an. Tatsächlich ist die Retina-Engine schlauer als diese und verdoppelt sich einfach $1.)

C # (.NET Core) , 231 , 203 , 200 , 196 , 192 Bytes

BEARBEITEN: Funktion ist jetzt bei 185 Bytes plus 18 für using System.Linq;

Danke an BMO (für 1> 0 = true plus Newline Removal) und Mr. XCoder (für f =! F Statements)!

EDIT2: Bis zu 182 Bytes plus 18 für using System.Linq danke an dana für ein paar !

EDIT3: Dank Verkörperung der Ignoranz für das int [] -> var, Entfernen des Kurzschlusses && -> & und Ändern von ToArray -> ToList! (178 bytes + 18 using)

EDIT4: Verkörperung der Ignoranz löschte 4 Bytes durch Ändern einer Zuordnung. Dummy ich hätte zählen sollen! Nochmals vielen Dank: D

p=>{var f=1>0;while(f){var t=p.Select(n=>n-48).ToList();p="";f=!f;for(var j=0;j<t.Count;j++){if(j<t.Count-1&t[j]==t[1+j]){p+=t[j]+t[++j];f=!f;continue;}p+=t[j];}};return p;};

Probieren Sie es online!

Perl 5 -p , 21 Bytes

s/(.)\1/$1*2/ge&&redo

Probieren Sie es online!

Japt v2.0a0 -h, 15 14 Bytes

Gibt den nthTerm der Sequenz zurück.

Æ=s_r/(.)\1/ÏÑ

Versuch es

Dies sollte für 10 Bytes funktionieren, aber es scheint einen Fehler in der rekursiven Ersetzungsmethode von Japt zu geben.

e/(.)\1/ÏÑ

Groovy , 63 Bytes

{s->r=/(\d)\1/
while(s=~r)s=s.replaceAll(r){(it[1]as int)*2}
s}

Probieren Sie es online!

05AB1E , 11 Bytes

Δγε2ôSO}˜J

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Δ             # Continue until the (implicit) input no longer changes:
 γ            #  Split the integer in chunks of the same adjacent digits
              #   i.e. 199999889 → [1,99999,88,9]
  ε     }     #  Map each to:
   2ô         #   Split it into parts of size 2
              #    i.e. 99999 → [99,99,9]
     €S       #   Split each part into digits
              #    i.e. [99,99,9] → [[9,9],[9,9],[9]]
       O      #   And take the sum of each part
              #    i.e. [[9,9],[9,9],[9]] → [18,18,9]
         ˜    #  Flatten the list
              #   i.e. [[1],[18,18,9],[16],[9]] → [1,18,18,9,16,9]
          J   #  Join everything together
              #   i.e. [1,18,18,9,16,9] → 118189169
              # (And output the result implicitly at the end)
              #  i.e. output = 28189169

Wolfram Language 108 Bytes

ToExpression[""<>ToString/@Total/@Flatten[Partition[#,UpTo@2]&/@Split@IntegerDigits@#,1]]&~FixedPoint~#&

Erläuterung

IntegerDigits wandelt die eingegebene Nummer in eine Liste ihrer Ziffern um.

Split gruppiert aufeinanderfolgende wiederholte Ziffern.

Partition[#, UpTo@2]&/@ Bricht Läufe von gleichen Ziffern in Listen von höchstens Längen von 2 auf.

Flatten[...,1] beseitigt gelegentlich übermäßig verschachtelte Klammern - z. B. wird {{2,2}} zu {2,2}

Total/@summiert die Summe der gepaarten Ziffern. Isolierte Ziffern müssen nicht summiert werden.

ToString wandelt die Summen (und die einzelnen Ziffern) in Zeichenfolgen um.

""<> Verbindet alle Zeichenfolgen in der Liste.

ToExpression konvertiert das Ergebnis in eine Ganzzahl.

...~FixedPoint~#& Wendet die Funktion an, bis sich das Ergebnis nicht mehr ändert.

C # (Visual C # Interactive Compiler) mit Flag /u:System.Text.RegularExpressions.Regex, 70 Byte

s=>{for(;s[0]!=(s[0]=Replace(s[0],@"(.)\1",m=>m.Value[0]*2-96+"")););}

Ausgänge durch Ändern des Eingangs. Nimmt eine Liste mit einer Zeichenfolge zur Eingabe auf.

Vielen Dank an @dana für das Golfen mit 23 Bytes!

Probieren Sie es online!

Sauber , 118 Bytes

import StdEnv,Data.List
$[a,b:t]|a==b=[1,(a*2)rem 10]%(1-a/5,1)++ $t=[a: $[b:t]]
$l=l

limit o iterate$o map digitToInt

Probieren Sie es online!

Nimmt den ersten wiederholten Wert ( limit) aus der unendlichen Liste der Anwendungen ( iterate) eines Lambdas, wobei ein einzelner Schritt des Zusammenlegens ausgeführt wird. Eingabe als [Char].

Rot , 84 83 80 Bytes

func[n][if parse s: form n[to some change[copy d skip d](2 * do d)to end][f s]s]

Probieren Sie es online!

Gibt den nthTerm der Sequenz zurück.

Erläuterung:

Red[]
f: func [ n ] [
    if parse s: form n [  ; parse the input converted to a string
        to some change [  ; find and change one or more
            copy d skip   ; digit (in fact any character, no predefined character classes)
            d             ; followed by itself
        ] (2 * do d)      ; with its doubled numeric value 
        to end            ; go to the end of the string
    ] [ f s ]             ; call the function with the altered string if parse returned true
    s                     ; finally return the string 
]

Scala , 84 Bytes

s=>{var t=s
while(t!=(t="(\\d)\\1".r.replaceAllIn(t,m=>s"$m"(0)*2-96+""),t)._2){}
t}

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 111 Byte

s=>{var t=s;do{s=t;t="";for(int i=0;i<s.Length;)t+=s[i]%48*(s[i++]!=(s+0)[i]?1:2*++i/i);}while(t!=s);return t;}

Probieren Sie es online!

RIESIGER Dank an @ASCIIOnly fürs Golfen ~ 30;) Zuerst haben wir beide Updates gleichzeitig gepostet, aber irgendwann ist er eindeutig in die Stadt gefahren!

-2 danke an @EmbodimentOfIgnorance!

Weniger Golf Code ...

// s is the input as a string
s=>{
  // t is another string used
  // to hold intermediate results
  var t=s;
  // the algorithm repeatedly
  // processes s and saves the
  // result to t
  do{
    // copy the last result to s
    // and blank out t
    s=t;
    t="";
    // iterate over s
    for(int i=0;i<s.Length;)
      // append either 1 or 2 times
      // the current digit to t
      t+=s[i]%48*
        // compare the current digit
        // to the next digit. to prevent
        // an out-of-bounds exception,
        // append a 0 to s which either
        // gets ignored or collapses
        // to 0
        (s[i++]!=(s+0)[i]
          // if they are different, then
          // the multiplier is 1
          ?1
          // if they are the same, then
          // the multiplier is 2, and we
          // have to increment i
          :2*++i/i);
  }
  // continue this until the input
  // and output are the same
  while(t!=s);
  return t;
}