Pour "décaler" sur plusieurs nemplacements, procédez comme suit:

• Supprimer les derniers nchiffres
• Ajoutez des ncopies du premier chiffre au début du numéro

Par exemple, pour déplacer le nombre de 31415trois, retirez les trois derniers chiffres pour obtenir 31, puis ajoutez trois autres copies du premier chiffre,, 3à la fin, en donnant 33331.

Si le nombre est négatif, les chiffres doivent être pris à gauche à la place et le premier chiffre doit être "rempli" à partir de la droite. Par exemple, la chaîne 31415décalée de -3 places donne 15555.

Si le nombre est 0, aucune modification ne doit être effectuée.

Si le décalage est supérieur à la durée du programme, alors les chiffres qui ont été remplis peuvent commencer à être supprimés. Cela signifie que si le nombre donné est supérieur à la longueur de la chaîne, aucune autre modification ne sera apportée après que la chaîne entière deviendra un seul chiffre.

Le défi

Étant donné deux nombres, net s, le retour a nchangé de splace.

Cas de test

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

Il s'agit de code-golf , donc la soumission valide la plus courte (mesurée en octets) l'emporte.

APL (Dyalog) , 32 octets

Fonction anonyme qui prend le crible comme argument de gauche et le nombre (comme chaîne) comme argument de droite.

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

Essayez-le en ligne!

{ fonction anonyme où ⍺ et ⍵ sont des arguments gauche et droit

 |⍺ la valeur absolue du décalage

 a← stocker dans un

 ⋄ puis

 ⌽⍵ inverser le nombre

 ⊃ choisir le premier (c'est-à-dire le dernier) chiffre

 a⍴ r Eshape à la longueur d' un

 ⍵, ajouter le numéro

 (… ), Ajoutez ce qui suit:

  ⊃⍵ le premier chiffre

  a⍴ r Eshape à la longueur d' un

 (… )↓ Supprimez le nombre de caractères suivant:

  a-⍺ un moins le décalage

 (… )↑ Prenez le nombre de caractères suivant:

  ≢⍵ la longueur du numéro d'origine

Python 2 , 50 octets

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

Essayez-le en ligne!

Haskell, 69 octets

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

Prend le nombre sous forme de chaîne. Essayez-le en ligne!

Comment ça fonctionne:

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 octets

tn:i-yn1&Xl)

Les entrées sont les suivantes: nombre à décaler sous forme de chaîne; quantité de décalage en nombre.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Entrées Consisder '452et '-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 octets

C'était l'une de ces situations en J où un verbe explicite semblait être le bon (le seul?) Choix, mais j'aimerais savoir s'il y a une réécriture tacite de ceci:

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

Le verbe shift intégré de J vous permet de configurer le caractère "fill":

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

La logique pour déterminer s'il faut utiliser le premier ou le dernier caractère comme caractère de remplissage est simple

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

Essayez-le en ligne!

J , 23 octets

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

L'entrée n et la sortie sont des chaînes contenant les nombres.

Essayez-le en ligne!

Explication

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

Rétine , 61 octets

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

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

Essayez-le en ligne!

05AB1E , 16 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Prend le nombre comme une chaîne et le décalage comme un entier. Renvoie une chaîne.

J'ai essayé d'incorporer l'inversion à l'intérieur de la fonction plutôt que de faire un appel récursif, mais je n'arrivais pas à faire les choses correctement.

Python 3 , 73 octets

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

Essayez-le en ligne!

Haskell , 108 octets

Eh bien, cela a empiré ce que je pensais ..

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

Essayez-le en ligne!

Non 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 octets

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

Aïe, méchant pour faire face aux entrées négatives aussi.

Pyth, 28 octets

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

Essayez-le en ligne ou testez certaines entrées

Explication

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 octets

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

Essayez-le en ligne!

05AB1E n'est pas si chaud avec des conditions.

JavaScript, 80 octets

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

Prend l'entrée comme une représentation sous forme de chaîne du nombre et d'une valeur numérique de «décalage». Renvoie une chaîne.

Extrait de test

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>