Output the length of (the length plus a message) [duplicate]

Question

The task is simple. You're given an arbitrary string message. Return that message prefixed with a number, such that the length of that number plus the message equals the number. In other words, the length in your output must be the total length of your output.

If multiple candidates exist, you can output any of them.

For example, take the following message: pull the other one, with a length of 18. Your final output should be 20 + pull the other one, because the total length of 20 + the total length of pull the other one is 20 ASCII characters.

Restrictions/clarifications:

• Your input and output can be given by any convenient method.
• The outputted length can be encoded in any way you like, as long as the encoding can represent any arbitrary positive number, and the encoding is consistent. You can, for example, output 10111 + pull the other one (10111 is 23 in binary, and the total length is 23). This also extends to types: e.g. a tuple of (int, string) is accepted as output, as long as you specify the encoding the integer must have.
• The input string can also have any encoding you like (well, except for the encoding in this question).
• Your program should be able to handle at least all messages of length <= 1,048,575 (2^20-1).
• The program can be a full program or just a function; either is fine.
• Standard loopholes are forbidden.
• Shortest code wins.

Some more test cases:

# base 10
"hello world" -> "13" + "hello world"
"the axes"    -> "9"  + "the axes"
"the axes"    -> "10" + "the axes"    # both of these are valid outputs
""            -> "1"  + ""            # the empty message should result in simply the output "1"

# base 2
"hello world" -> "1111" + "hello world"
"test"        -> "111"  + "test"
"test"        -> "1000" + "test"        # both of these are valid outputs
""            -> "1"    + ""            # the empty message can result in simply the output "1"
""            -> "10"   + ""            # in binary, this is also a valid result for the empty message

Answer 1

C (gcc), 43 bytes

f(b,s,n){for(;sprintf(b,"%d%s",++n,s)>n;);}

Try it online!

Answer 2

Pyth, 4 bytes

+Chl

Try it online!

Length encoded using Python chr.

Answer 3

Pyth, ⁷ 6 bytes

-1 byte thanks to @isaacg

+fql+Q

Attempt This Online!

Explanation

+fql+QTT<None>Q
+                #  add
 f               #    first input (T) where
   l             #      length of
    +QT          #        testcase + T
  q    T         #      equals T
              Q  #  to the testcase

Answer 4

Vyxal, 4 bytes

3(Lp

Try it Online! -1 thanks to lyxal, -2 thanks to Kevin Cruijjsen.

3(   # Three times
   p # Prepend to input
  L  # Length of current value

Answer 5

Charcoal, 10 bytes

⁺Ｌ⁺Ｌ⁺Ｌθθθθ

Try it online! Link is to verbose version of code. Explanation: Charcoal doesn't really do recursion, but the recursive approach of repeatedly taking the length of the string with the previous length prefixed to it never needs to iterate more than twice.

      θ     Input string
     Ｌ      Take the length
    ⁺       Concatenated with
       θ    Input string
   Ｌ        Take the length
  ⁺         Concatenated with
        θ   Input string
 Ｌ          Take the length
⁺           Concatenated with
         θ  Input string
            Implicitly print

Answer 6

Japt, 7 bytes

ÈsY}f+U

Try it here

ÈsY}f+U     :Implicit input of string U
È           :Function taking a string and a 0-based iteration index Y as arguments
 sY         :  Slice the string from the Yth character
   }        :End function
    f       :Get the first string that returns falsey (empty string)
     +U     :  Where each string is U appended to the current iteration index

Answer 7

Husk, 10 bytes

,ḟS=ȯL+¹sN

Try it online!

,ḟS=ȯL+¹sN
 ḟ          # get the first 
         N  # integer from 1..infinity
  =         # that equals       
   ȯ        # (compose 3 functions)
    L       #   the length of
     +¹     #   the input added to
       s    #   itself as a string
,           # finally, construct a pair of 
            # this number and the input

Answer 8

JavaScript (ES6), 31 bytes

-1 thanks to @Shaggy

Uses a decimal prefix.

s=>(g=n=>(S=++n+s)[n]?g(n):S)``

Try it online!

Answer 9

Ly, 15 bytes

iys>l`Sys<l+u&o

Try it online!

iys              - Read STDIN onto the stack, push stack size, save it
   >l`           - Switch to new stack, load saved size, increment by 1
      Sys        - Convert number to digits, get size of stack, save it
         <       - Switch back to the original stack (w/ STDIN and strlen)
          l+     - Load number of digits in the "strlen + 1", add to strlen
            u    - Write length as a number
             &o  - Write STDIN codepoints as characters

Answer 10

05AB1E, 4 bytes

3Fgì

Similar as my answer for the related challenge, but with a prepend instead of append. Will therefore also use base-10, and always use the smallest (9 instead of 10) if more than one option is available.

Try it online or verify all test cases.

Explanation:

3F    # Loop 3 times:
  g   #  Pop the current string, and push its length
      #  (which will use the implicit input-string in the first iteration)
   ì  #  Prepend this length to the (implicit) input-string
      # (after which the result is output implicitly)

Answer 11

Python, 24 bytes

lambda a:chr(len(a)+1)+a

Attempt This Online!

---

Python, 50 bytes

f=lambda a,b=1:(len(s:=str(b)+a)==b)*s or f(a,b+1)

Attempt This Online!

---

Python 2, 49 bytes

f=lambda a,b=1:(len(`b`+a)==b)*(`b`+a)or f(a,b+1)

Attempt This Online!

Python 2 solution suggested by Dominic van Essen

Answer 12

AWK, 41 38 bytes

{a=length;$0=length(length(a)+a)+a$0}1

# E.g.
awk '{a=length;$0=length(length(a)+a)+a$0}1' <<< "input"

Try it online

Remove the space (" ") between the final length and the string as suggested by @Dominic van Essen (-3 bytes)

Answer 13

Python, 65 bytes

I'm not 100% sure I understood the question right

lambda a,b=0:(z:=len(a)+len(str(b)))and((z,a)if z==b else f(a,z))

Attempt This Online!

Answer 14

Python, 47 bytes

f=lambda a,b=1:(b*f"{b}{a}")[-b:b*b]or f(a,b+1)

Attempt This Online!

Answer 15

Ruby, 39 34 bytes

->c,a=0{a+=1while(b=[a]*c+c)[a];b}

-5 bytes thanks to observations from jdt's C and Arnauld's JS.

Attempt This Online!

Answer 16

MathGolf, 6 bytes

£▌£▌£▌

Try it online.

Explanation:

£       # Pop and push the length of the (implicit) input-string
 ▌      # Prepend it to the (implicit) input-string
  £     # Pop and push the length of that
   ▌    # Prepend it to the (implicit) input-string
    £▌  # Rinse and repeat
        # (after which the entire stack is output implicitly)

Answer 17

><>, 43 41 bytes

r1>:0v >o<
1(?v$>1+$a,:
2l~<.03+1v?=@:$+-

Try it online! or Try without input

Explanation

r1                  # initialize with length as 1 (L)
  >:0v              # initialize length of (L) as 0 (N)
1(?v$>1+$a,:        # calculate (N)
2l~<     v?=@:$+-   # if the length of string (S) + (N) = (L)
       >o<          # print L followed by the string
    .03+1           # else, increment (L) and go back to calculation of (N)

The length is output as a charcode.

Answer 18

Nibbles, 4.5 bytes (9 nibbles)

/\`.$:,$@

Inspired by Pacmanboss's comment.

  `.            # iterate while unique
    $           # starting from the input:
     :          #   prepend
      ,$        #   its length 
        @       #   to the original input
 \              # then, reverse the list
/               # and fold over it 
                # getting the left-hand argument each time
                # (so getting the first element)

---

Previous approach:

Nibbles, 5.5 bytes (11 nibbles)

:/|,~~-,:`p

Nibbles adds implicit variables to the end of each program if they are needed for the arity of the functions used.
In this case, this works particularly well.

  |             # filter
   ,~           # 1..infinity
     ~          # for elements that are falsy for
       ,        #   the length of 
         `p     #    the string represention 
                #    (implicitly: of each element)
        :       #    concatenated with
                #    (implicitly: the input)
      -         #   minus
                #   (implicitly: itself)
 /              # now, fold over this list
                #   returning for each pair
                #   (implicitly: the left-hand argument)
                #   (so the fold returns the first element)
:               # finally, prepend this to
                #   (implicitly: the input)

Answer 19

Go, 95 bytes

import."fmt"
func f(s string)string{S:=Sprint
return S(len(s)+len(S(len(s)+len(S(len(s))))),s)}

Attempt This Online!

Go, Old 125 bytes

import(."fmt";."strings")
func f(s string)string{S:=Repeat("-",len(s))+s
for range`---`{S=Sprintf("%d%s",len(S),s)}
return S}

Attempt This Online!

Answer 20

Excel, 21 27 bytes

=LEN(LEN(LEN(A1)&A1)&A1)&A1

Admittedly boring. I tried to do something fancy with LOG() but it's longer than this solution.

Answer 21

JavaScript, 29 bytes

s=>(g=x=>x.length+s)(g(g(s)))

Try it online!

Answer 22

SQL (24 bits)

print len(@)+len(len(@))

Assuming we have: declare @ as varchar(max) = 'any-string'

Answer 23

SAS, 47 58 bytes

Fix something error. I just find this anwser is same with the Excel one.

%macro e(m);
%put%length(%length(%length(&m)&m)&m)&m;
%mend;

Try some example:

%e(hello world);
13hello world

%e(something);
11something

%e(the axes);
9the axes

Answer 24

PLIS, 81 bytes

&R($Z(strlen($0))$D(1+@(H@({$0^2}{$0-spT@$0-Z}a))@0)catat(48+digits(D),spT@D,$0))

Takes a string sequence as input, and returns a string sequence as output.

print(R("hello world"));        #=> 13hello world
print(R("the axes"));           #=> 9the axes
print(R("pull the other one")); #=> 20pull the other one
print(R(""));                   #=> 1

Explanation

Here is an equivalent, commented, ungolfed version of the above, with shortnames expanded.

&R(
  # set Z to strlen(input)
  $Z(strlen($0))
  # set D to 1 + the first index where
  $D(
    1 + @(
      # we find a 0 in
      A000007@(
        # the squared sequence of (i.e. absolute value of)
        {$0^2}
          # the difference between increasing positive integers ($0),
          # the length of that integer (A055642), and the input
          # string's length (Z)
          {$0 - A055642@$0 - Z} A000027
      )
    )@0
  )
  # D is now the appropriate number we need to prepend
  # 48 + digits(D) gives the ASCII version of this sequence
  # catat(A,n,B) will use the first  n  entries of  A  followed by
  # the entries in  B
  # this line has the effect we want
  catat(48 + digits(D), A055642@D, $0)
)

Answer 25

Terse, 4 bytes

地用找儿

Try it here

地　　　　　Length
　用　　　　+1
　　找　　　To character
　　　儿　　Append input