M: Give me a generic algorithm for a function, which gives a random integer, but only one that hasn’t been selected within the last N times that this function has been called for the same purpose. A real world example: I have a playlist with 2000 songs and, when I put it on shuffle with repeat on, I want to make sure that the song that comes up at least hasn’t been played within the last 50 songs. I don’t know if there’s any “official“ algorithmic language, but if there is please give me the answer in whatever one is considered most universal; otherwise, just do your best

G: TL;DR
Maintain a fixed-size “history” buffer (queue) and a matching set. On each request, pick a random candidate and reject it if it’s in the set, then enqueue it and evict the oldest when the buffer exceeds N.

Data structures

historyQueue: FIFO queue of up to N integers
historySet: hash-set of the same integers (for O(1) membership tests)
M: total number of possible integers (e.g. 2000 songs)
N: history length (e.g. 50)

1. Rejection-sampling algorithm

function init(M, N):
    historyQueue ← empty queue
    historySet ← empty set

function next():
    require N < M
    repeat:
        x ← random integer in [0 … M−1]
    until x ∉ historySet

    historyQueue.enqueue(x)
    historySet.add(x)

    if historyQueue.size > N:
        y ← historyQueue.dequeue()
        historySet.remove(y)

    return x

Pros: Simple, expected O(1) when N≪M.
Cons: unbounded loops if N≈M, though in practical playlists N≪M.

2. Alternative: dynamic “allowed” list

function init(M, N):
    allowedList ← list of [0…M−1]
    historyQueue ← empty queue

function next():
    if allowedList.empty:
        // no candidates left outside history; handle as you wish
    i ← random index in [0 … allowedList.size−1]
    x ← allowedList[i]

    historyQueue.enqueue(x)
    allowedList.removeAt(i)

    if historyQueue.size > N:
        y ← historyQueue.dequeue()
        allowedList.append(y)

    return x

Pros: true uniform choice among eligible items, no rejection loops.
Cons: removal from middle of a list can be O(M) unless you use a linked structure or swap-pop.

3. Full-shuffle option (no repeats until exhaustion)

If you prefer no repeats until all M items have played (then reshuffle):

Create an array A = [0…M−1].
On init or when A becomes empty, shuffle it via Fisher–Yates.
next() simply pops and returns A.pop() until empty.

Third consideration: when N ≥ M

If you set N ≥ M, you cannot avoid repeats in the last N. You must either reduce N, fall back to full shuffle, or allow repetition once all items are in history.