id int64 1 2.26k | language stringclasses 7
values | category stringclasses 3
values | difficulty stringclasses 2
values | task_description stringclasses 132
values | code stringlengths 68 753 | explanation stringclasses 449
values |
|---|---|---|---|---|---|---|
901 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack coll = { .top = -1 };
push(&coll, 44.97);
push(&coll, 58.54);
push(... | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
902 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack box_ = { .top = -1 };
push(&box_, 21.98);
push(&box_, 77.91);
push(... | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
903 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack box_ = { .top = -1 };
push(&box_, 95.1);
push(&box_, 35.71);
push(&... | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
904 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack coll = { .top = -1 };
push(&coll, 70.68);
push(&coll, 74.37);
push(... | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
905 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack s = { .top = -1 };
push(&s, 51.25);
push(&s, 27.49);
printf("%g\n",... | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
906 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack box_ = { .top = -1 };
push(&box_, 67.66);
push(&box_, 1.41);
printf... | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
907 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack buf = { .top = -1 };
push(&buf, 84.24);
push(&buf, 52.38);
printf("... | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
908 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack container = { .top = -1 };
push(&container, 99.29);
push(&container, 24... | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
909 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack q = { .top = -1 };
push(&q, 80.33);
push(&q, 58.21);
push(&q, 13.76... | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
910 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack buf = { .top = -1 };
push(&buf, 52.21);
push(&buf, 44.3);
push(&buf... | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
911 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack box_ = { .top = -1 };
push(&box_, 84.46);
push(&box_, 63.1);
push(&... | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
912 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack q = { .top = -1 };
push(&q, 3.54);
push(&q, 2.14);
push(&q, 77.23);... | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
913 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack q = { .top = -1 };
push(&q, 57.61);
printf("%g\n", (double)pop(&q));
... | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
914 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack coll = { .top = -1 };
push(&coll, 63.52);
printf("%g\n", (double)pop(&c... | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
915 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack buf = { .top = -1 };
push(&buf, 20.19);
printf("%g\n", (double)pop(&buf... | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
916 | C | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <stdio.h>
#define MAX 100
typedef struct { double items[MAX]; int top; } Stack;
void push(Stack* s, double value) { s->items[++s->top] = value; }
double pop(Stack* s) { return s->items[s->top--]; }
int main(void) {
Stack box_ = { .top = -1 };
push(&box_, 77.27);
printf("%g\n", (double)pop(&b... | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
917 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> coll;
coll.push(3);
coll.push(82);
coll.push(75);
std::cout << coll.top() << std::endl; coll.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
918 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(59);
q.push(77);
q.push(16);
std::cout << q.top() << std::endl; q.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
919 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(37);
s.push(34);
s.push(24);
std::cout << s.top() << std::endl; s.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
920 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(64);
q.push(47);
q.push(27);
std::cout << q.top() << std::endl; q.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
921 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(63);
q.push(3);
std::cout << q.top() << std::endl; q.pop();
q.push(10);
std::cout << q.top() << std::endl; q.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
922 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> coll;
coll.push(10);
coll.push(27);
std::cout << coll.top() << std::endl; coll.pop();
coll.push(54);
std::cout << coll.top() << std::endl; coll.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
923 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> buf;
buf.push(82);
buf.push(58);
std::cout << buf.top() << std::endl; buf.pop();
buf.push(24);
std::cout << buf.top() << std::endl; buf.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
924 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(23);
q.push(85);
std::cout << q.top() << std::endl; q.pop();
q.push(81);
std::cout << q.top() << std::endl; q.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
925 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(16);
q.push(44);
q.push(45);
q.push(62);
std::cout << q.top() << std::endl; q.pop();
std::cout << q.top() << std::endl; q.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
926 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> container;
container.push(1);
container.push(21);
container.push(67);
container.push(95);
std::cout << container.top() << std::endl; container.pop();
std::cout << container.top() << std::endl; container.pop();
return ... | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
927 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(78);
s.push(4);
s.push(69);
s.push(3);
std::cout << s.top() << std::endl; s.pop();
std::cout << s.top() << std::endl; s.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
928 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(28);
s.push(47);
s.push(15);
s.push(28);
std::cout << s.top() << std::endl; s.pop();
std::cout << s.top() << std::endl; s.pop();
return 0;
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
929 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(29);
std::cout << s.top() << std::endl; s.pop();
s.push(94);
s.push(89);
return 0;
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
930 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<int> s;
s.push(35);
std::cout << s.top() << std::endl; s.pop();
s.push(62);
s.push(26);
return 0;
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
931 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<int> q;
q.push(45);
std::cout << q.top() << std::endl; q.pop();
q.push(71);
q.push(84);
return 0;
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
932 | C++ | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<int> buf;
buf.push(60);
std::cout << buf.top() << std::endl; buf.pop();
buf.push(64);
buf.push(56);
return 0;
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
933 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> container;
container.push(94.69);
container.push(92.31);
container.push(25.76);
std::cout << container.top() << std::endl; container.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
934 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> coll;
coll.push(28.83);
coll.push(39.89);
coll.push(58.78);
std::cout << coll.top() << std::endl; coll.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
935 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> buf;
buf.push(17.4);
buf.push(21.38);
buf.push(72.48);
std::cout << buf.top() << std::endl; buf.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
936 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> box_;
box_.push(42.95);
box_.push(74.96);
box_.push(81.77);
std::cout << box_.top() << std::endl; box_.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
937 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> container;
container.push(38.92);
container.push(20.77);
std::cout << container.top() << std::endl; container.pop();
container.push(89.89);
std::cout << container.top() << std::endl; container.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
938 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> box_;
box_.push(17.56);
box_.push(4.34);
std::cout << box_.top() << std::endl; box_.pop();
box_.push(59.1);
std::cout << box_.top() << std::endl; box_.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
939 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> coll;
coll.push(95.09);
coll.push(53.52);
std::cout << coll.top() << std::endl; coll.pop();
coll.push(12.35);
std::cout << coll.top() << std::endl; coll.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
940 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> box_;
box_.push(79.3);
box_.push(36.42);
std::cout << box_.top() << std::endl; box_.pop();
box_.push(66.04);
std::cout << box_.top() << std::endl; box_.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
941 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> buf;
buf.push(13.11);
buf.push(32.54);
buf.push(2.08);
buf.push(33.56);
std::cout << buf.top() << std::endl; buf.pop();
std::cout << buf.top() << std::endl; buf.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
942 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> s;
s.push(56.6);
s.push(39.17);
s.push(60.58);
s.push(53.2);
std::cout << s.top() << std::endl; s.pop();
std::cout << s.top() << std::endl; s.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
943 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> container;
container.push(94.68);
container.push(80.94);
container.push(67.46);
container.push(57.82);
std::cout << container.top() << std::endl; container.pop();
std::cout << container.top() << std::endl; container.po... | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
944 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | #include <iostream>
#include <stack>
int main() {
std::stack<double> box_;
box_.push(32.46);
box_.push(32.69);
box_.push(20.52);
box_.push(80.47);
std::cout << box_.top() << std::endl; box_.pop();
std::cout << box_.top() << std::endl; box_.pop();
return 0;
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
945 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<double> box_;
box_.push(12.81);
std::cout << box_.top() << std::endl; box_.pop();
box_.push(60.54);
box_.push(59.53);
return 0;
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
946 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<double> s;
s.push(58.06);
std::cout << s.top() << std::endl; s.pop();
s.push(64.72);
s.push(85.75);
return 0;
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
947 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<double> q;
q.push(91.25);
std::cout << q.top() << std::endl; q.pop();
q.push(84.32);
q.push(40.88);
return 0;
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
948 | C++ | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | #include <iostream>
#include <stack>
int main() {
std::stack<double> container;
container.push(91.89);
std::cout << container.top() << std::endl; container.pop();
container.push(64.83);
container.push(7.88);
return 0;
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
949 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(54);
q.push(93);
q.push(39);
println!("{:?}", q.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
950 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | fn main() {
let mut buf: Vec<i32> = Vec::new();
buf.push(97);
buf.push(45);
buf.push(52);
println!("{:?}", buf.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
951 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | fn main() {
let mut container: Vec<i32> = Vec::new();
container.push(100);
container.push(41);
container.push(64);
println!("{:?}", container.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
952 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, pop. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(51);
q.push(39);
q.push(90);
println!("{:?}", q.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'pop']. |
953 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut box_: Vec<i32> = Vec::new();
box_.push(83);
box_.push(16);
println!("{:?}", box_.pop());
box_.push(80);
println!("{:?}", box_.pop());
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
954 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(29);
q.push(7);
println!("{:?}", q.pop());
q.push(18);
println!("{:?}", q.pop());
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
955 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut buf: Vec<i32> = Vec::new();
buf.push(89);
buf.push(93);
println!("{:?}", buf.pop());
buf.push(29);
println!("{:?}", buf.pop());
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
956 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(25);
q.push(93);
println!("{:?}", q.pop());
q.push(69);
println!("{:?}", q.pop());
} | Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
957 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut coll: Vec<i32> = Vec::new();
coll.push(7);
coll.push(34);
coll.push(6);
coll.push(15);
println!("{:?}", coll.pop());
println!("{:?}", coll.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
958 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(34);
q.push(43);
q.push(89);
q.push(79);
println!("{:?}", q.pop());
println!("{:?}", q.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
959 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut coll: Vec<i32> = Vec::new();
coll.push(22);
coll.push(18);
coll.push(75);
coll.push(59);
println!("{:?}", coll.pop());
println!("{:?}", coll.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
960 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut buf: Vec<i32> = Vec::new();
buf.push(19);
buf.push(97);
buf.push(75);
buf.push(53);
println!("{:?}", buf.pop());
println!("{:?}", buf.pop());
} | Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
961 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | fn main() {
let mut coll: Vec<i32> = Vec::new();
coll.push(16);
println!("{:?}", coll.pop());
coll.push(68);
coll.push(31);
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
962 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | fn main() {
let mut container: Vec<i32> = Vec::new();
container.push(62);
println!("{:?}", container.pop());
container.push(63);
container.push(36);
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
963 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | fn main() {
let mut buf: Vec<i32> = Vec::new();
buf.push(99);
println!("{:?}", buf.pop());
buf.push(62);
buf.push(29);
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
964 | Rust | Data Structures | intermediate | Implement a stack of ints and run the operation sequence: push, pop, push, push. | fn main() {
let mut q: Vec<i32> = Vec::new();
q.push(34);
println!("{:?}", q.pop());
q.push(38);
q.push(92);
} | Stack with int elements, ops=['push', 'pop', 'push', 'push']. |
965 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | fn main() {
let mut q: Vec<f64> = Vec::new();
q.push(35.95);
q.push(83.72);
q.push(25.0);
println!("{:?}", q.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
966 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | fn main() {
let mut s: Vec<f64> = Vec::new();
s.push(69.8);
s.push(8.44);
s.push(49.97);
println!("{:?}", s.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
967 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | fn main() {
let mut coll: Vec<f64> = Vec::new();
coll.push(22.4);
coll.push(82.03);
coll.push(19.6);
println!("{:?}", coll.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
968 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, pop. | fn main() {
let mut s: Vec<f64> = Vec::new();
s.push(81.59);
s.push(76.4);
s.push(51.88);
println!("{:?}", s.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'pop']. |
969 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut buf: Vec<f64> = Vec::new();
buf.push(71.14);
buf.push(65.87);
println!("{:?}", buf.pop());
buf.push(11.46);
println!("{:?}", buf.pop());
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
970 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut buf: Vec<f64> = Vec::new();
buf.push(39.17);
buf.push(45.79);
println!("{:?}", buf.pop());
buf.push(21.1);
println!("{:?}", buf.pop());
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
971 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut q: Vec<f64> = Vec::new();
q.push(28.51);
q.push(17.26);
println!("{:?}", q.pop());
q.push(87.11);
println!("{:?}", q.pop());
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
972 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, pop, push, pop. | fn main() {
let mut s: Vec<f64> = Vec::new();
s.push(46.63);
s.push(11.61);
println!("{:?}", s.pop());
s.push(2.64);
println!("{:?}", s.pop());
} | Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
973 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut buf: Vec<f64> = Vec::new();
buf.push(3.83);
buf.push(66.53);
buf.push(45.81);
buf.push(27.29);
println!("{:?}", buf.pop());
println!("{:?}", buf.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
974 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut box_: Vec<f64> = Vec::new();
box_.push(21.99);
box_.push(40.3);
box_.push(43.65);
box_.push(34.04);
println!("{:?}", box_.pop());
println!("{:?}", box_.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
975 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut q: Vec<f64> = Vec::new();
q.push(65.21);
q.push(73.47);
q.push(42.84);
q.push(30.11);
println!("{:?}", q.pop());
println!("{:?}", q.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
976 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop. | fn main() {
let mut container: Vec<f64> = Vec::new();
container.push(61.14);
container.push(52.34);
container.push(11.81);
container.push(5.94);
println!("{:?}", container.pop());
println!("{:?}", container.pop());
} | Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
977 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | fn main() {
let mut q: Vec<f64> = Vec::new();
q.push(6.26);
println!("{:?}", q.pop());
q.push(27.35);
q.push(7.52);
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
978 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | fn main() {
let mut q: Vec<f64> = Vec::new();
q.push(28.27);
println!("{:?}", q.pop());
q.push(70.25);
q.push(41.05);
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
979 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | fn main() {
let mut box_: Vec<f64> = Vec::new();
box_.push(11.03);
println!("{:?}", box_.pop());
box_.push(88.07);
box_.push(27.56);
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
980 | Rust | Data Structures | intermediate | Implement a stack of floats and run the operation sequence: push, pop, push, push. | fn main() {
let mut s: Vec<f64> = Vec::new();
s.push(17.93);
println!("{:?}", s.pop());
s.push(64.05);
s.push(70.88);
} | Stack with float elements, ops=['push', 'pop', 'push', 'push']. |
981 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, pop. | from collections import deque
buf = deque()
buf.append(94)
buf.append(1)
buf.append(13)
print(buf.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'pop']. |
982 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, pop. | from collections import deque
container = deque()
container.append(90)
container.append(80)
container.append(62)
print(container.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'pop']. |
983 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, pop. | from collections import deque
buf = deque()
buf.append(89)
buf.append(31)
buf.append(22)
print(buf.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'pop']. |
984 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, pop. | from collections import deque
coll = deque()
coll.append(9)
coll.append(22)
coll.append(24)
print(coll.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'pop']. |
985 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, pop, push, pop. | from collections import deque
box_ = deque()
box_.append(19)
box_.append(2)
print(box_.popleft())
box_.append(61)
print(box_.popleft()) | Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
986 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, pop, push, pop. | from collections import deque
buf = deque()
buf.append(3)
buf.append(23)
print(buf.popleft())
buf.append(10)
print(buf.popleft()) | Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
987 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, pop, push, pop. | from collections import deque
coll = deque()
coll.append(98)
coll.append(2)
print(coll.popleft())
coll.append(46)
print(coll.popleft()) | Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
988 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, pop, push, pop. | from collections import deque
container = deque()
container.append(1)
container.append(63)
print(container.popleft())
container.append(61)
print(container.popleft()) | Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']. |
989 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop. | from collections import deque
q = deque()
q.append(3)
q.append(73)
q.append(88)
q.append(38)
print(q.popleft())
print(q.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
990 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop. | from collections import deque
container = deque()
container.append(22)
container.append(97)
container.append(19)
container.append(100)
print(container.popleft())
print(container.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
991 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop. | from collections import deque
buf = deque()
buf.append(95)
buf.append(43)
buf.append(58)
buf.append(63)
print(buf.popleft())
print(buf.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
992 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop. | from collections import deque
container = deque()
container.append(33)
container.append(85)
container.append(63)
container.append(33)
print(container.popleft())
print(container.popleft()) | Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']. |
993 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, pop, push, push. | from collections import deque
q = deque()
q.append(46)
print(q.popleft())
q.append(91)
q.append(43) | Queue with int elements, ops=['push', 'pop', 'push', 'push']. |
994 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, pop, push, push. | from collections import deque
container = deque()
container.append(100)
print(container.popleft())
container.append(77)
container.append(62) | Queue with int elements, ops=['push', 'pop', 'push', 'push']. |
995 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, pop, push, push. | from collections import deque
q = deque()
q.append(35)
print(q.popleft())
q.append(67)
q.append(94) | Queue with int elements, ops=['push', 'pop', 'push', 'push']. |
996 | Python | Data Structures | intermediate | Implement a queue of ints and run the operation sequence: push, pop, push, push. | from collections import deque
coll = deque()
coll.append(3)
print(coll.popleft())
coll.append(53)
coll.append(29) | Queue with int elements, ops=['push', 'pop', 'push', 'push']. |
997 | Python | Data Structures | intermediate | Implement a queue of floats and run the operation sequence: push, push, push, pop. | from collections import deque
coll = deque()
coll.append(99.41)
coll.append(36.36)
coll.append(4.06)
print(coll.popleft()) | Queue with float elements, ops=['push', 'push', 'push', 'pop']. |
998 | Python | Data Structures | intermediate | Implement a queue of floats and run the operation sequence: push, push, push, pop. | from collections import deque
coll = deque()
coll.append(97.36)
coll.append(36.58)
coll.append(74.69)
print(coll.popleft()) | Queue with float elements, ops=['push', 'push', 'push', 'pop']. |
999 | Python | Data Structures | intermediate | Implement a queue of floats and run the operation sequence: push, push, push, pop. | from collections import deque
box_ = deque()
box_.append(64.23)
box_.append(96.58)
box_.append(87.84)
print(box_.popleft()) | Queue with float elements, ops=['push', 'push', 'push', 'pop']. |
1,000 | Python | Data Structures | intermediate | Implement a queue of floats and run the operation sequence: push, push, push, pop. | from collections import deque
box_ = deque()
box_.append(98.75)
box_.append(87.73)
box_.append(18.32)
print(box_.popleft()) | Queue with float elements, ops=['push', 'push', 'push', 'pop']. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.