Bir sayı nyerlerinde "kaydırmak" için aşağıdakileri yapın:

• Son nrakamları kaldır
• nİlk basamağın kopyalarını sayının başına ekle

Örneğin, 31415üç sayıyı değiştirmek için , son üç basamağı alın 31ve ardından ilk basamağın üç kopyasını 3sonuna ekleyin 33331.

Sayı negatifse, rakamlar soldan alınmalı ve ilk rakam sağdan "doldurulmalıdır". Örneğin, 31415-3 yere kaydırılan dize verir 15555.

Sayı 0 ise, değişiklik yapılmamalıdır.

Vardiya, programın uzunluğundan fazlaysa, doldurulmuş rakamlar kaldırılmaya başlayabilir. Bu, verilen sayı dizenin uzunluğundan fazlaysa, dizenin tamamı tek bir basamak haline geldikten sonra başka değişiklik yapılmayacağı anlamına gelir.

Meydan okuma

Verilen iki sayı nve sdönüş yerleri yer ndeğiştirdi s.

Test senaryoları

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

Bu kod golf , bu nedenle (bayt cinsinden ölçülen) en kısa geçerli gönderim kazanır.

APL (Dyalog) , 32 bayt

Sift'i sol argüman olarak ve sayıyı (dize olarak) sağ argüman olarak alan anonim işlev.

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

Çevrimiçi deneyin!

{⍺ ve ⍵ öğelerinin sol ve sağ argümanlar  olduğu anonim işlev

 |⍺ vardiya mutlak değeri

 a← mağaza a

 ⋄ sonra

 ⌽⍵ sayıyı ters çevir

 ⊃ ilk (yani son) basamağı seç

 a⍴ r uzunluk a

 ⍵, numarayı ekle

 (… ), Aşağıdakilerin başına:

  ⊃⍵ ilk basamak

  a⍴ r uzunluk a

 (… )↓ Aşağıdaki karakter sayısını bırakın:

  a-⍺ Bir eksi kayma

 (… )↑ Aşağıdaki karakter sayısını al:

  ≢⍵ orijinal numaranın uzunluğu

Python 2 , 50 bayt

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

Çevrimiçi deneyin!

Haskell, 69 bayt

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

Sayıyı dize olarak alır. Çevrimiçi deneyin!

Nasıl çalışır:

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 bayt

tn:i-yn1&Xl)

Girdiler şunlardır: dize olarak kaydırılacak sayı; sayı olarak kayma miktarı.

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

Consisder girişleri '452ve '-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 bayt

Bu, J'de açık bir fiilin doğru (tek?) Seçim gibi göründüğü durumlardan biriydi, ancak bunun zımni bir yeniden yazma olup olmadığını bilmek isterim:

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

J'nin yerleşik fiil, "dolgu" karakterini yapılandırmanızı sağlar:

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

Dolgu karakteri olarak ilk veya son karakterin kullanılıp kullanılmayacağını belirleyen mantık basittir

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

Çevrimiçi deneyin!

J , 23 bayt

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

N girişi ve çıkışı sayıları içeren dizelerdir.

Çevrimiçi deneyin!

açıklama

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

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

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

Çevrimiçi deneyin!

05AB1E , 16 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Sayıyı dize, kaydırmayı da tamsayı olarak alır. Bir dize döndürür.

Geri dönüşü yinelemeli çağrı yapmak yerine işlevin içine yerleştirmeyi denedim, ancak doğru yapamadım.

Python 3 , 73 bayt

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

Çevrimiçi deneyin!

Haskell , 108 bayt

Oh, bu düşündüğümden daha kötü oldu ..

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

Çevrimiçi deneyin!

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 bayt

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

Ah, olumsuz girdilerle uğraşmak da kötü.

Pyth, 28 bayt

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

Çevrimiçi deneyin veya bazı girişleri test edin

açıklama

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 bayt

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

Çevrimiçi deneyin!

05AB1E, koşullarla çok sıcak değil.

JavaScript, 80 bayt

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

Girdiyi sayının dize olarak temsili ve sayısal "shift" miktarı olarak alır. Bir dize döndürür.

Snippet'i Test Et

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>