Görev

Bu basit bir meydan okumadır. Girişiniz, yalnızca rakam 0123456789ve kareleri içeren boş olmayan tek bir dizedir #. Negatif olmayan bir tamsayı kodlayan ve dizenin sonuna dolanabilecek en az bir rakam dizisi içerecektir #. Tamsayı önde gelen sıfırlara sahip olabilir. Örneğin, ##44##, 013####ve 23###1geçerli girişler, süre ###, 0099ve #4#4değildir.

Senin görevin tamsayı ndizeden çıkarmak ve dizilen nadımları sağa döndürmek .

Örnekler

• Giriş #1##, 1 adım sağa döndürülmelidir, bu nedenle doğru çıktı ##1#.
• #026###Öndeki 0 dikkate alınmadığından, giriş 26 adım sağa döndürülmelidir. Doğru çıktı 26####0.
• Giriş 1####2, sonuna kadar sarılmış tamsayı 21'i içerir, bu nedenle 21 adım sağa döndürülmelidir. Doğru çıktı ##21##.

Kurallar ve puanlama

Tam bir program veya bir fonksiyon yazabilirsiniz. En düşük bayt sayısı kazanır ve standart boşluklar izin verilmez.

Sayının , dilinizin nstandart inttipine uygun olduğunu varsayabilirsiniz . Tersine, eğer bu standart inttip isteğe bağlı tam sayılar uygularsa, (teoride) isteğe bağlı olarak büyük olanı desteklemelisiniz n.

Test durumları

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

q_'#%W%sim>

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Bunun son iki test durumu için işe yaramayacağına dikkat edin, çünkü ilgili sayılar 64 bite uymuyor.

Nasıl çalışır

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 bayt

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

Bu bir dizgeyi kabul eden ve bir dize döndüren isimsiz bir işlevdir. Aramak için değişkene atayın.

Girdiyi kendine ekler, #ayırıcı olarak bir diziye böleriz, her bir tamsayıyı ayrıştırır ve azami değeri alırız. Bu, dizgeyi sağa kaydırmamızın sayısını tanımlar. CharDiziyi bir diziye, vardiyaya ve joinbirlikte geri döndürdük.

Python, 66 bayt

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
<Boşluk>

Martin sayesinde 8 byte kurtarıldı!

Çevrimiçi Deneyin!

Bunun, çevrimiçi olan çok büyük test senaryoları için ve çoğu aklı başında bulunan makinelerde, bazı büyükler için zaman aşımına uğradığını / tükeneceğini unutmayın.

Bu, dizedeki son sayıyı ve dizedeki ilk sayıyı ya da sayıyı almaz ve dizenin önüne koyar. Sonra bu birleşik sayıyı birleşik bir sayıya çevirir ve art arda döner.

Jöle, 12 10 bayt

ẋ2~ṣ0‘ḌṂṙ@

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Arka fon

Girişin dediğini söyle 51379#97.

Dizeyi iki kez tekrarlayarak ( 51379#9751379#97), sayının bitişik gösterimini içerdiğinden emin olabiliriz.

Daha sonra, tüm karakterlere bitsel olarak NOT uygularız. Böylece int döküm Bu denemeler, '1' için değerlendirilir alır 1 , daha sonra eşlenmiş ~ 1 = -2 . Başarısızlıkta ( #), 0 döndürür .

Örneğimiz için bu verir

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

Ardından, numarayı kodlayan kısmı diğerlerinden ayırmak için sıfıra böleriz.

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

Bit tarzı DEĞİL haritalar n için -n - 1 , Edinmemiz her artırır böylece -n .

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

Daha sonra, her listeyi 10 tabanından tam sayıya dönüştürürüz.

[-51379, -9751379, -97]

En düşük sayı, aradığımızın negatifi. Jöle listesi döndürme atomu solaṙ döndüğü için, sağa döndürmek için -1 ile çarpmaktan kaçının .

Nasıl çalışır

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

!G1Y4XXPZcXvUYS!

8 bayt daha az ödünç alıyor Dennis'in diziyi bölme ve parçaların sırasını tersine çevirme fikri

Son iki test durumu işe yaramıyor çünkü sayı çok büyük.

EDIT (20 Mayıs 2016) Bağlantıdaki kod , dilde yapılan son değişiklikler nedeniyle Xzyerine kullanılır Xv.

Çevrimiçi deneyin!

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

_{(Ancak aşağıdaki Ekstra Kredi bölümüne bakın)}

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, bir diziyi "değiştirme" kavramına sahip olmadığı için kendi çözümümü devirmek zorunda kaldım. Daha büyük sayılar için uzun zaman alacaktır , ancak sonunda 32 bitlik bir int'e uyan her şeyi tamamlamalıdır.

Girdiyi alır $ave yeni bir değişkeni [System.Collections.ArrayList] nesnesi $dolarak ayarlar . Teknik olarak, PowerShell'deki diziler değişmez olduğu için _{(aşağıda Ekstra} Kredi'de _{açıklanmaktadır)} ve bu nedenle, kaydırma için gereken keyfi eklemeleri veya çıkarmaları desteklemediğinden yapılır. Sonra bir döngüye giriyoruz .for

İlk koşul, bulduğum bir hiledir - eğer girdiyi bir araya getirirsek, bölüştürür #ve boşları yok sayarsak, sonuçtaki dizinin ikinci elemanı, sarmadan bağımsız olarak numaramıza eşit olacaktır. Bunu ayarladık $bve $bsıfıra kadar her seferinde azalttık .

Her yinelemede, $rarraististeki son eleman olarak yardımcı ayarlıyoruz , bu son elemanı çıkarıyoruz ve sonra elemanı öne doğru yerleştiriyoruz ... diziyi bir eleman tarafından sağa "kaydırıyor".

Sonunda, sadece -join$dbir dizge ile bir araya getirilmesi için çıktılar .

Ekstra kredi

Sorun dizisi kayması ise sol yerine sağ , kullandığımız önemli ölçüde daha kısa yapabilir çoklu atama . Temel olarak, "Atama değeri değişkenlerden daha fazla öğe içeriyorsa, kalan tüm değerler son değişkene atanır."

Özünde, bu bir şey $c=@(1,2,3)ve bir int ve bir dizi $a,$b=$c
sahip olacak anlamına gelir .$a=1$b=@(2,3)

PowerShell, 90 bayt, sağa kaydırma yerine sola kaydırma yapar

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

Burada bir kez daha girdi ve $byukarıdaki gibi ayarladık . $aBir karakter dizisi olarak yeniden yayınladık ve sonra foryukarıdakiyle aynı döngüye girdik. Bu sefer, keyfi çıkarmayı / eklemeyi desteklememize gerek olmadığından, pahalı [System.Collections.ArrayList]nesneyi ve pahalı yöntem çağrılarını kullanmamıza gerek kalmadı . Bunun yerine $r, ilk eleman olarak belirledik $ave geri kalan elemanlar yeniden kaydedildi $a. Sonra +=tekrar başa çıkacağız.

(Dediğim gibi, PowerShell dizileri teknik olarak değişkendir, ancak buradaki +=operatör aşırı yüklenmiştir - bir dizi ve başka bir nesneyi alır, onları bir araya getirir (teknik terim) yeni bir diziye yerleştirir, onu döndürür ve değişken adı olarak kaydeder ve yok eder Orijinal dizi: İşlevsel olarak, dizinin sonuna bir öğe ekledik, ancak teknik olarak (ve bir bellek / çöp temizleme perspektifinden vb.) yepyeni bir dizi. dizi büyük ya da karmaşıksa, flipside, diziler değişmez olduğu için, bunlara endekslenmesi ya da yinelenmesi çok ucuz olmasıdır.)

Çıktı aynı eylem olarak kalır, -jointek bir dizgeye dönüşecek bir ifade ile.

Cidden, 21 bayt

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

Çevrimiçi deneyin!

Uyarı: bu çözüm çok yetersizdir, bu nedenle daha büyük test senaryoları TIO'da zaman aşımına uğrar. Yerel tercümanı kullanın.

Açıklama:

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

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

Sayıların sırasını bulun, eğer 2 varsa, sıralarının tersine çevrilmesi gerekir. Dizeleri birleştirir (yalnızca bir tanesi sadece sayı dizesini döndürür). Dize sayısal olarak dönüştürün ve dizeyi bu sayı kadar döndürün.

Pyth, 22 14 bayt

.>zs-.<zxz\#\#

Burada dene!

açıklama

.> zs -. <zxz \ # \ # # z = giriş

     . <z # z ile sola dönün
        bir karma değerin ilk oluşumunun xz \ # # dizini
                  # bu, tamsayının sonuna dolanmamasını sağlar
    - \ # # tüm karmaları süzer
   s # bir tamsayıya dönüştürür, ayrıca baştaki sıfırları da kaldırır
.> z # giriş dizesinin son rotasyonunu yapın ve yazdırın

Bu, tüm test senaryoları için işe yarar ve aynı zamanda timsahlar çok büyük sayılar için anında bitirir.

JavaScript (ES6) 66

Bir kereliğine, %negatif sayılar için javascript’in aptal negatifi faydalı

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

Pyth, 10 bayt

.>zss_cz\#

Çevrimiçi deneyin. Test odası.

Bu Dennis'in CJam cevabının bir çevirisidir . Bunu bir topluluk wiki yapıyorum çünkü gelmedim.

açıklama

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

JavaScript (ES6), 67 64 bayt

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

Dennis'in CJam'ın cevabını başka bir liman.

Düzenleme: edc65'in cevabına dikkat çekmediği kısmına uygun olarak 3 bayt kurtardı.

Perl 5, 41 bayt

-lFBayraklar için 39 bayt artı iki ( -M5.01ücretsiz):perl -lF -M5.01 script.pl

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

Açıklama:

• -lFgirdiyi okur, izleyen yeni satırı kaldırır, geri kalanı dizeye $_koyar, karakterlere böler ve diziye bölünen koyar @F.
• /#+/ilk #s dizesini bulur ve ondan önceki öğelere eşit $_ve bundan sonraki öğelere $`eşit olarak ayarlar $'. Eğer $`boş sonra $'birkaçını içerebilir #s. Ancak, $'.$`başlangıç ​​alt dizgisi diziyi döndürme sayısı olan bir dizedir.
• Şimdi bir tamsayı gibi 1..$'.$`davranan $'.$`ve böylece herhangi bir finali soran #listeyi oluşturuyoruz, bu yüzden liste 1diziyi döndürmek için gereken sayıda.
• Bu listedeki her öğe için diziyi döndürürüz ( popson öğe ve unshiftbaşlangıcı).
• Sonra saydöndürülmüş dizinin tüm elemanları.

Ruby - 68 72 70 bayt

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

• split dizeyi diziye dönüştürür
• (s+s).scan(/\d+/) dizeyi kendine birleştirmek ve bir sayı dizisi almak (dizge olarak)
• map(&:to_i) dizeleri sayılara dönüştür
• max en büyük int'yi seç
• rotate max zamanlar
• *""bir dizeye dizi geri dönüştürmek (kısaltmasıdır join)

Kullanım: ruby scriptname.rb "[string]"

05AB1E , 14 13 bayt

Eh, kod 100000'den büyük sayılar için sonlandırmak pek mümkün değildir, ancak yeterince sabırlı iseniz, bir çıktı olacaktır :). Kod:

'#¡rJ¹sF¤rS\J

Açıklama:

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

Çevrimiçi deneyin!

CP-1252 kodlamasını kullanır

VBSCRIPT, 82 99 BYTES

önceki kod, sayı sonuna kadar sarılmış durumları işlemedi

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

Bu tür berbat ... muhtemelen bunu yapmak için daha iyi bir yol var, VBscript bile

Mathematica, 73 58 bayt

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

Çok bayt. 15 bayt kaydedilen sayesinde hiç IPoiler

Matlab (73)

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

• Bu, @luis kullanıp kullanmadığını merak ettiğim başka bir yaklaşım kullanıyor, çünkü onun açıklamasına atıfta bulunulan bazı ortak noktalar var (un)? Neyse ki kırpılmış Matl dilini anlamıyorum.

matlab (86) 72

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

• İşlev, dizgeyi iki kez, bir kez tamsayı çıkarma için, istenen görev için ikinciye çevirir, çok uzun sürmez çünkü matlab (Dim)modulus(Length), daha büyük aralıklar için segmentasyon arızasına düştüğü durumlar haricinde dönmeye devam eder .

• Nasıl daha fazla golf oynamak için mücadele edecek ...

(86)

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

• Bu işlev ile önceki işlev arasındaki fark, bu, tamsayıların iki uzak oluşumunu geriye doğru birleştirirken, birincisi onu döndürür.