Welcome to the Lounge

5-Feb-20 23:32

Bad first plan, Hela ended Odin before endgame for a friend. (6)

musefan6-Feb-20 1:20

musefan

6-Feb-20 1:20

I'm just going to guess Thanos because it fits the letters and theme, but really I have no idea.

Abbas A. Ali6-Feb-20 1:55

6-Feb-20 1:55

Nope.

Paddington Bear6-Feb-20 1:54

Paddington Bear

6-Feb-20 1:54

Phoebe?

It goes without saying

modified 6-Feb-20 8:17am.

Abbas A. Ali6-Feb-20 1:55

6-Feb-20 1:55

Yup!

musefan6-Feb-20 2:15

musefan

6-Feb-20 2:15

Ok so I get the initials bit, but how does "bad first" mean take the first letter of each following word?

Paddington Bear6-Feb-20 2:19

Paddington Bear

6-Feb-20 2:19

"Bad" because the first letters are not in order. They were in my initial response but that was a typo on my part.

It goes without saying

Abbas A. Ali6-Feb-20 2:26

Need an opinion on a circular IList<T> implementation

6-Feb-20 2:26

I obviously didn't pay much attention to the letters in your solution.

honey the codewitch5-Feb-20 22:47

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 22:47

I've implemented a list with circular buffer semantics meaning adding or removing from either end of the list is very efficient.

Because of this, the list can be efficiently used as a queue, a double ended queue, or a stack.

Well, right now I don't have any special methods to reflect the more efficient add and remove ops.

Doing an efficient add just means list.Add(item) for the end or list.Insert(0,item) for the beginning. Doing an efficient remove is similar with either list.RemoveAt(0) or list.RemoveAt(list.Count-1).

My question is this - should I add special methods for these efficient ops and if so what should they be?

I can go the .NET route that MS took and add methods like Enqueue() and Dequeue() (queue-like) but that only covers adding to the back, and removing from the front. I can add Pop() and Push() (stack-like) but that only covers adding and removing from the back. I can add both but that's cluttered and sill doesn't handle removing from the front.

Or I can take a page from C++/STL and add methods like PushFront() and PushBack() and similar remove methods, even though there's nothing in .NET like this.

Or I can just not add those extra methods and I can document the existing methods with the specially performing cases.

What would you do? Any ideas?

Real programmers use butterflies

phil.o5-Feb-20 22:56

phil.o

5-Feb-20 22:56

How come there's any end to a circular thing? Poke tongue | ;-P

"Five fruits and vegetables a day? What a joke!
Personally, after the third watermelon, I'm full."

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:04

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:04

because that's just the underlying data structure.

Real programmers use butterflies

phil.o5-Feb-20 23:24

phil.o

5-Feb-20 23:24

That was more of a mathematician's observation rather than a developper's one.
Naming the methods, though, is more of a preferences' question. It does not really matter provided their behaviour is clearly and unambiguously documented.

"Five fruits and vegetables a day? What a joke!
Personally, after the third watermelon, I'm full."

Re: Need an opinion on a circular IList<T> implementation

Jörgen Andersson5-Feb-20 23:34

Jörgen Andersson

5-Feb-20 23:34

So, since you Add and Remove from the underlying structure, you need to aim your naming towards that as well.

Wrong is evil and must be defeated. - Jeff Ello

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:44

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:44

I mean right, but microsoft adds and removes to queues with Enqueue and Dequeue, and to stacks with Push and Pop, not Add or Remove

I'd rather follow their conventions as much as I can in .NET. I believe in when in rome when it comes to interface design.

Real programmers use butterflies

Jörgen Andersson6-Feb-20 0:40

Jörgen Andersson

6-Feb-20 0:40

For the Circular part I would follow Microsofts convention on their LinkedList. (Which is Circular BTW, Reference Source[^] )
So AddBefore(), AddAfter(), AddFirst(), AddLast(), Remove(), RemoveFirst(), and RemoveLast().

But as soon as you treat it as a List, use the conventions of a list.

Wrong is evil and must be defeated. - Jeff Ello

Re: Need an opinion on a circular IList<T> implementation

harold aptroot5-Feb-20 23:03

harold aptroot

5-Feb-20 23:03

Add them. I don't care much what they're called, but add them. Having a handful of special cases of Insert and RemoveAt means that proper use relies on reciting the Special Magic Words every time.

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:05

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:05

fair enough. I'd like some methods too, but i just don't know what to call them. I'll stew on it some more.

Real programmers use butterflies

OriginalGriff5-Feb-20 23:19

OriginalGriff

5-Feb-20 23:19

Have an Add and a Remove method, but add an overload for the special cases that uses an enum to control where it goes or comes from. Yes, it's a little less efficient (but a delegate table can help with that if the enum indexes into it) but it's a load easier to keep track of mentally than half a dozen or so Add methods.

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
AntiTwitter: @DalekDave is now a follower!

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:39

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:39

I think i'll pass on that. It's more types, and it breaks with the way microsoft does things on their list based datastructures like Stack<T> and Queue<T>

Real programmers use butterflies

Sander Rossel5-Feb-20 23:27

Sander Rossel

5-Feb-20 23:27

What you could do is add them as extension methods, either on your own (base-)class or interface or on IList<T>.
That way, you keep the base interface/implementation clean, while still offering utility methods that possibly extend to every implementation of your interface.
If you go that way, I'd recommend creating an ICircularList<T>, inherit from IList<T>, and add the extension methods there.

Or just add PushFront and PushBack, which is easy and straight-forward Laugh | :laugh:

Best,
Sander

sanderrossel.com
Migrating Applications to the Cloud with Azure
arrgh.js - Bringing LINQ to JavaScript
Object-Oriented Programming in C# Succinctly

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:37

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:37

I actually thought about doing that but I don't want to add them to standard list interfaces, just this one. I don't like putting inefficient methods on standard lists because it will encourage poor programming.

As far as adding them just to the CircularList that way, or creating ICircularList<t>, I don't really want the latter as I'd like to follow what microsoft has done (most of the time) with their list based data structures like Queue<T> and Stack<T> and just create the class itself. I can add extension methods, and I almost did, but the rest of my class is factored as partial classes - CircularList.cs, CircularList.ICollection.cs, CircularList.IList.cs, etc so I'll probably just add it like that.

I'm leaning toward PushFront/PopFront/PushBack/PopBack like STL, because it's also at least somewhat like Microsoft's pattern in .NET

Real programmers use butterflies

Arthur V. Ratz5-Feb-20 23:31

Arthur V. Ratz

5-Feb-20 23:31

I'm got an opinion. As far as I'm familiar with programming and algorithms, I think that for circular lists you still have to create your own non-generic class ICircularList<t> and implement a functionality for performing the most of circular lists operations. In this case, the using of the existing generic .NET collections is not efficient for that purpose, since it might come to be wasteful.

Here's a list of guidelines on how to implement circular lists:

Create a Circular Singly Linked List in C# Csharp Star[^]
c# - Is the LinkedList in .NET a circular linked list? - Stack Overflow[^]
Circular Linked List | Set 1 (Introduction and Applications) - GeeksforGeeks[^]
Circular Linked list - Sorted Add Delete | C# Online Compiler | .NET Fiddle[^]
C# - Singly Linked Circular List[^]
Circular linked list – An implementation using C# | {love to code?}[^]

...

You may also google to find the answer by using the following query:

Quote:
circular linked list in c#

Cheers, Arthur. Smile | :)

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:42

Re: Need an opinion on a circular IList<T> implementation

5-Feb-20 23:42

First, it's not a linked list, circular or otherwise.

That would be a much different structure, with much different methods.

It's a circular buffer exposed as a IList<T>

Given your seeming confusion about that it might prompt me to rename though i'm not sure to what.

Because it's a circular buffer IList<T>, and ICollection<T> serve me fine. Sure you *can* call Insert(1, item) or RemoveAt(2) and that's not efficient, but it's no less efficient than doing it on a straight List<T> so I'm fine with it.

Real programmers use butterflies

Arthur V. Ratz5-Feb-20 23:51

Arthur V. Ratz

5-Feb-20 23:51

In this case, all that I would recommend is to write a specialization of the generic Queue<t> collection if it's good for your task, otherwise implement your own.

Specifically, first invoke, for example:

Queue<string> numbers = new Queue<string>();
numbers.Enqueue("one");
numbers.Enqueue("two");
numbers.Enqueue("three");
numbers.Enqueue("four");
numbers.Enqueue("five");

And then, implement some kind of push_front, push_back and pop_front, pop_back, as well as buffer shifting functionality to have an ability to perform circular ops. Smile | :)

Re: Need an opinion on a circular IList<T> implementation

honey the codewitch5-Feb-20 23:56