งาน

นี่เป็นความท้าทายที่เรียบง่าย ข้อมูลที่คุณป้อนเป็นสตริงที่ไม่ว่างเปล่าหนึ่งบรรทัดมีเฉพาะตัวเลข0123456789และแฮช#เท่านั้น มันจะมีอีกหนึ่งการทำงานของตัวเลขซึ่ง encodes #ติดลบและอาจห่อรอบจุดสิ้นสุดของสตริงและที่หนึ่งอย่างน้อย จำนวนเต็มอาจมีเลขศูนย์นำหน้า ตัวอย่างเช่น##44##, 013####และ23###1เป็นปัจจัยการผลิตที่ถูกต้องในขณะที่###, 0099และ#4#4ไม่ได้

งานของคุณคือการดึงจำนวนเต็มnจากสตริงและส่งออกnขั้นตอนการหมุนสตริงไปทางขวา

ตัวอย่าง

• การป้อนข้อมูลที่#1##ควรจะหมุนขั้นตอนที่ 1 ##1#ไปทางขวาเพื่อให้การส่งออกที่ถูกต้องคือ
• อินพุต#026###ควรหมุนไป 26 ขั้นตอนไปทางขวาเนื่องจากค่า 0 นำหน้าจะถูกละเว้น 26####0เอาท์พุทที่ถูกต้องคือ
• อินพุต1####2มีจำนวนเต็ม 21 ที่พันปลายดังนั้นจึงควรหมุน 21 ขั้นไปทางขวา ##21##เอาท์พุทที่ถูกต้องคือ

กฎและการให้คะแนน

คุณสามารถเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่น จำนวนไบต์ต่ำสุดที่ชนะและไม่อนุญาตช่องโหว่มาตรฐาน

คุณสามารถสันนิษฐานได้ว่าตัวเลขนั้นnเหมาะกับintภาษามาตรฐานของคุณ ตรงกันข้ามถ้าว่ามาตรฐานintการดำเนินการประเภทความแม่นยำ arbitrary จำนวนเต็มคุณต้องรองรับ (ในทางทฤษฎี) nความใหญ่พล

กรณีทดสอบ

#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 ไบต์

q_'#%W%sim>

ลองออนไลน์!หรือตรวจสอบกรณีทดสอบทั้งหมด

โปรดทราบว่าสิ่งนี้จะไม่สามารถใช้ได้กับกรณีทดสอบสองครั้งล่าสุดเนื่องจากตัวเลขที่เกี่ยวข้องไม่พอดีกับ 64 บิต

มันทำงานอย่างไร

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 ไบต์

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

นี่คือฟังก์ชันที่ไม่ระบุชื่อที่ยอมรับสตริงและส่งคืนสตริง หากต้องการเรียกใช้กำหนดค่าให้กับตัวแปร

เราผนวกข้อมูลเข้ากับตัวเองแยกเป็นอาร์เรย์ด้วย#ตัวคั่นแยกวิเคราะห์แต่ละจำนวนเต็มและใช้สูงสุด สิ่งนี้จะกำหนดจำนวนครั้งที่เราเลื่อนสตริงไปทางขวา เราตบสตริงเข้าไปในCharอาร์เรย์เลื่อนและjoinกลับมารวมกัน

Python ขนาด 66 ไบต์

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

จอประสาทตา 65 57 49

(\ d *) # * (\ + D)
$ 2 $ 1 $ 0
^ \ D +
$ *
+ `1 (. *) (.)
 $ 2 $ 1
<พื้นที่>

บันทึกไปแล้ว 8 ไบต์ขอบคุณ Martin!

ลองออนไลน์!

โปรดทราบว่านี่จะหมดเวลา / หน่วยความจำหมดสำหรับกรณีทดสอบที่มีขนาดใหญ่มากทางออนไลน์และบนเครื่องที่มีสติส่วนใหญ่สำหรับบางกรณีที่มีขนาดใหญ่กว่า

การดำเนินการนี้จะใช้ตัวเลขสุดท้ายในสตริงและหมายเลขแรกหรือไม่มีในสตริงและวางไว้ที่ด้านหน้าของสตริง จากนั้นจะแปลงจำนวนที่รวมกันเป็นเอกและหมุนซ้ำ ๆ ในขณะที่ลดจำนวนหลัก

เยลลี่, 12 10 ไบต์

ẋ2~ṣ0‘ḌṂṙ@

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

พื้นหลัง

51379#97บอกว่าใส่เป็น

โดยการทำซ้ำสตริงสองครั้ง ( 51379#9751379#97) เราสามารถตรวจสอบให้แน่ใจว่ามันจะมีการแสดงตัวเลขที่ต่อเนื่องกัน

ต่อไปเราจะใช้ bitwise NOT กับตัวละครทุกตัว ความพยายามในการนี้เพื่อโยน int ดังนั้น'1'ได้รับการประเมินเพื่อ1 , แมปแล้ว~ 1 = -2 ในความล้มเหลว ( #) ก็จะส่งกลับ0

สำหรับตัวอย่างของเราสิ่งนี้ให้

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

ต่อไปเราแบ่งที่ศูนย์เพื่อแยกส่วนที่เข้ารหัสหมายเลขจากส่วนที่เหลือ

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

Bitwise ไม่แผนที่nเพื่อ-n - 1ดังนั้นเราจึงเพิ่มขึ้นในแต่ละที่จะได้รับ-n

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

ต่อไปเราจะแปลงแต่ละรายการจากฐาน 10 เป็นจำนวนเต็ม

[-51379, -9751379, -97]

ตัวเลขต่ำสุดคือค่าลบของค่าที่เรากำลังค้นหา เนื่องจากอะตอมการหมุนของรายการเยลลี่ṙหมุนไปทางซ้ายการหลีกเลี่ยงการคูณด้วย-1จึงหมุนไปทางขวา

มันทำงานอย่างไร

ẋ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 ไบต์

!G1Y4XXPZcXvUYS!

8 ไบต์ยืมน้อยกว่าแนวคิดของเดนนิสในการแบ่งอาร์เรย์และสลับลำดับของชิ้นส่วน

กรณีทดสอบสองครั้งล่าสุดไม่ทำงานเพราะจำนวนมากเกินไป

แก้ไข (20 พฤษภาคม 2016) รหัสในลิงก์ใช้XzแทนXvเนื่องจากมีการเปลี่ยนแปลงล่าสุดในภาษา

ลองออนไลน์!

!         % 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 ไบต์

_{(แต่ดูส่วนเครดิตพิเศษด้านล่าง)}

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 ไม่มีแนวคิด "เปลี่ยน" อาเรย์ดังนั้นฉันจึงต้องใช้วิธีแก้ปัญหาของตัวเอง จะใช้เวลานานสำหรับจำนวนที่มากขึ้น แต่ในที่สุดมันก็ควรจะทำทุกอย่างให้พอดีกับ int 32- บิต

รับอินพุต$aและตั้งค่าตัวแปรใหม่$dเป็นวัตถุ[System.Collections.ArrayList] สิ่งนี้ทำได้เนื่องจากในทางเทคนิคอาร์เรย์ใน PowerShell นั้นไม่เปลี่ยนรูปแบบ_{(อธิบายเพิ่มเติมด้านล่างในเครดิตเสริม)}และดังนั้นจึงไม่สนับสนุนการแทรกหรือลบโดยพลการซึ่งจำเป็นสำหรับการเลื่อน จากนั้นเราเข้าสู่forวง

เงื่อนไขเริ่มต้นเป็นเคล็ดลับที่ฉันพบ - ถ้าเราต่อข้อมูลเข้าด้วยกันแยก#และไม่สนใจสิ่งที่สององค์ประกอบของอาร์เรย์ผลลัพธ์จะเท่ากับจำนวนของเราโดยไม่คำนึงถึงการห่อ เราตั้งค่านั้นเป็น$bและลด$bทุกครั้งจนกว่าจะมีค่าเป็นศูนย์

การวนซ้ำแต่ละครั้งเรากำหนดผู้ช่วย$rเป็นองค์ประกอบสุดท้ายใน arraylist เอาองค์ประกอบสุดท้ายออกแล้วแทรกองค์ประกอบลงบนด้านหน้า ... อย่างมีประสิทธิภาพ "เลื่อน" อาร์เรย์ไปทางขวาโดยองค์ประกอบหนึ่ง

ในที่สุดเราก็เอาท์พุทด้วย-join$dเพื่อที่จะตัดแบ่งเป็นสตริงเดียว

สินเชื่อพิเศษ

หากปัญหาเปลี่ยนไปทางซ้ายแทนที่จะเป็นขวาเราสามารถทำได้โดยใช้การมอบหมายหลายอย่าง โดยพื้นฐานแล้ว "หากค่าการมอบหมายมีองค์ประกอบมากกว่าตัวแปรค่าที่เหลือทั้งหมดจะถูกกำหนดให้กับตัวแปรสุดท้าย"

ในสาระสำคัญนี้หมายถึงสิ่งที่ชอบ$c=@(1,2,3)และ$a,$b=$c
จะมี$a=1int และ$b=@(2,3)อาร์เรย์

PowerShell 90 ไบต์ทำการเลื่อนซ้ายแทนการกะขวา

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

ที่นี่เราป้อนข้อมูลอีกครั้งและตั้งค่า$bตามด้านบน เรานำแสดง$aโดยเป็นอักขระอาร์เรย์อีกครั้งจากนั้นป้อนforลูปเดียวกันกับด้านบน อย่างไรก็ตามในเวลานี้เราไม่จำเป็นต้องสนับสนุนการลบ / การแทรกโดยพลการดังนั้นเราจึงไม่จำเป็นต้องใช้[System.Collections.ArrayList]วัตถุที่มีราคาแพงหรือวิธีการโทรที่มีราคาแพง แต่เราก็ตั้ง$rให้เป็นองค์ประกอบแรกของ$aและองค์ประกอบที่เหลือจะถูก $are-บันทึกไว้ใน จากนั้นเรา+=จะตะปูมันกลับไปยังจุดสิ้นสุด

(ดังที่ฉันบอกว่า PowerShell arrays นั้นไม่เปลี่ยนรูปแบบทางเทคนิค แต่ตัว+=ดำเนินการที่นี่มีการใช้งานมากเกินไป - มันต้องใช้อาร์เรย์และวัตถุอื่นรวมเข้าด้วยกัน (ศัพท์ทางเทคนิค) เป็นอาร์เรย์ใหม่ส่งคืนและบันทึกเป็นชื่อตัวแปรและทำลาย อาเรย์ดั้งเดิมฟังก์ชั่นเราเพิ่งเพิ่มองค์ประกอบไปยังส่วนท้ายของอาเรย์ แต่ในทางเทคนิค (และจากมุมมองของหน่วยความจำ / ขยะล้างข้อมูลเป็นต้น) มันเป็นอาเรย์ใหม่เอี่ยม ถ้าอาร์เรย์มีขนาดใหญ่หรือซับซ้อน flipside คือเนื่องจากอาร์เรย์ไม่เปลี่ยนรูปทำดัชนีลงไปหรือทำซ้ำมากกว่านั้นมีราคาถูกมาก)

เอาต์พุตยังคงเป็นแอ็คชันเดียวกันโดยมี-joinข้อความสั่งให้เปลี่ยนเป็นสตริงเดี่ยว

อย่างจริงจัง 21 ไบต์

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

ลองออนไลน์!

คำเตือน: วิธีนี้ไม่มีประสิทธิภาพมากดังนั้นกรณีทดสอบที่ใหญ่กว่าจะหมดเวลากับ TIO ใช้ล่ามท้องถิ่น

คำอธิบาย:

,;;+'#@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

Mathematica, 69 ไบต์

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

ค้นหาลำดับของตัวเลขในถ้ามี 2 ดังนั้นคำสั่งของพวกเขาจะต้องกลับรายการ ต่อสตริง (หากเป็นเพียงสตริงเดียวเท่านั้นก็จะส่งคืนสตริงตัวเลข) แปลงสตริงเป็นตัวเลขและหมุนสตริงที่จำนวนครั้ง

Pyth, 22 14 ไบต์

.>zs-.<zxz\#\#

ลองที่นี่!

คำอธิบาย

.> zs -. <zxz \ # \ # # z = อินพุต

     . <z # หมุน z ไปทางซ้าย
        xz \ # # ดัชนีของการเกิดแฮชครั้งแรก
                  # สิ่งนี้ทำให้มั่นใจได้ว่าจำนวนเต็มจะไม่ถูกพันรอบท้าย
    - \ # # กรองทั้งหมด hash out
   s # cast เป็นจำนวนเต็มยังลบศูนย์นำหน้าด้วย
.> z # ทำการ roation สุดท้ายของสตริงป้อนเข้าและพิมพ์

วิธีนี้ใช้ได้ผลกับการทดสอบทั้งหมดและเกือบจะเสร็จสิ้นในทันทีสำหรับตัวเลขจำนวนมาก

JavaScript (ES6) 66

ครั้งหนึ่งการลบ%จาวาสคริปต์สำหรับตัวเลขติดลบนั้นมีประโยชน์

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

Pyth, 10 ไบต์

.>zss_cz\#

ลองออนไลน์ ชุดทดสอบ

นี้เป็นคำแปลของเดนนิสคำตอบ CJam ฉันทำมันเป็นวิกิชุมชนเพราะฉันไม่ได้ทำมัน

คำอธิบาย

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

JavaScript (ES6), 67 64 ไบต์

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

อีกพอร์ตของคำตอบ CJam ของเดนนิส

แก้ไข: บันทึก 3 ไบต์โดยการแบ่งส่วนของคำตอบของ edc65 ที่เขาไม่ได้สนใจ

Perl 5, 41 ไบต์

39 ไบต์บวกสองค่าสำหรับ-lFแฟล็ก ( -M5.01ฟรี):perl -lF -M5.01 script.pl

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

คำอธิบาย:

• -lFอ่านอินพุตเอาขึ้นบรรทัดใหม่ทำให้เหลือเป็นสตริงที่แยกมันออกเป็นตัวอักษรและทำให้ที่แยกออกเป็นอาร์เรย์$_@F
• /#+/ค้นหาสตริงแรกของ#s $_และตั้ง$`ค่าเท่ากับสิ่งของก่อนหน้าและ$'เท่ากับสิ่งของหลังจากนั้น ถ้า$`เป็นที่ว่างเปล่าจากนั้น$'อาจจะมีมากขึ้น#s อย่างไรก็ตาม$'.$`เป็นสตริงที่มีสตริงย่อยเริ่มต้นคือจำนวนครั้งในการหมุนอาร์เรย์
• ตอนนี้เราสร้างรายการ1..$'.$`ซึ่งถือว่า$'.$`เป็นจำนวนเต็มและทำให้เป็นโมฆะมันซึ่งแถบ#s สุดท้ายใด ๆดังนั้นรายการจะมาจาก1จำนวนครั้งที่จะหมุนอาร์เรย์
• สำหรับแต่ละองค์ประกอบในรายการนั้นเราจะหมุนอาร์เรย์ ( popองค์ประกอบสุดท้ายและunshiftไปยังจุดเริ่มต้น)
• จากนั้นsayองค์ประกอบทั้งหมดของอาร์เรย์ที่หมุน

ทับทิม - 68 72 70 ไบต์

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

• split แปลงสตริงเป็นอาร์เรย์
• (s+s).scan(/\d+/) เชื่อมสตริงเข้ากับตัวเองและรับอาเรย์ของตัวเลข (เป็นสตริง)
• map(&:to_i) แปลงสตริงเป็น ints
• max เลือก int ที่ใหญ่ที่สุด
• rotate max ครั้ง
• *""แปลงอาร์เรย์กลับเป็นสตริง (ชวเลขสำหรับjoin)

การใช้งาน: ruby scriptname.rb "[string]"

05AB1E , 14 13 ไบต์

รหัสไม่น่าจะยุติได้สำหรับตัวเลขที่ใหญ่กว่า 100,000 แต่ถ้าคุณอดทนพอจะมีผลลัพธ์ :) รหัส:

'#¡rJ¹sF¤rS\J

คำอธิบาย:

'#¡             # 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

ลองออนไลน์!

ใช้การเข้ารหัสCP-1252

VBSCRIPT, 82 99 BYTES

รหัสก่อนหน้านี้ไม่ได้จัดการกับกรณีที่มีตัวเลขล้อมรอบ

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)

UNGOLFED

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

อันนี้ห่วย ... อาจมีวิธีที่ดีกว่าที่จะทำแม้ใน VBscript

Mathematica, 73 58 ไบต์

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

ไบต์เยอะ 15 ไบต์ บันทึก ขอบคุณ ไป IPoiler

Matlab (73)

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

• นี่ใช้วิธีอื่นที่ฉันสงสัยว่า @luis ใช้หรือเปล่าเพราะอ้างอิงจากคำอธิบายของเขามีบางจุดที่เหมือนกันในขณะที่ (un) โชคดีที่ฉันไม่เข้าใจภาษา Matl ที่ถูกครอบตัด

matlab (86) 72

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

• ฟังก์ชั่นรวมสตริงสองครั้งครั้งหนึ่งสำหรับการแยกจำนวนเต็มอันดับที่สองสำหรับงานที่ต้องการมันไม่ใช้เวลามากเกินไปเพราะ matlab ดำเนินการหมุนตาม(Dim)modulus(Length)ข้อยกเว้นว่าการแบ่งกลุ่มล้มเหลวสำหรับช่วงที่ใหญ่กว่า

• จะต้องดิ้นรนมากแค่ไหนในการตีกอล์ฟ ....

(86)

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

• ความแตกต่างระหว่างฟังก์ชั่นนี้กับหน้าที่ก่อนหน้านี้สิ่งนี้เชื่อมต่อกันสองเหตุการณ์ที่เกิดขึ้นจากจำนวนเต็มไปทางด้านหลังในขณะที่คนแรกแค่หมุนมัน