Longitudes de cadena anexas


51

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 , 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.


¿Qué caracteres pueden aparecer en la entrada?
Martin Ender

@MartinEnder Solo caracteres alfanuméricos, 0-9 y AZ / az. Entonces sí, puede tener cadenas con números al final. Agregaré un caso de prueba para uno.
Yodle

Respuestas:



18

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


Wow, JS es mucho más estricto que Python para esto.
mbomb007

@Arnauld No puedo entender esto. ¿Te importaría explicar cómo funciona este código?
Gowtham

12

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


Whoa, no creo que haya visto una respuesta de látex en ppcg antes.
pajonk

5

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>


Cuando hice clic en aparece Run Code Snippetun mensaje de error. No tengo conocimiento de Javascript - Solo estaba intentando
Prasanna

@Prasanna funciona para mí en Firefox; ¿Qué navegador estás usando?
Neil

@Prasanna funciona en la última versión de Google Chrome. ¿Estás seguro de que no estás usando IE11 o anterior, Opera o cualquier cosa que no sea compatible con ES6?
Ismael Miguel

Estoy usando un viejo buen cromo ( Version 48.0.2564.97). Intentaré esto con IE también. No puedo actualizar mi Chrome - problemas de seguridad de la oficina
Prasanna

5

C, 67 65 61 bytes

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

Caja de varitas


1
Ohh, sí, debería haber impreso ... De todos modos, felicidades por tener la solución C más corta: D +1
cat

4

Lua 5.2, 32 bytes

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

Donde la variable a es la cadena de entrada.


3

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)


Siempre me confunde cuán enterrado está el resultado real entre advertencias u otros mensajes :-)
Luis Mendo

2
Realmente debería solucionar el error web en el enlace de copia que deshabilita automáticamente el interruptor de advertencias
Azul

3

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


1
Creo que se puede hacer (s+`n`)[n:]para n<len(s+`n`).
xnor

3

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.


3

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.


3

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

3

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.


1
Esto no es válido entonces, debe pasar todos los casos de prueba
gato

¿Soportar una longitud de hasta 999 sería suficiente?
Forcent Vintier

La especificación dice "longitud arbitraria", que significa "siempre que su idioma sea capaz de manejar o sin quedarse sin memoria"
cat

El intérprete de brainfuck que está utilizando tiene celdas de 8 bits, por lo que siempre que su algoritmo funcione para cadenas de longitud arbitraria, debería estar bien si falla para cadenas de longitud 256 o superior. Los envíos de C y JavaScript también fallarán una vez que las cadenas se alarguen demasiado.
Dennis

Gracias Dennis, modificaré mi presentación en consecuencia
Forcent Vintier


2

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.


Solo se usa len un lugar. Si lo incluye, ahorrará 3 bytes l=;. Pero su solución aún será más larga que la mía;)
DepressedDaniel

2

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
}

2

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!


2

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.


¿Por qué 3 veces? Primero para agregar la longitud del texto, segundo para ajustar la longitud para incluir el número, tercero en caso de que el ajuste agregue un dígito adicional.
Tom Viner el


2

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.


2

> <> (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.



1

C #, 77 bytes

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

1
Ahora no tengo C #, pero ¿no podrías usar return(n+(a+1+c))como a=n.Length?
Laikoni

¿Y también soltar -1desde int c=(a+1).ToString().Length-1y +1desde el regreso?
Laikoni

1
Espera, ¿esto maneja los casos de prueba más grandes correctamente? Parece que regresa en aa...a100lugar del caso de prueba aa...a10199 a.
Laikoni

1

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

1

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

1

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 ]

1

Clojure, 72 bytes

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

1

R, 49 bytes

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

Solución bastante sencilla.


Esto no funciona para mí: Read 1 item Error in nchar(x + 1) : object 'x' not found. Descubrí que (t<-nchar(a))+...sí funcionó.
JAD

@JarkoDubbeldam: ¡Qué mal!
Frédéric

1

Wolfram, 56

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

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



1

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.