[Question]
  [
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
```
  
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-N`](https://codegolf.meta.stackexchange.com/a/14339/), 2 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
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](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LU4&code=6VY&input=IjEyMCIKMQ)
[Answer]
# [R](https://www.r-project.org/), 51 bytes
```
function(n,m,p=10^nchar(n))sum(n*p^(0:m))%/%10^m%%p
```
[Try it online!](https://tio.run/##Xc5RCoMwDAbg950iMArtKCxtx4SBl9gBBCfV@dBUant@p1O021v4kp/8YQo@1tGWU5uoib0nTtLJoVRYUfOuAychxuQ4XYaK48MJwa5sXjrGhi3LlTZSCTiDUfqUmV5MG5WbWWwecrv9Z@XdFN87eKUInbcj@HnwLTyBkrOhbyDU1Nk9gWuB4xXi@j6TDRB2OuynI24dpw8 "R – 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](https://www.r-project.org/), ~~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!](https://tio.run/##Xc7NCsIwDAfwu09RkECrgTWt6KmP0D6CMIaih2VQ6vPXzY4ZvSU//vnINU@lL7dQ7y8eynNizThiCjw8@qzZYAxkr3oESMYwQDzMberikaGDuE5rch7JqL3y5HbC3GLOkzS/2FxIO/3P4tlfPrlNbDsgwLb1MtLAqo2@9vODXX@obw "R – 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.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~61~~ 57 bytes
```
i=input
n=i()
k=int(i())%len(n)
print(int(n[-k:]+n[:-k]))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9M2M6@gtIQrzzZTQ5MrG8gr0QCyNFVzUvM08jS5CorAIkCcF62bbRWrnRdtpZsdq6n5/7@hgQGXEQA "Python 3 – 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*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 4 bytes
```
(._ï
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fQy/@8Pr//424DA0MDAE "05AB1E – Try It Online")
## Explanation
```
(._ï
(     : get negative of m
 ._   : rotate n left negative m times
   ï  : remove leading zeros
```
[Answer]
# [Perl 5](https://www.perl.org/) + `-pl`, 26 bytes
```
eval'$_=chop.$_;'x<>;$_|=0
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHXSXeNjkjv0BPJd5avcLGzlolvsbW4P9/QyNjLkMuEGkEJoE8AwMQG0ga/8svKMnMzyv@r1uQAwA "Perl 5 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 39 bytes
```
lambda n,m:int(((n*m)[-m:]+n)[:len(n)])
```
**[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSFPJ9cqM69EQ0MjTytXM1o31ypWO08z2ionNU8jTzNW839BEUg6TUPdwtzM1MTY0sDQSF1HwdBYU/M/AA "Python 3 – Try It Online")** Or see the [test-suite](https://tio.run/##VY/RaoUwDIbvfYrgjc2WgbVjG4JP4rzotGWCraX2HLYVn921yi5GEvIn@QKJ@w6fqxVvzh@6ez8WaT4mCZZMO9vAGLMPBvsn0w6PFvt2UZZZHPDQq08QGAL15dQY1ASzhZ/ZMcYbQf@CeJ28PlOORiAxTg0JeqYX8UpZZ6tTX/CkBD83s@aX5e2zidgWMK6Tgg50qVn0ynm2BZ/uwp2i2bEsQI7hJpeEqLtcWMaxAOfzS7qMud7TMF7YDi3EvtJyXiqqnNy2auj/3uq6Cxr2Eo9f "Python 3 – Try It Online").
### 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` `n`s concatenated together, `(n*m)[-m:]` giving us the 39 byte solution.
[Answer]
# [Taxi], ~~1698~~ 1678 bytes
No need to wrap single-byte plan names in quote marks. 0.6% byte reduction!
```
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!](https://tio.run/##zVU9b4MwEN37K27rZglIFra0UjtESiOlmSwGBwxYcW1kjGh@PTWfSR2Uxpk6AOLse@/d3QNr8s2a5l2ClrCVpYaPNGUxDWvwgJtLtU@0ZfGxKoBAQcqSiowqyCQTWZv1mssCdhU93dz1mVN4IQfKU1bmVJ1QT2mHw3LkvYm2ShKmmRSw4twQe8BKqIkJmWWiYaeJinPGE9hUX1RJLrORcG4pFANpf/mmYHBg74F/B7v@KQi6/qk/62nbsBcJVZmSlUgGyKmznUBlhCmEvWhXMx3n7YaCE2GiLAUhQQp60YabdBuilKxhS3Rubuo48NnhqS@9CWxRdFzpyrNUeQj70V2wVmLgXs7ZgU4SfYSD6HYGJtHZpxcD6mw6K//gLn9@@G8V5WbXvgjLGTsETh@mpZEgfIiuMf0BEy9siy3/pcUWCC/vsxiO7YoS94rWUqyJfh6nMb72Gl0yZ8T610aKEU4iZ6q7f7OPoEw6xGOwF@cLuj5xppGhpvH84Mn7AQ)
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!](https://tio.run/##zVY9c9swDN31K7B1aX0nOVm8pblrh/RSX9NMPg2wCEm8yKRKUnHbP@@ClKVTZdWxNXWQLQPE18MDaIc/5eGwgbXMXqCpwZUEUtWNs@8BhYAYnA5CS5lWgoVKQFbq9mQujXV8ns/UkjKyC0ijz9rbrDVrvua5zGi1ZzcVP8Z/LyIfi0Mh1GgtqYIMFFqqwpvde9dPDf06f@w7B/@IW6pyaUsyfLqNOpavbBf6vL87IaSTWsFdVfnYMUgLe2QZ69HBk0OTlbIS8NjsyOhKF33MKd1KHeO2T8Jlw1UJtK7/lgYcDSwDjubtojwYz0qQKYxulOic9hCHJA0nx36iDXyjVzKWQmO1YbPwlpVo0LEC0DALnDYkuONgNexZiwqMLEr3wZYy91SwjlCAzqGi/Cj1pNjEafS0ly4rfQp1xXYJyByUBq1ogPb5kh7RGL2HNbqSP8xLV9NY3uN/pNy4cupULYqjzOJFtEnSC12PbJczqhqQ/rpEE050mb5lxL39oo8Ta@hHI30LndwRz7jRDgPJvbJPzXrO9/6A0Mdkg9BJTAfDNuBXmLVpULYzQPkHez81VPGx53plpwi9vHLJjBJFBnSbTvhNOr@jQQnjkfF8HEcGC5QqwHRzQvjb/5bwN1z27aWEZwTutcp4KSh@JohzkrOHIzuBQ8yA40GrB3Tv@tZ3v9v6rrOdqDOZ4G7WVcxNd16KoJrd1q9HzeO006/Euw6Fj/Kb178NVySjwrRHvlSDhXXG6217lw7uxrBBS7aoGIR2U4p0RnGXX4jz/PS5qLmeB0UvJv4j9CRbHA5xsoziPw)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 3 bytes
```
YSU
```
[Try it online!](https://tio.run/##y00syfn/PzI49P9/JUMDQyNjJS4TAA "MATL – 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](https://github.com/lmendo/MATL), 5 bytes
```
ViYSU
```
[Try it online!](https://tio.run/##y00syfn/PywzMjj0/39DA0MjYy4TAA "MATL – Try It Online")
This answer takes both the inputs as integers.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
ＩＩ⭆θ§θ⁻κη
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sRhKBJcABdJ9Ews0CnUUHEs881JSK0BM38y80mKNbB2FDE0wsP7/39DAgMvkv25ZDgA "Charcoal – 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
 Ｉ          Cast to integer
Ｉ           Cast to string
            Implicitly print
```
Conveniently if you try to Subtract an integer and a string then the string gets cast to integer.
[Answer]
# [Python 3](https://docs.python.org/3/), 47 bytes
```
f=lambda n,m:m and f(n[-1]+n[:-1],m-1)or int(n)
```
[Try it online!](https://tio.run/##VVDRasMwDHz3V@gtNlMgjssKgexH0jCyxtkKtRpsF1ZCvz2TEvowZHEncRJnzY/8cyO3rlN7HcLXOABhaAIMNMKkqStt/0Zdw4ChtOYW4UJZk1mzT/mToAVta4f/Em3Fr9pAsnZGbfKwybFGhwd8d0cULlEZ5X9nf85@FImz3HR22ybc7lEBp933RdHdi9O9Ph7OBcJOrSuMmsQk24Q40LfXV0/6tdyYRoGYTjnq/QfdpTcKxNlukWsFnsvXzNZI3OBzYGDtHOUEU7FQ454IS2CA8gOWJGSJnW/b1D8Ls/4B "Python 3 – Try It Online")
Inputs \$n\$ as a string and \$m\$ as an integer.  
Returns rotated \$n\$ as an integer.
[Answer]
# APL+WIN, ~~8~~ 7 bytes
Prompts for n as integer and m as string:
```
⍎(-⎕)⌽⎕
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/6u3T0AWKaT7q2Quk/gMF/6dxqRsaGatzGXLBWEZwljGcZQJmqXOZGZuDWQYwDQYGMA1wBoIF0mnAxQUA "APL (Dyalog Classic) – Try It Online")
[Answer]
# 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!](https://tio.run/##hY/RCsIgFIbv9xTehMpy8@goCFzPMszJYtPI6PVNgmCbq@4OfN/5z3@u3bML@j7cHsz5i4m9ipNqrXKqnRg7W@J2wEtXhXHQhvA9A0pPpYvau@BHU43ekp4gBJRgEBJTiuoaSRDF2hALQ0jIDLkw0pQZzZ8rB3mkScPwySg2eibMv/J3S/6Tz/c52k6YGXkGX/8ZXw "JavaScript (Node.js) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/)`-lm`, ~~65~~ \$\cdots\$ ~~56~~ 55 bytes
Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
e;f(n,m){for(e=log10(n);m--;)n=n%10*exp10(e)+n/10;m=n;}
```
[Try it online!](https://tio.run/##bVHbboMwDH3vV1hIlZLWqAnZRVPGXqZ9xVpNFQ0dUuNWwAMa4tfHTKBTmZbExDk@x05MFh@zrO@dzQWhl21@LoVLT@ejVoKk9XFsJaW01GrlmguDTq5po5X1KdmuL6gGvy9IyEW7AB4DULuq/qD3HaTQ6sTgzFArXipsgyWms3Oln5SYoME7fDCPOPjDVDdcvo5rancIbGiNZoLRocjg63EqYNM3ZbLPfbmCcqwRbZu3ZNs8vbLdRwi3ZxOxIki4JyCGkgUdXMM6ZSf3Gariy51zcb2M3EzA6hexsF4HtoSxRdcHEGeaWhXiOzsL@2vY/xuuODz@sznuGP9tzV/hpWRKLqKlOSDwB@KXsC2rLfHzCcEjVMjt4fScZzcl7xZd/53lp/2x6uOT/wE "C (gcc) – Try It Online")
Inputs integers \$n\$ and \$m\$.  
Base-10 digitally rotates \$n\$ right \$m\$-times and returns it.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 4 bytes
```
v.>z
```
[Try it online!](https://tio.run/##K6gsyfj/v0zPrur/f2MuQ3MjSwA "Pyth – 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
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-hr`, 11 bytes
```
÷(¿|")⑷⅍⑸⅀ℤ
```
[Try it online!](https://tio.run/##ASYA2f9rZWf//8O3KMK/fCIp4pG34oWN4pG44oWA4oSk//8xMAox/y1ocg "Keg – 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
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 66 bytes
```
(n,x)->new Long((""+n+n).substring(x=(n=(""+n).length())-x%n,x+n))
```
[Try it online!](https://tio.run/##jY8xT8MwEIX3/IpTpUo2Tay0QTCUdGBAQoKpI2Jw0yR1cM5WfC6pUH97MBGI1dPTvfvenV4nzzLrjh@T6q0ZCLowC09Ki8ZjRcqguNkmlZbOwatUCF8JgPUHrSpwJCnI2agj9GHH9jQobN/eQQ6t4zMK8Kiefi89PCPVbT2kf/pisN1BA@XEMB15tsP6E35MxhaLFa6QC@cPbr7KxpJhOftc6BpbOjHOs3EZksHi03b@tr84qnthPAkbYqSRNUJaqy9svSnSnPMobh3JbSK5IpK7jeHSu@I@hsvjauRxLf65a3KdvgE "Java (JDK) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
(".@|.":)~-
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NZT0HGr0lKw063T/a/43NDJWSFMw5ILQRlDaGEqbcBkCSTNjcy5DA4gyAwOIMigFo8GqDQA "J – Try It Online")
### How it works
Uses [@Bubbler's tacit trick](https://codegolf.stackexchange.com/a/173657/95594) 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
```
[Answer]
# [Io](http://iolanguage.org/), 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!](https://tio.run/##NcgxCoAwDADA3VdkVFBQf@AiCOIfUpshorEkqd@vLm7H8V3KzCeBOUpEjYuk7KCEcWUh@xTzTjW2oUWwdLJPXncB0LZ8BdJG6SE1guNmaf6FpCxeytD31fgC "Io – Try It Online")
# [Io](http://iolanguage.org/), 56 bytes
```
method(a,b,doString(a splitAt(-b asNumber)reverse join))
```
[Try it online!](https://tio.run/##y8z/n6ZgZasQ8z83tSQjP0UjUSdJJyU/uKQoMy9dI1GhuCAns8SxREM3SSGx2K80Nym1SLMotSy1qDhVISs/M09T83@ahpKhgYGSjpGmQgFQV0lO3n8A "Io – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-nl`, 34 bytes
```
->m{($_*-~m*2)[~~/$/*m,~/$/].to_i}
```
[Try it online!](https://tio.run/##HYfLCoMwFAX3/YqLzaINJj5pV/ZHJIS2KBW8iZi4KDF@etMonGHmzMvrG/omsAe6C5GUbUjLa7ttGckoprsEt1oOPrQ057xOb9Vd8O75/jhYcYVpsQYSBQ2cHZE@BTwSY82dWUZ73L5F4RPwoTgVeVxkd1n99GQHrUxgavwD "Ruby – 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: `1231231231**2**3123123`
3. Take substring of length \$d=3\$: `1231231231**231**23123`
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~42~~ 40 bytes
```
lambda x,r:int(x[(a:=-r%len(x)):]+x[:a])
```
[Try it online!](https://tio.run/##ZcwxCoAgGEDhvVOEEPiTgWVUCJ2kGoySAjMRBzu90Wiu34NnHnfcmg3GBjnOQYlr3UTuieWndthPWPCxsoXaNfYAfCn9xMUCwdivS4zqhiFSA2SxNImwRNpIEOlYHwn9j@n/m8r3pQDhBQ "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), (4?) 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
4 if we may accept a list of digits (remove the leading `D`).
```
DṙN}Ḍ
```
**[Try it online!](https://tio.run/##y0rNyan8/9/l4c6ZfrUPd/T8///f2MTUzNzC0sDQ6L@hMQA "Jelly – 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
```
[Answer]
# [CJam](https://sourceforge.net/projects/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](https://tio.run/##S85KzP3/v6ioLteu7v9/QyNjBRMA)
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](https://tio.run/##S85KzP3/v7AupjjXru7/f0MjYwUjAA)
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
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 4 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))
Anonymous tacit infix function. Takes string `n` as right argument and number `m` as left argument.
```
⍎-⍛⌽
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1Fvn@6j3tmPevb@T3vUNgHIfdTV/Kh3zaPeLYfWGz9qm/iob2pwkDOQDPHwDP5vmKZuaGSsrqDwqHeugrGhEZcRsoCRsSGXMbIAkMVlgq7FzNgcKARTwQUy0gDIg3JBBhoYqKNw4bIGCmABQ7i8gSGXAbqFQBWWlpYW6mABSwtLSwA "APL (Dyalog Extended) – Try It Online")
`⍎` execute the result of
`-⍛` negating the left argument, then using that to
`⌽` cyclically rotate the right argument
[Answer]
# (non-competing) [L=tn](https://github.com/Ghilt/Listen), 10
```
cα;θ2$cD=0
```
Explanation (in order of execution):
```
cα;         -  Turn first number into a list of digits
    2$c     -  Fetch second number as a number 
   θ        -  Shift list from first step by number from second step
       D=0  -  Drop while equals to zero
```
It prints result as a string.
Note: The language is in progress and I did add stuff to code golf this. So it is not a competing submission.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 43 bytes
```
FromDigits@RotateRight[IntegerDigits@#,#2]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277360oP9clMz2zpNghKL8ksSQ1KDM9oyTaM68kNT21CCqjrKNsFKv2P6AoM69EwSE92tDIWMcwlguFb4TGN0bjmyDzdcyMzZH5BqjGGRigGofGRecDTTeI/f8fAA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 29 bytes
```
,.+
$*_
+`(.*)(\d)_
$2$1
^0+
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX0dPm0tFK55LO0FDT0tTIyZFM55LxUjFkCvOQJvr/39DI2MdQy4QaQQmjcGkCZehjpmxOZehAUjSwAAkCSYgJFCFAQA "Retina 0.8.2 – 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.
[Answer]
# Scala, 61 bytes
```
(n,m)=>{val s=n+""size;val(a,b)=n+""splitAt s-m%s;b++a toInt}
```
[Try it in Scastie](https://scastie.scala-lang.org/8jPaXDKbREuCSjrzyjAqKw)
[Answer]
# [PHP](https://www.php.net/), 45 43 bytes
Saved 2 bytes, realized we can shorten the variable names.
```
<?=(int)(substr($s,-$n).substr($s,0,-$n))?>
```
[Try it online](https://tio.run/##K8go@G9jX5BRoKBSbKtkaGCgZK2SZ2tkrWBvBxS31cjMK9HUKC5NKi4p0lAp1tFVydPUQ3ANwAKaQLX/gVq5jAA)
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.    
  
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 47 bytes
```
(n,m,k=(e=n+'').length)=>+(e+e).substr(k-m%k,k)
```
[Try it online!](https://tio.run/##dc1LDsIgGATgvadgY/oT6ANwAQu8S21oVSiYUnt9bGqjia27Sb7MzL2e6tgMt8eYTzK1OoGnPbUajPYky3DhjO/GK9ZnAoYYXMTnJY4D2Lw/WmpxaoKPwZnChQ5aYFzQCmOEyhLNGR22zFYWjO8oX5ULtqPiO72jp//L1ft26aIt8g9WP6iUkgvPqKRS6QU "JavaScript (V8) – Try It Online")
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 11 bytes
```
Àñ$x0Pñó^0«
```
[Try it online!](https://tio.run/##K/v//3DD4Y0qFQYBhzce3hxncGj1//@GBgb/jQA "V (vim) – 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
```
]