27
\$\begingroup\$

Given a positive number n, rotate its base-10 digits m positions rightward. That is, output the result of m steps of moving the last digit to the start. The rotation count m will be a non-negative integer.

You should remove leading zeroes in the final result, but not in any of the intermediate steps. For example, for the test case 100,2 => 1, we first rotate to 010, then to 001, then finally drop the leading zeroes to get 1.

Tests

n,m => Output

123,1 => 312
123,2 => 231
123,3 => 123
123,4 => 312
1,637 => 1
10,1 => 1
100,2 => 1
10,2 => 10 
110,2 => 101
123,0 => 123
9998,2 => 9899
\$\endgroup\$
  • \$\begingroup\$ I've edited the post (i.e. added some formatting/CGCC terms) to help make it even more understandable. Nice first challenge! \$\endgroup\$ – Lyxal Aug 15 at 4:25
  • 13
    \$\begingroup\$ The test cases suggest this loops around for big n, which isn't clear from the text. \$\endgroup\$ – xnor Aug 15 at 4:50
  • 1
    \$\begingroup\$ You should indicate in the text that the rotation is to the right \$\endgroup\$ – Luis Mendo Aug 15 at 12:49
  • 1
    \$\begingroup\$ @Shaggy Hm I guess "moving the last digit to the start" is clear enough \$\endgroup\$ – Luis Mendo Aug 15 at 16:25
  • 1
    \$\begingroup\$ From the test cases, it seems the input number can be base 4 or any higher base, to handle digits up to 3? Power-of-2 bases are much more efficient and convenient to work with in binary computers, e.g. hardware rotate instructions, and bit-shifts. e.g. x86 add ecx,ecx / ror eax, cl rotates by n 2-bit digits, in 4 bytes of machine code. Nothing in the question actually says you have to rotate base-10 digits, which would be inconvenient if you get input as an int or something. But I suspect you meant that? \$\endgroup\$ – Peter Cordes Aug 16 at 8:08

36 Answers 36

13
\$\begingroup\$

Japt -N, 2 bytes

Takes m as a string and V=n as an integer or string, outputs an integer. Prepend s or ì for +1 byte if we have to take both as integers.

éV

Try it

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Gorgeous!...... \$\endgroup\$ – Lonely Aug 30 at 21:52
  • \$\begingroup\$ @Lonely, I think the word you're looking for is "trivial"! \$\endgroup\$ – Shaggy Sep 1 at 21:51
9
\$\begingroup\$

R, 51 bytes

function(n,m,p=10^nchar(n))sum(n*p^(0:m))%/%10^m%%p

Try it online!

Numeric solution (that fails for combinations of n & m that cause it to exceed R's numeric range): chains the digits of n, m times (so: 123 => 123123123123 for m=4) and then calculates DIV 10^m (so: 12312312 for m=4) MOD 10^digits(n) (so: 312).


R, 61 53 bytes

Edit: -8 bytes thanks to Giuseppe

function(n,m,N=nchar(n),M=10^(m%%N))n%%M*10^N/M+n%/%M

Try it online!

Text-based function that Rotates by combining the two parts of the number together, so does not go out of numeric range: puts the last (m MOD digits(n)) digits of n first, followed by the other digits of n.

| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ 53 bytes for the second one, no need for text functions to stay in R's range (for the given test cases, anyway) \$\endgroup\$ – Giuseppe Aug 17 at 15:13
  • \$\begingroup\$ Thanks Giuseppe, that's very nice. \$\endgroup\$ – Dominic van Essen Aug 17 at 16:22
5
\$\begingroup\$

Python 3, 61 57 bytes

i=input
n=i()
k=int(i())%len(n)
print(int(n[-k:]+n[:-k]))

Try it online!

Uses string slicing to move the last k digits at the beginning and converts it to an integer to remove the leading zeroes.

-4 bytes thanks to Lyxal

| improve this answer | |
\$\endgroup\$
  • 3
    \$\begingroup\$ 57 bytes \$\endgroup\$ – Lyxal Aug 15 at 6:52
5
\$\begingroup\$

05AB1E, 4 bytes

(._ï

Try it online!

Explanation

(._ï
(     : get negative of m
 ._   : rotate n left negative m times
   ï  : remove leading zeros
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ I may be misremembering but doesn't 05AB1E also have a rotate right built-in, to save you a byte on the negation? \$\endgroup\$ – Shaggy Aug 15 at 13:27
  • \$\begingroup\$ @Shaggy, Pretty new to 05AB1E. I could not find a built-in to rotate right m units in the wiki, though there was a built-in to rotate right 1 unit (Á). \$\endgroup\$ – Mukundan314 Aug 15 at 13:37
  • \$\begingroup\$ That might've been what I was thinking of. Would a loop using that be shorter? \$\endgroup\$ – Shaggy Aug 15 at 17:05
  • 2
    \$\begingroup\$ @Shaggy this would be the same length: EÁ}ï. At least that is the best I can come up with. It would be shorter if we didn't need to remove leading zeroes (just ). \$\endgroup\$ – ovs Aug 15 at 18:52
4
\$\begingroup\$

MATL, 3 bytes

YSU

Try it online!

Takes n as a string and m as an integer.

Explanation

YS   % Shift first input second input number of times
  U  % Convert to integer to remove leading 0s

MATL, 5 bytes

ViYSU

Try it online!

This answer takes both the inputs as integers.

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

Charcoal, 9 bytes

II⭆θ§θ⁻κη

Try it online! Link is to verbose version of code. Explanation:

   θ        Input `n` as a string
  ⭆         Map over characters and join
       κ    Current index
      ⁻     Subtract
        η   Input `m`
    §       Cyclically indexed into
     θ      Input `n` as a string
 I          Cast to integer
I           Cast to string
            Implicitly print

Conveniently if you try to Subtract an integer and a string then the string gets cast to integer.

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

Perl 5 + -pl, 26 bytes

eval'$_=chop.$_;'x<>;$_|=0

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ @Dingus Is the should a must? I'll check. Thanks! \$\endgroup\$ – Dom Hastings Aug 15 at 14:08
4
\$\begingroup\$

APL+WIN, 8 7 bytes

Prompts for n as integer and m as string:

⍎(-⎕)⌽⎕

Try it online! Courtesy of Dyalog Classic

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

JavaScript (ES6), 36 bytes

Expects (m)(n), where n is a string and m is either a string or an integer.

m=>g=n=>m--?g(n%10+n.slice(0,-1)):+n

Try it online!

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

C (gcc)-lm, 65 \$\cdots\$ 56 55 bytes

Saved a byte thanks to ceilingcat!!!

e;f(n,m){for(e=log10(n);m--;)n=n%10*exp10(e)+n/10;m=n;}

Try it online!

Inputs integers \$n\$ and \$m\$.
Base-10 digitally rotates \$n\$ right \$m\$-times and returns it.

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

Pyth, 4 bytes

v.>z

Try it online!

Explanation

v.>zQ
    Q  : first line of input evaluated 
   z   : second line of input as string
 .>    : cyclically rotate second line right by number in first line
v      : evaluate to remove leading 0s
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Always happy to see people using Pyth. \$\endgroup\$ – isaacg Aug 16 at 5:19
3
\$\begingroup\$

Keg, -hr, 11 bytes

÷(¿|")⑷⅍⑸⅀ℤ

Try it online!

Explained

÷(¿|")⑷⅍⑸⅀ℤ
÷               # Split m into individual numbers
 (¿|")          # n times, shift the stack right
      ⑷⅍⑸      # turn each character into a string
           ⅀ℤ   # sum stack and convert to integer. `-hr` prints it as integer
| improve this answer | |
\$\endgroup\$
3
\$\begingroup\$

Python 3, 47 bytes

f=lambda n,m:m and f(n[-1]+n[:-1],m-1)or int(n)

Try it online!

Inputs \$n\$ as a string and \$m\$ as an integer.
Returns rotated \$n\$ as an integer.

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

Java (JDK), 66 bytes

(n,x)->new Long((""+n+n).substring(x=(n=(""+n).length())-x%n,x+n))

Try it online!

| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ n=110 m=2 seems to output 11 instead of 101... \$\endgroup\$ – Dominic van Essen Aug 15 at 16:54
  • 1
    \$\begingroup\$ Why is all the function support code (like import java.util.function.*; and even the trailing semicolon) not included in the bytes count? \$\endgroup\$ – Noodle9 Aug 15 at 20:53
  • 2
    \$\begingroup\$ @Noodle9 The trailing semicolon isn't counted because it's a lambda. One way of writing it is to have Lambda lambda = (x, y) -> x+y;, and yes you have a semicolon. Another way of using a lambda is this: f.acceptLambda((x, y) -> x+y);. Do you see a semicolon after the lambda ? No, but the lambda is still the same! This is possible because the semicolon isn't part of the lambda, but part of the storage of the lambda in a variable. Regarding the imports, I invite you to read the relevant meta post. \$\endgroup\$ – Olivier Grégoire Aug 15 at 21:12
  • \$\begingroup\$ @DominicvanEssen Good catch, I fixed it at a cost of 7 bytes. \$\endgroup\$ – Olivier Grégoire Aug 15 at 21:23
3
\$\begingroup\$

Python 3, 39 bytes

lambda n,m:int(((n*m)[-m:]+n)[:len(n)])

Try it online! Or see the test-suite.

How?

Rotating n right by m is the same as rotating n right by m modulo length n (m%len(n)), which is the concatenation of the last m%len(n) digits with the first len(n)-m%len(n) digits.

A simple slice would give us

lambda n,m:int(n[-m%len(n):]+n[:-m%len(n)])

for 43 bytes. To remove the need for the repeated -m% we can instead concatenate the last m%len(n) digits with all the digits of n and then take the first len(n) digits. This is

lambda n,m:int((n[-m%len(n):]+n)[:len(n)])

for 42 bytes. The n[-m%len(n):] can then be replaced with taking the rightmost m digits of m ns concatenated together, (n*m)[-m:] giving us the 39 byte solution.

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

J, 11 bytes

(".@|.":)~-

Try it online!

How it works

Uses @Bubbler's tacit trick for (F x) G (H y) = (G~F)~H.

(".@|.":)~-
          - negate y to shift right
(       )~  flip arguments, so ((-y) ".@|. (":x))
      ":    convert x to string
    |.      shift that by negated y
 ".@        and convert back to number
| improve this answer | |
\$\endgroup\$
2
\$\begingroup\$

Io, 89 bytes

Uses a reduce trick to assign different lines of STDIN to variables.

File standardInput readLines reduce(a,b,a splitAt(-b asNumber)reverse join)asNumber print

Try it online!

Io, 56 bytes

method(a,b,doString(a splitAt(-b asNumber)reverse join))

Try it online!

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

Python 3.8 (pre-release), 42 40 bytes

lambda x,r:int(x[(a:=-r%len(x)):]+x[:a])

Try it online!

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

Jelly, (4?) 5 bytes

4 if we may accept a list of digits (remove the leading D).

DṙN}Ḍ

Try it online!

How?

DṙN}Ḍ - Link: integer, n; integer, m
D     - convert to base ten
   }  - use m as the input of:
  N   -   negate
 ṙ    - rotate (n) left by (-m)
    Ḍ - convert from base ten
| improve this answer | |
\$\endgroup\$
  • 3
    \$\begingroup\$ Is it standard now to allow a list of digits as input when the challenge asks for an integer? All I could find was this sort-of-related proposed I/O default, but it doesn't have the votes to be considered accepted yet. \$\endgroup\$ – DLosc Aug 16 at 0:51
  • \$\begingroup\$ Hmm, I just saw strings being used in answers and assumed that meant list input must be fine. I could take an integer and prefix with D. \$\endgroup\$ – Jonathan Allan Aug 16 at 2:22
  • \$\begingroup\$ Are strings allowed in place of integers by default? \$\endgroup\$ – Jonathan Allan Aug 16 at 2:33
  • 1
    \$\begingroup\$ ... It depends? That's what the linked meta answer proposes, and it hasn't been accepted yet. But then, if you have a full program that gets input from stdin, it's going to be reading a string in most languages. I don't see how to get around that. "Must convert the input string to integer" won't work: some languages (coughlike minecough) don't even have different types for strings and numbers. I noticed the string inputs in other answers too, and didn't like them, but wasn't sure what to say; and then yours stuck out a bit more, so I commented on it. Thanks for the edit. :) \$\endgroup\$ – DLosc Aug 16 at 5:00
  • \$\begingroup\$ @DLosc: The OP's notion of a "number" is apparently a sequence of digits, not a binary integer, because they didn't even specify anything about what base it should be in. But it can't be base 2 (the natural base for computer integers) because they have digit values from 0 to 3. So at least base 4? With all this stuff about removing leading zeros in the result, it barely even makes sense for the result to be a fixed-width binary integer like C int either. If this is the kind of thing you want to do with numbers in your program, keeping them as strings or lists makes the most sense. \$\endgroup\$ – Peter Cordes Aug 16 at 8:22
2
\$\begingroup\$

CJam, 10 7 6 bytes

Saved 3 bytes by remembering that you can preform most array operations on strings.

-1 byte from @my pronoun is monicareinstate noting that m> takes arguments in either order.

rr~m>~

Try it online

Explanation:

rr       Read two string inputs
  ~      Parse m to number
   m>    Rotate n string right m times
     ~   Parse n to number to remove leading zeros
         (implicit) output

Old version, 7 bytes:

q~\sm>~

Try it online

Explanation:

q~        Take input as a string, evaluate to two numbers
  \       Swap order
   s      Convert n to string
    m>    Rotate n string right m times
      ~   Parse n to number to remove leading zeros
          (implicit) output
| improve this answer | |
\$\endgroup\$
  • 1
    \$\begingroup\$ 6 bytes? \$\endgroup\$ – the default. Aug 16 at 4:44
  • \$\begingroup\$ Huh, for some reason I never knew you could take the arguments for m> (and probably many other functions) in either order. \$\endgroup\$ – Ethan Chapman Aug 16 at 17:23
2
\$\begingroup\$

Taxi, 1698 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Addition Alley.1 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 1 l 2 l. Pickup a passenger going to Addition Alley.Go to Addition Alley:w 1 r 3 r 1 r 1 r.Pickup a passenger going to The Underground.Go to Chop Suey:n 1 r 2 r.[1]Switch to plan "2" if no one is waiting.Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 1 l 1 r 1 l.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan "1".[2]Go to Narrow Path Park:n 1 l 1 r 1 l.Switch to plan "3" if no one is waiting.Pickup a passenger going to Chop Suey.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan "2".[3]Go to Chop Suey:e 1 r 1 l 1 r.[a]Go to The Underground:s 1 r 1 l.Switch to plan "b" if no one is waiting.Pickup a passenger going to The Underground.Go to Fueler Up:s.Go to Chop Suey:n 3 r 1 l.Pickup a passenger going to Chop Suey.Switch to plan "a".[b]Go to Chop Suey:n 2 r 1 l.[4]Switch to plan "5" if no one is waiting.Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 1 l 1 r 1 l.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan "4".[5]Go to Narrow Path Park:n 1 l 1 r 1 l.[c]Switch to plan "d" if no one is waiting.Pickup a passenger going to KonKat's.Go to KonKat's:e 1 r.Pickup a passenger going to KonKat's.Go to Narrow Path Park:n 2 l.Switch to plan "c".[d]Go to KonKat's:e 1 r.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s.Pickup a passenger going to The Babelfishery.Go to KonKat's:n.Go to The Babelfishery:s.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

Try it online!

I chose to get fired rather than sacrifice the bytes required to return to the garage at the end. I have checked both very long inputs and very long rotations and the net gain is positive so you never run out of gas.


Formatted for legibility and with comments:

[ Pick up the inputs, add 1 to the second, and chop the first into pieces. ]
Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to Chop Suey.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s 1 l 1 r.
Pickup a passenger going to Addition Alley.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 1 l 2 l. 
Pickup a passenger going to Addition Alley.
Go to Addition Alley:w 1 r 3 r 1 r 1 r.
Pickup a passenger going to The Underground.
Go to Chop Suey:n 1 r 2 r.

[ Reverse the order the charaters are stored in so we can right-shift instead of left-shift. ]
[1]
Switch to plan "2" if no one is waiting.
Pickup a passenger going to Narrow Path Park.
Go to Narrow Path Park:n 1 l 1 r 1 l.
Go to Chop Suey:e 1 r 1 l 1 r.
Switch to plan "1".
[2]
Go to Narrow Path Park:n 1 l 1 r 1 l.
Switch to plan "3" if no one is waiting.
Pickup a passenger going to Chop Suey.
Go to Chop Suey:e 1 r 1 l 1 r.
Switch to plan "2".
[3]
Go to Chop Suey:e 1 r 1 l 1 r.

[ Loop the required times, rotating the passengers at Chop Suey each time. ]
[a]
Go to The Underground:s 1 r 1 l.
Switch to plan "b" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Fueler Up:s.
Go to Chop Suey:n 3 r 1 l.
Pickup a passenger going to Chop Suey.
Switch to plan "a".
[b]
Go to Chop Suey:n 2 r 1 l.

[ Reverse the character order again. ]
[4]
Switch to plan "5" if no one is waiting.
Pickup a passenger going to Narrow Path Park.
Go to Narrow Path Park:n 1 l 1 r 1 l.
Go to Chop Suey:e 1 r 1 l 1 r.
Switch to plan "4".
[5]
Go to Narrow Path Park:n 1 l 1 r 1 l.

[ Concatenate the passengers at Narrow Path Park. ]
[c]
Switch to plan "d" if no one is waiting.
Pickup a passenger going to KonKat's.
Go to KonKat's:e 1 r.
Pickup a passenger going to KonKat's.
Go to Narrow Path Park:n 2 l.
Switch to plan "c".

[ Convert to a number to remove leading zeros and then back to a string so the Post Office can handle it. ]
[d]
Go to KonKat's:e 1 r.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s.
Pickup a passenger going to The Babelfishery.
Go to KonKat's:n.
Go to The Babelfishery:s.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 l 1 r.

Try it online!

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

APL (Dyalog Extended), 4 bytes (SBCS)

Anonymous tacit infix function. Takes string n as right argument and number m as left argument.

⍎-⍛⌽

Try it online!

 execute the result of

-⍛ negating the left argument, then using that to

 cyclically rotate the right argument

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

Wolfram Language (Mathematica), 43 bytes

FromDigits@RotateRight[IntegerDigits@#,#2]&

Try it online!

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

Ruby, 44 40 bytes

->a,b{a.to_s.chars.rotate(-b).join.to_i}

-4 from Dingus.

Try it online!

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

Retina 0.8.2, 29 bytes

,.+
$*_
+`(.*)(\d)_
$2$1
^0+

Try it online! Link includes test cases. Takes input as n,m. Explanation:

,.+
$*_

Convert m to unary.

+`(.*)(\d)_
$2$1

Rotate n m times. This is O(m³) because of the way the regex backtracks trying to find a second match. Right-to-left matching, anchoring the match at the start, or rewriting the code to take input as m,n would reduce the time complexity (at a cost of a byte of course).

^0+

Delete leading zeros.

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

Scala, 61 bytes

(n,m)=>{val s=n+""size;val(a,b)=n+""splitAt s-m%s;b++a toInt}

Try it in Scastie

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

Ruby -nl, 34 bytes

->m{($_*-~m*2)[~~/$/*m,~/$/].to_i}

Try it online!

Takes \$n\$ from STDIN and \$m\$ as an argument. Concatenates \$n\$ \$2(m+1)\$ times, then from this string takes the substring of length \$d\$ (where \$d\$ is the number of digits in \$n\$) that begins \$m(d+1)\$ characters from the end. In the code, $_ is \$n\$ and ~/$/ gives \$d\$.

Example

For \$n=123\$, \$m=2\$:

  1. Concatenate \$n\$ \$2(m+1)=6\$ times: 123123123123123123
  2. Count back from the end \$m(d+1)=8\$ characters: 123123123123123123
  3. Take substring of length \$d=3\$: 123123123123123123
| improve this answer | |
\$\endgroup\$
1
\$\begingroup\$

PHP, 45 43 bytes

Saved 2 bytes, realized we can shorten the variable names.

<?=(int)(substr($s,-$n).substr($s,0,-$n))?>

Try it online

Explanation:

<?= ?>       Shorthand for <?php echo ;?>
  (int)      Typecast string to int, removes 0s from prefix
   substr()  substr(string,start,[length]), returns part of string, 
             if range go out of bounds, starts again from the opposite end.
             Basically returns part of from a 'circular' string.    
  
| improve this answer | |
\$\endgroup\$
  • \$\begingroup\$ Welcome to the site. I'm not sure that your code works. For inputs of 100 and 2, the output should be 1; your code outputs 10. \$\endgroup\$ – Dingus Aug 16 at 9:43
  • \$\begingroup\$ Thank you! Fixed it. @Dingus \$\endgroup\$ – Hackinet Aug 16 at 15:13
  • 2
    \$\begingroup\$ Nice work. I don't know PHP but it looks the input is hard-coded in the variables $s and $n? If so, that's not allowed. \$\endgroup\$ – Dingus Aug 17 at 0:02
  • 1
    \$\begingroup\$ It's also supposed to loop rotating when $n is greater than the length of $s, which your code doesn't (fails for test case 123,4 => 312) \$\endgroup\$ – Kaddath Aug 17 at 13:24
1
\$\begingroup\$

JavaScript (V8), 47 bytes

(n,m,k=(e=n+'').length)=>+(e+e).substr(k-m%k,k)

Try it online!

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

V (vim), 11 bytes

Àñ$x0Pñó^0«

Try it online!

Àñ    ñ       # (M-@)rg number of times
  $           # end of line
   x          # delete character (cut)
    0         # beginning of line
     P        # paste character
       ó      # (M-s)ubsitute 
        ^0«   # ^0\+
              # (implicitly) with nothing
| 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.