Temukan dan putar

30

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
Zgarb
sumber
7
Apakah kita harus mendukung semua kasus uji? Beberapa dari angka-angka itu cukup besar ... Apakah menggunakan bahasa dengan bilangan bulat 8-bit dapat diterima?
Dennis
@ Dennis Ini mungkin untuk menyelesaikan tantangan dengan aritmatika modular tanpa benar-benar memuat integer ke dalam memori ... tapi Anda benar, ini merepotkan dalam banyak bahasa. Katakanlah Anda hanya perlu menangani test case yang nsesuai dengan intjenis asli bahasa Anda (yang mungkin presisi sewenang-wenang). Saya akan memperbarui teks tantangan nanti.
Zgarb
Apa yang harus kita lakukan jika input = 1234?
CalculatorFeline
2
@CatsAreFluffy "dan setidaknya satu #"
FryAmTheEggman

Jawaban:

10

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.
Dennis
sumber
Oooh ... sangat sederhana!
Luis Mendo
7

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.

Alex A.
sumber
7

Python, 66 byte

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

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.

FryAmTheEggman
sumber
3

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.
Dennis
sumber
3

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
Luis Mendo
sumber
2

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.

AdmBorkBork
sumber
1

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
Mego
sumber
Concat dan take maksimal: ide bagus!
Luis Mendo
@LuisMendo Saya terhibur melihat jawaban Alex muncul dengan strategi yang sama ketika saya menulis penjelasannya di sini.
Mego
Sepertinya satu-satunya yang awalnya menggunakan pendekatan naif adalah saya :-) (memutar string awal sampai semua digit bersebelahan)
Luis Mendo
1

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.

IPoiler
sumber
FromDigitsbekerja bukan ToExpression.
CalculatorFeline
1

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.

Denker
sumber
Anda dapat melakukan -...\#bukan h:..."\d+"1. Juga, tidak perlu mengkonversi zke daftar karakter, .>berfungsi juga pada string.
Jakube
@ Jakube Terima kasih atas petunjuknya, cukup lelah ketika saya melakukan ini. ^^
Denker
1

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)
edc65
sumber
1
@WashingtonGuedes tidak, jumlah dalam b+aadalah rangkaian string. a='32',b='1', (b?b+a:a)=='132', (b|0+a)==33
edc65
1

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
Pietu1998
sumber
1

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.

Neil
sumber
Dengan menggunakan ternary dan penjumlahan alih-alih mundur ()
.gabung
@Downgoat Maaf, saya mendapatkan mereka sebagian besar belakangan ini, tetapi saya melakukan ini larut malam sehingga saya tidak berpikir jernih.
Neil
@ edc65 Tidak, itu membuat skor saya lebih tinggi. Jadi saya menyalin s+strik itu sebagai gantinya. (Saya benar-benar memikirkannya tadi malam tapi saya terlalu lelah untuk mencobanya saat itu.)
Neil
1

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.
msh210
sumber
1

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

FuzzyTree
sumber
saya baru disini. apa etiket mengirim beberapa jawaban dalam berbagai bahasa? Saya menambahkan jawaban terpisah kalau-kalau salah. jika tidak apa-apa menambahkan beberapa jawaban, beri tahu saya dan saya akan menghapusnya
FuzzyTree
1
Beberapa jawaban dalam berbagai bahasa baik-baik saja, bahkan dianjurkan (asalkan semuanya benar).
Zgarb
0

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

Adnan
sumber
0

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

Traceur
sumber
Selamat datang di Programming Puzzles dan Code Golf Stack Exchange. Jawaban ini dapat ditingkatkan dengan menambahkan rincian kode dan penjelasan di bawah kode golf Anda. Juga, dapatkah Anda menyimpan byte dengan membuat fungsi alih-alih program, di mana ainput fungsi, dan mengembalikan output? Dengan begitu, Anda tidak perlu inputboxdan msgboxmenelepon.
wizzwizz4
Mengapa Anda perlu b?
CalculatorFeline
0

Mathematica, 73 58 byte

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

Banyak byte. 15 byte disimpan berkat untuk IPoiler

CalculatorFeline
sumber
StringRotateRightmenyimpan beberapa byte di sini.
IPoiler
0

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.
Abr001am
sumber
0

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.
Abr001am
sumber