Để "thay đổi" qua một số nđịa điểm, hãy làm như sau:

• Xóa các nchữ số cuối
• Thêm nbản sao của chữ số đầu tiên vào đầu số

Ví dụ, để thay đổi số 31415ba vị trí, lấy ra ba chữ số cuối cùng để nhận 31, sau đó thêm ba bản sao nữa của chữ số đầu tiên 3, vào cuối, đưa ra 33331.

Nếu số âm, thay vào đó, các chữ số nên được lấy từ bên trái và chữ số đầu tiên phải được "điền" từ bên phải. Ví dụ, chuỗi 31415dịch chuyển trên -3 vị trí cho 15555.

Nếu số là 0, không nên thay đổi.

Nếu sự thay đổi lớn hơn độ dài của chương trình, thì các chữ số được điền vào có thể bắt đầu bị xóa. Điều này có nghĩa là nếu số đã cho lớn hơn độ dài của chuỗi, sẽ không có thay đổi nào nữa được thực hiện sau khi toàn bộ chuỗi trở thành một chữ số.

Các thách thức

Cho hai số, nvà s, trở lại nthay đổi qua các sđịa điểm.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy bài nộp hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

APL (Dyalog) , 32 byte

Hàm ẩn danh lấy sift làm đối số bên trái và số (dưới dạng chuỗi) làm đối số bên phải.

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

Hãy thử trực tuyến!

{ anonymous function nơi ⍺ và ⍵ còn lại và lập luận đúng

 |⍺ giá trị tuyệt đối của ca

 a← lưu trữ trong một

 ⋄ sau đó

 ⌽⍵ đảo ngược số

 ⊃ chọn chữ số đầu tiên (tức là cuối cùng)

 a⍴ r eshape nó theo chiều dài một

 ⍵, nhập số

 (... ), thêm vào trước sau:

  ⊃⍵ chữ số đầu tiên

  a⍴ r eshape nó theo chiều dài một

 (... )↓ thả số ký tự sau đây:

  a-⍺ một trừ sự thay đổi

 (Sọ )↑ lấy số ký tự sau:

  ≢⍵ độ dài của số gốc

Python 2 , 50 byte

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

Hãy thử trực tuyến!

Haskell, 69 byte

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

Lấy số dưới dạng một chuỗi. Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

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 byte

tn:i-yn1&Xl)

Các đầu vào là: số được dịch chuyển dưới dạng chuỗi; số lượng dịch chuyển như một số.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Đầu vào của người tiêu dùng '452và '-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 byte

Đây là một trong những tình huống trong J trong đó một động từ rõ ràng có vẻ như là sự lựa chọn đúng (duy nhất?), Nhưng tôi rất muốn biết liệu có viết lại ngầm này không:

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

Động từ shift tích hợp của J cho phép bạn định cấu hình ký tự "điền":

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

Logic để xác định nên sử dụng char đầu tiên hay cuối cùng làm ký tự điền là đơn giản

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

Hãy thử trực tuyến!

J , 23 byte

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

Đầu vào n và đầu ra là các chuỗi chứa các số.

Hãy thử trực tuyến!

Giải trình

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

Võng mạc , 61 byte

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

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

Hãy thử trực tuyến!

05AB1E , 16 byte

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

Lấy số dưới dạng chuỗi và dịch chuyển dưới dạng số nguyên. Trả về một chuỗi.

Tôi đã thử nhúng sự đảo ngược bên trong hàm thay vì thực hiện cuộc gọi đệ quy, nhưng dường như tôi không thể hiểu đúng.

Python 3 , 73 byte

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

Hãy thử trực tuyến!

Haskell , 108 byte

Oh tốt, điều này đã đi tồi tệ hơn tôi nghĩ ..

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

Hãy thử trực tuyến!

Ung dung

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 byte

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

Ouch, khó chịu để đối phó với đầu vào tiêu cực là tốt.

Bình thường, 28 byte

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

Hãy thử trực tuyến hoặc kiểm tra một số đầu vào

Giải trình

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 byte

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

Hãy thử trực tuyến!

05AB1E không quá nóng với điều kiện.

JavaScript, 80 byte

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

Lấy đầu vào dưới dạng một chuỗi đại diện cho số lượng và số lượng "thay đổi" số. Trả về một chuỗi.

Kiểm tra đoạn trích

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>