Easiest way to wrap around the indexed value in a list (mod doesn't quite work)

Tim

But the beauty of Smalltalk is that, if you need to use a particular
structure frequently, you can make it an object just by subclassing
something useful. In this case, you could create CircularList by subclassing
SequenceableCollection and re-implementing #before and #after (and maybe
tidying up #add if you don't want the circle to be extendable).

Pursuing this line of thought, we  already have one specialized subclass in
LinkedList. If the last element is linked to the first, this becomes
circular. I glanced at some of the methods to see how well this would work,
but because it regards links as separate from the linked objects, it got too
complicated. But it could give a starting point if you have lots of such
cases.

HTH

Peter Kenny


Tim Mackinnon wrote
> Hey thanks guys - while it certainly makes sense when you think about it,
> I was kind of hoping we had something that was much more readable and
> obvious. It seems strange that when we have lots of esoteric things in
> collection, that something which is quite common to do isn’t there. I was
> kind of hoping we might have some circular list or something.
>
> As it stands, if you really want to communicate this clearly you are
> almost better off just doing, the more obvious:
>
> (Index := index - 1) = 0 ifTrue: [index := items size].
>
> Anyway, an interesting one.
>
> Tim
>
>> On 28 Mar 2019, at 16:55, Peter Kenny <

> peter@.co

> > wrote:
>>
>> Tim
>>
>> I found myself puzzling as to *why* James's solution works. This longer
>> explanation helped me to understand.
>>
>> First, generalize moving forward to moving an arbitrary number of steps,
>> still with wrapping.
>>
>> ^list at: (index + move - 1 \\ size + 1
>>
>> Second, realize that moving backward one step with wrapping is exactly
>> equivalent to moving forward (size - 1) steps - because of wrapping, a
>> move
>> of size steps is null.
>>
>> Finally, substitute move = size - 1.
>>
>> ^list at: (index + size - 2 \\ size + 1.
>>
>> This can of course easily generalize to backward moves of any size.
>>
>> HTH
>>
>> Peter Kenny
>>
>>
>>
>> --
>> Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html
>>





--
Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html

Hey guys - I’m wondering if someone might have a nice way of selecting the previous value in a list - but wrapping around to the last value if you are at the front.

Essentially I have an exercise with some values in a collection like:

list :=  #($a $e $o $u).

And I have an index into the list, and want to loop around from index 1, back to 4 when I hit the beginning of the list.

While moving forwards is pretty easy with mod - e.g.

^list at: (index \\ list size + 1)

I’m struggling with the cleanest way to do this backwards - as the following is unreadable to me (assuming index = 1)

^list at: (index - 2 \\ list size + 1)

And then I tried (which isn't bad - but still not quite right).

^list before: (list at: index) ifAbsent: [ids last].


I’m sure there is a better way to do this - but it’s alluding me?

Tim

One of my recent assignments to first-year programming students was to model Left-Center-Right (https://en.wikipedia.org/wiki/LCR_(dice_game)) where they needed to do just what you are trying to do.

| size stream |

size := 10.

stream := WriteStream on: String new.

1 to: size do: [:i | 

stream

print: i; tab;

print: i \\ size + 1; tab;

print: i + size - 2 \\ size + 1; tab;

cr.

].

stream contents

On Mar 28, 2019, at 8:12 AM, Tim Mackinnon <[hidden email]> wrote:

Hey guys - I’m wondering if someone might have a nice way of selecting the previous value in a list - but wrapping around to the last value if you are at the front.

Essentially I have an exercise with some values in a collection like:

list :=  #($a $e $o $u).

And I have an index into the list, and want to loop around from index 1, back to 4 when I hit the beginning of the list.

While moving forwards is pretty easy with mod - e.g.

^list at: (index \\ list size + 1)

I’m struggling with the cleanest way to do this backwards - as the following is unreadable to me (assuming index = 1)

^list at: (index - 2 \\ list size + 1)

And then I tried (which isn't bad - but still not quite right).

^list before: (list at: index) ifAbsent: [ids last].


I’m sure there is a better way to do this - but it’s alluding me?

Tim

Hey thanks guys - while it certainly makes sense when you think about it, I was kind of hoping we had something that was much more readable and obvious. It seems strange that when we have lots of esoteric things in collection, that something which is quite common to do isn’t there. I was kind of hoping we might have some circular list or something.

As it stands, if you really want to communicate this clearly you are almost better off just doing, the more obvious:

(Index := index - 1) = 0 ifTrue: [index := items size].

Anyway, an interesting one.

Tim

> On 28 Mar 2019, at 16:55, Peter Kenny <[hidden email]> wrote:
>
> Tim
>
> I found myself puzzling as to *why* James's solution works. This longer
> explanation helped me to understand.
>
> First, generalize moving forward to moving an arbitrary number of steps,
> still with wrapping.
>
> ^list at: (index + move - 1 \\ size + 1
>
> Second, realize that moving backward one step with wrapping is exactly
> equivalent to moving forward (size - 1) steps - because of wrapping, a move
> of size steps is null.
>
> Finally, substitute move = size - 1.
>
> ^list at: (index + size - 2 \\ size + 1.
>
> This can of course easily generalize to backward moves of any size.
>
> HTH
>
> Peter Kenny
>
>
>
> --
> Sent from: http://forum.world.st/Pharo-Smalltalk-Users-f1310670.html
>