Вызов:

Получив строку sсимволов a- z, A- Z, 0- 9, добавьте длину sк себе, считая дополнительные символы в длине как часть общей длины s.

Входные данные:

Просто строка произвольной длины (может быть пустой).

Выход:

Та же строка, но с длиной, добавленной в конец. Символы, представляющие длину, также должны учитываться как часть длины. В случаях, когда требуется добавить несколько допустимых длин, выберите наименьшую возможную (см. Примеры тестов).

Тестовые случаи:

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

Правила:

Это код-гольф , поэтому выигрывает самый короткий код в байтах. Стандартные лазейки запрещены. Представления могут быть целой программой или функцией, и вы можете либо распечатать результат в стандартный вывод, либо вернуть его как переменную из функции.

Pyth - 7 байт

+Qfql+Q

Попробуйте это онлайн здесь .

JavaScript (ES6), 32 байта

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

Как это устроено

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

Начиная с N=0, мы проверяем N-й символ ( начиная с 0) строки, составленной из конкатенации исходной входной строки и десятичного представления N. Мы увеличиваем, Nпока этот символ больше не существует.

Пример:

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

Контрольные примеры

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

Латекс, 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 байт

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 байт

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

Wandbox

Lua 5.2, 32 байта

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

Где переменная а является входной строкой.

Пайк, 8 байт ( старая версия )

.f+liq)+

Объяснение:

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

Попробуй это здесь! (Новая версия, 9 байт)

Python 2, 54 48 46 байт

Простое решение Рекурсия оказалась короче.

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

Попробуйте онлайн

Haskell, 46 байтов

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

Пример использования: f "aaaaaaaa"-> "aaaaaaaa9".

Просто попробуйте все числа, начинающиеся с 0, и возьмите первое, которое подходит.

Mathematica, 57 байт

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

Безымянная функция, принимающая массив символов в качестве входных данных и возвращающая строку. Используется тот факт, что если aдлина ввода, то число, добавляемое к входу, aплюс число цифр в ( a+ длина a), а не просто aплюс число цифр a. К сожалению, это не даст правильный ответ для ввода пустой строки без ~Max~1специального случая.

Брахилог , 13 байт

l<L$@:?rc.lL,

Попробуйте онлайн!

объяснение

В основном описание проблемы. Он будет проверять каждое значение, Lпревышающее длину ввода, пока не найдет значение, для которого при конкатенации с входом будет длина этой конкатенации.

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 байт

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

Ввод должен быть завершен переводом строки (LF). Работает только для входов с длиной менее 256 (включая LF).

Попробуйте онлайн!

объяснение

# 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
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Примечание: я использовал код из этого SO-ответа, чтобы преобразовать длину в вывод ascii; Я надеюсь, что это приемлемо на PPCG. Это моя первая заявка на Codegolf и моя вторая программа BF. Обратная связь приветствуется.

Сетчатка , 22 байта

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

Попробуйте онлайн!

Что ж, если бы не цифры, появляющиеся на входе, это было бы всего 11 байтов:

+r`\d*$
$._

Рубин, 62 58 56 байт

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

Проверено в irb.

Возможно, есть лучший способ сделать это, но это было первое, что я придумал. Любая помощь в гольф будет оценена.

редактировать: я понял, что использование скобок было чрезмерным.

Perl 6 ,  46  35 байт

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

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

Попробуй

Expanded:

{   # 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 байт

[¹¾JDg¾Q#¼\

Довольно простая грубая сила:

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

Попробуйте онлайн!

Python, 39 байт

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

Более длинная форма:

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

Итеративно в Python 2 (41 байт):

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

Начиная с xвходной строки a, применяет преобразование x -> a + str(len(x))три раза. Мне до сих пор не ясно, зачем нужны три приложения, чтобы всегда достигать фиксированной точки.

PHP, 42 байта

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

Беги с -r. Тест на OnlinePHPфункциях .

bash, 47 байт

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

Сохраните это как скрипт и передайте входную строку в качестве аргумента.

Это реализация грубой силы: попробуйте каждый номер по очереди, пока не найдете тот, который работает.

> <> (Рыба) 35 байт

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

Делает ввод в стек, проверяет длину по значениям 9,99,999 ... и, если длина больше, чем 1, добавьте к длине стека.

Haskell , 61 60 байт

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

Попробуйте онлайн!

Рекурсивное решение. Использование:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 байт

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

MATL , 11 байт

`G@Vhtn@>]&

Попробуйте онлайн! Или проверьте все тестовые случаи .

`      % 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 байт (программа)

Рубин, 49 байт (функция)

Программа (последняя новая строка не нужна и, следовательно, не отмечена):

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

Функция (последний перевод строки отмечен):

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

Фактор, 55 байт

Это прогулка в парке! Я придумал это в своей голове, как только прочитал вопрос.

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

Clojure, 72 байта

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

R, 49 байт

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

Довольно простое решение.

Вольфрам, 56

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

Учитывая l = StringLength[x]это присоединяет l + IntegerLength[l + IntegerLength[l]]к x.

Лабиринт , 48 45 41 байт

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

Попробуйте онлайн!

Сохранено 4 байта, благодаря @Martin Ender

ForceLang, 83 байта

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