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 |
|---|---|---|---|---|---|---|
601 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | function insertionSort(records) {
for (let i = 1; i < records.length; i++) {
const key = records[i];
let j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
records[j + 1] = key;
}
return records;
}
module.exports = { insertionSort };
console.log(in... | Insertion sort on float data, variable named 'records', 10 elements. |
602 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
const key = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
return arr;
}
module.exports = { insertionSort };
console.log(insertionSort([38.01, 37.85, 50.33... | Insertion sort on float data, variable named 'arr', 10 elements. |
603 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | function insertionSort(list1) {
for (let i = 1; i < list1.length; i++) {
const key = list1[i];
let j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = key;
}
return list1;
}
module.exports = { insertionSort };
console.log(insertionSort([45.... | Insertion sort on float data, variable named 'list1', 10 elements. |
604 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | function insertionSort(seq) {
for (let i = 1; i < seq.length; i++) {
const key = seq[i];
let j = i - 1;
while (j >= 0 && seq[j] > key) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
}
return seq;
}
module.exports = { insertionSort };
console.log(insertionSort([2.87, 20.92, 7.62, ... | Insertion sort on float data, variable named 'seq', 12 elements. |
605 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | function insertionSort(collection) {
for (let i = 1; i < collection.length; i++) {
const key = collection[i];
let j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
}
collection[j + 1] = key;
}
return collection;
}
module.exports = { inserti... | Insertion sort on float data, variable named 'collection', 12 elements. |
606 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | function insertionSort(elements) {
for (let i = 1; i < elements.length; i++) {
const key = elements[i];
let j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
elements[j + 1] = key;
}
return elements;
}
module.exports = { insertionSort };
consol... | Insertion sort on float data, variable named 'elements', 12 elements. |
607 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | function insertionSort(input_arr) {
for (let i = 1; i < input_arr.length; i++) {
const key = input_arr[i];
let j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
input_arr[j + 1] = key;
}
return input_arr;
}
module.exports = { insertionSort }... | Insertion sort on float data, variable named 'input_arr', 15 elements. |
608 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | function insertionSort(buffer) {
for (let i = 1; i < buffer.length; i++) {
const key = buffer[i];
let j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer[j + 1] = key;
}
return buffer;
}
module.exports = { insertionSort };
console.log(insertionS... | Insertion sort on float data, variable named 'buffer', 15 elements. |
609 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | function insertionSort(items) {
for (let i = 1; i < items.length; i++) {
const key = items[i];
let j = i - 1;
while (j >= 0 && items[j] > key) {
items[j + 1] = items[j];
j--;
}
items[j + 1] = key;
}
return items;
}
module.exports = { insertionSort };
console.log(insertionSort([88.... | Insertion sort on float data, variable named 'items', 15 elements. |
610 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | function insertionSort(vals) {
for (let i = 1; i < vals.length; i++) {
const key = vals[i];
let j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
return vals;
}
module.exports = { insertionSort };
console.log(insertionSort([36.37, 14.1... | Insertion sort on float data, variable named 'vals', 20 elements. |
611 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | function insertionSort(vals) {
for (let i = 1; i < vals.length; i++) {
const key = vals[i];
let j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
return vals;
}
module.exports = { insertionSort };
console.log(insertionSort([-18.82, 75.... | Insertion sort on float data, variable named 'vals', 20 elements. |
612 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | function insertionSort(input_arr) {
for (let i = 1; i < input_arr.length; i++) {
const key = input_arr[i];
let j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
input_arr[j + 1] = key;
}
return input_arr;
}
module.exports = { insertionSort }... | Insertion sort on float data, variable named 'input_arr', 20 elements. |
613 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] input_arr) {
for (int i = 1; i < input_arr.length; i++) {
int key = input_arr[i];
int j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
... | Insertion sort on int data, variable named 'input_arr', 5 elements. |
614 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] nums) {
for (int i = 1; i < nums.length; i++) {
int key = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;... | Insertion sort on int data, variable named 'nums', 5 elements. |
615 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] input_arr) {
for (int i = 1; i < input_arr.length; i++) {
int key = input_arr[i];
int j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
... | Insertion sort on int data, variable named 'input_arr', 5 elements. |
616 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] elements) {
for (int i = 1; i < elements.length; i++) {
int key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on int data, variable named 'elements', 8 elements. |
617 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] nums) {
for (int i = 1; i < nums.length; i++) {
int key = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;... | Insertion sort on int data, variable named 'nums', 8 elements. |
618 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] seq) {
for (int i = 1; i < seq.length; i++) {
int key = seq[i];
int j = i - 1;
while (j >= 0 && seq[j] > key) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
... | Insertion sort on int data, variable named 'seq', 8 elements. |
619 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] list1) {
for (int i = 1; i < list1.length; i++) {
int key = list1[i];
int j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1]... | Insertion sort on int data, variable named 'list1', 10 elements. |
620 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] elements) {
for (int i = 1; i < elements.length; i++) {
int key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on int data, variable named 'elements', 10 elements. |
621 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] collection) {
for (int i = 1; i < collection.length; i++) {
int key = collection[i];
int j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
... | Insertion sort on int data, variable named 'collection', 10 elements. |
622 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] vals) {
for (int i = 1; i < vals.length; i++) {
int key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;... | Insertion sort on int data, variable named 'vals', 12 elements. |
623 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] dataset) {
for (int i = 1; i < dataset.length; i++) {
int key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
... | Insertion sort on int data, variable named 'dataset', 12 elements. |
624 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] entries) {
for (int i = 1; i < entries.length; i++) {
int key = entries[i];
int j = i - 1;
while (j >= 0 && entries[j] > key) {
entries[j + 1] = entries[j];
j--;
}
... | Insertion sort on int data, variable named 'entries', 12 elements. |
625 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] nums) {
for (int i = 1; i < nums.length; i++) {
int key = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;... | Insertion sort on int data, variable named 'nums', 15 elements. |
626 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] data) {
for (int i = 1; i < data.length; i++) {
int key = data[i];
int j = i - 1;
while (j >= 0 && data[j] > key) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = key;... | Insertion sort on int data, variable named 'data', 15 elements. |
627 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] input_arr) {
for (int i = 1; i < input_arr.length; i++) {
int key = input_arr[i];
int j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
... | Insertion sort on int data, variable named 'input_arr', 15 elements. |
628 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] buffer) {
for (int i = 1; i < buffer.length; i++) {
int key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer... | Insertion sort on int data, variable named 'buffer', 20 elements. |
629 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] buffer) {
for (int i = 1; i < buffer.length; i++) {
int key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer... | Insertion sort on int data, variable named 'buffer', 20 elements. |
630 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | public class Main {
static void insertionSort(int[] records) {
for (int i = 1; i < records.length; i++) {
int key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
... | Insertion sort on int data, variable named 'records', 20 elements. |
631 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] values) {
for (int i = 1; i < values.length; i++) {
double key = values[i];
int j = i - 1;
while (j >= 0 && values[j] > key) {
values[j + 1] = values[j];
j--;
}
... | Insertion sort on float data, variable named 'values', 5 elements. |
632 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] list1) {
for (int i = 1; i < list1.length; i++) {
double key = list1[i];
int j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[... | Insertion sort on float data, variable named 'list1', 5 elements. |
633 | Java | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] elements) {
for (int i = 1; i < elements.length; i++) {
double key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on float data, variable named 'elements', 5 elements. |
634 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] arr) {
for (int i = 1; i < arr.length; i++) {
double key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
... | Insertion sort on float data, variable named 'arr', 8 elements. |
635 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] elements) {
for (int i = 1; i < elements.length; i++) {
double key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on float data, variable named 'elements', 8 elements. |
636 | Java | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] items) {
for (int i = 1; i < items.length; i++) {
double key = items[i];
int j = i - 1;
while (j >= 0 && items[j] > key) {
items[j + 1] = items[j];
j--;
}
items[... | Insertion sort on float data, variable named 'items', 8 elements. |
637 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] arr) {
for (int i = 1; i < arr.length; i++) {
double key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
... | Insertion sort on float data, variable named 'arr', 10 elements. |
638 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] collection) {
for (int i = 1; i < collection.length; i++) {
double key = collection[i];
int j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
... | Insertion sort on float data, variable named 'collection', 10 elements. |
639 | Java | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] records) {
for (int i = 1; i < records.length; i++) {
double key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
... | Insertion sort on float data, variable named 'records', 10 elements. |
640 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] vals) {
for (int i = 1; i < vals.length; i++) {
double key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] ... | Insertion sort on float data, variable named 'vals', 12 elements. |
641 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] arr) {
for (int i = 1; i < arr.length; i++) {
double key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
... | Insertion sort on float data, variable named 'arr', 12 elements. |
642 | Java | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] buffer) {
for (int i = 1; i < buffer.length; i++) {
double key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
... | Insertion sort on float data, variable named 'buffer', 12 elements. |
643 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] seq) {
for (int i = 1; i < seq.length; i++) {
double key = seq[i];
int j = i - 1;
while (j >= 0 && seq[j] > key) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
... | Insertion sort on float data, variable named 'seq', 15 elements. |
644 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] items) {
for (int i = 1; i < items.length; i++) {
double key = items[i];
int j = i - 1;
while (j >= 0 && items[j] > key) {
items[j + 1] = items[j];
j--;
}
items[... | Insertion sort on float data, variable named 'items', 15 elements. |
645 | Java | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] records) {
for (int i = 1; i < records.length; i++) {
double key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
... | Insertion sort on float data, variable named 'records', 15 elements. |
646 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] list1) {
for (int i = 1; i < list1.length; i++) {
double key = list1[i];
int j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[... | Insertion sort on float data, variable named 'list1', 20 elements. |
647 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] data) {
for (int i = 1; i < data.length; i++) {
double key = data[i];
int j = i - 1;
while (j >= 0 && data[j] > key) {
data[j + 1] = data[j];
j--;
}
data[j + 1] ... | Insertion sort on float data, variable named 'data', 20 elements. |
648 | Java | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | public class Main {
static void insertionSort(double[] dataset) {
for (int i = 1; i < dataset.length; i++) {
double key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
... | Insertion sort on float data, variable named 'dataset', 20 elements. |
649 | C | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int vals[], int n) {
for (int i = 1; i < n; i++) {
int key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
}
int main(void) {
int vals[] = {... | Insertion sort on int data, variable named 'vals', 5 elements. |
650 | C | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int dataset[], int n) {
for (int i = 1; i < n; i++) {
int key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'dataset', 5 elements. |
651 | C | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int input_arr[], int n) {
for (int i = 1; i < n; i++) {
int key = input_arr[i];
int j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
input_arr[j + 1] = key;
}
}
int m... | Insertion sort on int data, variable named 'input_arr', 5 elements. |
652 | C | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int elements[], int n) {
for (int i = 1; i < n; i++) {
int key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
elements[j + 1] = key;
}
}
int main(vo... | Insertion sort on int data, variable named 'elements', 8 elements. |
653 | C | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int dataset[], int n) {
for (int i = 1; i < n; i++) {
int key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'dataset', 8 elements. |
654 | C | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int elements[], int n) {
for (int i = 1; i < n; i++) {
int key = elements[i];
int j = i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
elements[j + 1] = key;
}
}
int main(vo... | Insertion sort on int data, variable named 'elements', 8 elements. |
655 | C | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int dataset[], int n) {
for (int i = 1; i < n; i++) {
int key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'dataset', 10 elements. |
656 | C | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int records[], int n) {
for (int i = 1; i < n; i++) {
int key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
records[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'records', 10 elements. |
657 | C | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int buffer[], int n) {
for (int i = 1; i < n; i++) {
int key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer[j + 1] = key;
}
}
int main(void) {
in... | Insertion sort on int data, variable named 'buffer', 10 elements. |
658 | C | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int data[], int n) {
for (int i = 1; i < n; i++) {
int key = data[i];
int j = i - 1;
while (j >= 0 && data[j] > key) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = key;
}
}
int main(void) {
int data[] = {... | Insertion sort on int data, variable named 'data', 12 elements. |
659 | C | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int vals[], int n) {
for (int i = 1; i < n; i++) {
int key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
}
int main(void) {
int vals[] = {... | Insertion sort on int data, variable named 'vals', 12 elements. |
660 | C | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int values[], int n) {
for (int i = 1; i < n; i++) {
int key = values[i];
int j = i - 1;
while (j >= 0 && values[j] > key) {
values[j + 1] = values[j];
j--;
}
values[j + 1] = key;
}
}
int main(void) {
in... | Insertion sort on int data, variable named 'values', 12 elements. |
661 | C | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int entries[], int n) {
for (int i = 1; i < n; i++) {
int key = entries[i];
int j = i - 1;
while (j >= 0 && entries[j] > key) {
entries[j + 1] = entries[j];
j--;
}
entries[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'entries', 15 elements. |
662 | C | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int list1[], int n) {
for (int i = 1; i < n; i++) {
int key = list1[i];
int j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = key;
}
}
int main(void) {
int list... | Insertion sort on int data, variable named 'list1', 15 elements. |
663 | C | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int input_arr[], int n) {
for (int i = 1; i < n; i++) {
int key = input_arr[i];
int j = i - 1;
while (j >= 0 && input_arr[j] > key) {
input_arr[j + 1] = input_arr[j];
j--;
}
input_arr[j + 1] = key;
}
}
int m... | Insertion sort on int data, variable named 'input_arr', 15 elements. |
664 | C | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int records[], int n) {
for (int i = 1; i < n; i++) {
int key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
records[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on int data, variable named 'records', 20 elements. |
665 | C | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int seq[], int n) {
for (int i = 1; i < n; i++) {
int key = seq[i];
int j = i - 1;
while (j >= 0 && seq[j] > key) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
}
}
int main(void) {
int seq[] = {76, 71,... | Insertion sort on int data, variable named 'seq', 20 elements. |
666 | C | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(int nums[], int n) {
for (int i = 1; i < n; i++) {
int key = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;
}
}
int main(void) {
int nums[] = {... | Insertion sort on int data, variable named 'nums', 20 elements. |
667 | C | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double vals[], int n) {
for (int i = 1; i < n; i++) {
double key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
}
int main(void) {
double v... | Insertion sort on float data, variable named 'vals', 5 elements. |
668 | C | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double data[], int n) {
for (int i = 1; i < n; i++) {
double key = data[i];
int j = i - 1;
while (j >= 0 && data[j] > key) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = key;
}
}
int main(void) {
double d... | Insertion sort on float data, variable named 'data', 5 elements. |
669 | C | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double vals[], int n) {
for (int i = 1; i < n; i++) {
double key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
}
int main(void) {
double v... | Insertion sort on float data, variable named 'vals', 5 elements. |
670 | C | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double list1[], int n) {
for (int i = 1; i < n; i++) {
double key = list1[i];
int j = i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = key;
}
}
int main(void) {
do... | Insertion sort on float data, variable named 'list1', 8 elements. |
671 | C | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double records[], int n) {
for (int i = 1; i < n; i++) {
double key = records[i];
int j = i - 1;
while (j >= 0 && records[j] > key) {
records[j + 1] = records[j];
j--;
}
records[j + 1] = key;
}
}
int main(vo... | Insertion sort on float data, variable named 'records', 8 elements. |
672 | C | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double collection[], int n) {
for (int i = 1; i < n; i++) {
double key = collection[i];
int j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
}
collection[j + 1] = key;
... | Insertion sort on float data, variable named 'collection', 8 elements. |
673 | C | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double seq[], int n) {
for (int i = 1; i < n; i++) {
double key = seq[i];
int j = i - 1;
while (j >= 0 && seq[j] > key) {
seq[j + 1] = seq[j];
j--;
}
seq[j + 1] = key;
}
}
int main(void) {
double seq[] =... | Insertion sort on float data, variable named 'seq', 10 elements. |
674 | C | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double vals[], int n) {
for (int i = 1; i < n; i++) {
double key = vals[i];
int j = i - 1;
while (j >= 0 && vals[j] > key) {
vals[j + 1] = vals[j];
j--;
}
vals[j + 1] = key;
}
}
int main(void) {
double v... | Insertion sort on float data, variable named 'vals', 10 elements. |
675 | C | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double buffer[], int n) {
for (int i = 1; i < n; i++) {
double key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on float data, variable named 'buffer', 10 elements. |
676 | C | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double entries[], int n) {
for (int i = 1; i < n; i++) {
double key = entries[i];
int j = i - 1;
while (j >= 0 && entries[j] > key) {
entries[j + 1] = entries[j];
j--;
}
entries[j + 1] = key;
}
}
int main(vo... | Insertion sort on float data, variable named 'entries', 12 elements. |
677 | C | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double dataset[], int n) {
for (int i = 1; i < n; i++) {
double key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(vo... | Insertion sort on float data, variable named 'dataset', 12 elements. |
678 | C | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double collection[], int n) {
for (int i = 1; i < n; i++) {
double key = collection[i];
int j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
}
collection[j + 1] = key;
... | Insertion sort on float data, variable named 'collection', 12 elements. |
679 | C | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double dataset[], int n) {
for (int i = 1; i < n; i++) {
double key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(vo... | Insertion sort on float data, variable named 'dataset', 15 elements. |
680 | C | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double values[], int n) {
for (int i = 1; i < n; i++) {
double key = values[i];
int j = i - 1;
while (j >= 0 && values[j] > key) {
values[j + 1] = values[j];
j--;
}
values[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on float data, variable named 'values', 15 elements. |
681 | C | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double collection[], int n) {
for (int i = 1; i < n; i++) {
double key = collection[i];
int j = i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
}
collection[j + 1] = key;
... | Insertion sort on float data, variable named 'collection', 15 elements. |
682 | C | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double buffer[], int n) {
for (int i = 1; i < n; i++) {
double key = buffer[i];
int j = i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer[j + 1] = key;
}
}
int main(void) {
... | Insertion sort on float data, variable named 'buffer', 20 elements. |
683 | C | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double dataset[], int n) {
for (int i = 1; i < n; i++) {
double key = dataset[i];
int j = i - 1;
while (j >= 0 && dataset[j] > key) {
dataset[j + 1] = dataset[j];
j--;
}
dataset[j + 1] = key;
}
}
int main(vo... | Insertion sort on float data, variable named 'dataset', 20 elements. |
684 | C | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using insertion sort. | #include <stdio.h>
void insertion_sort(double nums[], int n) {
for (int i = 1; i < n; i++) {
double key = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;
}
}
int main(void) {
double n... | Insertion sort on float data, variable named 'nums', 20 elements. |
685 | C++ | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& elements) {
for (size_t i = 1; i < elements.size(); i++) {
int key = elements[i];
int j = (int) i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on int data, variable named 'elements', 5 elements. |
686 | C++ | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& list1) {
for (size_t i = 1; i < list1.size(); i++) {
int key = list1[i];
int j = (int) i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = ... | Insertion sort on int data, variable named 'list1', 5 elements. |
687 | C++ | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& arr) {
for (size_t i = 1; i < arr.size(); i++) {
int key = arr[i];
int j = (int) i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
... | Insertion sort on int data, variable named 'arr', 5 elements. |
688 | C++ | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& entries) {
for (size_t i = 1; i < entries.size(); i++) {
int key = entries[i];
int j = (int) i - 1;
while (j >= 0 && entries[j] > key) {
entries[j + 1] = entries[j];
j--;
}
ent... | Insertion sort on int data, variable named 'entries', 8 elements. |
689 | C++ | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& list1) {
for (size_t i = 1; i < list1.size(); i++) {
int key = list1[i];
int j = (int) i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = ... | Insertion sort on int data, variable named 'list1', 8 elements. |
690 | C++ | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& items) {
for (size_t i = 1; i < items.size(); i++) {
int key = items[i];
int j = (int) i - 1;
while (j >= 0 && items[j] > key) {
items[j + 1] = items[j];
j--;
}
items[j + 1] = ... | Insertion sort on int data, variable named 'items', 8 elements. |
691 | C++ | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& collection) {
for (size_t i = 1; i < collection.size(); i++) {
int key = collection[i];
int j = (int) i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
... | Insertion sort on int data, variable named 'collection', 10 elements. |
692 | C++ | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& nums) {
for (size_t i = 1; i < nums.size(); i++) {
int key = nums[i];
int j = (int) i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;
... | Insertion sort on int data, variable named 'nums', 10 elements. |
693 | C++ | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& list1) {
for (size_t i = 1; i < list1.size(); i++) {
int key = list1[i];
int j = (int) i - 1;
while (j >= 0 && list1[j] > key) {
list1[j + 1] = list1[j];
j--;
}
list1[j + 1] = ... | Insertion sort on int data, variable named 'list1', 10 elements. |
694 | C++ | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& buffer) {
for (size_t i = 1; i < buffer.size(); i++) {
int key = buffer[i];
int j = (int) i - 1;
while (j >= 0 && buffer[j] > key) {
buffer[j + 1] = buffer[j];
j--;
}
buffer[j ... | Insertion sort on int data, variable named 'buffer', 12 elements. |
695 | C++ | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& values) {
for (size_t i = 1; i < values.size(); i++) {
int key = values[i];
int j = (int) i - 1;
while (j >= 0 && values[j] > key) {
values[j + 1] = values[j];
j--;
}
values[j ... | Insertion sort on int data, variable named 'values', 12 elements. |
696 | C++ | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& nums) {
for (size_t i = 1; i < nums.size(); i++) {
int key = nums[i];
int j = (int) i - 1;
while (j >= 0 && nums[j] > key) {
nums[j + 1] = nums[j];
j--;
}
nums[j + 1] = key;
... | Insertion sort on int data, variable named 'nums', 12 elements. |
697 | C++ | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& arr) {
for (size_t i = 1; i < arr.size(); i++) {
int key = arr[i];
int j = (int) i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
... | Insertion sort on int data, variable named 'arr', 15 elements. |
698 | C++ | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& values) {
for (size_t i = 1; i < values.size(); i++) {
int key = values[i];
int j = (int) i - 1;
while (j >= 0 && values[j] > key) {
values[j + 1] = values[j];
j--;
}
values[j ... | Insertion sort on int data, variable named 'values', 15 elements. |
699 | C++ | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& elements) {
for (size_t i = 1; i < elements.size(); i++) {
int key = elements[i];
int j = (int) i - 1;
while (j >= 0 && elements[j] > key) {
elements[j + 1] = elements[j];
j--;
}
... | Insertion sort on int data, variable named 'elements', 15 elements. |
700 | C++ | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using insertion sort. | #include <iostream>
#include <vector>
void insertionSort(std::vector<int>& collection) {
for (size_t i = 1; i < collection.size(); i++) {
int key = collection[i];
int j = (int) i - 1;
while (j >= 0 && collection[j] > key) {
collection[j + 1] = collection[j];
j--;
... | Insertion sort on int data, variable named 'collection', 20 elements. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.