Question: This is a general array question but, for my case, it is a list of strings.

Given: [a, b, c, d, e, f, g, h] and an item inside of the collection, say f.

Output: [f, g, h, a, b, c, d, e]

I can use substring methods or things like .take and .skip. But are there any cleaner alternatives like using linq or something else I might be unaware of?

edit: Okay, I apologize that I did not write question correctly. When I say LINQ, I meant something involving lambda expressions? Thanks for your comments. I will just stick with take and skip.

Answer: 
If you don't mind creating a new `List` or array, you can use an extension method (for `IEnumerable<T>`) to rotate the items and then create the collection you want.

```
// num - return items starting with numth item and wrapping around
//       e.g. rotate items so that numth item is first
public static IEnumerable<T> Rotate<T>(this IEnumerable<T> items, int num) {
    if (num > 0)
        if (items is IList<T> itemList) {
            for (int j1 = 0; j1 < itemList.Count; ++j1)
                yield return itemList[(j1+num) % itemList.Count];
        }
        else
            using (var itemsEnum = items.GetEnumerator()) {
                var q = new Queue<T>();

                while (itemsEnum.MoveNext() && num-- > 0)
                    q.Enqueue(itemsEnum.Current);

                do {
                    yield return itemsEnum.Current;
                } while (itemsEnum.MoveNext());

                while (q.Count > 0)
                    yield return q.Dequeue();
            }
}

```

With this extension method, you can do

```
var ans = src.Rotate(src.IndexOf("f")).ToList(); // or .ToArray()

```

If you want to do this with no additional object creation, you can use [this answer](https://stackoverflow.com/a/58977280/2557128) instead.
another possibility

```
var newlist = new List<string>(oldList.Count);
newList.Add("f");
newList.AddRange(oldList.Where(x=>x!="f"));

```

less efficeint since it keeps looking at the elements even after its found the target one, but the code is simple