Para "deslocar" vários nlugares, faça o seguinte:

• Remova os últimos ndígitos
• Adicione ncópias do primeiro dígito ao início do número

Por exemplo, para mudar o número 31415três lugares, retire os três últimos dígitos 31e, em seguida, adicione mais três cópias do primeiro dígito 3, ao final, dando 33331.

Se o número for negativo, os dígitos devem ser retirados da esquerda e o primeiro dígito deve ser "preenchido" da direita. Por exemplo, a string 31415deslocada sobre -3 lugares fornece 15555.

Se o número for 0, nenhuma alteração deve ser feita.

Se o turno for maior que a duração do programa, os dígitos preenchidos podem começar a ser removidos. Isso significa que, se o número fornecido for maior que o comprimento da string, nenhuma alteração adicional será feita depois que a string inteira se tornar um único dígito.

O desafio

Dados dois números, ne sreturn retornou nsobre os slugares.

Casos de teste

   n,  s -> result
7243,  1 -> 7724
 452, -1 -> 522
  12,  1 -> 11
 153,  4 -> 111

Isso é código-golfe , portanto, o menor envio válido (medido em bytes) vence.

APL (Dyalog) , 32 bytes

Função anônima que usa o crivo como argumento à esquerda e o número (como uma string) como argumento à direita.

{a←|⍺⋄(≢⍵)↑(a-⍺)↓(a⍴⊃⍵),⍵,a⍴⊃⌽⍵}

Experimente online!

{ função anônima onde ⍺ e ⍵ são argumentos à esquerda e à direita

 |⍺ o valor absoluto da mudança

 a← armazenar em um

 ⋄ então

 ⌽⍵ reverter o número

 ⊃ escolha o primeiro (ex. último) dígito

 a⍴ r moldá-lo para comprimento um

 ⍵, Anexar o número

 (… ), Acrescente o seguinte:

  ⊃⍵ o primeiro dígito

  a⍴ r moldá-lo para comprimento um

 (… )↓ Solte o seguinte número de caracteres:

  a-⍺ a menos a mudança

 (… )↑ Pegue o seguinte número de caracteres:

  ≢⍵ o comprimento do número original

Python 2 , 50 bytes

lambda n,s:(n[0]*s+n+n[-1]*-s)[-s*(s<0):][:len(n)]

Experimente online!

Haskell, 69 bytes

s#n|l<-[1..abs n]=take(length s)$drop(-2*n)$(s!!0<$l)++s++(last s<$l)

Pega o número como uma sequência. Experimente online!

Como funciona:

s#n                         -- s: input number as a string
                            -- n: shift amount

(s!!0<$l)++s++(last s<$l)   -- make a string:
                            -- n times the first digit, the whole number, n times the last digit
                            -- e.g. "567" 2 -> 5556777
drop(-2*n)                  -- drop the first (-2 * n) chars, i.e. 0 if n>0
take(length s)              -- take as may chars as there are in s

MATL , 12 bytes

tn:i-yn1&Xl)

As entradas são: número a ser deslocado como uma string; quantidade de deslocamento como um número.

Experimente online! Ou verifique todos os casos de teste .

Entradas do Consisder '452e '-1'.

t     % Implicitly input string. Duplicate
      % STACK: '452', '452'
n     % Number of elements
      % STACK: '452', 3
:     % Range
      % STACK: '452', [1 2 3]
i     % Input number
      % STACK: '452', [1 2 3], -1
-     % Subtract, element-wise
      % STACK: '452', [2 3 4]
y     % Duplicate from below
      % STACK: '452', [2 3 4], '452'
n     % Number of elements
      % STACK: '452', [2 3 4], 3
1     % Push 1
      % STACK: '452', [2 3 4], 3, 1
&Xl   % Clamp, with three inputs. Applies min function, then max
      % STACK: '452', [2 3 3]
)     % Reference indexing. Implicitly display
      % STACK: '522'

J, 37 bytes

Essa foi uma daquelas situações em J em que um verbo explícito parecia a escolha certa (a única?), Mas eu adoraria saber se há uma reescrita tácita disso:

4 :'(-x)(|.!.((x>0)&{({:,{.)":y))":y'

O verbo turno incorporado de J permite configurar o caractere "preenchimento":

|.!.f  NB. f is the fill character

A lógica para determinar se deve usar o primeiro ou o último caractere como o caractere de preenchimento é simples

(x>0)&{ ({: , {.)

Experimente online!

J , 23 bytes

(_&(]{.,],{:)~|)}.~_2*]

A entrada ne a saída são cadeias contendo os números.

Experimente online!

Explicação

(_&(]{.,],{:)~|)}.~_2*]  Input: 'integer n' as a string (LHS), integer s (RHS)
(              )         Extend 'n' by copying its head and tail 's' times
              |            Abs(s)
 _&(]       )~             Nest 'Abs(s)' times on 'n'
          {:                 Tail
        ],                   Append the tail to itself
     {.                      Head
       ,                     Prepend the head to the previous
                   _2*]  Multiply 's' by -2
                }.~      Drop abs(-2*s) from the head if 's' < 0 else from the tail

Retina , 61 bytes

\d+¶
$*1¶
+`(?<!-).¶(.)(.*).
¶$1$1$2
-

+`.¶.(.*)(.)$
¶$1$2$2

Experimente online!

05AB1E , 16 bytes

0‹©iR}¹ÄF¨¬ì}®iR

Experimente online!

Explicação

0‹                 # input_1 is negative
  ©                # store a copy in register
   iR}             # if true (input_1 is negative), reverse input_2
      ¹ÄF          # abs(input_1) times do
         ¨         # remove the last element
          “       # prepend the head
            }      # end loop
             ®iR   # if input_1 was negative, reverse result

Python 2 , 87 bytes

f=lambda n,s:s<0and f(n[::-1],-s)[::-1]or n[0]*min(len(n),s)+n[:[0,len(n)-s][len(n)>s]]

Experimente online!

Pega o número como uma sequência e o deslocamento como um número inteiro. Retorna uma string.

Tentei incorporar a reversão dentro da função em vez de fazer uma chamada recursiva, mas não consegui acertar.

Python 3 , 73 bytes

f=lambda s,i:(f(s+1,i[1:]+i[-1])if s<0else f(s-1,i[0]+i[:-1]))if s else i

Experimente online!

Haskell , 108 bytes

Oh bem, isso foi pior do que eu pensava ..

n#s=print$show n&s
r=reverse
n&s|s<0=r$r n&abs s|(a:b,c)<-splitAt s n=take(length n)$(a<$[0..s])++b++c|1>0=n

Experimente online!

Ungolfed

n # s = print $ show n & s
n & s
  | s < 0                = reverse (reverse n & abs s)
  | (a:b,c)<-splitAt s n = take (length n) (replicate s a ++ b ++ c)
  | otherwise            = n

Clojure, 121 bytes

#(let[T(if(pos? %2)reverse vec)](apply str(concat(repeat %2(first %))(T(drop(Math/abs %2)(T %)))(repeat(- %2)(last %)))))

Ouch, desagradável para lidar com entradas negativas também.

Pitão, 28 bytes

AQ=Y<+*hJ?K<0H`G_`GHJlJ?KY_Y

Experimente online ou teste algumas entradas

Explicação

AQ=Y<+*hJ?K<0H`G_`GHJlJ?KY_Y
AQ                           | Split Q into 2 parts, G and H.
        J?K<0H`G_`G          | If 0 < H, J = str(G). Else, J = reverse(str(G)). Return J
       h                     | Find 1st element
      *            H         | Repeat H times
     +              J        | Concatenate with J
    <                lJ      | Find 1st length(J) elements
  =Y                         | Assign to Y.
                       ?KY_Y | If K, implicit print Y. Else implicit print reverse(Y).

05AB1E , 33 bytes

ÄF¹0‹©i¨ë¦}}²®i¤ë¬}sg¹Ä‚Ws\×®i«ëì

Experimente online!

05AB1E não é tão quente com condicionais.

JavaScript, 80 bytes

(n,s,k=n.length,p=s<=0)=>n.slice(p*-s,p?k:-s)[p?"padEnd":"padStart"](k--,n[p*k])

Recebe a entrada como uma representação de sequência do número e um valor numérico de "turno". Retorna uma string.

Snippet de teste

let f=
(n,s,k=n.length,p=s<=0)=>n.slice(p*-s,p?k:-s)[p?"padEnd":"padStart"](k--,n[p*k])

I.value="31415";J.value="3";D.oninput()

<div id=D oninput="O.value=I.value.length&J.value.length?f(I.value,+J.value):''">n: <input id=I size=10> s: <input id=J size=2><br><input id=O disabled>