Anexando comprimentos de string


51

Desafio:

Dada uma sequência snos caracteres a- z, A- Z, 0- 9, acrescente o comprimento de ssi mesmo, contando os caracteres adicionais no comprimento como parte do comprimento total de s.

Entrada:

Apenas uma sequência de comprimento arbitrário (pode estar vazio).

Resultado:

A mesma sequência, mas com seu comprimento anexado ao final. Os caracteres que representam o comprimento também devem ser contados como parte do comprimento. Nos casos em que há vários comprimentos válidos para acrescentar, escolha o menor possível (consulte exemplos de casos de teste).

Casos de teste:

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

Regras:

Isso é , então o código mais curto em bytes vence. As brechas padrão são proibidas. Os envios podem ser um programa inteiro ou uma função, e você pode imprimir o resultado em stdout ou retorná-lo como uma variável de uma função.


Quais caracteres podem aparecer na entrada?
Martin Ender

@MartinEnder Apenas caracteres alfanuméricos, 0-9 e AZ / az. Então, sim, você pode ter strings com números no final. Vou adicionar um caso de teste para um.
Yodle

Respostas:



18

JavaScript (ES6), 32 bytes

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

Como 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

Começando com N=0, testamos o enésimo caractere (baseado em 0) da sequência feita da concatenação da sequência original de entrada e a representação decimal de N. Nós incrementamos Naté que esse personagem não exista mais.

Exemplo:

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

Casos de teste


Uau, JS é muito mais tenso do que Python para isso.
mbomb007

@ Arnauld Eu não consigo entender isso. Você se importa em explicar como esse código funciona?
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


Acho que nunca vi uma resposta de látex no 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>


Ao clicar em Run Code Snippet, recebo uma mensagem de erro. Eu não tenho conhecimento de Javascript - Eu só estava tentando
Prasanna

@Prasanna Funciona para mim no Firefox; Qual navegador você está usando?
Neil

@Prasanna Funciona no Google Chrome mais recente. Tem certeza de que não está usando o IE11 ou mais antigo, Opera ou qualquer coisa que não seja compatível com o ES6?
Ismael Miguel

Estou usando um bom e velho chrome ( Version 48.0.2564.97). Vou tentar isso com o IE também. Não é possível atualizar meus cromo - questões de segurança de escritório
Prasanna

5

C, 67 65 61 bytes

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

Wandbox


11
Ah, sim, eu deveria imprimir ... De qualquer forma, parabéns por ter a solução C mais curta: D +1
cat

4

Lua 5.2, 32 bytes

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

Onde a variável a é a sequência de entrada.


3

Pyke, 8 bytes ( versão antiga )

.f+liq)+

Explicação:

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

Experimente aqui! (Nova versão, 9 bytes)


Ele sempre me confunde como enterrado a saída real está entre advertências ou outras mensagens :-)
Luis Mendo

2
Eu realmente deveria dar a volta a corrigir o bug web no link de cópia que desactiva automaticamente os avisos mudar
Azul

3

Python 2, 54 48 46 bytes

Solução simples. A recursão acabou sendo mais curta.

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

Experimente online


11
Eu acho que você pode fazer (s+`n`)[n:]por n<len(s+`n`).
Xnor

3

Haskell, 46 bytes

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

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

Simplesmente tente todos os números que começam com 0 e pegue o primeiro que se encaixa.


3

Mathematica, 57 bytes

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

Função sem nome, recebendo uma matriz de caracteres como entrada e retornando uma string. Usa o fato de que se aé o comprimento da entrada, o número a ser acrescentado à entrada é amais o número de dígitos em ( a+ o comprimento de a), em vez de apenas ao número de dígitos de a. Infelizmente, não daria a resposta certa para a entrada de cadeia vazia sem o ~Max~1caso especial.


3

Braquilog , 13 bytes

l<L$@:?rc.lL,

Experimente online!

Explicação

Basicamente, uma descrição do problema. Ele tentará todos os valores Lmaiores que o comprimento da entrada até encontrar um para o qual, quando concatenado com a entrada, é o comprimento dessa concatenação.

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

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

A entrada deve ser finalizada por um avanço de linha (LF). Funciona apenas para entradas com comprimento menor que 256 (incluindo o LF).

Experimente online!

Explicação

# 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: usei o código desta resposta do SO para converter o comprimento em saída ascii; Espero que isso seja aceitável no PPCG. Esta é minha primeira submissão ao Codegolf e meu segundo programa de graduação. O feedback é bem-vindo.


11
Isso não é válido, portanto, deve passar em todos os casos de teste
cat

Então, suportar um comprimento de até 999 seria suficiente?
Forcent Vintier

A especificação diz "comprimento arbitrário", que significa "desde que seu idioma seja capaz de lidar ou sem ficar sem memória"
cat

O intérprete de cérebro que você está usando possui células de 8 bits, desde que seu algoritmo funcione para cadeias de comprimento arbitrário, tudo bem se falhar para cadeias de comprimento 256 ou superior. Os envios C e JavaScript também falharão quando as seqüências ficarem muito longas.
Dennis

Obrigado Dennis, vou modificar minha submissão de acordo.
Forcent Vintier


2

Ruby, 62 58 56 bytes

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

Testado em irb.

Provavelmente existe uma maneira melhor de fazer isso, mas essa foi a primeira coisa que me veio à cabeça. Qualquer ajuda no golfe seria apreciada.

editar: percebi que meu uso de parênteses era excessivo.


Você só usa lem um só lugar. Se você incorporar isso, você salvará 3 bytes l=;. Mas sua solução ainda vai ser maior do que o meu;)
DepressedDaniel

2

Perl 6 ,  46  35 bytes

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

Tente

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#¼\

Força bruta bastante direta:

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

Experimente online!


2

Python, 39 bytes

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

Forma mais longa:

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

Iterativamente em Python 2 (41 bytes):

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

Começando com xcomo a sequência de entrada a, aplica a transformação x -> a + str(len(x))três vezes. Ainda não estou claro por que três aplicativos são necessários para sempre atingir o ponto fixo.


Por que 3 vezes? Primeiro para anexar o comprimento do texto, segundo para ajustar o comprimento para incluir o número, terceiro caso esse ajuste tenha adicionado um dígito extra.
Tom Viner


2

bash, 47 bytes

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

Salve isso como um script e passe a string de entrada como argumento.

É uma implementação de força bruta: tente cada número por vez até encontrar um que funcione.


2

> <> (Peixe) 35 bytes

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

Coloca entrada na pilha, verifica o comprimento em relação aos valores 9,99.999 ... e se o comprimento for maior que adicionar 1 ao comprimento da pilha.



1

C #, 77 bytes

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

11
Agora eu não c #, mas você não poderia usar return(n+(a+1+c))como a=n.Length?
Laikoni

E também largar o -1de int c=(a+1).ToString().Length-1e o +1de retorno?
Laikoni

11
Aguarde, isso lida com os casos de teste maiores corretamente? Parece que ele retorna em aa...a100vez de aa...a101para o acaso de teste 99 .
Laikoni

1

MATL , 11 bytes

`G@Vhtn@>]&

Experimente online! Ou verifique todos os casos de teste .

`      % 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 (função)

Programa (a última nova linha não é necessária e, portanto, sem pontuação):

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

Função (a última nova linha é pontuada):

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

1

Fator, 55 bytes

É um passeio no parque! Eu pensei nisso assim que li a pergunta.

[ 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='')

Solução bastante simples.


Isso não funciona para mim: Read 1 item Error in nchar(x + 1) : object 'x' not found. Eu achei que (t<-nchar(a))+...funcionou.
JAD

@JarkoDubbeldam: Meu mal!
Frédéric

1

Wolfram, 56

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

Dada l = StringLength[x]ele acrescenta 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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.