Nhiệm vụ

Đây là một thử thách đơn giản. Đầu vào của bạn là một chuỗi không trống, chỉ chứa các chữ số 0123456789và băm #. Nó sẽ chứa chính xác một chuỗi chữ số, mã hóa một số nguyên không âm và có thể bao quanh phần cuối của chuỗi và ít nhất một chữ số #. Số nguyên có thể có các số 0 đứng đầu. Ví dụ, ##44##, 013####và 23###1là đầu vào hợp lệ, trong khi ###, 0099và #4#4không.

Nhiệm vụ của bạn là trích xuất số nguyên ntừ chuỗi và xuất các nbước xoay chuỗi sang phải.

Ví dụ

• Đầu vào #1##phải được xoay 1 bước sang phải, vì vậy đầu ra đúng là ##1#.
• Đầu vào #026###phải được xoay 26 bước sang phải, vì đầu 0 bị bỏ qua. Đầu ra đúng là 26####0.
• Đầu vào 1####2chứa số nguyên 21 được bao bọc ở cuối, do đó, nó phải được xoay 21 bước sang phải. Đầu ra đúng là ##21##.

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Bạn có thể cho rằng số đó nphù hợp với intloại tiêu chuẩn của ngôn ngữ của bạn. Ngược lại, nếu intloại tiêu chuẩn đó thực hiện các số nguyên chính xác tùy ý, bạn phải hỗ trợ (về lý thuyết) một lượng lớn tùy ý n.

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

#1## -> ##1#
##4## -> #4###
1####1 -> ####11
1####2 -> ##21##
#026### -> 26####0
#000### -> #000###
###82399 -> ##82399#
51379#97 -> #9751379
#98##### -> ###98###
#######4## -> #4########
60752#1183 -> 8360752#11
####99366800## -> 366800######99
########9##### -> ###9##########
91#####515694837 -> 1#####5156948379
###6114558###### -> #6114558########
######219088736090042#### -> 9088736090042##########21
#46055080150577874656291186550000138168########### -> 0138168############4605508015057787465629118655000
568375993099127531613012513406622393034741346840434468680494753262730615610086255892915828812820699971764142551702608639695081452206500085233149468399533981039485419872101852######################3680 -> 99533981039485419872101852######################36805683759930991275316130125134066223930347413468404344686804947532627306156100862558929158288128206999717641425517026086396950814522065000852331494683

CJam, 11 byte

q_'#%W%sim>

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

Lưu ý rằng điều này sẽ không hoạt động trong hai trường hợp thử nghiệm gần đây, vì các số liên quan không khớp với 64 bit.

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

q_          e# Read all input and push it twice.
  '#%       e# Split at runs of '#'.
     W%     e# Reverse the resulting array.
       si   e# Cast to string, then to int.
         m> e# Rotate the original input that many places to the right.

Julia, 71 65 byte

s->join(circshift([s...],maximum(parse,split(s*s,"#",keep=1<0))))

Đây là một hàm ẩn danh chấp nhận một chuỗi và trả về một chuỗi. Để gọi nó, gán nó cho một biến.

Chúng tôi nối thêm đầu vào cho chính nó, chia nó thành một mảng với #dấu phân cách, phân tích từng số nguyên và lấy mức tối đa. Điều này xác định số lần chúng ta dịch chuyển chuỗi sang phải. Chúng tôi chia chuỗi thành một Charmảng, dịch chuyển và nối joinlại với nhau.

Python, 66 byte

lambda l:(2*l)[-int(''.join(l.split('#')[::-1]))%len(l):][:len(l)]

Võng mạc, 65 57 49

(\ d *) # * (\ d +)
$ 2 $ 1 $ 0
^ \ d +
$ *
+ `1 (. *) (.)
 $ 2 $ 1
<không gian>

Đã lưu 8 byte nhờ Martin!

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

Lưu ý rằng điều này sẽ hết thời gian / hết bộ nhớ cho các trường hợp thử nghiệm trực tuyến rất lớn và trên hầu hết các máy lành mạnh, đối với một số máy lớn hơn.

Điều này lấy số cuối cùng trong chuỗi và số đầu tiên hoặc không có trong chuỗi và đặt chúng ở trước chuỗi. Sau đó, nó chuyển đổi số kết hợp thành đơn vị và liên tục xoay trong khi thả một chữ số đơn.

Thạch, 12 10 byte

ẋ2~ṣ0‘ḌṂṙ@

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

Lý lịch

Nói đầu vào là 51379#97.

Bằng cách lặp lại chuỗi hai lần ( 51379#9751379#97), chúng ta có thể chắc chắn rằng nó sẽ chứa một đại diện liền kề của số.

Tiếp theo, chúng tôi áp dụng bitwise KHÔNG cho tất cả các ký tự. Điều này cố gắng truyền tới int, vì vậy '1' được ước tính thành 1 , sau đó được ánh xạ tới ~ 1 = -2 . Khi thất bại ( #), nó trả về 0 .

Ví dụ của chúng tôi, điều này mang lại

[-6, -2, -4, -8, -10, 0, -10, -8, -6, -2, -4, -8, -10, 0, -10, -8]

Tiếp theo, chúng tôi chia ra các số 0 để tách phần mã hóa số này khỏi phần còn lại.

[[-6, -2, -4, -8, -10], [-10, -8, -6, -2, -4, -8, -10], [-10, -8]]

Bitwise KHÔNG ánh xạ n đến -n - 1 , vì vậy chúng tôi tăng từng cái để có được -n .

[[-5, -1, -3, -7, -9], [-9, -7, -5, -1, -3, -7, -9], [-9, -7]]

Tiếp theo, chúng tôi chuyển đổi từng danh sách từ cơ sở 10 sang số nguyên.

[-51379, -9751379, -97]

Số thấp nhất là số âm của số chúng tôi đang tìm kiếm. Vì nguyên tử xoay danh sách Jelly ṙquay sang trái , điều này tránh nhân với -1 để xoay sang phải.

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

ẋ2~ṣ0‘ḌṂṙ@  Main link. Input: S (string)

ẋ2          Repeat the string twice.
  ~         Apply bitwise NOT to all characters.
            This maps 'n' to ~n = -(n+1) and '# to 0.
   ṣ0       Split at occurrences of zeroes.
     ‘      Increment all single-digit numbers.
      Ḍ     Convert each list from base 10 to integer.
       Ṃ    Take the minimum.
        ṙ@  Rotate S that many places to the left.

MATL , 28 25 17 16 byte

!G1Y4XXPZcXvUYS!

Ít hơn 8 byte mượn ý tưởng của Dennis về việc chia mảng và đảo ngược thứ tự của các mảnh

Hai trường hợp thử nghiệm cuối cùng không hoạt động vì số lượng quá lớn.

EDIT (ngày 20 tháng 5 năm 2016) Mã trong liên kết sử dụng Xzthay vì Xv, do những thay đổi gần đây trong ngôn ngữ.

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

!         % take implicit input: string. Transpose into column char array
G         % push input string again
1Y4       % predefined literal '\d' (for regexp)
XX        % match regexp. Gives cell array with 1 or 2 strings
P         % flip that array
ZcXv      % join the strings in that array, without spaces
U         % convert to number
YS        % rotate the transposed input that many times
!         % put back into row form (string). Implicitly display

PowerShell, 153 byte

_{(Nhưng xem phần Tín dụng bổ sung, bên dưới)}

param($a)$d=[System.collections.arraylist][char[]]$a;for($b=+("$a$a"-split"#"-ne'')[1];$b;$b--){$r=$d[-1];$d.removeAt($d.Count-1);$d.insert(0,$r)}-join$d

PowerShell không có khái niệm "dịch chuyển" một mảng, vì vậy tôi phải đưa ra giải pháp của riêng mình. Sẽ mất nhiều thời gian cho các số lớn hơn, nhưng cuối cùng nó sẽ hoàn thành bất cứ điều gì phù hợp với int 32 bit.

Lấy đầu vào $avà đặt một biến mới $dlàm đối tượng [System.Collections.ArrayList] . Điều này được thực hiện bởi vì, về mặt kỹ thuật, các mảng trong PowerShell là không thay đổi _{(được giải thích thêm dưới đây trong Tín dụng bổ sung)} và do đó không hỗ trợ chèn hoặc xóa tùy ý, cần thiết cho việc dịch chuyển. Sau đó, chúng tôi nhập một forvòng lặp.

Điều kiện ban đầu là một mẹo tôi tìm thấy - nếu chúng ta ghép các đầu vào lại với nhau, tách ra #và bỏ qua các trống, phần tử thứ hai của mảng kết quả sẽ bằng số của chúng ta, bất kể gói. Chúng tôi đặt nó thành $bvà giảm dần $bmỗi lần cho đến khi nó bằng không.

Mỗi lần lặp, chúng ta đặt trình trợ giúp $rlàm thành phần cuối cùng trong danh sách mảng, loại bỏ phần tử cuối cùng đó và sau đó chèn phần tử lên phía trước ... "dịch chuyển" mảng sang bên phải một cách hiệu quả.

Cuối cùng, chúng ta chỉ cần xuất ra -join$dđể nó được nối thành một chuỗi.

Tín dụng thêm

Nếu vấn đề là dịch chuyển mảng sang trái thay vì phải , chúng ta có thể thực hiện ngắn hơn đáng kể bằng cách sử dụng nhiều phép gán . Về cơ bản, "Nếu giá trị gán chứa nhiều phần tử hơn biến, tất cả các giá trị còn lại được gán cho biến cuối cùng."

Về bản chất, điều này có nghĩa là một cái gì đó giống $c=@(1,2,3)và $a,$b=$c
sẽ có $a=1một int và $b=@(2,3)một mảng.

PowerShell, 90 byte, thực hiện dịch chuyển trái thay vì dịch chuyển phải

param($a)$b=+("$a$a"-split"#"-ne'')[1];$a=[char[]]$a;for(;$b;$b--){$r,$a=$a;$a+=$r}-join$a

Ở đây chúng tôi một lần nữa lấy đầu vào, và đặt $bnhư trên. Chúng tôi đúc lại $adưới dạng một mảng char, và sau đó nhập cùng một forvòng lặp như trên. Tuy nhiên, lần này, chúng tôi không cần hỗ trợ xóa / chèn tùy ý, vì vậy chúng tôi không cần sử dụng [System.Collections.ArrayList]đối tượng tốn kém cũng như các cuộc gọi phương thức đắt tiền. Thay vào đó, chúng tôi chỉ đơn giản là đặt thành $rphần tử đầu tiên $avà các phần tử còn lại được lưu lại $a. Sau đó, chúng tôi +=để giải quyết nó trở lại đến cuối cùng.

(Như tôi đã nói, các mảng PowerShell là bất biến về mặt kỹ thuật, nhưng +=toán tử ở đây bị quá tải - nó lấy một mảng và một đối tượng khác, ghép chúng lại với nhau (thuật ngữ kỹ thuật) vào một mảng mới, trả về nó và lưu nó dưới dạng tên biến và phá hủy Về mảng ban đầu. Về mặt chức năng, chúng tôi vừa thêm một phần tử vào cuối mảng, nhưng về mặt kỹ thuật (và từ góc độ dọn dẹp bộ nhớ / rác, v.v.) đó là một mảng hoàn toàn mới. Đây rõ ràng có thể trở thành một hoạt động tốn kém nếu mảng lớn hoặc phức tạp. Flipside là vậy, vì các mảng là bất biến, việc lập chỉ mục vào chúng hoặc lặp lại trên chúng là rất rẻ.)

Đầu ra vẫn giữ nguyên hành động, với một -joincâu lệnh biến nó thành một chuỗi đơn.

Nghiêm túc, 21 byte

,;;+'#@s`≈`MM@#@`/`nΣ

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

Cảnh báo: giải pháp này rất không hiệu quả, vì vậy các trường hợp thử nghiệm lớn hơn sẽ hết thời gian trên TIO. Sử dụng trình thông dịch địa phương.

Giải trình:

,;;+'#@s`≈`MM@#@`/`nΣ
,;;+                   make 3 copies of input, and concatenate two of them
    '#@s               split on #s
        `≈`MM          convert strings to ints, take maximum
             @#@       explode final copy of input
                `/`n   rotate to the right n times
                    Σ  join

Toán học, 69 byte

#~StringRotateRight~ToExpression[""<>Reverse@TextCases[#,"Number"]]&

Tìm dãy số trong, nếu có 2 thì thứ tự của chúng cần được đảo ngược. Nối chuỗi (nếu chỉ có một chuỗi, nó chỉ trả về chuỗi số). Chuyển đổi chuỗi thành số và xoay chuỗi số lần đó.

Kim tự tháp, 22 14 byte

.>zs-.<zxz\#\#

Hãy thử nó ở đây!

Giải trình

.> zs -. <zxz \ # \ # # z = đầu vào

     . <z # xoay z trái
        xz \ # # chỉ mục của lần xuất hiện đầu tiên của hàm băm
                  # điều này đảm bảo rằng số nguyên không bị quấn quanh cuối
    - \ # # lọc tất cả các giá trị băm
   s # cast thành một số nguyên, cũng loại bỏ các số 0 đứng đầu
.> z # thực hiện chuyển động cuối cùng của chuỗi đầu vào và in nó

Điều này hoạt động cho tất cả các testcase và gần như kết thúc ngay lập tức cho những con số rất lớn.

JavaScript (ES6) 66

Lần đầu tiên, tiêu cực ngu ngốc %của javascript cho số âm trở nên hữu ích

z=>(z+z).substr(-(l=z.length,[a,b]=z.match(/\d+/g),b?b+a:a)%l-l,l)

Bình thường, 10 byte

.>zss_cz\#

Hãy thử trực tuyến. Bộ thử nghiệm.

Đây là bản dịch câu trả lời của Dennis 'CJam . Tôi đang biến nó thành một wiki cộng đồng, vì tôi đã không nghĩ ra nó.

Giải trình

      cz\#   split input at #
     _       reverse
    s        join
   s         cast to integer
.>z          rotate input right

JavaScript (ES6), 67 64 byte

s=>(l=s.length,s+s).substr(l-s.split(/#+/).reverse().join``%l,l)

Một cổng khác của câu trả lời CJam của Dennis.

Chỉnh sửa: Đã lưu 3 byte bằng cách chiếm phần của câu trả lời của edc65 mà anh ta không thu hút sự chú ý.

Perl 5, 41 byte

39 byte cộng với hai cho các -lFcờ ( -M5.01miễn phí):perl -lF -M5.01 script.pl

/#+/;map{unshift@F,pop@F}1..$'.$`;say@F

Giải trình:

• -lFđọc đầu vào, loại bỏ dòng mới, đặt phần còn lại vào chuỗi $_, chia nó thành các ký tự và đặt phân tách thành mảng @F.
• /#+/tìm chuỗi đầu tiên của #s trong $_và đặt $`bằng với thứ trước nó và $'bằng với thứ sau nó. Nếu $`trống thì $'có thể chứa nhiều #s. Tuy nhiên, $'.$`là một chuỗi có chuỗi con ban đầu là số lần xoay mảng.
• Bây giờ chúng ta xây dựng danh sách 1..$'.$`, xử lý $'.$`như một số nguyên và do đó số hóa nó, loại bỏ bất kỳ #s cuối cùng nào , vì vậy danh sách này từ 1số lần để xoay mảng.
• Đối với mỗi phần tử trong danh sách đó, chúng tôi xoay mảng ( popphần tử cuối cùng và unshiftphần đầu vào phần đầu).
• Sau đó, saytất cả các yếu tố của mảng xoay.

Ruby - 68 72 70 byte

s=ARGV[0]
p s.split(//).rotate(-(s+s).scan(/\d+/).map(&:to_i).max)*""

• split chuyển đổi chuỗi thành một mảng
• (s+s).scan(/\d+/) nối chuỗi với chính nó và lấy một mảng các số (dưới dạng chuỗi)
• map(&:to_i) chuyển đổi chuỗi thành ints
• max chọn int lớn nhất
• rotate max lần
• *""chuyển đổi mảng trở lại thành một chuỗi (viết tắt cho join)

Sử dụng : ruby scriptname.rb "[string]"

05AB1E , 14 13 byte

Chà, mã rất khó có thể chấm dứt đối với các số lớn hơn 100000, nhưng nếu bạn đủ kiên nhẫn, sẽ có một đầu ra :). Mã số:

'#¡rJ¹sF¤rS\J

Giải trình:

'#¡             # Split the input on '#'
   r            # Reverse the stack
    J           # Join the stack
     ¹          # Take the first input
      s         # Swap with the number
       F        # For N in range(0, number), do...
        ¤       #   Obtain the last character
         r      #   Reverse the stack
          S     #   Split everything to individual characters
           \    #   Delete the last character
            J   #   Join the stack

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

Sử dụng mã hóa CP-1252

VBSCRIPT, 82 99 B BYNG

mã trước đó không xử lý các trường hợp có số được bọc ở cuối

b=len(a):f=replace(a,"#","/",1,1):c=replace(split(f&f,"/")(1),"#",d) mod b:d=right(a,c)&left(a,b-c)

NÂNG CẤP

b=len(a)                                 -a->implicit input, get its length 
f=replace(a,"#","/",1,1)  -replace first instance of # so we can split later
c=replace(split(f&f,"/")(1),"#",d) mod b    -get the number and calc the mod
d=right(a,c)&left(a,b-c)                    -d->implicit output

điều này thật tệ ... có lẽ là một cách tốt hơn để làm điều đó, ngay cả trong VBscript

Toán học, 73 58 byte

#~StringRotateRight~Max[FromDigits/@StringSplit[#<>#,"#"]]&

Nhiều byte. 15 byte lưu nhờ để IPoiler

Matlab (73)

  @(a)regexprep(a,'(\d*)#*(\d*)#*','${circshift($0,[0 str2num([$2 $1])])}')

• Điều này đang sử dụng một cách tiếp cận khác mà tôi tự hỏi liệu @luis có sử dụng nó không, bởi vì tham chiếu đến mô tả của anh ta có một số điểm chung trong khi (un)? May mắn thay tôi không hiểu ngôn ngữ Matl bị cắt.

chiếu (86) 72

 @(n)circshift(n,[0 str2num(circshift(n(n~='#'),[0,-find(n=='#',1)+1]))])

• Hàm tổng hợp chuỗi hai lần, một lần để trích xuất số nguyên, lần thứ hai cho tác vụ mong muốn, nó không mất quá nhiều thời gian vì matlab tiến hành xoay theo (Dim)modulus(Length)ngoại lệ rằng nó rơi vào thất bại phân đoạn cho phạm vi lớn hơn.

• Sẽ đấu tranh làm thế nào để chơi golf nhiều hơn ....

(86)

  @(n)circshift(n,[0 str2num([strtok(n(find(n=='#',1,'last'):end),'#') strtok(n,'#')])])

• Sự khác biệt giữa hàm này và hàm trước, hàm này không ghép hai lần xuất hiện của các số nguyên cách xa nhau, trong khi hàm thứ nhất chỉ xoay nó.