“请说一说”或“说您看到的内容”序列是一系列数字，每个数字都描述了最后一个数字。

1
11 (one one)
21 (two ones)
1211 (one two, one one)
111221 (one one, one two, two ones)
312211 (three ones, two twos, one one)

等等... https://oeis.org/A005150

无论如何，这是一个常规的代码挑战（以最少的字节数获胜），使程序需要两个参数，即初始数和迭代次数。例如，如果您插入“ 1”和“ 2”，则结果将是“ 21”。如果您插入“ 2”和“ 4”，则结果将是“ 132112”。玩得开心！

Pyth，10 8字节

@FryAmTheEggman -2字节

ussrG8Qz

说明：

            Implicit: z=first line as string, Q=second line
u         the result of reducing lambda G:
  s s rG8   flattened run-length-encoded G
  Q       Q times
  z     starting with z

在这里尝试。

CJam，8个字节

q~{se`}*

输入格式首先是初始数字，然后是迭代，由空格隔开。

在这里测试。

说明

q~   e# Read and evaluate input, dumping both numbers on the stack.
{    e# Run this block once for each iteration...
  s  e#   Convert to string... in the first iteration this just stringifies the input
     e#   number again. In subsequent iterations it flattens and then stringifies the
     e#   array we get from the run-length encoding.
  e` e#   Run-length encode.
}*

数组在打印之前也已展平，因此结果仅为所需的数字。

JavaScript，57个字节

F=(a,b)=>b?F(a.replace(/(.)\1*/g,c=>c.length+c[0]),b-1):a

递归很好地解决了这个问题。第一个参数是字符串形式的初始数字，第二个参数是迭代次数。

MATL，9个字节

:"Y'wvX:!

输入为：迭代次数，初始次数。

在线尝试！

:      % implicit input: number of iterations. Create vector with that size
"      % for loop
  Y'   %   RLE. Pushes two arrays: elements and numbers of repetitions.
       %   First time implicitly asks for input: initial number
  w    %   swap
  v    %   concatenate vertically
  X:   %   linearize to column array
  !    %   transpose to row array
       % implicitly end loop
       % implicitly display

R，87个字节

function(a,n){for(i in 1:n){r=rle(el(strsplit(a,"")));a=paste0(r$l,r$v,collapse="")};a}

取消说明

f=function(a,n){
    for(i in 1:n){                      # For 1...n
        r=rle(el(strsplit(a,"")))       # Run length encoding
        a=paste0(r$l,r$v,collapse="")   # concatenate length vector and values vector and collapse
    };
    a                                   # print final result
}

Perl 6，63位元组

say (@*ARGS[0],*.trans(/(.)$0*/=>{$/.chars~$0})…*)[@*ARGS[1]]

这是我目前所能知道的那么短，可能有些棘手的标志可以减少它，我不确定

Ruby，63个字节

一个完整的程序，因为这个问题似乎要求这样做。将输入作为命令行参数。

i,n=$*
n.to_i.times{i=i.gsub(/(.)\1*/){"#{$&.size}#$1"}}
puts i

^{不，gsub!不能使用，因为其中的字符串$*是冻结的：/}

视网膜，46 45 27字节

马丁做了很多事情来帮助打高尔夫球。

+`(\d)(\1?)*(?=.*_)_?
$#2$1

在线尝试

采用以下格式的输入：

<start><count>

<start> 是初始编号。

<count> 一元，所有下划线，是执行了多少次迭代。

单次迭代，20 16字节：

(\d)(\1?)*
$#2$1

Haskell，62个字节

import Data.List
0%y=y
x%y=do x<-group$(x-1)%y;[length x,x!!0]

在线尝试！

JavaScript ES6，71个字节

(m,n)=>[...Array(n)].map(_=>m=m.replace(/(.)\1*/g,x=>x.length+x[0]))&&m

将输入作为字符串和数字。

Perl 5，50个字节

$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say

参数是相反的顺序（迭代次数，然后是种子）。例：

> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 4 2
132112
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 0 2
2
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 2 0
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 1 10
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 11 1
3113112221232112111312211312113211

05AB1E，9个字节（不竞争）

由于Emigna的评论已更正，请参见下文/编辑。

F.¡vygyÙJ

在线尝试！

R，61 57字节

-4感谢@JayCe，就在我确定无法将其简单完成之前！

f=function(a,n)`if`(n,f(t(sapply(rle(c(a)),c)),n-1),c(a))

在线尝试！

Mathematica，81 73字节

FromDigits@Nest[Flatten[(Tally/@Split@#)~Reverse~3]&,IntegerDigits@#,#2]&

果冻，6个字节（无竞争）

ŒrUFµ¡

在线尝试！

           Implicit input: first argument.
     µ¡    Do this to it <second argument> times:
Œr            Run-length encode into [value, times] pairs
  U           Flip them
   F          Flatten list

Stax，10 个字节

Çα▲ì4↔┌j█♀

在线运行和调试！

在正确的IO格式上花费了太多字节...

说明

使用解压后的版本进行解释。

DE|R{rm:f$e
D              Do `2nd parameter` times
 E             Convert number to digits
                   Starting from the `1st parmeter`
  |R           Convert to [element, count] pairs for each run
    {rm        Revert each pair
       :f      Flatten the array
         $     Convert array to string of digits
          e    Convert string of digits to integer

基本部分是D|R{rm:f（8个字节）。

如果第一个输入可以作为一个数字数组，则整个程序可以9个字节编写：在线运行和调试！

Python 3，138个字节

我使用了递归方法。

def g(a,b):
 if b<1:return a
 else:
  c,n=1,'';f,*a=str(a)+'_'
  for i in a:
   if i==f:c+=1
   else:n+=str(c)+f;f,c=i,1
  return g(n,b-1)

该函数接受两个int，a并且如上所述b。

我对这里的条目如此简洁感到惊讶！也许有人也会带来更好的Python方法。

Perl，38 + 2字节

for$i(1..<>){s/(.)\1*/(length$&).$1/ge}

需要-p标志：

$ perl -pe'for$i(1..<>){s/(.)\1*/(length$&).$1/ge}' <<< $'1\n5'
312211

输入是多行字符串：

input number
numbers of iterations

如果还需要所有步骤，那么我们可以将其更改为以下内容，即44 + 2个字节：

$ perl -nE'for$i(1..<>){s/(.)\1*/(length$&).$1/ge,print}' <<< $'1\n5'
11
21
1211
111221
312211

定向塔，11

i:At,{n,A}j

怎么运行的：

i      # Get input from command line.
:A     # Initialize A
  t    # Set A to the top of the stack.
,      # Pop the top of the stack.
{      # Start a for loop.
 n     # Run length encode the stack.
  ,    # Seperate command and iteration
   A   # Repeat A times.
    }  # End for loop.
j      # Join the stack with '' and print it and then exit. 

SmileBASIC，100 98字节

DEF S N,T?N
WHILE""<N
C=C+1C$=SHIFT(N)IF C$!=(N+@L)[0]THEN O$=O$+STR$(C)+C$C=0
WEND
S O$,T-T/T
END

打印出所有步骤。 T/T当T为0时有结束程序的地方。

APL（Dyalog Classic），22字节

{∊(≢,⊃)¨⍵⊂⍨1,2≠/⍵}⍣⎕,⎕

在线尝试！

视网膜，27字节

~(`^
K`
$
+`(.)\1$*¶$$.&$$1

在线尝试！

K（ngn / k），30个字节

{y{,/{(#x;*x)}'(&~=':x)_x}/,x}

在线尝试！

蟒3.6，100 98 93个字节

import re
f=lambda s,n:n and eval("f'"+re.sub(r'((.)\2*)',r'{len("\1")}\2',f(s,n-1))+"'")or s

在线尝试！

请注意，这将创建一个接受字符串和整数并返回字符串的lambda。例：f('1', 5) == '312211'

查找所有重复的字符（((.)\2*)正则表达式），从其长度和字符本身（r'{len("\1")}\2'）中提取一个f字符串，然后对其求值。在计数器（n and ...f(s,n-1)... or s）上使用递归以避免必须定义适当的函数和循环。