Para "desplazarse" sobre un número de nlugares, haga lo siguiente:

• Eliminar los últimos ndígitos
• Agregue ncopias del primer dígito al comienzo del número

Por ejemplo, para cambiar el número 31415tres lugares, saque los últimos tres dígitos para obtener 31, y luego agregue tres copias más del primer dígito 3, al final, dando 33331.

Si el número es negativo, los dígitos deben tomarse desde la izquierda y el primer dígito debe "rellenarse" desde la derecha. Por ejemplo, la cadena 31415desplazada sobre -3 lugares da 15555.

Si el número es 0, no se debe realizar ningún cambio.

Si el turno es mayor que la duración del programa, entonces los dígitos que se completaron podrían comenzar a eliminarse. Esto significa que si el número dado es mayor que la longitud de la cadena, no se realizarán más cambios después de que toda la cadena se convierta en un solo dígito.

El reto

Dados dos números, ny s, el retorno ncambió de slugar.

Casos de prueba

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

Este es el código de golf , por lo que gana el envío válido más corto (medido en bytes).

APL (Dyalog) , 32 bytes

Función anónima que toma el tamiz como argumento izquierdo y el número (como una cadena) como argumento derecho.

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

Pruébalo en línea!

{ función anónima donde ⍺ y ⍵ son argumentos izquierdo y derecho

 |⍺ el valor absoluto del turno

 a← almacenar en un

 ⋄ entonces

 ⌽⍵ revertir el número

 ⊃ elija el primer (es decir, el último) dígito

 a⍴ r darle forma a una longitud

 ⍵, anteponer el número

 (... ), anteponer lo siguiente:

  ⊃⍵ el primer dígito

  a⍴ r darle forma a una longitud

 (... )↓ suelte el siguiente número de caracteres:

  a-⍺ un menos el turno

 (... )↑ tome el siguiente número de caracteres:

  ≢⍵ la longitud del número original

Python 2 , 50 bytes

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

Pruébalo en línea!

Haskell, 69 bytes

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

Toma el número como una cadena. Pruébalo en línea!

Cómo 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)

Las entradas son: número que se desplazará como una cadena; cantidad de desplazamiento como un número.

Pruébalo en línea! O verificar todos los casos de prueba .

Consisder entradas '452y '-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

Esta fue una de esas situaciones en J donde un verbo explícito parecía la opción correcta (¿la única?), Pero me encantaría saber si hay una reescritura tácita de esto:

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

El verbo shift incorporado de J le permite configurar el carácter de "relleno":

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

La lógica para determinar si usar el primer o el último carácter como el carácter de relleno es sencillo

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

Pruébalo en línea!

J , 23 bytes

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

La entrada ny la salida son cadenas que contienen los números.

Pruébalo en línea!

Explicación

(_&(]{.,],{:)~|)}.~_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

Pruébalo en línea!

05AB1E , 16 bytes

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

Pruébalo en línea!

Explicación

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]]

Pruébalo en línea!

Toma el número como una cadena y el cambio como un entero. Devuelve una cadena.

Intenté incrustar la inversión dentro de la función en lugar de hacer una llamada recursiva, pero parecía que no podía hacerlo bien.

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

Pruébalo en línea!

Haskell , 108 bytes

Oh bueno, esto fue peor de lo que pensaba ...

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

Pruébalo en línea!

Sin golf

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 %)))))

Ay, desagradable tratar con entradas negativas también.

Pyth, 28 bytes

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

Pruébelo en línea o pruebe algunas entradas

Explicación

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«ëì

Pruébalo en línea!

05AB1E no es tan caliente con condicionales.

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])

Toma la entrada como una representación de cadena del número y una cantidad numérica de "desplazamiento". Devuelve una cadena.

Fragmento de prueba

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>