Tugas

Ini adalah tantangan sederhana. Input Anda adalah string tunggal yang tidak kosong, hanya berisi digit 0123456789dan hash #. Ini akan berisi tepat satu putaran digit, yang mengkodekan integer nonnegatif dan mungkin membungkus ujung string, dan setidaknya satu #. Bilangan bulat mungkin memiliki angka nol di depan. Sebagai contoh, ##44##, 013####dan 23###1merupakan input yang valid, sementara ###, 0099dan #4#4tidak.

Tugas Anda adalah mengekstrak integer ndari string, dan mengeluarkan string yang diputar nke kanan.

Contohnya

• Input #1##harus diputar 1 langkah ke kanan, sehingga output yang benar adalah ##1#.
• Input #026###harus diputar 26 langkah ke kanan, karena awalan 0 diabaikan. Output yang benar adalah 26####0.
• Input 1####2berisi bilangan bulat 21 yang dibungkus ujungnya, sehingga harus diputar 21 langkah ke kanan. Output yang benar adalah ##21##.

Aturan dan penilaian

Anda dapat menulis program atau fungsi lengkap. Hitungan byte terendah menang, dan celah standar tidak diizinkan.

Anda dapat menganggap bahwa nomor tersebut nsesuai dengan intjenis standar bahasa Anda. Sebaliknya, jika inttipe standar itu mengimplementasikan bilangan bulat presisi arbitrer, Anda harus mendukung (secara teori) besar sembarang n.

Uji kasus

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

Cobalah online! atau verifikasi semua kasus uji .

Perhatikan bahwa ini tidak akan berfungsi untuk dua kasus uji terakhir, karena angka yang terlibat tidak masuk ke dalam 64 bit.

Bagaimana itu bekerja

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

Ini adalah fungsi anonim yang menerima string dan mengembalikan string. Untuk menyebutnya, tetapkan ke variabel.

Kami menambahkan input ke dirinya sendiri, membaginya menjadi array dengan #sebagai pemisah, parsing setiap integer, dan ambil yang maksimal. Ini menentukan berapa kali kita menggeser string ke kanan. Kami memerciki string menjadi Chararray, bergeser, dan joinkembali bersama.

Python, 66 byte

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

Retina, 65 57 49

(\ d *) # * (\ d +)
$ 2 $ 1 $ 0
^ \ d +
$ *
+ `1 (. *) (.)
 $ 2 $ 1
<spasi>

Disimpan 8 byte berkat Martin!

Cobalah secara Online!

Perhatikan bahwa ini akan kehabisan / kehabisan memori untuk kasus uji yang sangat besar secara online, dan pada sebagian besar mesin waras, untuk beberapa yang lebih besar.

Ini mengambil angka terakhir dalam string dan angka pertama atau tidak ada dalam string dan menempatkannya di depan string. Kemudian mengkonversi angka gabungan menjadi unary dan berulang kali berputar sambil menjatuhkan digit unary.

Jelly, 12 10 byte

ẋ2~ṣ0‘ḌṂṙ@

Cobalah online! atau verifikasi semua kasus uji .

Latar Belakang

Katakan inputnya 51379#97.

Dengan mengulangi string dua kali ( 51379#9751379#97), kita dapat memastikan bahwa itu akan berisi representasi angka yang berdekatan.

Selanjutnya, kami menerapkan bitwise TIDAK untuk semua karakter. Ini mencoba untuk melemparkan ke int, jadi '1' akan dievaluasi menjadi 1 , lalu dipetakan ke ~ 1 = -2 . Pada kegagalan ( #), ia mengembalikan 0 .

Sebagai contoh kita, ini memberi

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

Selanjutnya, kami membagi pada nol untuk memisahkan bagian yang menyandikan nomor dari yang lain.

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

Bitwise TIDAK memetakan n ke -n - 1 , jadi kami menambah masing-masing untuk mendapatkan -n .

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

Selanjutnya, kami mengonversi setiap daftar dari basis 10 ke integer.

[-51379, -9751379, -97]

Angka terendah adalah negatif dari yang kita cari. Karena atom rotasi daftar jeli ṙberputar ke kiri , ini menghindari perkalian dengan -1 untuk memutar ke kanan.

Bagaimana itu bekerja

ẋ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!

8 byte kurang meminjam ide Dennis untuk memisahkan array dan membalik urutan potongan

Dua test case terakhir tidak berfungsi karena angkanya terlalu besar.

EDIT (20 Mei 2016) Kode dalam tautan menggunakan Xzalih-alih Xv, karena perubahan bahasa terbaru.

Cobalah online!

!         % 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

_{(Tetapi lihat bagian Kredit Ekstra, di bawah)}

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 tidak memiliki konsep "menggeser" array, jadi saya harus memutar solusi saya sendiri. Akan membutuhkan waktu lama untuk angka yang lebih besar, tetapi pada akhirnya harus menyelesaikan apa pun yang cocok dengan int 32-bit.

Mengambil input $a , dan menetapkan variabel baru $dsebagai objek [System.Collections.ArrayList] . Ini dilakukan karena, secara teknis, array di PowerShell tidak dapat diubah _{(dijelaskan lebih lanjut di bawah dalam Kredit Tambahan)} , dan karenanya tidak mendukung penyisipan atau pemindahan yang sewenang-wenang, yang diperlukan untuk pengalihan. Lalu, kita masukkan satu forlingkaran.

Kondisi awal adalah trik yang saya temukan - jika kita menggabungkan input bersama, membagi #, dan mengabaikan kosong, elemen kedua dari array yang dihasilkan akan sama dengan nomor kita, terlepas dari pembungkusnya. Kami atur itu $b, dan kurangi $bsetiap kali hingga nol.

Setiap iterasi, kami menetapkan helper $rsebagai elemen terakhir dalam daftar array, menghapus elemen terakhir, dan kemudian memasukkan elemen ke depan ... secara efektif "menggeser" array ke kanan dengan satu elemen.

Akhirnya, kami cukup mengeluarkan dengan -join$dsehingga disatukan menjadi satu string.

Kredit tambahan

Jika masalahnya adalah menggeser array ke kiri dan bukan ke kanan , kita dapat melakukannya secara signifikan menggunakan lebih pendek banyak penugasan . Pada dasarnya, "Jika nilai penugasan berisi lebih banyak elemen daripada variabel, semua nilai yang tersisa ditugaskan ke variabel terakhir."

Intinya, ini berarti sesuatu seperti $c=@(1,2,3)dan $a,$b=$c
akan memiliki $a=1int dan$b=@(2,3) array.

PowerShell, 90 byte, melakukan shift kiri dan bukannya shift kanan

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

Di sini kita sekali lagi mengambil input, dan mengatur $bseperti di atas. Kami melemparkan kembali $asebagai array char, dan kemudian masukkan forloop yang sama seperti di atas. Namun, kali ini, kami tidak perlu mendukung penghapusan / penyisipan sewenang-wenang, jadi kami tidak perlu menggunakan [System.Collections.ArrayList]objek yang mahal , maupun metode yang mahal. Alih-alih, kami hanya mengatur $runtuk menjadi elemen pertama $a, dan elemen lainnya disimpan kembali $a. Lalu kita +=kembalikan ke akhir.

(Seperti yang saya katakan, array PowerShell secara teknis tidak dapat diubah, tetapi += operator di sini kelebihan beban - dibutuhkan sebuah array dan objek lain, menggabungkan keduanya (istilah teknis) ke dalam array baru, mengembalikannya dan menyimpannya sebagai nama variabel, dan menghancurkannya array asli. Secara fungsional, kami baru saja menambahkan elemen ke akhir array, tetapi secara teknis (dan dari perspektif memori / sampah-pembersihan, dll) itu adalah array baru. Ini jelas dapat menjadi operasi yang mahal jika array berukuran besar atau kompleks, flipside adalah itu, karena array tidak dapat diubah, pengindeksan ke dalam array atau iterasi di atasnya sangat murah.)

Output tetap aksi yang sama, dengan -joinpernyataan untuk mengubahnya menjadi string tunggal.

Serius, 21 byte

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

Cobalah online!

Peringatan: solusi ini sangat tidak efisien, sehingga kasus uji yang lebih besar akan habis pada TIO. Gunakan penerjemah lokal.

Penjelasan:

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

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

Temukan urutan angka dalam, jika ada 2 maka urutannya perlu dibalik. Menggabungkan string (jika hanya satu itu hanya mengembalikan string angka). Ubah string menjadi numerik dan putar string tersebut beberapa kali.

Pyth, 22 14 byte

.>zs-.<zxz\#\#

Coba di sini!

Penjelasan

.> zs -. <zxz \ # \ # # z = input

     . <z # putar z ke kiri oleh
        xz \ # # indeks kemunculan pertama hash
                  # ini memastikan bahwa bilangan bulat tidak melilit ujungnya
    - \ # # filter semua hash keluar
   s # dilemparkan ke integer, juga menghilangkan angka nol di depan
.> z # lakukan roation akhir dari string input dan cetaklah

Ini berfungsi untuk semua testcases dan juga hampir selesai secara instan untuk angka yang sangat besar.

JavaScript (ES6) 66

Untuk sekali ini, %javascript negatif bodoh untuk angka negatif berguna

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

Pyth, 10 byte

.>zss_cz\#

Cobalah online. Suite uji.

Ini adalah terjemahan dari jawaban Dennis 'CJam . Saya menjadikannya wiki komunitas, karena saya tidak memunculkannya.

Penjelasan

      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)

Port lain dari jawaban Dennis CJam.

Sunting: Disimpan 3 byte dengan menggunakan bagian jawaban edc65 yang tidak menarik perhatiannya.

Perl 5, 41 byte

39 byte plus dua untuk -lFbendera ( -M5.01gratis):perl -lF -M5.01 script.pl

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

Penjelasan:

• -lFmembaca input, menghapus baris baru, memasukkan sisanya ke dalam string $_, membaginya menjadi karakter, dan menempatkan yang terbagi ke dalam array@F .
• /#+/menemukan string pertama #dalam $_dan set $`sama dengan barang sebelumnya dan $'sama dengan barang setelahnya. Jika $`kosong maka $'mungkin mengandung lebih banyak# s. Namun, $'.$`adalah string yang substring awalnya adalah berapa kali untuk memutar array.
• Sekarang kita membangun daftar 1..$'.$`, yang memperlakukan $'.$`sebagai bilangan bulat dan dengan demikian menjumlahkannya, yang menghapus final# , jadi daftar adalah dari 1berapa kali untuk memutar array.
• Untuk setiap elemen dalam daftar itu, kami memutar array (pop elemen terakhir danunshift itu ke awal).
• Kemudian saysemua elemen dari array yang diputar.

Ruby - 68 72 70 byte

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

• split mengubah string menjadi array
• (s+s).scan(/\d+/) merangkai string ke dirinya sendiri dan mendapatkan array angka (sebagai string)
• map(&:to_i) mengkonversi string ke ints
• max pilih int terbesar
• rotate max waktu
• *""mengubah array kembali menjadi string (singkatan untuk join)

Penggunaan: ruby scriptname.rb "[string]"

05AB1E , 14 13 byte

Yah, kodenya sangat tidak mungkin untuk diakhiri untuk angka yang lebih besar dari 100000, tetapi jika Anda cukup sabar, akan ada output :). Kode:

'#¡rJ¹sF¤rS\J

Penjelasan:

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

Cobalah online!

Menggunakan pengodean CP-1252

VBSCRIPT, 82 99 BYTES

kode sebelumnya tidak menangani kasus dengan nomor dibungkus ujung

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

ini agak menyebalkan ... mungkin ada cara yang lebih baik untuk melakukannya, bahkan dalam VBscript

Mathematica, 73 58 byte

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

Banyak byte. 15 byte disimpan berkat untuk IPoiler

Matlab (73)

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

• Ini menggunakan pendekatan lain yang saya bertanya-tanya apakah @luis menggunakannya, karena merujuk pada deskripsinya ada beberapa poin yang sama (un)? Untungnya saya tidak mengerti bahasa Matl yang dipangkas.

matlab (86) 72

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

• Fungsi menjumlahkan string dua kali, sekali untuk ekstraksi bilangan bulat, kedua untuk tugas yang diinginkan, tidak membutuhkan terlalu banyak waktu karena matlab melanjutkan untuk memutar oleh (Dim)modulus(Length) pengecualian bahwa ia jatuh dalam kegagalan segmentasi untuk rentang yang lebih besar.

• Akan berjuang bagaimana golf itu lebih ....

(86)

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

• Perbedaan antara fungsi ini dan yang sebelumnya, yang satu ini memang menggabungkan dua kejadian bilangan bulat jauh ke belakang, sedangkan yang pertama hanya memutarnya.