Desafío:

Dada una cadena sen los caracteres a- z, A- Z, 0- 9, agregue la longitud de ssí mismo, contando los caracteres adicionales en la longitud como parte de la longitud total de s.

Entrada:

Solo una cadena de longitud arbitraria (puede estar vacía).

Salida:

La misma cadena, pero con su longitud añadida al final. Los caracteres que representan la longitud también deben contarse como parte de la longitud. En los casos en que haya varias longitudes válidas para agregar, elija la más pequeña posible (consulte los casos de prueba para ver ejemplos).

Casos de prueba:

INPUT     -> OUTPUT       // Comment
aaa       -> aaa4
          -> 1            // Empty string
aaaaaaaa  -> aaaaaaaa9    // aaaaaaaa10 would also normally be valid, but violates using the smallest number rule mentioned above
aaaaaaaaa -> aaaaaaaaa11
a1        -> a13          // Input can contain numbers at the end of the string, you do not have to handle the fact that it looks like 13 rather than 3.

Longer test case(s):

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa101
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa102

Reglas:

Este es el código de golf , por lo que gana el código más corto en bytes. Las lagunas estándar están prohibidas. Los envíos pueden ser un programa completo o una función, y puede imprimir el resultado en stdout o devolverlo como una variable desde una función.

Pyth - 7 bytes

+Qfql+Q

Pruébelo en línea aquí .

JavaScript (ES6), 32 bytes

f=(s,n=0)=>(s+n)[n]?f(s,n+1):s+n

Cómo funciona

f = (s, n = 0) =>   // given a string 's' and starting with n = 0:
  (s + n)[n] ?      // if the Nth character of (s + n) exists:
    f(s, n + 1)     //   try again with n + 1
  :                 // else
    s + n           //   return s + n

Comenzando con N=0, probamos el enésimo carácter (basado en 0) de la cadena hecha de la concatenación de la cadena de entrada original y la representación decimal de N. Incrementamos Nhasta que este personaje ya no exista.

Ejemplo:

N =  0 : abcdefghi0
         ^
N =  1 : abcdefghi1
          ^
N =  2 : abcdefghi2
           ^
...
N =  8 : abcdefghi8
                 ^
N =  9 : abcdefghi9
                  ^
N = 10 : abcdefghi10
                   ^
N = 11 : abcdefghi11    -> success
                    ^

Casos de prueba

f=(s,n=0)=>(s+n)[n]?f(s,n+1):s+n

console.log(f("aaa"));       // -> aaa4
console.log(f(""));          // -> 1
console.log(f("aaaaaaaa"));  // -> aaaaaaaa9
console.log(f("aaaaaaaaa")); // -> aaaaaaaaa11
console.log(f("a1"));        // -> a13

LaTeX, 108/171

\newcounter{c}\def\s#1#2]{\stepcounter{c}\def\t{#2}\ifx\empty\t\arabic{c}\else#1\s#2]\fi}\def\q[#1]{\s#10]}

\q[] //1

JavaScript (ES6), 37 bytes

f=(s,t=s,u=s+t.length)=>t==u?t:f(s,u)

<input oninput=o.textContent=f(this.value)><pre id=o>

C, 67 65 61 bytes

x;f(*v){printf("%d",(int)log10(x=-~printf(v))*-~(x%10>8)+x);}

Caja de varitas

Lua 5.2, 32 bytes

a=arg[1]print(a..#a+#(''..#a+1))

Donde la variable a es la cadena de entrada.

Pyke, 8 bytes ( versión anterior )

.f+liq)+

Explicación:

.f    )  -  first where (i++)
  +      -    input + i
   l     -    len(^)
    iq   -   ^ == i
       + - input + ^

Pruébalo aquí! (Nueva versión, 9 bytes)

Python 2, 54 48 46 bytes

Solución simple. La recursión terminó siendo más corta.

f=lambda s,n=0:f(s,n+1)if(s+`n`)[n:]else s+`n`

Pruébalo en línea

Haskell, 46 bytes

f s=[l|i<-[0..],l<-[s++show i],length l==i]!!0

Ejemplo de uso: f "aaaaaaaa"-> "aaaaaaaa9".

Simplemente pruebe todos los números que comienzan con 0 y tome el primero que encaje.

Mathematica, 57 bytes

#<>ToString[(a=Length@#)+(i=IntegerLength)[a+i@a]~Max~1]&

Función sin nombre que toma una matriz de caracteres como entrada y devuelve una cadena. Utiliza el hecho de que si aes la longitud de la entrada, entonces el número a agregar a la entrada es amás el número de dígitos en ( a+ la longitud de a), en lugar de simplemente amás el número de dígitos de a. Desafortunadamente, no daría la respuesta correcta para la entrada de cadena vacía sin el ~Max~1caso especial.

Brachylog , 13 bytes

l<L$@:?rc.lL,

Pruébalo en línea!

Explicación

Básicamente una descripción del problema. Intentará cada valor Lmayor que la longitud de la entrada hasta que encuentre uno para el cual, cuando se concatena con la entrada, sea la longitud de esa concatenación.

l<L              length(Input) < L
  L$@            Convert L to a string
     :?rc.       The Output is the concatenation of the Input with L as string
         .lL,    The length of the Output is L itself

Brainfuck, 258 bytes

,>+<----------[++++++++++>+[>+<-],----------]<[<]>[.>]>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

La entrada debe ser terminada por un salto de línea (LF). Solo funciona para entradas con una longitud inferior a 256 (incluido el LF).

Pruébalo en línea!

Explicación

# read first char and add one to cell #1
# the cell after the input will contain the length
,>+<
# subtract 10 to check for LF
----------
# while the input is not 10 (LF)
[
# restore the input to its original value
++++++++++
# add one to the length
>+
# cut and paste the length to the next cell, then read the input
[>+<-],
# subtract 10 to check for LF
----------
]
# for input abc, the tape here would be: a b c *0* 4
# rewind to the beginning of the input
<[<]>
# print the input string
[.>]>
# convert the length to ascii chars and output them
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Nota: Utilicé el código de esta respuesta SO para convertir la longitud en salida ASCII; Espero que esto sea aceptable en PPCG. Esta es mi primera presentación de Codegolf y mi segundo programa BF. La retroalimentación es bienvenida.

Retina , 22 bytes

\G`
.
x
+r`\d*$
$._
x

Pruébalo en línea!

Ah, bueno, si no fuera por los dígitos que aparecen en la entrada, esto sería solo 11 bytes:

+r`\d*$
$._

Ruby, 62 58 56 bytes

s=gets.chomp;p s+"#{(s+"#{(s+"#{s.size}").size}").size}"

Probado en irb.

Probablemente haya una mejor manera de hacer esto, pero esto fue lo primero que se me ocurrió. Cualquier ayuda en el golf sería apreciada.

editar: me di cuenta de que mi uso de paréntesis era excesivo.

Perl 6 ,  46  35 bytes

{$_~(.chars,*.chars+.chars...{$^a==$^b})[*-1]}

{$_~(.chars,*.chars+.chars...*)[2]}

Intentalo

Expandido:

{   # bare block lambda with implicit parameter ｢$_｣

  $_  # the input

  ~   # concatenated with

  (  # sequence generator

    .chars,  # the number of chars in ｢$_｣ (seed the generator)


    *\      # Whatever lambda input (represents previous value)
    .chars  # number of chars in that
    +       # plus
    .chars  # the number of chars in ｢$_｣


    ...     # keep doing that until

    *       # indefinitely

  )[2] # get the value at index 2 of the sequence
}

05AB1E , 11 bytes

[¹¾JDg¾Q#¼\

Fuerza bruta bastante sencilla:

            Implicit i = 0
[           while true
 ¹¾J        Concatenate input and i -> str
    Dg¾Q#   Break if length(str) == i
         ¼\ Else, i += 1

Pruébalo en línea!

Python, 39 bytes

lambda a:eval('a+str(len('*3+'a))))))')

Forma más larga:

lambda a:a+str(len(a+str(len(a+str(len(a))))))

Iterativamente en Python 2 (41 bytes):

x=a=input();exec"x=a+`len(x)`;"*3;print x

Comenzando con xla cadena de entrada a, aplica la transformación x -> a + str(len(x))tres veces. Todavía no estoy claro por qué se necesitan tres aplicaciones para llegar siempre al punto fijo.

PHP, 42 bytes

while(++$n<strlen($a=$argv[1].$n));echo$a;

Corre con -r. Prueba en OnlinePHPfunctions .

bash, 47 bytes

 for((n=-1;${#s} != $n;));{ s=$1$[++n];};echo $s

Guarde esto como un script y pase la cadena de entrada como argumento.

Es una implementación de fuerza bruta: pruebe cada número por turno hasta que encuentre uno que funcione.

> <> (Pescado) 35 bytes

i:1+?!v:o
ln;v9l<  >
*9+>:&)?!^1l&a

Toma datos en la pila, comprueba la longitud con los valores 9,99,999 ... y si la longitud es mayor que agregue 1 a la longitud de la pila.

Haskell , 61 60 bytes

e=length
l%n|s<-show$l+1,n>e s=s|m<-n+1=(l+1)%m
c s=s++e s%2

Pruébalo en línea!

Solución recursiva. Uso:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 bytes

n=>{int a=n.Length;int c=(a+1).ToString().Length-1;return(n+(n.Length+1+c));}

MATL , 11 bytes

`G@Vhtn@>]&

Pruébalo en línea! O verificar todos los casos de prueba .

`      % Do...while
  G    %   Push input
  @    %   Push iteration index (1-based)
  V    %   Convert number to string
  h    %   Concatenate horizontally
  t    %   Duplicate
  n    %   Get length of concatenated string
  @    %   Push iteration index
  >    %   True if length of concatenated string exceeds iteration index
]      % End. Run next iteration if top of stack is true; else exit loop
&      % Specifiy that next function (implicit display) takes only one input
       % Implicitly display top of the stack. This is the concatenated string
       % that had a length equal to the iteration index

Ruby, 51 bytes (programa)

Ruby, 49 bytes (función)

Programa (la última línea nueva no es necesaria y, por lo tanto, no tiene puntaje):

x=gets.strip
i=0
i+=1 until(y=x+i.to_s).size==i
p y

Función (se puntúa la última línea nueva):

def f x
i=0
i+=1 until(y=x+i.to_s).size==i
y
end

Factor, 55 bytes

¡Es un paseo por el parque! Se me ocurrió esto en mi cabeza tan pronto como leí la pregunta.

[ dup length dup log10 ⌈ + >integer 10 >base append ]

Clojure, 72 bytes

(defn f([s](f s 1))([s n](if(=(count(str s n))n)(str s n)(f s(inc n)))))

R, 49 bytes

cat(a<-scan(,""),(t<-nchar(a))+nchar(t+1),sep='')

Solución bastante sencilla.

Wolfram, 56

#<>ToString@Nest[l+IntegerLength@#&,l=StringLength@#,2]&

Dado l = StringLength[x]que añade l + IntegerLength[l + IntegerLength[l]]a x.

Laberinto , 48 45 41 bytes

)"   10/{:@!
.,;: _ { _ ;
   })"}) 10-9!@

Pruébalo en línea!

Guardado 4 bytes agradecidos a @Martin Ender

ForceLang, 83 bytes

set s io.readln()
label 1
set n 1+n
set t s+n
if t.len=n
 io.write t
 exit()
goto 1