La séquence «Regardez et dites» ou «Dites ce que vous voyez» est une série de nombres où chacun décrit le dernier.

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)

et ainsi de suite ... https://oeis.org/A005150

Quoi qu'il en soit, il s'agit d'un défi de golf de code normal (le nombre de victoires par octet) pour créer un programme qui prend deux arguments, un nombre initial et le nombre d'itérations. Par exemple, si vous avez branché "1" et "2", le résultat serait "21". Si vous branchez "2" et "4" le résultat serait "132112". S'amuser!

Pyth, 10 8 octets

-2 octets par @FryAmTheEggman

ussrG8Qz

Explication:

            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

Essayez-le ici .

CJam, 8 octets

q~{se`}*

Le format d'entrée est le nombre initial en premier, les itérations en second, séparés par des espaces.

Testez-le ici.

Explication

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.
}*

Le tableau est également aplati avant d'être imprimé afin que le résultat soit juste le nombre requis.

JavaScript, 57 octets

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

La récursivité fonctionne bien pour ce problème. Le premier paramètre est le nombre initial sous forme de chaîne et le second est le nombre d'itérations.

MATL , 9 octets

:"Y'wvX:!

Les entrées sont: nombre d'itérations, nombre initial.

Essayez-le en ligne!

:      % 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 octets

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

Non golfé et expliqué

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 octets

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

C'est aussi court que possible pour l'instant, il pourrait y avoir des drapeaux délicats qui pourraient le réduire, je ne suis pas sûr

Rubis, 63 octets

Un programme complet, puisque la question semble demander cela. Prend l'entrée comme arguments de ligne de commande.

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

^{Non, gsub!ne peut pas être utilisé, car les chaînes $*sont gelées: /}

Rétine , 46 45 27 octets

Martin a fait beaucoup pour aider au golf.

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

Essayez-le en ligne

Prend entrée au format:

<start><count>

<start> est le nombre initial.

<count> est en unaire, tous les traits de soulignement et représente le nombre d'itérations effectuées.

Itération unique, 20 16 octets:

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

Haskell , 62 octets

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

Essayez-le en ligne!

JavaScript ES6, 71 octets

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

Prend l'entrée sous forme de chaîne et de nombre.

Perl 5, 50 octets

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

Les arguments sont dans l'ordre inverse (nombre d'itérations puis graine). Exemple:

> 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 octets (non concurrent)

Corrigé en raison des commentaires d'Emigna, voir ci-dessous / modifications.

F.¡vygyÙJ

Essayez-le en ligne!

R , 61 57 octets

-4 grâce à @JayCe, juste au moment où j'étais sûr que cela ne pourrait pas être plus simple!

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

Essayez-le en ligne!

Mathematica, 81 73 octets

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

Gelée , 6 octets (non concurrent)

ŒrUFµ¡

Essayez-le en ligne!

           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 octets

Çα▲ì4↔┌j█♀

Exécutez et déboguez en ligne!

Trop d'octets dépensés sur le bon format d'E / S ...

Explication

Utilise la version décompressée pour expliquer.

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

La partie essentielle est D|R{rm:f(8 octets).

Si la première entrée peut être considérée comme un tableau de chiffres, tout le programme peut être écrit en 9 octets: Exécuter et déboguer en ligne!

Python 3, 138 octets

J'ai utilisé une approche récursive.

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)

La fonction accepte deux entrées aet bcomme décrit.

Je suis étonné de voir à quel point les entrées sont laconiques! Peut-être que quelqu'un viendra aussi avec une meilleure méthode Python.

Perl, 38 + 2 octets

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

Nécessite le -pdrapeau:

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

L'entrée est une chaîne de plusieurs lignes:

input number
numbers of iterations

Si toutes les étapes sont également requises, nous pouvons les modifier comme suit, soit 44 + 2 octets:

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

Pylônes , 11

i:At,{n,A}j

Comment ça marche:

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 octets

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

Imprime toutes les étapes. T/Test là pour terminer le programme lorsque T est 0.

APL (Dyalog Classic) , 22 octets

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

Essayez-le en ligne!

Rétine , 27 octets

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

Essayez-le en ligne!

K (ngn / k) , 30 octets

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

Essayez-le en ligne!

Python 3.6, 100 98 93 octets

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

Essayez-le en ligne!

Notez que cela crée un lambda qui prend une chaîne et un entier et renvoie une chaîne. Exemple:f('1', 5) == '312211'

Recherche tous les caractères répétés ( ((.)\2*)regex), crée une chaîne f à partir de leur longueur et du caractère lui-même ( r'{len("\1")}\2'), puis l'évalue. Utilise la récursivité sur le compteur ( n and ...f(s,n-1)... or s) pour éviter d'avoir à définir une fonction appropriée et une boucle.