원형 덱 연습: 최근 기록 창과 되돌리기

'use strict';
class CircularDeque {
    constructor(capacity) {
        if (! Number.isInteger(capacity) || capacity < 1) {
            throw new RangeError('capacity must be a positive integer');
        }
        this.data = new Array(capacity);
        this.capacity = capacity;
        this.front = 0;
        this.length = 0;
    }
    pushFront(value) {
        if (this.length === this.capacity) return false;
        this.front =(this.front - 1 + this.capacity) % this.capacity;
        this.data[this.front] = value;
        this.length += 1;
        return true;
    }
    pushBack(value) {
        if (this.length === this.capacity) return false;
        const index =(this.front + this.length) % this.capacity;
        this.data[index] = value;
        this.length += 1;
        return true;
    }
    popFront() {
        if (this.length === 0) return {
            done : true
        };
        const value = this.data[this.front];
        this.data[this.front] = undefined;
        this.front =(this.front + 1) % this.capacity;
        this.length -= 1;
        return {
            done : false, value
        };
    }
    popBack() {
        if (this.length === 0) return {
            done : true
        };
        const index =(this.front + this.length - 1) % this.capacity;
        const value = this.data[index];
        this.data[index] = undefined;
        this.length -= 1;
        return {
            done : false, value
        };
    }
    toArray() {
        const result = [];
        for (let offset = 0; offset < this.length; offset += 1) {
            result.push(this.data[(this.front + offset) % this.capacity]);
        }
        return result;
    }
}
function solve( {
    capacity, events
}) {
    const deque = new CircularDeque(capacity);
    const snapshots = [];
    for (const event of events) {
        if (event.type === 'add') {
            if (! deque.pushBack(event.value)) {
                deque.popFront();
                deque.pushBack(event.value);
            }
        } else if (event.type === 'undo') {
            deque.popBack();
        } else {
            throw new TypeError('unknown event type');
        }
        snapshots.push(deque.toArray());
    }
    return snapshots;
}

def solve(input):
    cap=input['capacity']
    data=[None]*cap
    front=size=0
    out=[]
    for event in input['events']:
        if event['type']=='add':
            if size==cap:
                front=(front+1)%cap
                size-=1
            data[(front+size)%cap]=event['value']
            size+=1
        elif size:
            size-=1
            data[(front+size)%cap]=None
        out.append([data[(front+i)%cap] for i in range(size)])
    return out

import java.util.*;
class Solution {
    static class Event {
        String type;
        Object value;
        Event(String t, Object v) {
            type = t;
            value = v;
        }
    }
    public Object[][] solve(int capacity, Event[] events) {
        Object[] data = new Object[capacity];
        int front = 0, size = 0;
        List < Object[] > out = new ArrayList < >();
        for (Event e : events) {
            if (e.type.equals("add")) {
                if (size == capacity) {
                    front =(front + 1) % capacity;
                    size--;
                }
                data[(front + size) % capacity] = e.value;
                size++;
            } else if (size > 0) {
                size--;
                data[(front + size) % capacity] = null;
            }
            Object[] row = new Object[size];
            for (int i = 0; i < size; i++) row[i] = data[(front + i) % capacity];
            out.add(row);
        }
        return out.toArray(new Object[0][]);
    }
}

#include <cstddef>
#include <string>
#include <vector>
#include <variant>
using Value = std::variant < std::nullptr_t, bool, long long, std::string >;
struct Event {
    std::string type;
    Value value = nullptr;
};
std::vector < std::vector < Value >> solve(int capacity, const std::vector < Event > & events) {
    std::vector < Value > data(capacity);
    int front = 0, size = 0;
    std::vector < std::vector < Value >> out;
    for (const auto & e : events) {
        if (e.type == "add") {
            if (size == capacity) {
                front =(front + 1) % capacity;
                size--;
            }
            data[(front + size) % capacity] = e.value;
            size++;
        } else if (size) {
            size--;
            data[(front + size) % capacity] = nullptr;
        }
        std::vector < Value > row;
        for (int i = 0; i < size; i++) row.push_back(data[(front + i) % capacity]);
        out.push_back(row);
    }
    return out;
}

using System.Collections.Generic;
public class Solution {
    public class Event {
        public string type;
        public object value;
        public Event(string t, object v) {
            type = t;
            value = v;
        }
    }
    public object[][] Solve(int capacity, Event[] events) {
        var data = new object[capacity];
        int front = 0, size = 0;
        var result = new List < object[] >();
        foreach(var e in events) {
            if (e.type == "add") {
                if (size == capacity) {
                    front =(front + 1) % capacity;
                    size--;
                }
                data[(front + size) % capacity] = e.value;
                size++;
            } else if (size > 0) {
                size--;
                data[(front + size) % capacity] = null;
            }
            var row = new object[size];
            for (int i = 0; i < size; i++) row[i] = data[(front + i) % capacity];
            result.Add(row);
        }
        return result.ToArray();
    }
}