これは私たちがロールする方法です

18

Pietはいくつかの理由で興味深いプログラミング言語です。今日は、1つの理由に注目します。ロールコマンドです。rollコマンドはもともとPostScriptからのもので、スタックを操作する強力な方法です。

rollコマンドは、スタックの上位2つの要素をポップし、それらをパラメーターとして使用します。最初の値をポップturnsし、2番目の値を呼び出しますdepth。深さnへのターンは、スタックの最上位の要素を取得し、スタック内のn番目の要素にし、その上の各要素を1つ上に移動します。turns 負の場合、これは反対方向に行われます。つまり、n番目の要素は上に移動し、他の要素は下に移動します。これは何abs(turns)度も繰り返されます。

チャレンジ

スタックを取り込んで、ロールの実行後にそのスタックを返すプログラムまたは関数を作成します。

ルール

  • 入力および出力は、リスト、配列、区切り文字付きの文字列、一度に1つの要素、またはその他の適切な形式で渡すことができます。出力は入力と同じ形式である必要があります。
  • depth 負になることはなく、スタックの長さを超えることはありません。
  • 入力スタックには常に少なくとも2つの要素が含まれます。
  • これはコードゴルフなので、各言語で最短の答えが勝ちます。そのため、私は答えを受け入れません。
  • 標準的な抜け穴は禁止されています。

テストケース

in:  out:
2    
4    
1    3
2    4
3    1
4    2
5    5
6    6

in:  out:
-2   
3
1    2
2    3
3    1

in:  out:
-42
0
1    1
2    2
3    3
4    4
5    5
code-golf  stack 
— マイク・ブファルデシ
ソース
2
各言語の最短回答が勝ち、それは[code-golf]の仕組みではありません。最短回答が勝ちます。限目。
— mbomb007
4
@ mbomb007 エヘン 何これについて
— クリストファー・
7
私は非常にこれはリック・ローリング伴わない方法でやったことに失望した
— クリストファー・
2
@ mbomb007タグの説明やメタのクイック検索では表示されないので、そうではないと思います。
— マイクブファルデチ
2
@ mbomb007あなたが私にそれを変えて欲しいなら、「あなたは間違っていて、私は正しい」と何度も何度も言う以外のある種の議論を提供してください。これには先例がありますが、却下しましたが、チャレンジには勝者が1人だけ必要であるとか、回答を受け入れる必要があるとは言いません。
— マイクブファルデチ

回答:

8

Haskell、64 62バイト

編集：-2バイト：@xnorは私が間違っていると思っていたものを見ました。

rのリストをInt取り返します。

r(t:d:l)|d<1=l|(x,y)<-d%l,(z,w)<-mod t d%x=w++z++y
(%)=splitAt

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

splitAt n lリストを分割lしたインデックスにn、mod除算の余りを計算++を連結リストを。

— オルジャン・ヨハンセン
ソース
1
(%)=splitAt中置を定義することで2バイトを削減できると思います。
— -xnor
@xnorああ、私は何とかその仕事ではないだろう自分自身を納得させていた
— Ørjanヨハンセン
8

JavaScript（ES6）、49 47バイト

(t,d,...a)=>a.splice(t=(t%d+d)%d,d-t).concat(a)

編集：@Shaggyのおかげで、スタック要素を個別のパラメーターとして使用して2バイトを節約しました。説明：

  • ターンが深さの倍数である場合、何も起こりません。したがって、最初のステップは、回転モジュロ深度を計算することです。JavaScriptは剰余の計算方法しか知らないため、2つのステップでこれを行う必要があります。
  • を回すと1、一番上の要素が要素に移動しdepthます。回転により2、上部の2つの要素などが移動します。ただし、回転と深さの間で要素を前方に移動することでも、これを実現できます。spliceこれらの要素を削除concatし、残りの要素の前に追加します。（長さが同じなので、代わりに配列内包表記を使用することもできます。）
  • とは異なりslice、の2番目のパラメーターspliceは削除する要素の数です。
— ニール
ソース
(t%d+d)%dと同じではありませんt%dか？
— ルーク
@Lukeいいえ、%剰余なので、負の場合tは否定的な答えを返します。
— ニール
(t,d,...a)=>ルールでは一度に1つの要素で入力を渡すことができるため、使用することで2バイトを節約できます。
— シャギー
@Shaggyありがとう、気づかなかった。
— ニール
7

CJam、31バイト

)\):N@\,0a|={NW*1$1$>)\+@@<\+}*

入力と出力はスタック上の配列で、最後の要素はスタックの最上部を表します。

スタックトレース：

                   e# Stack:                [6 5 4 3 2 1 4 2]
)                  e# Take out first value: [6 5 4 3 2 1 4] 2
\                  e# Swap:                 2 [6 5 4 3 2 1 4]
)                  e# Take out first value: 2 [6 5 4 3 2 1] 4
:N                 e# Store in N:           2 [6 5 4 3 2 1] 4; N=4
@                  e# Rotate:               [6 5 4 3 2 1] 4 2
\                  e# Swap:                 [6 5 4 3 2 1] 2 4
,                  e# Range:                [6 5 4 3 2 1] 2 [0 1 2 3]
0                  e# Push 0:               [6 5 4 3 2 1] 2 [0 1 2 3] 0
a                  e# Wrap in array:        [6 5 4 3 2 1] 2 [0 1 2 3] [0]
|                  e# Logical or:           [6 5 4 3 2 1] 2 [0 1 2 3]
                   e# (This will replace an empty array with [0] to handle a special case of n=0)
=                  e# Get array value:      [6 5 4 3 2 1] 2
{NW*1$1$>)\+@@<\+} e# Push block:           [6 5 4 3 2 1] 2 {NW*1$1$>)\+@@<\+}
*                  e# Preform n times:      [6 5 4 3 2 1]
  N                e# Push N:               [6 5 4 3 2 1] 4
  W*               e# Negate:               [6 5 4 3 2 1] -4
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1]
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1] -4
  >                e# Slice a[-4:]          [6 5 4 3 2 1] -4 [4 3 2 1]
  )                e# Take first value:     [6 5 4 3 2 1] -4 [4 3 2] 1
  \                e# Swap:                 [6 5 4 3 2 1] -4 1 [4 3 2]
  +                e# Append:               [6 5 4 3 2 1] -4 [1 4 3 2]
  @@               e# Rotate twice:         [1 4 3 2] [6 5 4 3 2 1] -4
  <                e# Slice a[:-4]:         [1 4 3 2] [6 5]
  \                e# Swap:                 [6 5] [1 4 3 2]
  +                e# Append:               [6 5 1 4 3 2]
e# Preform the block again:                 [6 5 2 1 4 3]
— エソランジングフルーツ
ソース
6

Mathematica、58 50バイト

編集：8バイトを保存してくれたMartin Enderに感謝します。

Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&@@#&

説明：

リストの先頭がスタックのトップを表すリストを期待する純粋な関数。リストの要素を純関数に渡しますTake[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&。xは、3番目の引数で始まる要素のシーケンスに設定されます。次に、最初の#2（2番目の引数）要素をx左#（最初の引数）回、次にJoin残りの要素を左に回転させxます。

3最初にリストにあるのではなく、関数に直接スタック要素を引数として渡した場合、バイト数を節約できますが、入力形式と出力形式は一致しません。

元のソリューション：

#/.{t_,d_,x___}:>{x}~Take~d~RotateLeft~t~Join~Drop[{x},d]&

この一連の挿入関数について本当に満足のいくものがあります。リストを最初の要素t、2番目の要素d、残りの要素xで置き換え、最初のd要素を{x}左に回転させt、残りの要素を結合し{x}ます。

— ゲニシス
ソース
1
いいね！あなたは、1バイトのプレフィックス機能使って、3つのバイトを保存することができ±、交換ルールのinsetadを、そして利用することによって、別の1つのバイトTakeDropとしては、以下： ±{t_,d_,x___}:=#~RotateLeft~t~Join~#2&@@{x}~TakeDrop~d
— グレッグ・マーティン
グレッグと同じことをコメントするつもりでしたが、実際にはもっと短くすることもできます。どちらか（それは入力かかるのでそれはビット危険なのですが、無名の可変引数の関数を作成...&[1, 1, 3, 4]し、リターンを{3, 4}またはを使って手動でそれを行うApply初めに：Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&@@#&（ちょうど明確にすることが、私の最初の提案は省略@@#&）。
— マーティン・エンダー
5

ルビー、40バイト

x=->s{n,d,*s=s;s[0,d]=s[0,d].rotate n;s}

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

入力をリストとして受け取り、リストを返します。rotate正と負の両方の回転を処理できるビルトインが存在するという事実は、これを簡単にします。

— ベンテロ
ソース
5

Python、141 98 87 74バイト

@Coleのおかげで11バイト節約

def f(s):*s,d,t=s;n=len(s)-d;return s*0**d or s[:n]+s[-t%d-d:]+s[n:-t%d-d]

入力をリストとして受け取ります。最後の要素はスタックの最上部です。

0ⁿトリックを使用して、深さゼロおよびPythonの符号調整モジュロ演算子をフィルタリングし、切り取るリストの一部を決定します。

— ウリエル
ソース
なぜちょうど取らないのf(s,t,d)ですか？
— コール
@Cole開梱してくれてありがとう！しかし、私はあなたが何を意味したのかわかりませんf(s,t,d)（入力はスタック全体です）。
— ウリエル
展開するための素晴らしいアイデアですが、それを私に信用してはいけないとは思いません（変数を個別に取得することを提案していました）。入力仕様では、深さを取得できるように思われ、スタックから個別の変数として回転します。出力は入力と同じ形式でなければなりません。」
— コール
で1バイト節約できますr=-t%d-d。また、に置き換えるs*0**dとs*(d<1)バイトカウントが維持されますが、読みやすさは向上する可能性があります（それが目標ではありません）。0**0==1Pythonでそれを知りませんでしたが、それは興味深いです。
— ベンフランケル
@BenFrankel私は保存することはできません-t%d-d（私は前に行ったように）ときので、値としてdあり0、これは、ゼロ除算例外をトリガします。
— ウリエル
3

JavaScriptのES6、109の 92バイト

x=>{for(i=x.shift(),i=i>0?i:-i,j=x.shift();i-->0&&j>0;)x=x.splice(j,1).concat(x);return x}

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

整数の配列の形式で入力を受け取ります。
矢印へのカウントもあります：P

説明：

コードはシフト関数を使用して、リストの最初の2つの要素を抽出します。

次に、最初の要素の絶対値、つまり回転数を取得します。

Javascriptのインデックスはゼロであるため、深度インデックスを1減らす必要があります。

深さインデックスが0または1の場合、何も変更されるべきではありませんが、減少のため、インデックス0は変更を引き起こします。したがって、深度インデックスが<= 0でない場合、ループを終了します。

splice（a、b）関数は、配列から開始インデックスaを持つ長さbのサブ配列を返し、元の配列にこれらの要素を残します。

元の配列の残りの部分と連結された場合、これは深さインデックスでの配列の単一回転です。

この操作をn回（nはターン数）実行すると、結果の配列はロール演算子の結果になります。

— fəˈnɛtɪk
ソース
2

TI-Basic、141 150バイト（非競合）

Prompt L1
L1(1→T
L1(2→D
seq(L1(C),C,3,dim(L1→L1
If TD>0
Then
For(A,1,T
L1(1→B
For(C,2,D
L1(C→L1(C–1
End
B→L1(D
End
End
If TD<0
Then
For(A,1,-T
L1(D→B
For(C,D,2,-1
L1(C–1→L1(C
End
B→L1(1
End
End
L1

編集：深さがゼロ（+9バイト）の場合を修正

TI-Basicは長さ0のリストをサポートしていないため、このアプローチは長さ2の入力に対して機能しません。

説明：

Prompt L1                # 4 bytes, input list
L1(1→T                   # 7 bytes, turns
L1(2→D                   # 7 bytes, depth
seq(L1(C),C,3,dim(L1→L1   # 18 bytes, remove turns and depth from list
If TD>0                  # 6 bytes, if turns is positive and depth is nonzero (can't be negative)
Then                     # 2 bytes
For(A,1,T                # 7 bytes, do this 'turns' times
L1(1→B                    # 7 bytes, backup the first item
For(C,2,D                # 7 bytes, shuffle the rest along
L1(C→L1(C–1               # 12 bytes
End                      # 2 bytes
B→L1(D                   # 7 bytes, restore the backup to where it should be
End                      # 2 bytes
End                      # 2 bytes
If TD<0                  # 6 bytes, if T is negative and D is nonzero
Then                     # 2 bytes
For(A,1,-T               # 8 bytes, do this -'turns' times
L1(D→B                   # 7 bytes, backup the Dth item
For(C,D,2,-1             # 10 bytes, shuffle the items the other way
L1(C–1→L1(C              # 12 bytes
End                      # 2 bytes
B→L1(1                   # 7 bytes, restore backup to where it belongs
End                      # 2 bytes
End                      # 2 bytes
L1                       # 2 bytes, implicitly return
— ピザパンツ184
ソース
2要素リストの場合にも対処するコードが必要だと思います。現在、でエラーになりseq(ます。
— リルトシアスト
1

バッチ、163バイト

@set s=
@set r=
@set/ad=%2,t=(%1%%d+d)%%d
:l
@shift
@set/af=t-=1,f^^=d-=1
@if %f% lss 0 (set r=%r% %2)else set s=%s% %2
@if not "%3"=="" goto l
@echo%r%%s%

入力をコマンドラインパラメーターとして受け取り、スペースで区切られたリストを出力します。間でパラメータtとは、d中に抽出されr、それらが前に付加することができるように、変数sの他のすべてのパラメータを受け取る変数。

— ニール
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.