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 |
|---|---|---|---|---|---|---|
1 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | def bubble_sort(buffer):
n = len(buffer)
for i in range(n):
for j in range(0, n - i - 1):
if buffer[j] > buffer[j + 1]:
buffer[j], buffer[j + 1] = buffer[j + 1], buffer[j]
return buffer
print(bubble_sort([-22, -44, 20, 12, 7])) | Bubble sort on int data, variable named 'buffer', 5 elements. |
2 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | def bubble_sort(values):
n = len(values)
for i in range(n):
for j in range(0, n - i - 1):
if values[j] > values[j + 1]:
values[j], values[j + 1] = values[j + 1], values[j]
return values
print(bubble_sort([-24, 89, -28, 58, -42])) | Bubble sort on int data, variable named 'values', 5 elements. |
3 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
print(bubble_sort([-27, 5, 9, 79, -44])) | Bubble sort on int data, variable named 'arr', 5 elements. |
4 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | def bubble_sort(input_arr):
n = len(input_arr)
for i in range(n):
for j in range(0, n - i - 1):
if input_arr[j] > input_arr[j + 1]:
input_arr[j], input_arr[j + 1] = input_arr[j + 1], input_arr[j]
return input_arr
print(bubble_sort([0, 89, 57, 6, 64, 21, -49, -10])) | Bubble sort on int data, variable named 'input_arr', 8 elements. |
5 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | def bubble_sort(seq):
n = len(seq)
for i in range(n):
for j in range(0, n - i - 1):
if seq[j] > seq[j + 1]:
seq[j], seq[j + 1] = seq[j + 1], seq[j]
return seq
print(bubble_sort([58, 37, 21, -11, 5, 36, -24, -27])) | Bubble sort on int data, variable named 'seq', 8 elements. |
6 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | def bubble_sort(collection):
n = len(collection)
for i in range(n):
for j in range(0, n - i - 1):
if collection[j] > collection[j + 1]:
collection[j], collection[j + 1] = collection[j + 1], collection[j]
return collection
print(bubble_sort([-26, 41, 38, 17, -39, 67, 87, ... | Bubble sort on int data, variable named 'collection', 8 elements. |
7 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([46, -30, 91, 25, 42, 97, -1, -33, -39, 8])) | Bubble sort on int data, variable named 'entries', 10 elements. |
8 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | def bubble_sort(vals):
n = len(vals)
for i in range(n):
for j in range(0, n - i - 1):
if vals[j] > vals[j + 1]:
vals[j], vals[j + 1] = vals[j + 1], vals[j]
return vals
print(bubble_sort([24, -30, 9, -25, 47, 21, 66, 43, -9, 44])) | Bubble sort on int data, variable named 'vals', 10 elements. |
9 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | def bubble_sort(list1):
n = len(list1)
for i in range(n):
for j in range(0, n - i - 1):
if list1[j] > list1[j + 1]:
list1[j], list1[j + 1] = list1[j + 1], list1[j]
return list1
print(bubble_sort([3, 18, -32, -7, 86, 12, -9, 68, 47, 19])) | Bubble sort on int data, variable named 'list1', 10 elements. |
10 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([92, 6, 33, -36, 8, -42, 30, 52, 18, -34, 4, 95])) | Bubble sort on int data, variable named 'entries', 12 elements. |
11 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([30, 4, 77, 51, 67, -14, 17, -15, 13, 93, 87, 17])) | Bubble sort on int data, variable named 'entries', 12 elements. |
12 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | def bubble_sort(seq):
n = len(seq)
for i in range(n):
for j in range(0, n - i - 1):
if seq[j] > seq[j + 1]:
seq[j], seq[j + 1] = seq[j + 1], seq[j]
return seq
print(bubble_sort([99, 59, 99, 52, 42, 6, -15, 80, 76, -27, -38, -22])) | Bubble sort on int data, variable named 'seq', 12 elements. |
13 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | def bubble_sort(values):
n = len(values)
for i in range(n):
for j in range(0, n - i - 1):
if values[j] > values[j + 1]:
values[j], values[j + 1] = values[j + 1], values[j]
return values
print(bubble_sort([-10, 58, -34, 48, 47, 69, 85, 14, 91, -48, -21, 87, 18, 37, -22])) | Bubble sort on int data, variable named 'values', 15 elements. |
14 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | def bubble_sort(nums):
n = len(nums)
for i in range(n):
for j in range(0, n - i - 1):
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
return nums
print(bubble_sort([61, -10, 66, -50, 17, 78, -5, 79, -23, 26, 79, 0, -11, 45, -9])) | Bubble sort on int data, variable named 'nums', 15 elements. |
15 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | def bubble_sort(input_arr):
n = len(input_arr)
for i in range(n):
for j in range(0, n - i - 1):
if input_arr[j] > input_arr[j + 1]:
input_arr[j], input_arr[j + 1] = input_arr[j + 1], input_arr[j]
return input_arr
print(bubble_sort([85, -50, 32, 75, -46, -22, 42, 28, 11, ... | Bubble sort on int data, variable named 'input_arr', 15 elements. |
16 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | def bubble_sort(records):
n = len(records)
for i in range(n):
for j in range(0, n - i - 1):
if records[j] > records[j + 1]:
records[j], records[j + 1] = records[j + 1], records[j]
return records
print(bubble_sort([-33, 86, -18, -18, 71, 90, -8, 17, 85, 58, 4, 88, 1, 29, ... | Bubble sort on int data, variable named 'records', 20 elements. |
17 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | def bubble_sort(items):
n = len(items)
for i in range(n):
for j in range(0, n - i - 1):
if items[j] > items[j + 1]:
items[j], items[j + 1] = items[j + 1], items[j]
return items
print(bubble_sort([7, -34, 36, -45, 91, 8, 6, -49, -32, -35, 8, -33, -42, 34, -32, 81, 10, 21,... | Bubble sort on int data, variable named 'items', 20 elements. |
18 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | def bubble_sort(input_arr):
n = len(input_arr)
for i in range(n):
for j in range(0, n - i - 1):
if input_arr[j] > input_arr[j + 1]:
input_arr[j], input_arr[j + 1] = input_arr[j + 1], input_arr[j]
return input_arr
print(bubble_sort([-17, 96, 97, 71, 12, 71, 54, -2, -26, -... | Bubble sort on int data, variable named 'input_arr', 20 elements. |
19 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | def bubble_sort(vals):
n = len(vals)
for i in range(n):
for j in range(0, n - i - 1):
if vals[j] > vals[j + 1]:
vals[j], vals[j + 1] = vals[j + 1], vals[j]
return vals
print(bubble_sort([82.54, 9.59, 2.63, 33.39, 30.2])) | Bubble sort on float data, variable named 'vals', 5 elements. |
20 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | def bubble_sort(nums):
n = len(nums)
for i in range(n):
for j in range(0, n - i - 1):
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
return nums
print(bubble_sort([35.05, 84.06, -11.03, 76.15, 81.86])) | Bubble sort on float data, variable named 'nums', 5 elements. |
21 | Python | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | def bubble_sort(data):
n = len(data)
for i in range(n):
for j in range(0, n - i - 1):
if data[j] > data[j + 1]:
data[j], data[j + 1] = data[j + 1], data[j]
return data
print(bubble_sort([-13.98, 98.91, 79.49, 95.31, 90.24])) | Bubble sort on float data, variable named 'data', 5 elements. |
22 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | def bubble_sort(records):
n = len(records)
for i in range(n):
for j in range(0, n - i - 1):
if records[j] > records[j + 1]:
records[j], records[j + 1] = records[j + 1], records[j]
return records
print(bubble_sort([8.13, 28.36, 37.28, 82.89, 87.39, -0.41, -19.74, 26.46])) | Bubble sort on float data, variable named 'records', 8 elements. |
23 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([73.3, 34.15, 30.34, 93.92, 98.46, 46.14, 65.49, -1.58])) | Bubble sort on float data, variable named 'entries', 8 elements. |
24 | Python | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | def bubble_sort(nums):
n = len(nums)
for i in range(n):
for j in range(0, n - i - 1):
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
return nums
print(bubble_sort([5.91, -13.04, 67.55, -12.75, 17.32, -14.03, 36.74, 89.41])) | Bubble sort on float data, variable named 'nums', 8 elements. |
25 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | def bubble_sort(input_arr):
n = len(input_arr)
for i in range(n):
for j in range(0, n - i - 1):
if input_arr[j] > input_arr[j + 1]:
input_arr[j], input_arr[j + 1] = input_arr[j + 1], input_arr[j]
return input_arr
print(bubble_sort([-1.27, 94.33, -10.47, 2.11, 50.81, 60.3... | Bubble sort on float data, variable named 'input_arr', 10 elements. |
26 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | def bubble_sort(elements):
n = len(elements)
for i in range(n):
for j in range(0, n - i - 1):
if elements[j] > elements[j + 1]:
elements[j], elements[j + 1] = elements[j + 1], elements[j]
return elements
print(bubble_sort([-15.27, -10.24, 58.23, 47.26, 17.65, 11.03, 59.7... | Bubble sort on float data, variable named 'elements', 10 elements. |
27 | Python | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | def bubble_sort(buffer):
n = len(buffer)
for i in range(n):
for j in range(0, n - i - 1):
if buffer[j] > buffer[j + 1]:
buffer[j], buffer[j + 1] = buffer[j + 1], buffer[j]
return buffer
print(bubble_sort([15.7, 17.63, 69.47, -11.37, 34.54, 98.82, 98.54, -11.28, 5.37, 11.... | Bubble sort on float data, variable named 'buffer', 10 elements. |
28 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([21.53, -11.81, 9.07, 13.91, 32.14, 44.64, 16.0, 97.08, 76... | Bubble sort on float data, variable named 'entries', 12 elements. |
29 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | def bubble_sort(entries):
n = len(entries)
for i in range(n):
for j in range(0, n - i - 1):
if entries[j] > entries[j + 1]:
entries[j], entries[j + 1] = entries[j + 1], entries[j]
return entries
print(bubble_sort([58.94, 91.73, -4.02, -6.26, -7.26, 45.83, 12.41, 51.97, 6... | Bubble sort on float data, variable named 'entries', 12 elements. |
30 | Python | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | def bubble_sort(dataset):
n = len(dataset)
for i in range(n):
for j in range(0, n - i - 1):
if dataset[j] > dataset[j + 1]:
dataset[j], dataset[j + 1] = dataset[j + 1], dataset[j]
return dataset
print(bubble_sort([9.88, 88.07, -13.95, 55.48, 78.69, -14.75, 19.69, -4.43, ... | Bubble sort on float data, variable named 'dataset', 12 elements. |
31 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | def bubble_sort(input_arr):
n = len(input_arr)
for i in range(n):
for j in range(0, n - i - 1):
if input_arr[j] > input_arr[j + 1]:
input_arr[j], input_arr[j + 1] = input_arr[j + 1], input_arr[j]
return input_arr
print(bubble_sort([-18.85, -11.05, 85.09, 87.57, 44.93, 79... | Bubble sort on float data, variable named 'input_arr', 15 elements. |
32 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | def bubble_sort(items):
n = len(items)
for i in range(n):
for j in range(0, n - i - 1):
if items[j] > items[j + 1]:
items[j], items[j + 1] = items[j + 1], items[j]
return items
print(bubble_sort([59.37, 22.09, 46.63, 84.09, 95.89, 69.19, 90.17, 8.17, -0.66, 75.19, 1.07, ... | Bubble sort on float data, variable named 'items', 15 elements. |
33 | Python | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | def bubble_sort(collection):
n = len(collection)
for i in range(n):
for j in range(0, n - i - 1):
if collection[j] > collection[j + 1]:
collection[j], collection[j + 1] = collection[j + 1], collection[j]
return collection
print(bubble_sort([75.47, 82.82, 76.48, 11.75, 73... | Bubble sort on float data, variable named 'collection', 15 elements. |
34 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | def bubble_sort(items):
n = len(items)
for i in range(n):
for j in range(0, n - i - 1):
if items[j] > items[j + 1]:
items[j], items[j + 1] = items[j + 1], items[j]
return items
print(bubble_sort([27.42, 13.15, -11.74, 72.03, 21.79, 40.62, 60.86, 80.4, 19.41, -16.72, 84.3... | Bubble sort on float data, variable named 'items', 20 elements. |
35 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | def bubble_sort(data):
n = len(data)
for i in range(n):
for j in range(0, n - i - 1):
if data[j] > data[j + 1]:
data[j], data[j + 1] = data[j + 1], data[j]
return data
print(bubble_sort([25.84, 48.61, 10.31, 64.35, -19.8, 90.14, 44.08, 65.61, 68.29, 59.8, 23.34, -11.67, ... | Bubble sort on float data, variable named 'data', 20 elements. |
36 | Python | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | def bubble_sort(collection):
n = len(collection)
for i in range(n):
for j in range(0, n - i - 1):
if collection[j] > collection[j + 1]:
collection[j], collection[j + 1] = collection[j + 1], collection[j]
return collection
print(bubble_sort([62.97, 45.98, 2.83, 59.13, 25.... | Bubble sort on float data, variable named 'collection', 20 elements. |
37 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(seq) {
const n = seq.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (seq[j] > seq[j + 1]) {
[seq[j], seq[j + 1]] = [seq[j + 1], seq[j]];
}
}
}
return seq;
}
console.log(bubbleSort([-7, -29, 22, 81, 35])); | Bubble sort on int data, variable named 'seq', 5 elements. |
38 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
console.log(bubbleSort([10, 29, 7, 0, -13])); | Bubble sort on int data, variable named 'data', 5 elements. |
39 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(arr) {
const n = arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
console.log(bubbleSort([-39, 12, 71, -32, 66])); | Bubble sort on int data, variable named 'arr', 5 elements. |
40 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(collection) {
const n = collection.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (collection[j] > collection[j + 1]) {
[collection[j], collection[j + 1]] = [collection[j + 1], collection[j]];
}
}
}
return collection;
}
console.log... | Bubble sort on int data, variable named 'collection', 8 elements. |
41 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(entries) {
const n = entries.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (entries[j] > entries[j + 1]) {
[entries[j], entries[j + 1]] = [entries[j + 1], entries[j]];
}
}
}
return entries;
}
console.log(bubbleSort([-23, 58, 6, -5... | Bubble sort on int data, variable named 'entries', 8 elements. |
42 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(items) {
const n = items.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (items[j] > items[j + 1]) {
[items[j], items[j + 1]] = [items[j + 1], items[j]];
}
}
}
return items;
}
console.log(bubbleSort([-19, 66, -16, 68, 85, 93, 31, 63... | Bubble sort on int data, variable named 'items', 8 elements. |
43 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
console.log(bubbleSort([79, 5... | Bubble sort on int data, variable named 'elements', 10 elements. |
44 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(vals) {
const n = vals.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (vals[j] > vals[j + 1]) {
[vals[j], vals[j + 1]] = [vals[j + 1], vals[j]];
}
}
}
return vals;
}
console.log(bubbleSort([83, 74, 11, 20, 62, -31, 23, 10, 19, 35])... | Bubble sort on int data, variable named 'vals', 10 elements. |
45 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
console.log(bubbleSort([88, -30, -15, -12, 9, 48, -11, 4... | Bubble sort on int data, variable named 'list1', 10 elements. |
46 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(collection) {
const n = collection.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (collection[j] > collection[j + 1]) {
[collection[j], collection[j + 1]] = [collection[j + 1], collection[j]];
}
}
}
return collection;
}
console.log... | Bubble sort on int data, variable named 'collection', 12 elements. |
47 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
console.log(bubbleSort([-49, 40, 26, 4... | Bubble sort on int data, variable named 'dataset', 12 elements. |
48 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
console.log(bubbleSort([-43, 49, 36, 5... | Bubble sort on int data, variable named 'dataset', 12 elements. |
49 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
console.log(bubbleSort([59, -16, 68, -4, -38, 16, 47, 33, 4, 66, ... | Bubble sort on int data, variable named 'data', 15 elements. |
50 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(nums) {
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (nums[j] > nums[j + 1]) {
[nums[j], nums[j + 1]] = [nums[j + 1], nums[j]];
}
}
}
return nums;
}
console.log(bubbleSort([-30, 70, -46, 88, -37, 39, 7, -33, -40, -... | Bubble sort on int data, variable named 'nums', 15 elements. |
51 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(values) {
const n = values.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (values[j] > values[j + 1]) {
[values[j], values[j + 1]] = [values[j + 1], values[j]];
}
}
}
return values;
}
console.log(bubbleSort([71, -21, 94, 5, 69, 15,... | Bubble sort on int data, variable named 'values', 15 elements. |
52 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
console.log(bubbleSort([46, 5... | Bubble sort on int data, variable named 'elements', 20 elements. |
53 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
console.log(bubbleSort([60, 42, 67, -11, 61, -5, 83, 19, 87, 73, ... | Bubble sort on int data, variable named 'data', 20 elements. |
54 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
console.log(bubbleSort([47, 3... | Bubble sort on int data, variable named 'elements', 20 elements. |
55 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
console.log(bubbleSort([46.07, 8.6, 36... | Bubble sort on float data, variable named 'dataset', 5 elements. |
56 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(arr) {
const n = arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
console.log(bubbleSort([-8.93, 6.37, 62.32, 16.44, 49.21])); | Bubble sort on float data, variable named 'arr', 5 elements. |
57 | JavaScript | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
console.log(bubbleSort([45.86, 20.91, ... | Bubble sort on float data, variable named 'dataset', 5 elements. |
58 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
console.log(bubbleSort([12.24, 9.92, -... | Bubble sort on float data, variable named 'dataset', 8 elements. |
59 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(items) {
const n = items.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (items[j] > items[j + 1]) {
[items[j], items[j + 1]] = [items[j + 1], items[j]];
}
}
}
return items;
}
console.log(bubbleSort([67.89, 12.9, 50.16, 70.46, 51.02... | Bubble sort on float data, variable named 'items', 8 elements. |
60 | JavaScript | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
console.log(bubbleSort([1.35, -18.32, 43.56, 12.64, 95.9... | Bubble sort on float data, variable named 'list1', 8 elements. |
61 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(records) {
const n = records.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (records[j] > records[j + 1]) {
[records[j], records[j + 1]] = [records[j + 1], records[j]];
}
}
}
return records;
}
console.log(bubbleSort([69.58, -7.79, ... | Bubble sort on float data, variable named 'records', 10 elements. |
62 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
console.log(bubbleSort([27.68, -11.18, 54.9, -13.62, -2.25, 46.98... | Bubble sort on float data, variable named 'data', 10 elements. |
63 | JavaScript | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
console.log(bubbleSort([50.94... | Bubble sort on float data, variable named 'elements', 10 elements. |
64 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | function bubbleSort(seq) {
const n = seq.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (seq[j] > seq[j + 1]) {
[seq[j], seq[j + 1]] = [seq[j + 1], seq[j]];
}
}
}
return seq;
}
console.log(bubbleSort([-8.19, 70.77, 54.44, 11.49, -10.34, 8.54, 45.69, -... | Bubble sort on float data, variable named 'seq', 12 elements. |
65 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | function bubbleSort(nums) {
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (nums[j] > nums[j + 1]) {
[nums[j], nums[j + 1]] = [nums[j + 1], nums[j]];
}
}
}
return nums;
}
console.log(bubbleSort([64.13, 63.66, 34.03, 61.8, 89.95, 73.75, ... | Bubble sort on float data, variable named 'nums', 12 elements. |
66 | JavaScript | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | function bubbleSort(entries) {
const n = entries.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (entries[j] > entries[j + 1]) {
[entries[j], entries[j + 1]] = [entries[j + 1], entries[j]];
}
}
}
return entries;
}
console.log(bubbleSort([11.61, -3.07, ... | Bubble sort on float data, variable named 'entries', 12 elements. |
67 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | function bubbleSort(input_arr) {
const n = input_arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (input_arr[j] > input_arr[j + 1]) {
[input_arr[j], input_arr[j + 1]] = [input_arr[j + 1], input_arr[j]];
}
}
}
return input_arr;
}
console.log(bubbleSo... | Bubble sort on float data, variable named 'input_arr', 15 elements. |
68 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | function bubbleSort(vals) {
const n = vals.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (vals[j] > vals[j + 1]) {
[vals[j], vals[j + 1]] = [vals[j + 1], vals[j]];
}
}
}
return vals;
}
console.log(bubbleSort([0.85, 41.76, 32.63, 13.1, 98.64, 31.87, 7... | Bubble sort on float data, variable named 'vals', 15 elements. |
69 | JavaScript | Sorting Algorithm | intermediate | Sort a 15-element array of floats in ascending order using bubble sort. | function bubbleSort(buffer) {
const n = buffer.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (buffer[j] > buffer[j + 1]) {
[buffer[j], buffer[j + 1]] = [buffer[j + 1], buffer[j]];
}
}
}
return buffer;
}
console.log(bubbleSort([92.48, 76.81, 45.46, 34... | Bubble sort on float data, variable named 'buffer', 15 elements. |
70 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | function bubbleSort(vals) {
const n = vals.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (vals[j] > vals[j + 1]) {
[vals[j], vals[j + 1]] = [vals[j + 1], vals[j]];
}
}
}
return vals;
}
console.log(bubbleSort([39.32, 32.6, -13.86, 11.78, -4.41, 14.28,... | Bubble sort on float data, variable named 'vals', 20 elements. |
71 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | function bubbleSort(values) {
const n = values.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (values[j] > values[j + 1]) {
[values[j], values[j + 1]] = [values[j + 1], values[j]];
}
}
}
return values;
}
console.log(bubbleSort([39.31, 65.28, 40.56, 12... | Bubble sort on float data, variable named 'values', 20 elements. |
72 | JavaScript | Sorting Algorithm | intermediate | Sort a 20-element array of floats in ascending order using bubble sort. | function bubbleSort(nums) {
const n = nums.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (nums[j] > nums[j + 1]) {
[nums[j], nums[j + 1]] = [nums[j + 1], nums[j]];
}
}
}
return nums;
}
console.log(bubbleSort([79.66, 49.01, 58.53, 82.97, 33.14, 37.64,... | Bubble sort on float data, variable named 'nums', 20 elements. |
73 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(buffer) {
const n = buffer.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (buffer[j] > buffer[j + 1]) {
[buffer[j], buffer[j + 1]] = [buffer[j + 1], buffer[j]];
}
}
}
return buffer;
}
module.exports = { bubbleSort };
console.log(bu... | Bubble sort on int data, variable named 'buffer', 5 elements. |
74 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
module.exports = { bubbleSort... | Bubble sort on int data, variable named 'elements', 5 elements. |
75 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of ints in ascending order using bubble sort. | function bubbleSort(entries) {
const n = entries.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (entries[j] > entries[j + 1]) {
[entries[j], entries[j + 1]] = [entries[j + 1], entries[j]];
}
}
}
return entries;
}
module.exports = { bubbleSort };
conso... | Bubble sort on int data, variable named 'entries', 5 elements. |
76 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
module.exports = { bubbleSort };
console.log(bubbleSort([70, 17, ... | Bubble sort on int data, variable named 'data', 8 elements. |
77 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
module.exports = { bubbleSort };
console.log(bubbleSort(... | Bubble sort on int data, variable named 'list1', 8 elements. |
78 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of ints in ascending order using bubble sort. | function bubbleSort(collection) {
const n = collection.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (collection[j] > collection[j + 1]) {
[collection[j], collection[j + 1]] = [collection[j + 1], collection[j]];
}
}
}
return collection;
}
module.expo... | Bubble sort on int data, variable named 'collection', 8 elements. |
79 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(vals) {
const n = vals.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (vals[j] > vals[j + 1]) {
[vals[j], vals[j + 1]] = [vals[j + 1], vals[j]];
}
}
}
return vals;
}
module.exports = { bubbleSort };
console.log(bubbleSort([-36, 25,... | Bubble sort on int data, variable named 'vals', 10 elements. |
80 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(buffer) {
const n = buffer.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (buffer[j] > buffer[j + 1]) {
[buffer[j], buffer[j + 1]] = [buffer[j + 1], buffer[j]];
}
}
}
return buffer;
}
module.exports = { bubbleSort };
console.log(bu... | Bubble sort on int data, variable named 'buffer', 10 elements. |
81 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of ints in ascending order using bubble sort. | function bubbleSort(dataset) {
const n = dataset.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (dataset[j] > dataset[j + 1]) {
[dataset[j], dataset[j + 1]] = [dataset[j + 1], dataset[j]];
}
}
}
return dataset;
}
module.exports = { bubbleSort };
conso... | Bubble sort on int data, variable named 'dataset', 10 elements. |
82 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
module.exports = { bubbleSort };
console.log(bubbleSort(... | Bubble sort on int data, variable named 'list1', 12 elements. |
83 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
module.exports = { bubbleSort };
console.log(bubbleSort(... | Bubble sort on int data, variable named 'list1', 12 elements. |
84 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of ints in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
module.exports = { bubbleSort... | Bubble sort on int data, variable named 'elements', 12 elements. |
85 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(seq) {
const n = seq.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (seq[j] > seq[j + 1]) {
[seq[j], seq[j + 1]] = [seq[j + 1], seq[j]];
}
}
}
return seq;
}
module.exports = { bubbleSort };
console.log(bubbleSort([-17, -27, 25, 33,... | Bubble sort on int data, variable named 'seq', 15 elements. |
86 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(entries) {
const n = entries.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (entries[j] > entries[j + 1]) {
[entries[j], entries[j + 1]] = [entries[j + 1], entries[j]];
}
}
}
return entries;
}
module.exports = { bubbleSort };
conso... | Bubble sort on int data, variable named 'entries', 15 elements. |
87 | Node.js | Sorting Algorithm | intermediate | Sort a 15-element array of ints in ascending order using bubble sort. | function bubbleSort(input_arr) {
const n = input_arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (input_arr[j] > input_arr[j + 1]) {
[input_arr[j], input_arr[j + 1]] = [input_arr[j + 1], input_arr[j]];
}
}
}
return input_arr;
}
module.exports = { b... | Bubble sort on int data, variable named 'input_arr', 15 elements. |
88 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(buffer) {
const n = buffer.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (buffer[j] > buffer[j + 1]) {
[buffer[j], buffer[j + 1]] = [buffer[j + 1], buffer[j]];
}
}
}
return buffer;
}
module.exports = { bubbleSort };
console.log(bu... | Bubble sort on int data, variable named 'buffer', 20 elements. |
89 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(entries) {
const n = entries.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (entries[j] > entries[j + 1]) {
[entries[j], entries[j + 1]] = [entries[j + 1], entries[j]];
}
}
}
return entries;
}
module.exports = { bubbleSort };
conso... | Bubble sort on int data, variable named 'entries', 20 elements. |
90 | Node.js | Sorting Algorithm | intermediate | Sort a 20-element array of ints in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
module.exports = { bubbleSort };
console.log(bubbleSort([66, -27,... | Bubble sort on int data, variable named 'data', 20 elements. |
91 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(values) {
const n = values.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (values[j] > values[j + 1]) {
[values[j], values[j + 1]] = [values[j + 1], values[j]];
}
}
}
return values;
}
module.exports = { bubbleSort };
console.log(bu... | Bubble sort on float data, variable named 'values', 5 elements. |
92 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
module.exports = { bubbleSort };
console.log(bubbleSort(... | Bubble sort on float data, variable named 'list1', 5 elements. |
93 | Node.js | Sorting Algorithm | intermediate | Sort a 5-element array of floats in ascending order using bubble sort. | function bubbleSort(seq) {
const n = seq.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (seq[j] > seq[j + 1]) {
[seq[j], seq[j + 1]] = [seq[j + 1], seq[j]];
}
}
}
return seq;
}
module.exports = { bubbleSort };
console.log(bubbleSort([30.09, -6.48, -12... | Bubble sort on float data, variable named 'seq', 5 elements. |
94 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
module.exports = { bubbleSort... | Bubble sort on float data, variable named 'elements', 8 elements. |
95 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(arr) {
const n = arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
module.exports = { bubbleSort };
console.log(bubbleSort([-12.76, 37.0, 27.... | Bubble sort on float data, variable named 'arr', 8 elements. |
96 | Node.js | Sorting Algorithm | intermediate | Sort a 8-element array of floats in ascending order using bubble sort. | function bubbleSort(elements) {
const n = elements.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (elements[j] > elements[j + 1]) {
[elements[j], elements[j + 1]] = [elements[j + 1], elements[j]];
}
}
}
return elements;
}
module.exports = { bubbleSort... | Bubble sort on float data, variable named 'elements', 8 elements. |
97 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(input_arr) {
const n = input_arr.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (input_arr[j] > input_arr[j + 1]) {
[input_arr[j], input_arr[j + 1]] = [input_arr[j + 1], input_arr[j]];
}
}
}
return input_arr;
}
module.exports = { b... | Bubble sort on float data, variable named 'input_arr', 10 elements. |
98 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(list1) {
const n = list1.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (list1[j] > list1[j + 1]) {
[list1[j], list1[j + 1]] = [list1[j + 1], list1[j]];
}
}
}
return list1;
}
module.exports = { bubbleSort };
console.log(bubbleSort(... | Bubble sort on float data, variable named 'list1', 10 elements. |
99 | Node.js | Sorting Algorithm | intermediate | Sort a 10-element array of floats in ascending order using bubble sort. | function bubbleSort(data) {
const n = data.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
[data[j], data[j + 1]] = [data[j + 1], data[j]];
}
}
}
return data;
}
module.exports = { bubbleSort };
console.log(bubbleSort([-8.91, -... | Bubble sort on float data, variable named 'data', 10 elements. |
100 | Node.js | Sorting Algorithm | intermediate | Sort a 12-element array of floats in ascending order using bubble sort. | function bubbleSort(buffer) {
const n = buffer.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n - i - 1; j++) {
if (buffer[j] > buffer[j + 1]) {
[buffer[j], buffer[j + 1]] = [buffer[j + 1], buffer[j]];
}
}
}
return buffer;
}
module.exports = { bubbleSort };
console.log(bu... | Bubble sort on float data, variable named 'buffer', 12 elements. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.