blocks|key|242196|text|scala>+val+l+=+List(1,2,3,4,5)
l:+List[Int]+=+List(1,+2,+3,+4,+5)

scala>+val+reorderings+=+Stream.continually(l.reverse).flatten.sliding(l.size).map(_.reverse)
reorderings:+Iterator[scala.collection.immutable.Stream[Int]]+=+non-empty+iterator

scala>+reorderings.take(5).foreach(x+=>+println(x.toList))
List(1,+2,+3,+4,+5)
List(5,+1,+2,+3,+4)
List(4,+5,+1,+2,+3)
List(3,+4,+5,+1,+2)
List(2,+3,+4,+5,+1)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|242197|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>scala&gt; val l = List(1,2,3,4,5)
l: List[Int] = List(1, 2, 3, 4, 5)

scala&gt; val reorderings = Stream.continually(l.reverse).flatten.sliding(l.size).map(_.reverse)
reorderings: Iterator[scala.collection.immutable.Stream[Int]] = non-empty iterator

scala&gt; reorderings.take(5).foreach(x =&gt; println(x.toList))
List(1, 2, 3, 4, 5)
List(5, 1, 2, 3, 4)
List(4, 5, 1, 2, 3)
List(3, 4, 5, 1, 2)
List(2, 3, 4, 5, 1)
</code></pre>


blocks|key|3127704|text|不可变的实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3127705|ring+buffer是一对指向此序列的IndexedSeq和Int指针。我提供了一个不可变版本的代码。请注意，并不是所有可能有用的方法都实现了；比如更改IndexedSeq内容的赋值器。|offset|length|style|CODE|3127706|通过这种实现，shifting只是创建了一个新对象。所以它是非常高效的。|3127707|示例代码|3127708|class+RingBuffer[A](val+index:+Int,+val+data:+IndexedSeq[A])+extends+IndexedSeq[A]+{
++def+shiftLeft+=+new+RingBuffer((index+%2B+1)+%25+data.size,+data)
++def+shiftRight+=+new+RingBuffer((index+%2B+data.size+-+1)+%25+data.size,+data)
++def+length+=+data.length
++def+apply(i:+Int)+=+data((index+%2B+i)+%25+data.size)
}

val+rb+=+new+RingBuffer(0,+IndexedSeq(2,3,5,7,11))

println("plain:+"+%2B+rb)
println("sl:+"+%2B+rb.shiftLeft)
println("sr:+"+%2B+rb.shiftRight)|code-block|syntax|javascript|3127709|输出|3127710|plain:+Main(2,+3,+5,+7,+11)
sl:+Main(3,+5,+7,+11,+2)
sr:+Main(11,+2,+3,+5,+7)|3127711|与可变实现的性能比较|3127712|OP提到，如果你需要性能，你应该考虑可变的实现(例如this+answer)。一般来说，这不是真的。一如既往:视情况而定。|3127713|不可变的|3127714|3127715|+update：O(log+n)基本上是底层O(log+n)+O(1)的更新复杂性，它还涉及创建一个新对象，这可能会耗费一些|unordered-list-item|3127716|周期|3127717|可变的|3127718|数组更新：O(1)，|3127719|，O(1)+O(n)，就像它更新一样快，你必须触摸每个元素一次；基元数组上的快速实现可能仍然会胜过小数组的不可变版本，因为恒定因子|3127720|3127721|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Circular_buffer|1|https://stackoverflow.com/a/15997514/108915^0|0|K|A|V|3|25|A|0|B|0|0|0|0|0|0|0|0|Q|B|1|0|0|0|8|8|M|8|V|4|0|0|0|5|4|0|1|4|6|4|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]]|9|@$D|1V|E|1W|1|1X]]|A|$]]|$1|H|3|I|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|20|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|21|8|@]|9|@]|A|$]]|$1|S|3|T|5|N|7|22|8|@]|9|@]|A|$O|P]]|$1|U|3|V|5|6|7|23|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|24|8|@]|9|@$D|25|E|26|1|27]]|A|$]]|$1|Y|3|Z|5|6|7|28|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|29|8|@]|9|@]|A|$]]|$1|11|3|12|5|13|7|2A|8|@$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]|$D|2F|E|2G|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2H|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2I|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2J|8|@$D|2K|E|2L|F|G]]|9|@]|A|$]]|$1|1A|3|1B|5|13|7|2M|8|@$D|2N|E|2O|F|G]|$D|2P|E|2Q|F|G]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]]|1E|$1F|$5|1G|1H|1I|A|$1J|1K]]|1L|$5|1G|1H|1I|A|$1J|1M]]]]

<h1>Immutable implementation</h1>

<p>A <a href="http://en.wikipedia.org/wiki/Circular_buffer" rel="nofollow noreferrer">ring buffer</a> is a pair of an <code>IndexedSeq</code> and an <code>Int</code> pointer into this sequence. I provide code for a immutable version. Note that not all methods that might be useful are implemented; like the mutators that change the content of the <code>IndexedSeq</code>.</p>

<p>With this implementation, shifting is just creating one new object. So it's pretty efficient.</p>

<h3>Example code</h3>

<pre><code>class RingBuffer[A](val index: Int, val data: IndexedSeq[A]) extends IndexedSeq[A] {
  def shiftLeft = new RingBuffer((index + 1) % data.size, data)
  def shiftRight = new RingBuffer((index + data.size - 1) % data.size, data)
  def length = data.length
  def apply(i: Int) = data((index + i) % data.size)
}

val rb = new RingBuffer(0, IndexedSeq(2,3,5,7,11))

println("plain: " + rb)
println("sl: " + rb.shiftLeft)
println("sr: " + rb.shiftRight)
</code></pre>

<h3>Output</h3>

<pre><code>plain: Main(2, 3, 5, 7, 11)
sl: Main(3, 5, 7, 11, 2)
sr: Main(11, 2, 3, 5, 7)
</code></pre>

<h2>Performance comparison to mutable implementations</h2>

<p>The OP mentions that you should look at the mutable implementations (e.g. <a href="https://stackoverflow.com/a/15997514/108915">this answer</a>), if you need performance. This is not true in general. As always: It depends.</p>

<h3>Immutable</h3>

<ul>
<li>update: <code>O(log n)</code>, which is basically the update complexity of the underlying <code>IndexedSeq</code>;</li>
<li>shifting: <code>O(1)</code>, also involves creating a new object which may cost some cycles</li>
</ul>

<h3>Mutable</h3>

<ul>
<li>update: <code>O(1)</code>, array update, as fast as it gets</li>
<li>shifting: <code>O(n)</code>, you have to touch every element once; fast implementations on primitive arrays might still win against the immutable version for small arrays, because of constant factor</li>
</ul>


blocks|key|3127732|text|我解决Scala问题的方法是先在Haskell中解决它们，然后再翻译。:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3127733|reorderings+xs+=+take+len+.+map+(take+len)+.+tails+.+cycle+$+xs
++where+len+=+length+xs|code-block|syntax|javascript|3127734|这是我能想到的最简单的方法，通过反复“左移”来生成所有可能的移位列表。|3127735|ghci>+reorderings+[1..5]
[[1,2,3,4,5],[2,3,4,5,1],[3,4,5,1,2],[4,5,1,2,3],[5,1,2,3,4]]|3127736|这个概念相对简单(对于那些熟悉函数式编程的人来说，就是这样)。首先，对原始列表执行cycle操作，生成一个可从中提取的无限大的流。接下来，将该流分解为流的流，其中每个后续流都丢弃了前一个流的第一个元素(tails)。接下来，将每个子流限制为原始列表(map+(take+len))的长度。最后，将流的长度限制为原始列表的长度，因为只有len+possible+reorderings+(take+len)。|offset|length|style|CODE|3127737|现在让我们在Scala中实现这一点。|3127738|def+reorderings[A](xs:+List[A]):List[List[A]]+=+{
++val+len+=+xs.length
++Stream.continually(xs).flatten+//+cycle
++++.tails
++++.map(_.take(len).toList)
++++.take(len)
++++.toList
}|3127739|我们只需要对cycle使用一个小的变通方法(不确定Scala标准库是否提供了cycle，尽管我惊喜地发现它们提供了tails)和一些toLists+(Haskell列表是惰性流，而Scala的列表是严格的)，但除此之外，它与Haskell完全相同，据我所知，它的行为也完全相同。您几乎可以认为Scala的.的行为与Haskell类似，只是流向相反。|3127740|还请注意，这与dhg的解决方案几乎相同，除了没有反转，这(在积极方面)使其更有效，但(在不利方面)提供了“回溯”顺序的周期，而不是“向前”顺序。|3127741|entityMap^0|0|0|0|0|15|5|2T|5|3H|E|4N|3|5D|8|0|0|0|6|5|1L|5|1U|6|48|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@$M|15|N|16|O|P]|$M|17|N|18|O|P]|$M|19|N|1A|O|P]|$M|1B|N|1C|O|P]|$M|1D|N|1E|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1H|8|@$M|1I|N|1J|O|P]|$M|1K|N|1L|O|P]|$M|1M|N|1N|O|P]|$M|1O|N|1P|O|P]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|Z|$]]

<p>The way I solve Scala problems is solving them in Haskell first, and then translating. :)</p>

<pre><code>reorderings xs = take len . map (take len) . tails . cycle $ xs
  where len = length xs
</code></pre>

<p>This is the easiest way I could think of, which produces the list of all possible shifts, by "shifting left" repeatedly.</p>

<pre><code>ghci&gt; reorderings [1..5]
[[1,2,3,4,5],[2,3,4,5,1],[3,4,5,1,2],[4,5,1,2,3],[5,1,2,3,4]]
</code></pre>

<p>The concept is relatively simple (for those comfortable with functional programming, that is). First, <code>cycle</code> the original list, producing an infinite stream from which to draw from. Next, break that stream into a stream of streams, where each subsequent stream has dropped the first element of the previous stream (<code>tails</code>). Next, limit each substream to the length of the original list (<code>map (take len)</code>). Finally, limit the stream of streams to the length of the original list, since there are only <code>len</code> possible reorderings (<code>take len</code>).</p>

<p>So let's do that in Scala now.</p>

<pre><code>def reorderings[A](xs: List[A]):List[List[A]] = {
  val len = xs.length
  Stream.continually(xs).flatten // cycle
    .tails
    .map(_.take(len).toList)
    .take(len)
    .toList
}
</code></pre>

<p>We just had to use a small workaround for <code>cycle</code> (not sure if Scala standard libs provide cycle, though I was pleasantly surprised to find they provide <code>tails</code>), and a few <code>toList</code>s (Haskell lists <em>are</em> lazy streams, while Scala's are strict), but other than that, it's exactly the same as the Haskell, and as far as I can tell, behaves exactly the same. You can almost think of Scala's <code>.</code> as behaving like Haskell's, except flowing the opposite way.</p>

<p>Also note this is very nearly the same as dhg's solution, except without the reverses, which (on the upside) makes it more efficient, but (on the downside) provides the cycles in "backwinding" order, rather than "forward" order.</p>


blocks|key|239891|text|我自己也需要这样的手术，就是这样。方法rotate将给定的索引序列(数组)向右旋转(负值向左移动)。该过程是就地进行的，因此不需要额外的内存，并且修改了原始数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|239892|它不是特定于Scala的，也不是函数式的，它意味着非常快。|239893|import+annotation.tailrec;
import+scala.collection.mutable.IndexedSeq

//+...

++@tailrec
++def+gcd(a:+Int,+b:+Int):+Int+=
++++if+(b+==+0)+a
++++else+gcd(b,+a+%25+b);

++@inline
++def+swap[A](a:+IndexedSeq[A],+idx:+Int,+value:+A):+A+=+{
++++val+x+=+a(idx);
++++a(idx)+=+value;
++++return+x;
++}

++/**
+++*+Time+complexity:+O(a.size).
+++*+Memory+complexity:+O(1).
+++*/
++def+rotate[A](a:+IndexedSeq[A],+shift:+Int):+Unit+=
++++rotate(a,+0,+a.size,+shift);
++def+rotate[A](a:+IndexedSeq[A],+start:+Int,+end:+Int,+shift:+Int):+Unit+=+{
++++val+len+=+end+-+start;
++++if+(len+==+0)
++++++return;

++++var+s+=+shift+%25+len;
++++if+(shift+==+0)
++++++return;
++++if+(s+<+0)
++++++s+=+len+%2B+s;

++++val+c+=+gcd(len,+s);
++++var+i+=+0;
++++while+(i+<+c)+{
++++++var+k+=+i;
++++++var+x+=+a(start+%2B+len+-+s+%2B+k);
++++++do+{
++++++++x+=+swap(a,+start+%2B+k,+x);
++++++++k+=+(k+%2B+s)+%25+len;
++++++}+while+(k+!=+i);
++++++i+=+i+%2B+1;
++++}
++++return;
++}|code-block|syntax|javascript|239894|entityMap^0|J|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

<p>I needed such an operation myself, here it is. Method <code>rotate</code> rotates the given indexed sequence (array) to the right (negative values shift to the left). The process is in-place, so no additional memory is required and the original array is modified.</p>

<p>It's not Scala-specific or functional at all, it's meant to be very fast.</p>

<pre><code>import annotation.tailrec;
import scala.collection.mutable.IndexedSeq

// ...

  @tailrec
  def gcd(a: Int, b: Int): Int =
    if (b == 0) a
    else gcd(b, a % b);

  @inline
  def swap[A](a: IndexedSeq[A], idx: Int, value: A): A = {
    val x = a(idx);
    a(idx) = value;
    return x;
  }

  /**
   * Time complexity: O(a.size).
   * Memory complexity: O(1).
   */
  def rotate[A](a: IndexedSeq[A], shift: Int): Unit =
    rotate(a, 0, a.size, shift);
  def rotate[A](a: IndexedSeq[A], start: Int, end: Int, shift: Int): Unit = {
    val len = end - start;
    if (len == 0)
      return;

    var s = shift % len;
    if (shift == 0)
      return;
    if (s &lt; 0)
      s = len + s;

    val c = gcd(len, s);
    var i = 0;
    while (i &lt; c) {
      var k = i;
      var x = a(start + len - s + k);
      do {
        x = swap(a, start + k, x);
        k = (k + s) % len;
      } while (k != i);
      i = i + 1;
    }
    return;
  }
</code></pre>


blocks|key|244928|text|有一个非常简单的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|244929|val+orderings+=+List(1,2,3,4,5)
(orderings+%2B%2B+orderings.dropRight(1)).sliding(orderings.length).toList

List(List(1,+2,+3,+4,+5),+List(2,+3,+4,+5,+1),+List(3,+4,+5,+1,+2),+List(4,+5,+1,+2,+3),+List(5,+1,+2,+3,+4))|code-block|syntax|javascript|244930|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>There is a very simple solution:</p>

<pre><code>val orderings = List(1,2,3,4,5)
(orderings ++ orderings.dropRight(1)).sliding(orderings.length).toList

List(List(1, 2, 3, 4, 5), List(2, 3, 4, 5, 1), List(3, 4, 5, 1, 2), List(4, 5, 1, 2, 3), List(5, 1, 2, 3, 4))
</code></pre>


blocks|key|3127825|text|以下是序列的一种可能的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3127826|class+ShiftWarper(+seq:+Seq[+Int+]+)+{
++def+shiftLeft:+Seq[+Int+]+=+{
++++if+(+seq.isEmpty+)+{
++++++seq
++++}+else+{
++++++seq.tail+:%2B+seq.head
++++}
++}
++def+shiftRight:+Seq[+Int+]+=+{
++++if+(+seq.isEmpty+)+{
++++++seq
++++}+else+{
++++++seq.last+%2B:+seq.init
++++}
++}
}
implicit+def+createShiftWarper(+seq:+Seq[+Int+]+)+=
++++new+ShiftWarper(+seq+)+

def+shift_n_Times(
++times:+Int,
++seq:+Seq[+Int+],
++operation:+Seq[+Int+]+=>+Seq[+Int+]+):+Seq[+Int+]+=+{
++if+(+times+>+0+)+{
++++shift_n_Times(
++++++times+-+1,
++++++operation(+seq+),
++++++operation+)
++}+else+{
++++seq
++}
}+

val+initialSeq+=+(+0+to+9+)

(+initialSeq+shiftLeft+)+shiftRight
shift_n_Times(
++5,
++initialSeq,
++initialSeq+=>+new+ShiftWarper(+initialSeq+).shiftRight+)|code-block|syntax|javascript|3127827|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is one possible solution for sequences </p>

<pre class="lang-scala prettyprint-override"><code>class ShiftWarper( seq: Seq[ Int ] ) {
  def shiftLeft: Seq[ Int ] = {
    if ( seq.isEmpty ) {
      seq
    } else {
      seq.tail :+ seq.head
    }
  }
  def shiftRight: Seq[ Int ] = {
    if ( seq.isEmpty ) {
      seq
    } else {
      seq.last +: seq.init
    }
  }
}
implicit def createShiftWarper( seq: Seq[ Int ] ) =
    new ShiftWarper( seq ) 

def shift_n_Times(
  times: Int,
  seq: Seq[ Int ],
  operation: Seq[ Int ] =&gt; Seq[ Int ] ): Seq[ Int ] = {
  if ( times &gt; 0 ) {
    shift_n_Times(
      times - 1,
      operation( seq ),
      operation )
  } else {
    seq
  }
} 

val initialSeq = ( 0 to 9 )

( initialSeq shiftLeft ) shiftRight
shift_n_Times(
  5,
  initialSeq,
  initialSeq =&gt; new ShiftWarper( initialSeq ).shiftRight )
</code></pre>


blocks|key|2913594|text|这是另一个简单的scala解决方案，用于将Stream向右或向左移动任意数量。"Cycle“无限重复流，然后"shift”找到正确的切片。"posMod“允许您按大于xs.length的索引进行移位，但实际上不会在无限流中偏离超过xs.length元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2913595|scala>+def+posMod(a:Int,+b:Int)+=+(a+%25+b+%2B+b)+%25+b

scala>+def+cycle[T](xs+:+Stream[T])+:+Stream[T]+=+xs+#:::+cycle(xs)

scala>+def+shift[T](xs:Stream[T],+x:+Int)+=+cycle(xs)
++++++++++.drop(posMod(x,+xs.length))
++++++++++.take(xs.length)|code-block|syntax|javascript|2913596|然后：|2913597|scala>+shift(Stream(1,2,3,4),+3).toList
-->+List[Int]+=+List(4,+1,+2,+3)

scala>+shift(Stream(1,2,3,4),+-3).toList
-->+List[Int]+=+List(2,+3,+4,+1)

scala>++shift(Stream(1,2,3,4),+30000001).toList
-->+List[Int]+=+List(2,+3,+4,+1)|2913598|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here's another simple scala solution for shifting a Stream right or left by arbitrary amounts.  "Cycle" repeats the stream infintely, then "shift" finds the correct slice. "posMod" allows you to shift by an index larger than xs.length but without actually straying more than xs.length elements in the infinite Stream:</p>

<pre><code>scala&gt; def posMod(a:Int, b:Int) = (a % b + b) % b

scala&gt; def cycle[T](xs : Stream[T]) : Stream[T] = xs #::: cycle(xs)

scala&gt; def shift[T](xs:Stream[T], x: Int) = cycle(xs)
          .drop(posMod(x, xs.length))
          .take(xs.length)
</code></pre>

<p>Then:</p>

<pre><code>scala&gt; shift(Stream(1,2,3,4), 3).toList
--&gt; List[Int] = List(4, 1, 2, 3)

scala&gt; shift(Stream(1,2,3,4), -3).toList
--&gt; List[Int] = List(2, 3, 4, 1)

scala&gt;  shift(Stream(1,2,3,4), 30000001).toList
--&gt; List[Int] = List(2, 3, 4, 1)
</code></pre>


blocks|key|2913610|text|@dhg和@Roman+Zykov版本的完美组合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2913611|scala>+val+l+=+List(1,2,3,4,5)
l:+List[Int]+=+List(1,+2,+3,+4,+5)

scala>+val+re+=+Stream+continually+(l+%2B%2B+l.init+sliding+l.length)+flatten
re:+scala.collection.immutable.Stream[List[Int]]+=+Stream(List(1,+2,+3,+4,+5),+?)

scala>+re+take+10+foreach+println
List(1,+2,+3,+4,+5)
List(2,+3,+4,+5,+1)
List(3,+4,+5,+1,+2)
List(4,+5,+1,+2,+3)
List(5,+1,+2,+3,+4)
List(1,+2,+3,+4,+5)
List(2,+3,+4,+5,+1)
List(3,+4,+5,+1,+2)
List(4,+5,+1,+2,+3)
List(5,+1,+2,+3,+4)|code-block|syntax|javascript|2913612|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Nice combination of @dhg and @Roman Zykov versions:</p>

<pre><code>scala&gt; val l = List(1,2,3,4,5)
l: List[Int] = List(1, 2, 3, 4, 5)

scala&gt; val re = Stream continually (l ++ l.init sliding l.length) flatten
re: scala.collection.immutable.Stream[List[Int]] = Stream(List(1, 2, 3, 4, 5), ?)

scala&gt; re take 10 foreach println
List(1, 2, 3, 4, 5)
List(2, 3, 4, 5, 1)
List(3, 4, 5, 1, 2)
List(4, 5, 1, 2, 3)
List(5, 1, 2, 3, 4)
List(1, 2, 3, 4, 5)
List(2, 3, 4, 5, 1)
List(3, 4, 5, 1, 2)
List(4, 5, 1, 2, 3)
List(5, 1, 2, 3, 4)
</code></pre>


blocks|key|2913620|text|我的建议是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2913621|def+circ[A](+L:+List[A],+times:+Int+):+List[A]+=+{
++++if+(+times+==+0+%7C%7C+L.size+<+2+)+L
++++else+circ(L.drop(1)+:%2B+L.head+,+times-1)
}

val+G+=+(1+to+10).toList
println(+circ(G,1)+)+//List(2,+3,+4,+5,+6,+7,+8,+9,+10,+1)
println(+circ(G,2)+)+//List(3,+4,+5,+6,+7,+8,+9,+10,+1,+2)
println(+circ(G,3)+)+//List(4,+5,+6,+7,+8,+9,+10,+1,+2,+3)
println(+circ(G,4)+)+//List(5,+6,+7,+8,+9,+10,+1,+2,+3,+4)|code-block|syntax|javascript|2913622|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>My proposition:</p>

<pre><code>def circ[A]( L: List[A], times: Int ): List[A] = {
    if ( times == 0 || L.size &lt; 2 ) L
    else circ(L.drop(1) :+ L.head , times-1)
}

val G = (1 to 10).toList
println( circ(G,1) ) //List(2, 3, 4, 5, 6, 7, 8, 9, 10, 1)
println( circ(G,2) ) //List(3, 4, 5, 6, 7, 8, 9, 10, 1, 2)
println( circ(G,3) ) //List(4, 5, 6, 7, 8, 9, 10, 1, 2, 3)
println( circ(G,4) ) //List(5, 6, 7, 8, 9, 10, 1, 2, 3, 4)
</code></pre>


blocks|key|2913639|text|您可以实例化一个包含数组(A)和所需旋转步数(S)的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2913640|def+rotate(A:+Array[Int],+S:+Int):+Int+=+{+(A+drop+A.size+-+(S+%25+A.size))+%2B%2B+(A+take+A.size+-+(S+%25+A.size))+}

rotate(Array(1,+2,+3,+4,+5),+1)|code-block|syntax|javascript|2913641|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You can instantiate a function that will include the Array(A) and the number of rotation steps that you need(S): </p>

<pre><code>def rotate(A: Array[Int], S: Int): Int = { (A drop A.size - (S % A.size)) ++ (A take A.size - (S % A.size)) }

rotate(Array(1, 2, 3, 4, 5), 1)
</code></pre>


blocks|key|239963|text|我对此的看法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|239964|@tailrec
+def+shift(times:Int,+data:Array[Int]):Array[Int]+=+times+match+{
++++++++case+t:Int+if(t+<=+0)+=>+data;
++++++++case+t:Int+if(t+<=+data.length)+=>+shift(0,+(data%2B%2Bdata.take(times)).drop(times))+
++++++++case+_+=>+shift(times+%25+data.length,+data);
}|code-block|syntax|javascript|239965|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>My take on it: </p>

<pre><code>@tailrec
 def shift(times:Int, data:Array[Int]):Array[Int] = times match {
        case t:Int if(t &lt;= 0) =&gt; data;
        case t:Int if(t &lt;= data.length) =&gt; shift(0, (data++data.take(times)).drop(times)) 
        case _ =&gt; shift(times % data.length, data);
}
</code></pre>


<p>I have to implement a kind of an array or sequence or list, which supports the cheapest way of circulated forwarding and back winding of elements. See this example:</p>

<pre><code>Original sequence: 1 2 3 4 5

Forwarded once: 5 1 2 3 4
Forwarded twice: 4 5 1 2 3
</code></pre>

<p>Same but opposite is for the back winding. What would be the cheapest and most Scala-style way of implementing this? In Java I could use LinkedList and it would do great... However, I could not find any definite answer for Scala.</p>

<p>Also, it also has to be easy to replace any given element by index, as in LinkedList.</p>

<p><strong>UPDATE:</strong></p>

<p>For the fastest, but not-so-idiomatic variant of algorithm (you know when you need it), refer to the answer of Petr Pudlák!!!</p>


Best practice for shifting a sequence in a circular manner

Java

我必须实现一种数组或序列或列表，它支持循环转发和回绕元素的最便宜的方式。请参阅此示例：Original sequence: 1 2 3 4 5Forwarded once: 5 1 2 3 4Forwarded twice: 4 5 1 2 3相同的，但相反的是后绕线。实现这一点的最便宜和最Scala风格的方式是什么？...

问以循环方式移位序列的最佳实践
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问以循环方式移位序列的最佳实践EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问以循环方式移位序列的最佳实践
EN