16
\$\begingroup\$

Task

Write a program that will take (as input) a positive integer. It will then count up from 0, appending each integer to a String, only continuing if the length of the String is less than the value of the input.

A serialized integer is defined as the fully-formed integer with the maximum value belonging to the String. By "fully-formed", the integer should have no missing digits (which would occur if the length constraint of the String is met).

The output of the program should be the serialized integer for its respective, positive input.


Rules

  • It's code golf, so the shortest answer (in bytes) wins!
  • Input will always be positive.
  • The output must be an integer in base-10 (decimal).
  • The program must be 0-indexed.

Example Input | Output

   5 | 4   (0 1 2 3 4              - Length of 5)
  11 | 9   (0 1 2 3 4 5 6 7 8 9 1  - Length of 11)
  12 | 10  (0 1 2 3 4 5 6 7 8 9 10 - Length of 12)
1024 | 377 (0 1 2 3 4 5 6 7 8 ...  - Length of 1024)

Note(s)

\$\endgroup\$
  • 6
    \$\begingroup\$ suggested test case : 11 \$\endgroup\$ – Rod Jul 11 '17 at 13:35
  • \$\begingroup\$ @Rod Added it, hopefully it makes it easier to understand! \$\endgroup\$ – Jacob G. Jul 11 '17 at 13:38
  • \$\begingroup\$ Adding quote marks to the string in the examples might make it easier to understand that it's a string. \$\endgroup\$ – isaacg Jul 11 '17 at 20:18
  • \$\begingroup\$ So the first N-1 digits of the Champernowne constant, with a 0 prepended? \$\endgroup\$ – Mego Nov 14 '17 at 18:19

20 Answers 20

8
\$\begingroup\$

JavaScript (ES6), 40 37 bytes

f=(n,i=s='0')=>(s+=++i)[n]?i-1:f(n,i)
<input type=number min=1 value=1 oninput=o.textContent=f(this.value)><pre id=o>0

Edit: Saved 3 bytes with some help from @Arnauld.

|improve this answer|||||
\$\endgroup\$
6
\$\begingroup\$

05AB1E, 10 7 bytes

Idea to use prefixes from Jonathan's Jelly answer

LηJ€g›O

Try it online!

Explanation

L         # range [1 ... input]
 η        # prefixes
  J       # join each to string
   €g     # get length of each string
     ›    # input is greater than string length
      O   # sum
|improve this answer|||||
\$\endgroup\$
5
\$\begingroup\$

Python 2, 55 bytes

Recursive lambda port from @officialaimm's answer.

f=lambda k,s='',i=1:k>len(s+`i`)and f(k,s+`i`,i+1)or~-i

Try it online!

|improve this answer|||||
\$\endgroup\$
5
\$\begingroup\$

Japt, 13 bytes

1n@P±X l >U}a

Test it online!

Explanation

1n@ P± X l >U}a
1nX{P+=X l >U}a
                   Implicit: U = input integer, P = empty string
  X{         }a    Return the first integer X in [0, 1, 2, ...] that returns a truthy value:
    P+=X             Append X to P.
         l >U        Return P.length > U.
                   This returns the first integer that can't fit into the U-char string.
1n                 Subtract 1 from the result.
                   Implicit: output result of last expression
|improve this answer|||||
\$\endgroup\$
4
\$\begingroup\$

PHP, 56 bytes

for(;$argn>$l=strlen($r);)$r.=+$i++;echo$i-1-($argn<$l);

Try it online!

|improve this answer|||||
\$\endgroup\$
4
\$\begingroup\$

Haskell, 55 53 50 bytes

(n#x)a|l<-a++show x=last$x-1:[n#l$x+1|length l<=n]

Try it online!

Usage is (1024#"") 0

|improve this answer|||||
\$\endgroup\$
4
\$\begingroup\$

Python 2, 60 59 58 bytes

  • Thanks @Felipe for 2 bytes
i,j,k='',1,input()
while len(i+`j`)<k:i+=`j`;j+=1
print~-j

Try it online!

|improve this answer|||||
\$\endgroup\$
4
\$\begingroup\$

Jelly,  11 10  9 bytes

RD;\L€<⁸S

A monadic link taking a positive integer and returning a non-negative integer.

Try it online!

How?

editing...

RD;\L€<⁸S - link: number n
R         - range -> [1,2,...10,11,...,n-1]
 D        - convert to decimal (vectorises) -> [[1],[2],...,[1,0],[1,1],...D(n-1)]
   \      - cumulative reduce by:
  ;       -   concatenation -> prefixes i.e.: [[1],[1,2],...,[1,2,...,1,0],[1,2,...,1,0,1,1],[1,2,...,1,0,1,1,...Flattened(D(n))]]
    L€    - length of €ach -> [1,2,3,...,11,13,...,length([1,2,...,1,0,1,1,...Flattened(D(n))])]
       ⁸  - chain's left argument, n
      <   - less than? (vectorises)
        S - sum (yields the number of prefixes that are less than or equal in length to n)
          -   Note: `0` is excluded from the range and all the prefixes, but including
          -         it would mean comparing to n+1 AND decrementing at the end (for a
          -         total cost of a byte)
|improve this answer|||||
\$\endgroup\$
4
\$\begingroup\$

Pyth, 8 7 bytes

tf<Q=+d

Try it online. Test suite.

|improve this answer|||||
\$\endgroup\$
  • \$\begingroup\$ I love it! Using slicing as a comparison is brilliant. \$\endgroup\$ – isaacg Jul 11 '17 at 20:20
  • \$\begingroup\$ @isaacg It's one of the nice golf features of Pyth(on). I got the idea when I saw Neil's answer (indexing instead of slicing, but same idea). < num seq was also very helpful. \$\endgroup\$ – PurkkaKoodari Jul 11 '17 at 20:25
3
\$\begingroup\$

Perl 6, 36 bytes

{(0...^{([~] 0..$^a).comb>$_})[*-1]}

Try it online!

  • 0 ...^ {...} is the sequence of numbers from zero until one less than the number for which the code block in braces returns true. (... without the caret would return the first number for which the block returned true.)
  • [~] 0 .. $^a is the concatenation of numbers from 0 up to the current number $^a (the parameter to the code block).
  • .comb is a list of all of the characters (digits) in the concatenated string. Interpreted as a number, it evaluates to the length of the string. .chars would be more natural to use here, since it evaluates directly to the length of the string, but the name is one character longer.
  • $_ is the argument to the top-level function.
  • [*-1] selects the last element of the generated list.
|improve this answer|||||
\$\endgroup\$
2
\$\begingroup\$

QBIC, 34 bytes

{A=!p$~_lB+A|>:|_xp-1|\B=B+A]p=p+1

Explanation

{           DO infinitely
A=!p$       Set A$ to p cast to num
            Note that p starts out as 0.
~      >:   IF the input number is exceeded by
 _l   |     the length of
   B+A      A$ and B$ combined
_xp-1|      THEN QUIT, printing the last int successfully added to B$
            The _X operator quits, (possibly) printing something if followed by a-zA-Z
            _x is slightly different, it prints the expression between the operator _x and |
\B=B+A      ELSE add A$ to B$
]           END IF
p=p+1       Raise p, and rerun
|improve this answer|||||
\$\endgroup\$
2
\$\begingroup\$

Python 2, 44 bytes

f=lambda k,i=0:-2*(k<0)or-~f(k-len(`i`),i+1)

Try it online!

|improve this answer|||||
\$\endgroup\$
2
\$\begingroup\$

J, 26 bytes

(>i:1:)([:+/\[:>.10^.1+i.)

((>i:1:)([:+/\[:>.10^.1+i.))"0 ] 5 11 12 1024 2000 20000 100000 1000000
4 9 10 377 702 5276 22221 185184
|improve this answer|||||
\$\endgroup\$
1
\$\begingroup\$

R, 43 bytes

n=scan();sum(cumsum(floor(log10(1:n))+1)<n)

Try it online!

|improve this answer|||||
\$\endgroup\$
0
\$\begingroup\$

WendyScript, 42 bytes

<<f=>(x){<<n=""#i:0->x{n+=i?n.size>=x/>i}}

f(1024) // returns 377

Try it online!

Ungolfed:

let f => (x) {
  let n = ""
  for i : 0->x { 
    n+=i
    if n.size >= x 
    ret i
  }
  ret
}
|improve this answer|||||
\$\endgroup\$
0
\$\begingroup\$

PHP, 41 bytes

while(strlen($s.=+$i++)<=$argn);echo$i-2;

Try it online.

|improve this answer|||||
\$\endgroup\$
0
\$\begingroup\$

Java 8, 64 bytes

n->{int i=0;for(String t="0";;t+=++i)if(t.length()>n)return~-i;}

Or slight alternatives with the same byte-count:

n->{int i=0;for(String t="";;t+=i++)if(t.length()>n)return i-2;}
n->{int i=-1;for(String t="";;t+=++i)if(t.length()>n)return~-i;}

Explanation:

Try it here.

n->{                  // Method with integer as both parameter and return-type
  int i=0;            //  Integer `i`, starting at 0
  for(String t="0";   //  String, starting at "0"
      ;               //  Loop indefinitely
       t+=++i)        //    After every iteration: append the String with `i+1`
                      //    by first increasing `i` by 1 with `++i`
    if(t.length()>n)  //   If the length of the String is larger than the input:
      return~-i;      //    Return `i-1`
                      //  End of loop (implicit / single-line body)
}                     // End of method
|improve this answer|||||
\$\endgroup\$
0
\$\begingroup\$

Ruby, 39 bytes

->n{~-(0..n).find{|x|0>n-="#{x}"=~/$/}}

Try it online!

|improve this answer|||||
\$\endgroup\$
0
\$\begingroup\$

Ruby, 44 bytes

Inspired by Kevin Cruijssen's JAVA answer. -4 bytes thanks to G B.

->n{i,t=0,'';t+="#{i+=1}"while t.size<n;i-1}
|improve this answer|||||
\$\endgroup\$
  • \$\begingroup\$ (i+=1;t+=i.to_s) is the same as t+="#{i+=1}", only 4 bytes longer \$\endgroup\$ – G B Nov 14 '17 at 7:11
  • \$\begingroup\$ And if you do that, you don't need the variable t anymore, you can subtract the size from n and then compare with 0. \$\endgroup\$ – G B Nov 14 '17 at 7:14
0
\$\begingroup\$

Perl 5, 31 + 1 (-p) = 32 bytes

$".=++$\while$_>=length$"}{$\--

Try it online!

|improve this answer|||||
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.