タスク

これは簡単な挑戦です。入力は、数字0123456789とハッシュのみを含む単一の空ではない文字列#です。これには、非負の整数をエンコードし、文字列の終わりを囲む可能性のある1桁の数字と、少なくとも1桁が含まれます#。整数には先行ゼロが含まれる場合があります。たとえば、##44##、013####および23###1有効な入力、しばらくしている###、0099と#4#4はありません。

あなたの仕事はn、文字列から整数を抽出し、文字列をn右に回転させて出力することです。

例

• 入力#1##は右に1ステップ回転する必要があるため、正しい出力は##1#です。
• #026###先頭の0は無視されるため、入力は26ステップ右に回転する必要があります。正しい出力は26####0です。
• 入力1####2には最後に整数21がラップされているため、21ステップ右に回転する必要があります。正しい出力は##21##です。

ルールとスコアリング

完全なプログラムまたは関数を作成できます。最小のバイトカウントが優先され、標準の抜け穴は許可されません。

あなたは、その数があなたの言語のn標準的なintタイプに適合すると仮定することができます。逆に、その標準int型が任意精度の整数を実装する場合、（理論上）任意の大きなをサポートする必要があります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​​ビットに収まらないため、これは最後の2つのテストケースでは機能しないことに注意してください。

使い方

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.

ジュリア、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
<スペース>

Martinのおかげで8バイト節約されました！

オンラインでお試しください！

これは、非常に大規模なオンラインのテストケース、および一部の大規模なテストケースでは、タイムアウト/メモリ不足になることに注意してください。

これは、文字列の最後の数字と文字列の最初の数字または数字なしを取り、それらを文字列の前に置きます。次に、その結​​合数を単項に変換し、単項数字をドロップしながら繰り返し回転します。

ゼリー、12 10バイト

ẋ2~ṣ0‘ḌṂṙ@

オンラインでお試しください！または、すべてのテストケースを確認します。

バックグラウンド

入力がであるとし51379#97ます。

文字列を2回（51379#9751379#97）繰り返すことで、数字の連続した表現が含まれることを確認できます。

次に、すべての文字にビット単位の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]]

ビット単位のNOTはnを-n-1にマッピングするため、それぞれをインクリメントして-nを取得します。

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

次に、各リストを基数10から整数に変換します。

[-51379, -9751379, -97]

最も小さい数は、検索しているものの負数です。Jellyリストの回転アトムṙは左に回転するため、右に回転するために-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バイト少ない

数が大きすぎるため、最後の2つのテストケースは機能しません。

編集（2016年5月20日）言語の最近の変更により、リンクのコードはの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には配列を「シフトする」という概念がないため、独自のソリューションを展開する必要がありました。かかる長いより多くの時間を、それは32ビットintに収まる最終的には完全に何もする必要があります。

入力を受け取り$a、新しい変数$dを[System.Collections.ArrayList]オブジェクトとして設定します。技術的には、PowerShellの配列は不変であり_{（以下の追加クレジットで説明します）}、シフトに必要な任意の挿入または削除をサポートしないため、これが行われます。次に、forループに入ります。

初期条件は私が見つけたトリックです-入力を連結し、分割し#、空を無視する場合、結果の配列の2番目の要素は、ラップに関係なく、数と等しくなります。これをに設定し$b、$bゼロになるまで毎回デクリメントします。

繰り返しごとに、ヘルパー$rをarraylistの最後の要素として設定し、その最後の要素を削除してから、その要素を前面に挿入します。配列を1要素だけ効果的に「シフト」します。

最後に、単にを出力し-join$dて、1つの文字列に連結します。

追加クレジット

問題が配列を右ではなく左にシフトしていた場合、複数の割り当てを使用して大幅に短くすることができます。基本的に、「代入値に変数よりも多くの要素が含まれている場合、残りの値はすべて最後の変数に割り当てられます。」

本質的には、このような何かを意味$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、上記のように設定します。$achar-arrayとして再キャストし、for上記と同じループに入ります。ただし、今回は、任意の削除/挿入をサポートする必要がないため、高価な[System.Collections.ArrayList]オブジェクトや高価なメソッド呼び出しを使用する必要はありません。代わりに$r、の最初の要素に設定するだけ$aで、残りの要素はに再保存され$aます。その後+=、最後までやり直します。

（私が言ったように、PowerShell配列は技術的に不変ですが、+=ここの演算子はオーバーロードされています-配列と別のオブジェクトを取り、それらをまとめて（技術用語）新しい配列にし、それを返して変数名として保存し、破棄します機能的には、配列の最後に要素を追加しただけですが、技術的に（およびメモリ/ガベージクリーンアップなどの観点から）それはまったく新しい配列です。これは明らかにコストのかかる操作になる可能性があります配列が大きいか複雑な場合。逆に、配列は不変であるため、配列へのインデックス付けや反復処理は非常に安価です。

出力は同じアクションのままで、-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がある場合、順序を逆にする必要があります。文字列を連結します（1つだけの場合は、数値文字列を返します）。文字列を数値に変換し、その回数だけ文字列を回転させます。

Pyth、22 14バイト

.>zs-.<zxz\#\#

ここで試してみてください！

説明

。> zs-。<zxz \＃\＃＃z = input

     。<z＃zを左に回転
        xz \＃＃ハッシュの最初の出現のインデックス
                  ＃これにより、整数が末尾をラップしないようになります
    -\＃＃すべてのハッシュをフィルタリングする
   s＃整数にキャストし、先行ゼロも削除します
。> z＃入力文字列の最終的なローテーションを行い、それを出力します

これはすべてのテストケースで機能し、非常に大きな数値でもほぼ瞬時に終了します。

JavaScript（ES6）66

一度、%負の数のjavascript の愚かなネガが役に立つ

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回答の別のポート。

編集：edc65の回答の一部に注意を向けなかったため、3バイトを節約しました。

Perl 5、41バイト

39バイトと-lFフラグ用の2つ（-M5.01無料）：perl -lF -M5.01 script.pl

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

説明：

• -lF入力を読み取り、末尾の改行を削除し、残りを文字列に入れ、$_それを文字に分割し、その分割を配列に入れ@Fます。
• /#+/#内のsの最初の文字列を検索し、その前のものとその後のものに等しい$_セットを設定します。場合は空で、その後、より含まれていてもよいのを。ただし、初期サブストリングが配列を回転させる回数であるストリングです。$`$'$`$'#$'.$`
• 次に、リストを作成します1..$'.$`。これは$'.$`整数として扱われ、そのために数値化し、最後#のs を取り除きます。そのため、リストはfromから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) 文字列をintに変換します
• max 最大の整数を選ぶ
• rotate max 回
• *""配列を文字列に戻します（略記join）

使用法 ： ruby scriptname.rb "[string]"

05AB1E、14 13バイト

さて、コードが100000を超える数で終了することはほとんどありませんが、十分な忍耐力があれば、出力があります:)。コード：

'#¡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 バイト

前のコードは、末尾に数字がラップされているケースを処理しませんでした

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)

無形

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がそれを使用しているかどうか疑問に思う別のアプローチを使用しています。

matlab （86） 72

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

• この関数は、文字列を2回トテートします。1回は整数抽出、2回目は目的のタスクです。matlabは(Dim)modulus(Length)より大きな範囲でセグメンテーションエラーに陥るという例外まで回転するため、あまり時間がかかりません。

• それをもっとゴルフする方法に苦労します。

（86）

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

• この関数と以前の関数との違いは、この関数は2つの離れた整数の出現を逆方向に連結しますが、最初の関数はそれを回転させるだけです。