Sort by

recency

|

511 Discussions

|

  • + 0 comments

    C solution:

    #include <stdio.h>
    #include <string.h>
    #include <math.h>
    #include <stdlib.h>
    #include <stdint.h>
    
    
    typedef struct {
        int type;
        int value;
    } query_t;
    
    typedef struct {
        int* stack;
        size_t tos;
        size_t size;
    } stack_t;
    
    typedef struct {
        stack_t* s1;
        stack_t* s2;
    } queue_t;
    
    
    void stack_init(stack_t* s, size_t size) {
        s->size = size;
        s->stack = malloc(sizeof(int) * size);
        s->tos = 0;
    }
    
    stack_t* stack_new(size_t size) {
        if(size < 2) {
            return NULL;
        }
        stack_t* s = malloc(sizeof(stack_t) * 1);
        stack_init(s, size);
        return s;
    }
    
    void stack_deinit(stack_t * s) {
        s->size = 0;
        s->tos = 0;
        free(s->stack);
    }
    
    void stack_destroy(stack_t* s) {
        stack_deinit(s);
        free(s);
    }
    
    static inline int stack_is_empty(stack_t* s) {
        return s->tos == 0;
    }
    
    static inline int stack_is_full(stack_t* s) {
        return s->tos == s->size;
    }
    
    #if 0
    void stack_resize(stack_t* s, size_t new_size) {
        int* new_mem = malloc(sizeof(int) * new_size);
        memcpy(new_mem, s->stack, s->tos * sizeof(int));
        free(s->stack);
        s->stack = new_mem;
        s->size = new_size;
    }
    
    void stack_expand(stack_t* s) {
        stack_resize(s, s->size * 2);
    }
    
    void stack_shrink(stack_t* s) {
        if(s->size > 2) {
            stack_resize(s, s->size / 2);
        }
    }
    #endif /* 0 */
    
    int stack_push(stack_t * s, int item) {
        /*
        if(s->tos > ((s->size * 3) / 4)) {
            stack_expand(s);
        }
        */
        if(stack_is_full(s)) {
            return 0;
        }
        s->stack[s->tos++] = item;
        return 1;
    }
    
    int stack_pop(stack_t* s, int* item) {
        if(stack_is_empty(s)) {
            return 0;
        }
        /*
        if(s->tos < (s->size / 4)) {
            stack_shrink(s);
        }
        */
        int temp = s->stack[--s->tos];
        if(item) {
            (*item) = temp;
        }
        return 1;
    }
    
    int stack_peek(stack_t* s, int* item) {
        if(stack_is_empty(s)) {
            return 0;
        }
        (*item) = s->stack[s->tos - 1];
        return 1;
    }
    
    void queue_init(queue_t* q, size_t size) {
        q->s1 = stack_new(size);
        q->s2 = stack_new(size);
    }
    
    queue_t* queue_new(size_t size) {
        queue_t* q = malloc(sizeof(queue_t) * 1);
        queue_init(q, size);
        return q;
    }
    
    void queue_deinit(queue_t* q) {
        stack_deinit(q->s1);
        stack_deinit(q->s2);
    }
    
    void queue_destroy(queue_t* q) {
        stack_destroy(q->s1);
        stack_destroy(q->s2);
        free(q);
    }
    
    int queue_is_empty(queue_t* q) {
        return stack_is_empty(q->s1) && stack_is_empty(q->s2);
    }
    
    int queue_push(queue_t * q, int item) {
        return stack_push(q->s1, item);
    }
    
    int queue_pop(queue_t* q, int * item) {
        if(stack_is_empty(q->s2)) {
            while(!stack_is_empty(q->s1)) {
                int temp = 0;
                stack_pop(q->s1, &temp);
                stack_push(q->s2, temp);
            }
        }
        return stack_pop(q->s2, item);
    }
    
    int queue_peek(queue_t* q, int* item) {
        if(stack_is_empty(q->s2)) {
            while(!stack_is_empty(q->s1)) {
                int temp = 0;
                stack_pop(q->s1, &temp);
                stack_push(q->s2, temp);
            }
        }
        return stack_peek(q->s2, item);
    }
    
    int main() {
        uint32_t num_queries = 0;
        query_t * queries = NULL;
        char buffer[16] = {0};
        int read_chars = 0;
        
        fgets(buffer, sizeof(buffer) - 1, stdin);
        sscanf(buffer, "%u", &num_queries);
        
        queries = malloc(sizeof(query_t) * num_queries);
        
        for(size_t i = 0; i < num_queries; ++i) {
            fgets(buffer, sizeof(buffer), stdin);
            read_chars = sscanf(buffer, "%d", &queries[i].type);
            if(queries[i].type == 1) {
                sscanf(&buffer[read_chars], "%d", &queries[i].value);
            }
            /* printf(">>> %s", buffer); */
        }
        
        /*
        for(size_t i = 0; i < num_queries; ++i) {
            printf("%d ", queries[i].type);
            if(queries[i].type == 1) {
                printf(": %d", queries[i].value);
            }
            printf("\n");
        }
        */
        
        queue_t * queue = queue_new(100000);
        for(size_t q = 0; q < num_queries; ++q) {
            if(queries[q].type == 1) {
                queue_push(queue, queries[q].value);
                
            } else if(queries[q].type == 2) {
                queue_pop(queue, NULL);
                
            } else {
                int item = 0;
                queue_peek(queue, &item);
                printf("%d\n", item);
            }
        }
        
        queue_destroy(queue);
        free(queries);
        
        /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
        return 0;
    }
    
  • + 0 comments

    typescript boilerplate:

    `use strict";

    process.stdin.resume(); process.stdin.setEncoding("utf-8"); let inputString: string = ""; let inputLines: string[] = []; let currentLine: number = 0; process.stdin.on("data", function (inputStdin: string): void { inputString += inputStdin; });

    process.stdin.on("end", function (): void { inputLines = inputString.split("\n"); inputString = ""; main(); });

    function readLine(): string { return inputLines[currentLine++]; }

    class stackQueue { private s1: number[] = []; private s2: number[] = [];

    constructor() { this.s1 = []; this.s2 = []; }

    enqueue(x: number) { // Enter your code here }

    dequeue() { // Enter your code here }

    print() { // Enter your code here } }

    function main() { const testQueue = new stackQueue(); const commandMap = { "1": "enqueue", "2": "dequeue", "3": "print" } as const;

    inputLines.shift();

    inputLines.map((inputLine: string) => { const [command, input] = inputLine.split(" ") as ["1" | "2" | "3", string]; const method = commandMap[command]; if (method == "enqueue") { return testQueue.enqueue(Number(input)); } return testQueuemethod; }); }

    `

    javascript boilerplate "use strict";

    process.stdin.resume(); process.stdin.setEncoding("utf-8"); let inputString = ""; let inputLines = []; let currentLine = 0; process.stdin.on("data", function (inputStdin) { inputString += inputStdin; });

    process.stdin.on("end", function () { inputLines = inputString.split("\n"); inputString = ""; main(); });

    function readLine() { return inputLines[currentLine++]; }

    class stackQueue { constructor() { this.s1 = []; this.s2 = []; }

    enqueue(x) { // Enter your code here }

    dequeue() { // Enter your code here }

    print() { // Enter your code here } }

    function main() { const testQueue = new stackQueue(); const commandMap = { 1: "enqueue", 2: "dequeue", 3: "print" };

    inputLines.shift();

    inputLines.map((inputLine) => { const [command, input] = inputLine.split(" "); const method = commandMap[command]; if (method == "enqueue") { return testQueue.enqueue(Number(input)); } return testQueuemethod; }); }

    `

  • + 0 comments
    que=[]
    for i in range(int(input())):
        x=input()
        if x[0]=='1':
            val=int(x[2:])
            que.append(val)
        elif x[0]=='2':
            que.pop(0)
        elif x[0]=='3':
            print(que[0])
    
  • + 1 comment

    Java solution

    public class Solution { private Stack stackEnqueue = new Stack<>(); private Stack stackDequeue = new Stack<>();

    // Enqueue
    public void enqueue(int n){
        stackEnqueue.push(n);
    }
    
    // Dequeue
    public void dequeue(){
        reverseStack();
        if(!stackDequeue.isEmpty()){
            stackDequeue.pop();
        }
    }
    
    //Reverse
    private void reverseStack(){
        if(stackDequeue.isEmpty()){
            while(!stackEnqueue.isEmpty()){
                stackDequeue.push(stackEnqueue.pop());
            }
        }
    }
    
    //Print front element
    public void printFrontElement(){
        reverseStack();
        if(!stackDequeue.isEmpty()){
            System.out.println(stackDequeue.peek());
        }
    }
    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner scanner = new Scanner((System.in));
        Solution twoStackQueue = new Solution();
        int count = scanner.nextInt();
        for(int i = 0; i< count; i++){
            int choice = scanner.nextInt();
            switch (choice){
                case 1:
                    int enqueueNumber = scanner.nextInt();
                    twoStackQueue.enqueue(enqueueNumber);
                    break;
                case 2:
                    twoStackQueue.dequeue();
                    break;
                case 3:
                    twoStackQueue.printFrontElement();
                    break;
            }
        }
        scanner.close();
    }
    

    }

  • + 0 comments

    Using Python3

    old, new = [], []
    for _ in range(int(input())):
        val = list(map(int,input().split()))
        if val[0] == 1:
            new.append(val[1])
        elif val[0] == 2:
            if not old :
                while new : old.append(new.pop())
            old.pop()
        else:
            print(old[-1] if old else new[0])