# Shifted auto-sum

Let’s take a positive integer such as 123. We define the shifted auto-sum of this integer as follows:

• 123 has 3 digits. We thus consider 3 copies of 123.

• We stack each copy on top of each other, shifted by 1 digit each time:

123
123
123

• We pad each copy with 0s (excluding the last one) to get a standard column addition:

12300
1230
123
-----
13653


### Test cases

Input                Shifted auto-sum

1                    1
12                   132
100                  11100
123                  13653
6789                 7542579
4815162342           5350180379464981962


### Scoring

This is , so the shortest answer in bytes wins.

# Japt, 3 bytes

ì£U


Try it

Found a 3 that works with numbers.

ì£U
ì      Convert to base-10 array of digits, do ... and convert back:
£     Map over the array with:
U    Return the original input


# Japt, 4 bytes

*sç1


Try it

*sç1
*       Multiply the input with
s      Transform the input as a string:
ç1    Replace each char by 1


If it is allowed to take the number as a string:

# Japt, 3 bytes

*ç1


Try it

*ç1
*      Multiply the input with (coercing both sides to number)
ç1    Replace each char by 1


# Jelly, 4 3 bytes

-1 byte thanks to Unrelated String.

ṁDḌ


Try it online!

A port of my PARI/GP answer.

 D     # To digits
ṁ      # Fill with the input
Ḍ    # From digits

• -1! Commented Jul 26, 2022 at 8:45

f n=n*read('1'<$show n)  Try it online! Multiplies n by the number obtained from replacing each of its digits with a 1. Same length pointfree: (*)<*>read.('1'<$).show


Try it online!

# R, 21 bytes

\(x)x*10^nchar(x)%/%9

Attempt This Online!

Uses an 'x multiplied by 111' approach, where the '111' is constructed as the next power-of-10 greater-or-equal to x, integer-divided by 9.

# Python 2, 25 bytes

lambda n:10**len(n)/9*n


Try it online!

# Vyxal, 8 bytes

₌ẏL+↲›⌊∑


Try it Online!

(yes I know there's a 4 byter, but I liked this approach so much I posted it separately)

Kids these days with their "ten to the power of" approaches. Hasn't anyone ever heard of literal spec interpretation? :p

Takes input as a string.

## Explained

₌ẏL+↲›⌊∑
₌ẏL      # Push the range [0, len(in)) and len(in)
↲›    # pad the input left with spaces until length for each item in that list and replace all spaces with 0s
⌊∑  # convert each item to int and sum


# JavaScript (Node.js), 27 bytes

n=>(n+'').replace(/./g,1)*n


Try it online!

It is shorter than

n=>n*(g=i=>i<n?g(i+9):i/9) // 28 bytes
n=>~~(.1**~Math.log10(n)/9)*n // 29 bytes
n=>(10**-~Math.log10(n)-1)/9*n // 30 bytes

• I suspect there might be a clever recursive solution... Commented Jul 26, 2022 at 9:09
• @emanresuA Best recursive function I can get is 33 bytes. Even worse than the Math.log10 ones. n=>(g=i=>i+n<[n]+n&&i+g(i*10))(n)
– tsh
Commented Jul 26, 2022 at 9:21
• @tsh 30 bytes recursive: n=>(g=i=>i&&n+10*g(i/10|0))(n). Commented Jul 26, 2022 at 11:03
• @alephalpha nice idea. and I got a 28 bytes recursive, still longer than the string replace.
– tsh
Commented Jul 27, 2022 at 2:26

# Bash, 19 bytes

expr ${1//?/1} *$1


An unusual example of expr being shorter than regular $[] arithmetic expansion. Try it online! # Jelly, 5 bytes D1€Ḍ×  Try it online! I suspect there's a 4-byter but I can't find one. D Ḍ # To digits... 1€ # Fill with 1 × # Multiply by original  # C (gcc), 38 36 35 bytes m;f(n){n*=m=exp10(m=log10(n)+1)/9;}  Try it online! Saved 2 3 bytes thanks to tsh!!! • f(n){n=n*(exp10(n=log10(n)+1)-1)/9;} At least works on TIO gcc. Though actually UB. – tsh Commented Jul 26, 2022 at 9:08 • @tsh Most golfed C uses UB, works with gcc v11 and v13. Nice one - thanks! :D Commented Jul 26, 2022 at 9:10 • 35 bytes: m;f(n){n*=m=exp10(m=log10(n)+1)/9;} – tsh Commented Jul 26, 2022 at 10:39 # Retina, 16 bytes .+$.($($.&*1)**


Try it online! Link includes test cases. Explanation: $($.&*1) represents the input with its characters replaced by 1s, which is then implicitly multiplied by the original input. (Retina's multiplication is decimal times unary, so the extra * is required to convert one of the decimal numbers to unary for the multiplication, and the $.( converts the result back to decimal.) • How is it possible for this to return a value greater than the amount of memory in bytes? Commented Jul 28, 2022 at 14:13 • @Deadcode Although $.( has the semantics of "length of contents", Retina 1 doesn't actually calculate the contents and then take the length. Instead, it calculates the length of each of the terms and takes the sum, using arbitrary-precision arithmetic. See github.com/m-ender/retina/wiki/…
– Neil
Commented Jul 28, 2022 at 15:17

# APL (Dyalog Unicode), 7 bytes

Anonymous tacit prefix function.

10⊥⊢⊣¨⍕


Try it online!

⍕  stringify

⊣¨ defer each digit in favour of:

⊢ the argument

10⊥ evaluate as (carrying) base-10 digits

# BQN, 15 bytes

10⊸×⊸+˜´⊢⊣¨•Fmt


Try it at BQN online!

### Explanation

10⊸×⊸+˜´⊢⊣¨•Fmt
•Fmt  Convert the argument number to a string (list of characters)
⊣¨      Replace each character with
⊢         The argument number
´          Right fold
˜           on this function with reversed arguments:
⊸+              Add the right argument to
10⊸×                The left argument times 10


### Other versions

Another 15-byte solution that constructs a list of powers of 10:

+´⊢×10⋆↕∘≠∘•Fmt


A 16-byte solution that constructs a list of 10s and multiplication-scans it:

+´÷⟜10×·10¨•Fmt


Another 16-byte solution that constructs a string of 1s and evaluates it:

⊢×·•BQN·'1'¨•Fmt


# Desmos, 29 bytes

f(k)=∑_{n=0}^{logk-.5}10^nk


Try It On Desmos!

Using the formula $$n\cdot\frac{10^{length(n)}-1}9$$ is surprisingly 1 byte longer:

f(k)=k(10^{floor(logk)+1}-1)/9

• was waiting for this lol Commented Jul 26, 2022 at 22:42

# K (ngn/k), 17 14 bytes

{x*10/(#$x)#1}  Try it online! -3 bytes thanks to ovs! Explanations: {x*10/(#$x)#1}  Main function. x is input (123)
1   The number 1              (1)
#    Duplicate by the amount of
( $x) x converted to string ("123") # Length times (3) (This creates an array of integers, which is (1, 1, 1)) 10/ Convert the integers to base 10 x* Multiply by x  • I think I$,/$ can be 10/ and there is a way to express the part to right of it without # and parentheses – ovs Commented Nov 12, 2022 at 8:43 # Python, 57 bytes lambda n:sum(n//10for i in range(len(str(n)))if(n:=n*10))  Attempt This Online! # Python, 31 bytes lambda n:int('1'*len(str(n)))*n  Attempt This Online! # Python, 29 bytes Port of @xnor's answer. lambda n:10**len(str(n))//9*n  Attempt This Online! # 05AB1E, 5 4 bytes $g×*


-1 byte porting emanresuA's Jelly answer

Alternative 4-byter (port of @Bubbler's Japt answer:

gиTβ


Explanation:

$# Push 1 and the input g # Pop the input, and push its length × # Repeat 1 that many times * # Multiply it to the (implicit) input-integer # (after which the result is output implicitly) g # Push the length of the (implicit) input-integer и # Repeat the (implicit) input-list that many times Tβ # Convert it from a base-10 list to a base-10 integer # (after which the result is output implicitly)  • alternative 4 bytes: SdJ* (or ādJ*, and some more equivalences) Commented Jul 26, 2022 at 19:33 • @CommandMaster Yeah, I came across SdJ* as well when I was trying to find a 3-byter. There are indeed a lot of 3-byters to create "1"*len(input()) in Python-pseudo-code, like ηĀJ or €dJ or S1: or €gJ. Another 4-byter based on the second answer for just the legacy version of 05AB1E is €ITβ. But yeah, no 3 byter found thus far.. Commented Jul 26, 2022 at 20:58 # Nibbles, 4 bytes (8 nibbles) @~.p$@


    p$# convert input to string . # map function over each element (characters in string): @ # second argument (arg1=element, arg2=input) # so now we have digits-of-input copies of the input @ # interpret as digits in base ~ # 10  # Burlesque, 8 bytes Jq./]m|*  Try it online! Takes input as a string (as from standard in) containing number. J # Duplicate input q./ # Quoted isNumeric (returns 1 for each digit) ]m # Map and concat to string |* # String multiply  # Charcoal, 8 bytes Ｉ×ＮＩ×1Ｌθ  Try it online! Link is to verbose version of code. Works with both integer and string input. Explanation:  1 Literal string 1 × Repeated by θ First input Ｌ Digit length Ｉ Cast to integer × Multiplied by Ｎ Input as an integer Ｉ Cast to string Implicitly print  7 bytes but only accepts numeric input in JSON format: Ｉ↨χＥＩθθ  Try it online! Link is to verbose version of code. Explanation: Port of @alephalpha's Jelly answer.  θ Input Ｉ Cast to string Ｅ Map over characters θ Input ↨χ Convert from "base 10" Ｉ Cast to string Implicitly print  # Pip, 7 bytes a*:1X#a  Try it online! ### Explanation a*:1X#a #a Length (number of digits) of cmdline argument 1X String of that many 1s *: (Treat as a number and) Multiply by a Cmdline argument  # dc, 10 ?dZAr^9/*p  Try it online! ### Explanation ? # Read input d # duplicate input on stack Z # push count digits of input to stack Ar # push 10, reverse top 2 stack elements ^ # calculate power of 10 9/ # divide by 9 to get 111....1 * # multiply by original input p # print  # Brachylog, 5 bytes lᵐ×↙?  Try it online!  ᵐ For each digit of the input, l get its length (i.e. 1), ᵐ and concatenate the lengths back into an integer. ×↙? Multiply by the input.  # Vyxalr, 4 bytes Lẋ₀β  Try it Online! Another approach. ## Vyxals, 3 bytes ẏ↵*  Try it Online! To get even with these 3 byters, lol. # Perl 5-Minteger -pF , 12 bytes $_*=10**@F/9


Try it online!

$_*=s/./1/gr  Multiplies itself with 1, 11, 111, etc, depending on the length of the input. Try it online! • Cool to see you posting answers again! Your perl is-prime regex post in 1997 kind of started the whole unary regex math thing. Which I've expanded on by a lot. I linked to it here. Commented Jul 28, 2022 at 17:23 # Wolfram Language (Mathematica), 27 26 bytes #(10^IntegerLength@#-1)/9&  Try it online! # Regex 🐇 (PCRE2 v10.35+), 36 bytes ^(?*(\1{10}|^x{9})*x(x*$))(?*\2x+)x+


Attempt This Online!
Attempt This Online! - just the test cases (that are small enough to complete in reasonable time)

Takes its input in unary, as the length of a string of xs. Returns its output as the number of ways the regex can match. (The rabbit emoji indicates this output method. It can yield outputs bigger than the input, and is really good at multiplying.)

^                     # Anchor to start; tail = N = input number
(?*                   # Non-atomic lookahead - try all possibilities to find ones
# resulting in a later match. This is used to multiply the
# number of possible matches outside by the number of
# possible matches inside.
(\1{10}|^x{9})*x  # tail -= {any power of 10}
(x*$) # \2 = tail = N - {the power of 10} ) (?* # Another non-atomic lookahead \2 # tail = {the power of 10 chosen above} x+ # Multiply the number of possible matches by tail. This # applies for each power of 10 found, and those numbers of # matches will add together. ) x+ # Add tail possible matches, where tail==N, with the above # multiplier being applied.  # Regex 🐇 (Perl / PCRE), 108 76 bytes ^(x?)(?=(x*)\2$).*(?=\2((x+)\4{8}(?=\4$))*x{5}$)()?x+.*(?=\2$)(()?x+|\1+$)|x


Try it online! - Perl v5.28.2 / Attempt This Online! - Perl v5.36+
Try it online! - PCRE1
Try it online! - PCRE2 v10.33 / Attempt This Online! - PCRE2 v10.40+
Try it online! - PCRE2 - just the test cases

Without (?*...) molecular lookahead, it's much harder to do multiplication. So we reserve half of the number to use as a counter for one operand of the multiplication, letting $$\a=\lfloor n/2\rfloor\$$ and $$\b=n\bmod 2\$$, such that $$\2a+b=n\$$, in order to emulate operations on $$\n\$$.

We don't actually need to construct the number of the form 111...111 to multiply by. We can pretty much directly sum $$\n\$$ multiplied by each power of $$\10\$$, that is to say,

$$\large\left({\sum_{k=1}^{\lfloor log_{10}n\rfloor}2{{10^k}\over 2}(2a+b)}\right)+n = \sum_{k=0}^{\lfloor log_{10}n\rfloor}10^k n$$

using emulated arithmetic on $$\2a+b=n\$$.

    ^                         # Anchor to start; tail = N = input number
(x?)                      # \1 = N % 2; tail -= \1
(?=(x*)\2$) # \2 = floor(N / 2) .* # Find any value of tail ≤ N satisfying the # following: (?= # Assert that 2*(tail-\2) is a power of 10 \2 # tail -= \2 ( (x+)\4{8}(?=\4$)  # Assert tail is divisible by 10; tail /= 10
)*                    # Iterate the above as many times as possible,
# minimum zero.
x{5}$# Assert tail == 5 ) ()? # possibleMatches *= 2, for the following: x+ # possibleMatches *= tail - \2, for the following: .*(?=\2$)                 # tail = \2
(
()?                   # possibleMatches *= 2, for the following:
x+                    # possibleMatches += tail
|
\1+$# possibleMatches += \1 ) | # Unanchored x # possibleMatches += N  # Regex (.NET), 129 117 bytes ^(?=(x)*)(x?)(?=(x*)\3$)(((?=\3((x+)\7{8}(?=\7$))*x{5}$)(?=((?=.*(?=\3)(?<1>x)*){4}(?=.*(?=\2)(?<1>x)?){2}x)*\3))?x)*

Try it online!
Try it online! - just the test cases

Returns its output as the capture count of \1.

This is now a fairly straight port of the Perl/PCRE 🐇 version.

The former 129 byte version actually constructed the number whose digits are all 1 to multiply by – indirectly – by constructing the number $$\c\$$ whose every digit is a 1 and has one less digit than the input, such that $$\10c+1\$$ is the actually desired number, then returning $$\(10c)(2a+b)+n\$$ $$\=(10c+1)n\$$ as a capture count. That version couldn't return a result for an input of $$\0\$$, but this version can.

^                               # Anchor to start; tail = N = input number
(?=(x)*)                        # \1.captureCount = tail = N
(x?)                            # \2 = N % 2; tail = tail-\2 == \3 * 2
(?=(x*)\3$) # \3 = floor(N / 2) ( ( (?= # Lookahead conditional # Assert that 2*(tail-\3) is a power of 10 \3 # tail -= \3 ( (x+)\7{8}(?=\7$)    # Assert tail is divisible by 10; tail /= 10
)*                      # Iterate the above as many times as possible,
# minimum zero.
x{5}$# Assert tail == 5 ) # If the above assertion matches, do the following: (?= ( (?= .*(?=\3) # tail = \3 (?<1>x)* # \1.captureCount += tail ){4} # Iterate the above 4 times (?= .*(?=\2) # tail = \2 (?<1>x)? # \1.captureCount += tail ){2} # Iterate the above 2 times x )* # Iterate the above as many times as possible, # which will be a number of iterations equal to # exactly half the current power of 10. \3 # Assert tail >= \3 ) )? x )* # Iterate the above as many times as possible, # applying the payload to each power of 10  I think I may have discovered a bug in the .NET regex engine, or at least the version on TIO, while working on this. The following variant of the same length should have worked, but didn't: ^(?=(x)*)(x?)(?=(x*)\3$)((?(?=\3((x+)\6{8}(?=\6$))*x{5}$)(?=((?=.*(?=\3)(?<1>x)*){4}(?=.*(?=\2)(?<1>x)?){2}x)*\3))x)*

# PHP, 29 bytes

fn($n)=>$n*~-10**strlen(\$n)/9


Try it online!

• This is a code-golf challenge i.e. your code needs to be as short as possible. You can start with removing whitespace and move on to better tricks like the ones in the site's PHP thread.. Happy golfing! Commented Jul 30, 2022 at 17:10
• Here's a start, at 84 bytes: Try it online! Commented Jul 30, 2022 at 18:29
• Using a formula, though, this can be 29 bytes: Try it online! Commented Jul 30, 2022 at 18:35
• @Steffan thank you so much for correction :) Commented Jul 30, 2022 at 19:07
• @Steffan how did you convert this into just 29 bytes? i mean can you please guide me so that I can answer more questions? Commented Jul 30, 2022 at 19:18

# Knight, 12 bytes

O*/^10L=xP9x


Try it online!

Ungolfed:

OUTPUT (* (/ (^ 10 (LENGTH (= x PROMPT))) 9) x)