id,language,category,difficulty,task_description,code,explanation
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, -19]))","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, -36, 11, 95, -30, -29, 74]))","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, 52, 45, 62, 82, 65, -20]))","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, 74, 4]))","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, -26, 60, 40, 58, 55, 69, -37, -25, -35, 53, 36]))","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.35, 7.99, -5.73, 85.94, 9.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, 17.39, 11.61, -4.43]))","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.56]))","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.04, 42.94, 59.48, 46.0]))","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, 65.4, 4.23, 55.47, 11.41]))","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, 96.6, -0.77, 32.58, 63.97]))","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.32, 49.32, -2.38, -4.83, 16.68, 86.98, 74.74, 82.42, 86.97, 5.0]))","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, 29.06, 1.34, 90.01, 73.1]))","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.7, -7.14, 83.79, 82.17, 6.47, 77.17, 34.78, 16.32, 74.65, 7.08, -17.18]))","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.37, 11.08, 49.09, 97.04, -15.45, 50.99, 21.14, 73.58, 31.93, 97.12]))","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, 59.04, 19.29, 17.36, 80.91, 65.65, 15.74, 16.8, 28.6]))","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.12, 69.03, 0.71, 47.72, 28.32, 79.21, 16.16, 5.01, 73.51, 52.19, 18.35, 32.57, 60.4, 40.83, 74.45, 94.22]))","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(bubbleSort([97, -1, 48, 76, 52, 12, -13, -49]));","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, 82, 68, -38, 92]));","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, 59, 90, 64, -10, 71, 65, 16, 13, 20]));","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, -34, 56]));","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(bubbleSort([34, 88, 69, 56, -35, 2, 57, 49, 99, -45, 97, 47]));","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, 49, 57, 87, 89, 6, 74, 6, 19, 61]));","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, 53, -8, 69, -18, 86, -44, 50, 94, -44]));","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, 33, 36, 47, 21, 57]));","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, -43, 13, 1, -45, -11, 11]));","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, 44, -8, -21, -9, 29, -23, 98, -44, 29]));","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, 51, 0, -31, 12, -24, 27, -20, 94, -40, 38, 86, 59, 44, -33, 79, 37, -47, 57, 75]));","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, 69, 61, 18, 32, 12, -28, 21, 65, 12, 68]));","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, 36, -43, 76, 33, -4, 74, 4, 40, 16, 37, 21, 20, 92, -48, 82, -2, -29, 11, 54]));","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.66, 64.71, 33.33]));","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, 98.6, 45.5, 21.87]));","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, -5.64, 2.92, -5.77, 43.77, 70.7, 2.03]));","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, 96.68, 79.08, 15.25]));","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.94, 45.85, 62.99, -4.97]));","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, -18.54, 13.84, 36.97, 20.54, 94.89, 10.04, 82.55, -6.42]));","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, 16.16, 98.28, -5.9, 70.97]));","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, 53.59, 72.31, 25.26, 88.11, 15.39, 50.03, 31.03, 47.67, -12.83]));","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, -1.37, 28.61, 62.04, 35.92, -16.12]));","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, 54.38, 58.68, 91.11, 30.59, 44.8, 57.07]));","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, -12.9, 74.32, 50.81, 78.08, 89.62, 32.26, 35.78, 16.19, 27.9, 12.4]));","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(bubbleSort([38.76, -10.43, -15.26, 31.41, 18.36, 9.79, -9.13, 94.47, 79.48, 48.45, 93.14, 98.95, 60.0, 12.07, -15.21]));","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, 76.9, 95.32, 35.93, 28.59, 18.21, -7.55, -0.86, 28.99, 38.96]));","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.12, 17.43, 18.47, 95.45, 28.1, 41.24, 97.59, 58.26, 44.57, 29.18, 2.32, 23.05]));","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, 84.82, 37.68, -16.56, 54.97, 75.12, 64.46, 16.98, -18.37, 28.55, 6.74, 80.13, -6.5, 92.7, 57.08]));","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.54, 79.33, 96.65, 9.0, 45.6, 25.65, 89.7, 40.48, 84.64, 82.82, 12.87, 74.01, 29.38, 91.18, 40.42, 77.65, 13.66]));","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, 19.56, 70.78, 24.89, 91.01, 83.48, 96.71, 8.42, 25.57, 81.87, 28.88, 17.86, 36.28, 88.7, 25.37]));","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(bubbleSort([-12, 76, -41, -18, 78]));","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 };
console.log(bubbleSort([34, -25, 62, -25, 84]));","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 };
console.log(bubbleSort([66, -47, -14, 54, -11]));","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, 36, 51, -30, 34, 86, 47]));","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([74, 88, -41, -33, 10, 23, 8, -27]));","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.exports = { bubbleSort };
console.log(bubbleSort([-25, -25, 63, -8, 26, -43, -39, 33]));","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, 41, 45, 60, -13, 12, 85, 55, 94]));","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(bubbleSort([-4, -7, -6, -30, 47, 11, 77, 99, -14, 9]));","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 };
console.log(bubbleSort([15, 67, 15, -48, 69, 23, 89, -10, -32, 63]));","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([26, 58, 14, 66, 27, 0, 48, 73, -23, 10, 47, 96]));","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([97, 25, 25, -45, 51, 20, -48, 94, -38, 77, 23, 8]));","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 };
console.log(bubbleSort([40, 6, -2, 14, -15, -26, -40, 29, 62, -42, 98, 43]));","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, 56, -6, 1, -17, 88, 43, 85, 78, 19, -8, 15]));","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 };
console.log(bubbleSort([73, 25, 36, -21, 69, -31, -14, 7, 51, 92, 43, -27, 51, -47, 17]));","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 = { bubbleSort };
console.log(bubbleSort([-19, 66, 44, 17, 99, 47, 45, -23, 9, 70, -44, 93, 33, 6, -34]));","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(bubbleSort([68, 27, 54, -21, -15, -39, -41, 27, 76, -21, -26, 10, 87, -16, 49, 66, 44, 88, 57, -11]));","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 };
console.log(bubbleSort([56, -25, 75, 54, 21, -42, 44, 5, 63, 63, 10, 42, -25, 44, 89, 41, -35, 51, 20, -2]));","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, 4, -45, -38, 35, 12, -18, 94, 2, -33, 91, 3, 5, 9, 34, -13, -50, 20, -13]));","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(bubbleSort([44.29, 75.02, -6.92, 83.11, -4.32]));","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([74.01, 8.31, 18.53, 0.74, -13.76]));","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.44, 33.34, 23.08]));","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 };
console.log(bubbleSort([-7.02, 39.96, 92.5, -14.84, 73.2, 83.17, 42.05, 34.51]));","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.79, 61.65, 38.34, 88.25, -11.25, -10.39]));","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 };
console.log(bubbleSort([-2.35, -4.98, 54.29, 49.66, 64.75, 25.33, 51.09, 15.09]));","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 = { bubbleSort };
console.log(bubbleSort([52.05, -8.2, 63.51, 81.48, 57.46, 71.51, 65.78, 5.59, 33.74, 7.19]));","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([78.46, 27.45, 66.82, 17.19, 17.19, 10.33, 93.48, 61.73, 36.44, -9.14]));","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, -8.51, 67.92, 76.6, 46.21, 49.79, 46.83, 19.23, -5.45, 22.08]));","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(bubbleSort([91.99, 30.33, 88.99, -13.88, 14.23, 17.18, -7.67, 40.38, -1.59, 37.38, 80.83, 21.66]));","Bubble sort on float data, variable named 'buffer', 12 elements."
101,Node.js,Sorting Algorithm,intermediate,Sort a 12-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 = { bubbleSort };
console.log(bubbleSort([23.74, 70.75, 48.32, 76.06, 80.57, 95.97, 77.39, 53.02, 56.48, -16.88, 90.56, 78.71]));","Bubble sort on float data, variable named 'input_arr', 12 elements."
102,Node.js,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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([-16.55, 12.52, 70.73, 89.66, 21.77, 1.59, -2.95, 58.22, -11.72, 68.18, 95.65, -9.08]));","Bubble sort on float data, variable named 'nums', 12 elements."
103,Node.js,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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([5.6, 29.96, 20.57, 24.04, 65.87, 72.44, 47.54, -9.89, -13.74, -1.27, 53.52, 60.2, 12.38, 58.77, 37.79]));","Bubble sort on float data, variable named 'input_arr', 15 elements."
104,Node.js,Sorting Algorithm,intermediate,Sort a 15-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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([29.29, 5.65, 40.97, 21.08, -6.8, 60.71, 50.58, 42.71, 16.7, 6.24, 97.15, -13.48, 4.33, 92.49, 71.31]));","Bubble sort on float data, variable named 'dataset', 15 elements."
105,Node.js,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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([10.41, 19.05, -19.08, 68.89, 0.91, 25.24, 63.74, 39.53, 79.17, 75.94, -11.42, 82.55, -14.97, -17.77, 89.62]));","Bubble sort on float data, variable named 'vals', 15 elements."
106,Node.js,Sorting Algorithm,intermediate,Sort a 20-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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([17.25, 31.08, 28.13, 56.18, 14.45, 28.2, 94.98, 0.45, 92.77, 34.75, 62.06, 23.06, 31.97, -7.4, 31.85, 27.65, -10.64, 83.59, 68.75, 6.37]));","Bubble sort on float data, variable named 'records', 20 elements."
107,Node.js,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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([0.01, 40.75, -6.43, 40.68, 87.8, 21.58, 66.56, 77.45, 76.99, 8.12, -2.57, 3.48, 51.69, 70.47, 58.01, 1.08, 71.97, 38.8, 69.78, 70.43]));","Bubble sort on float data, variable named 'vals', 20 elements."
108,Node.js,Sorting Algorithm,intermediate,Sort a 20-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;
}

module.exports = { bubbleSort };
console.log(bubbleSort([61.05, 84.96, 56.52, 97.4, 18.46, 95.55, 17.62, 32.33, 35.8, 55.13, 74.76, 50.38, 21.88, -11.17, 34.95, -15.52, 23.88, 14.16, 56.72, 96.31]));","Bubble sort on float data, variable named 'dataset', 20 elements."
109,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] data) {
        int n = data.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] data = {79, 48, 68, 98, 91};
        bubbleSort(data);
        for (int v : data) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'data', 5 elements."
110,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (vals[j] > vals[j + 1]) {
                    int temp = vals[j];
                    vals[j] = vals[j + 1];
                    vals[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] vals = {-40, 65, 96, -2, 32};
        bubbleSort(vals);
        for (int v : vals) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'vals', 5 elements."
111,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] elements) {
        int n = elements.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (elements[j] > elements[j + 1]) {
                    int temp = elements[j];
                    elements[j] = elements[j + 1];
                    elements[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] elements = {71, 78, -12, -35, 65};
        bubbleSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'elements', 5 elements."
112,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] data) {
        int n = data.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] data = {37, -29, 79, -6, -40, 13, 62, 62};
        bubbleSort(data);
        for (int v : data) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'data', 8 elements."
113,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    int temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {83, -10, 43, 45, 22, 49, 54, 36};
        bubbleSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'input_arr', 8 elements."
114,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] buffer) {
        int n = buffer.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (buffer[j] > buffer[j + 1]) {
                    int temp = buffer[j];
                    buffer[j] = buffer[j + 1];
                    buffer[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] buffer = {-37, 35, -34, 34, -26, 92, 48, 22};
        bubbleSort(buffer);
        for (int v : buffer) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'buffer', 8 elements."
115,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {-12, 35, -30, 99, -14, 39, 29, 50, -17, -29};
        bubbleSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'nums', 10 elements."
116,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {93, 46, 34, -18, 84, -27, 58, 80, 42, -46};
        bubbleSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'nums', 10 elements."
117,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] list1) {
        int n = list1.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (list1[j] > list1[j + 1]) {
                    int temp = list1[j];
                    list1[j] = list1[j + 1];
                    list1[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] list1 = {29, -4, 4, 37, 74, -1, 7, -15, -11, -31};
        bubbleSort(list1);
        for (int v : list1) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'list1', 10 elements."
118,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {-25, 79, 88, 84, -41, 36, -17, 46, -11, -9, -4, -8};
        bubbleSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'nums', 12 elements."
119,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] seq) {
        int n = seq.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (seq[j] > seq[j + 1]) {
                    int temp = seq[j];
                    seq[j] = seq[j + 1];
                    seq[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] seq = {62, -39, 55, 43, 10, 63, 22, 64, 9, 86, 11, 29};
        bubbleSort(seq);
        for (int v : seq) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'seq', 12 elements."
120,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (vals[j] > vals[j + 1]) {
                    int temp = vals[j];
                    vals[j] = vals[j + 1];
                    vals[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] vals = {70, -1, 44, 96, 62, 68, 22, 47, 78, 85, 57, -9};
        bubbleSort(vals);
        for (int v : vals) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'vals', 12 elements."
121,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] records) {
        int n = records.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (records[j] > records[j + 1]) {
                    int temp = records[j];
                    records[j] = records[j + 1];
                    records[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] records = {1, -15, 14, -37, 73, 45, 91, -24, 82, -19, 22, -29, -9, 19, 65};
        bubbleSort(records);
        for (int v : records) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'records', 15 elements."
122,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (entries[j] > entries[j + 1]) {
                    int temp = entries[j];
                    entries[j] = entries[j + 1];
                    entries[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] entries = {81, -13, 61, -27, 6, 65, 39, -44, 56, -37, 51, 78, 45, 10, 48};
        bubbleSort(entries);
        for (int v : entries) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'entries', 15 elements."
123,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] data) {
        int n = data.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] data = {45, 7, -43, 31, -25, 35, -13, -15, -41, 23, 70, -15, 70, 64, -49};
        bubbleSort(data);
        for (int v : data) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'data', 15 elements."
124,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (entries[j] > entries[j + 1]) {
                    int temp = entries[j];
                    entries[j] = entries[j + 1];
                    entries[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] entries = {-30, -46, 15, 5, -12, 90, 85, 58, -22, 23, 10, 27, -19, -38, 11, 57, 67, -34, -22, 77};
        bubbleSort(entries);
        for (int v : entries) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'entries', 20 elements."
125,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] elements) {
        int n = elements.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (elements[j] > elements[j + 1]) {
                    int temp = elements[j];
                    elements[j] = elements[j + 1];
                    elements[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] elements = {87, -46, 81, 97, 11, -14, 24, 59, -50, 40, 11, 96, 56, -3, -29, 84, 42, -33, 84, 89};
        bubbleSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'elements', 20 elements."
126,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(int[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    int temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {79, 91, -45, 49, 70, -39, 49, 45, 14, -46, 41, -33, 38, 11, -24, 98, 35, -16, -39, 40};
        bubbleSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on int data, variable named 'input_arr', 20 elements."
127,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    double temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] input_arr = {20.29, 56.49, 78.82, 61.48, 96.72};
        bubbleSort(input_arr);
        for (double v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'input_arr', 5 elements."
128,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] dataset) {
        int n = dataset.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (dataset[j] > dataset[j + 1]) {
                    double temp = dataset[j];
                    dataset[j] = dataset[j + 1];
                    dataset[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] dataset = {55.18, 76.57, -12.49, 72.37, 34.46};
        bubbleSort(dataset);
        for (double v : dataset) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'dataset', 5 elements."
129,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    double temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] nums = {3.99, 74.14, 85.41, 17.56, 16.9};
        bubbleSort(nums);
        for (double v : nums) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'nums', 5 elements."
130,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] collection) {
        int n = collection.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (collection[j] > collection[j + 1]) {
                    double temp = collection[j];
                    collection[j] = collection[j + 1];
                    collection[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] collection = {97.71, 44.62, 10.14, 69.64, 2.74, 22.48, 72.92, 83.03};
        bubbleSort(collection);
        for (double v : collection) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'collection', 8 elements."
131,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] list1) {
        int n = list1.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (list1[j] > list1[j + 1]) {
                    double temp = list1[j];
                    list1[j] = list1[j + 1];
                    list1[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] list1 = {12.51, 75.12, 32.0, 27.6, 32.33, 93.82, 20.35, 2.23};
        bubbleSort(list1);
        for (double v : list1) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'list1', 8 elements."
132,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] seq) {
        int n = seq.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (seq[j] > seq[j + 1]) {
                    double temp = seq[j];
                    seq[j] = seq[j + 1];
                    seq[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] seq = {39.21, 89.99, 41.79, 75.34, 66.52, -10.61, 51.69, 77.86};
        bubbleSort(seq);
        for (double v : seq) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'seq', 8 elements."
133,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    double temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] input_arr = {14.96, -7.79, 19.02, 15.18, 33.06, 65.4, -0.17, 32.83, 33.21, 66.49};
        bubbleSort(input_arr);
        for (double v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'input_arr', 10 elements."
134,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (entries[j] > entries[j + 1]) {
                    double temp = entries[j];
                    entries[j] = entries[j + 1];
                    entries[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] entries = {21.95, 98.78, 12.67, 96.62, 92.8, -11.07, 55.86, 23.23, 75.33, 60.85};
        bubbleSort(entries);
        for (double v : entries) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'entries', 10 elements."
135,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    double temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] arr = {-3.01, 52.3, 72.98, -15.86, -12.0, 72.64, 23.59, 25.56, 47.5, 52.01};
        bubbleSort(arr);
        for (double v : arr) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'arr', 10 elements."
136,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] buffer) {
        int n = buffer.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (buffer[j] > buffer[j + 1]) {
                    double temp = buffer[j];
                    buffer[j] = buffer[j + 1];
                    buffer[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] buffer = {33.54, 24.14, 32.83, -10.85, -3.61, 23.67, 17.41, 13.16, 94.3, -16.92, 2.14, 41.61};
        bubbleSort(buffer);
        for (double v : buffer) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'buffer', 12 elements."
137,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (entries[j] > entries[j + 1]) {
                    double temp = entries[j];
                    entries[j] = entries[j + 1];
                    entries[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] entries = {46.84, 11.15, 10.97, 33.11, 98.57, 13.98, 89.06, 38.45, -5.41, 81.49, 33.79, 86.94};
        bubbleSort(entries);
        for (double v : entries) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'entries', 12 elements."
138,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] dataset) {
        int n = dataset.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (dataset[j] > dataset[j + 1]) {
                    double temp = dataset[j];
                    dataset[j] = dataset[j + 1];
                    dataset[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] dataset = {98.67, 76.45, 95.14, 97.4, 59.47, 64.44, 45.45, 14.55, 15.69, -1.26, 64.44, 63.33};
        bubbleSort(dataset);
        for (double v : dataset) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'dataset', 12 elements."
139,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] values) {
        int n = values.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (values[j] > values[j + 1]) {
                    double temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] values = {74.45, 40.54, -5.56, 3.92, -3.47, 74.05, -16.87, 45.93, 23.9, 75.64, 45.65, 52.82, -9.74, 16.81, 98.95};
        bubbleSort(values);
        for (double v : values) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'values', 15 elements."
140,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] seq) {
        int n = seq.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (seq[j] > seq[j + 1]) {
                    double temp = seq[j];
                    seq[j] = seq[j + 1];
                    seq[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] seq = {36.96, 28.88, 28.72, 48.41, -5.09, 17.73, -11.17, 35.43, 41.57, -4.73, 78.66, 45.61, 49.95, 71.37, -4.65};
        bubbleSort(seq);
        for (double v : seq) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'seq', 15 elements."
141,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    double temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] input_arr = {88.37, -13.41, -5.22, -1.79, -0.41, 18.4, 64.41, 21.18, 91.97, 86.5, 80.67, 9.82, 55.57, 45.55, -5.1};
        bubbleSort(input_arr);
        for (double v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'input_arr', 15 elements."
142,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    double temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] nums = {53.12, -8.88, 56.28, 50.43, 49.1, 0.37, 54.31, 87.34, 20.18, 89.95, -15.1, 82.79, -10.33, 92.88, 71.75, 11.49, 5.09, 48.08, 53.55, -16.4};
        bubbleSort(nums);
        for (double v : nums) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'nums', 20 elements."
143,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (entries[j] > entries[j + 1]) {
                    double temp = entries[j];
                    entries[j] = entries[j + 1];
                    entries[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] entries = {54.63, 14.47, 93.84, 37.47, 75.76, 61.51, 15.39, -11.32, -12.87, 32.31, 37.63, 4.28, 52.19, 17.2, 65.49, 67.37, 82.43, 96.07, -4.44, 24.09};
        bubbleSort(entries);
        for (double v : entries) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'entries', 20 elements."
144,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"public class Main {
    static void bubbleSort(double[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (input_arr[j] > input_arr[j + 1]) {
                    double temp = input_arr[j];
                    input_arr[j] = input_arr[j + 1];
                    input_arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        double[] input_arr = {-7.36, 8.77, -5.42, 33.5, -3.24, -13.98, 92.5, 82.84, 29.76, 94.56, 87.37, 76.8, 91.12, 65.81, 2.59, -1.04, 98.52, 35.55, 84.61, 39.19};
        bubbleSort(input_arr);
        for (double v : input_arr) System.out.print(v + "" "");
    }
}","Bubble sort on float data, variable named 'input_arr', 20 elements."
145,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int data[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (data[j] > data[j + 1]) {
                int temp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int data[] = {50, 79, 67, 11, 5};
    int n = sizeof(data) / sizeof(data[0]);
    bubble_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","Bubble sort on int data, variable named 'data', 5 elements."
146,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                int temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int elements[] = {40, -38, -38, 22, 76};
    int n = sizeof(elements) / sizeof(elements[0]);
    bubble_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Bubble sort on int data, variable named 'elements', 5 elements."
147,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                int temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int elements[] = {70, 23, 87, -48, -23};
    int n = sizeof(elements) / sizeof(elements[0]);
    bubble_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Bubble sort on int data, variable named 'elements', 5 elements."
148,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int collection[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) {
                int temp = collection[j];
                collection[j] = collection[j + 1];
                collection[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int collection[] = {-16, 17, 43, 53, 43, -39, 52, -37};
    int n = sizeof(collection) / sizeof(collection[0]);
    bubble_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Bubble sort on int data, variable named 'collection', 8 elements."
149,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                int temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int elements[] = {93, -1, 42, 91, 23, -32, 48, 79};
    int n = sizeof(elements) / sizeof(elements[0]);
    bubble_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Bubble sort on int data, variable named 'elements', 8 elements."
150,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int dataset[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) {
                int temp = dataset[j];
                dataset[j] = dataset[j + 1];
                dataset[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int dataset[] = {90, 21, -20, -18, -26, 50, 45, 36};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    bubble_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","Bubble sort on int data, variable named 'dataset', 8 elements."
151,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) {
                int temp = input_arr[j];
                input_arr[j] = input_arr[j + 1];
                input_arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int input_arr[] = {43, -14, 0, 80, 52, 78, -40, -39, -41, -15};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    bubble_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Bubble sort on int data, variable named 'input_arr', 10 elements."
152,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int seq[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (seq[j] > seq[j + 1]) {
                int temp = seq[j];
                seq[j] = seq[j + 1];
                seq[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int seq[] = {35, 71, 82, 66, -12, 81, -15, 33, 31, -9};
    int n = sizeof(seq) / sizeof(seq[0]);
    bubble_sort(seq, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)seq[i]);
    return 0;
}","Bubble sort on int data, variable named 'seq', 10 elements."
153,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int collection[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) {
                int temp = collection[j];
                collection[j] = collection[j + 1];
                collection[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int collection[] = {26, 36, 79, 80, 86, 75, 94, 26, 71, -46};
    int n = sizeof(collection) / sizeof(collection[0]);
    bubble_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Bubble sort on int data, variable named 'collection', 10 elements."
154,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) {
                int temp = list1[j];
                list1[j] = list1[j + 1];
                list1[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int list1[] = {34, -22, 56, 99, 28, -44, 71, 17, 98, 97, 8, -37};
    int n = sizeof(list1) / sizeof(list1[0]);
    bubble_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Bubble sort on int data, variable named 'list1', 12 elements."
155,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                int temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int elements[] = {72, -7, 84, 47, -13, 12, -42, 96, -22, -2, -46, 62};
    int n = sizeof(elements) / sizeof(elements[0]);
    bubble_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Bubble sort on int data, variable named 'elements', 12 elements."
156,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) {
                int temp = list1[j];
                list1[j] = list1[j + 1];
                list1[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int list1[] = {57, -12, 55, 2, 55, 78, 70, -35, -15, 82, 3, 93};
    int n = sizeof(list1) / sizeof(list1[0]);
    bubble_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Bubble sort on int data, variable named 'list1', 12 elements."
157,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) {
                int temp = list1[j];
                list1[j] = list1[j + 1];
                list1[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int list1[] = {72, 84, 46, 30, -6, 67, 86, 37, 89, 40, 17, 73, -1, 13, 21};
    int n = sizeof(list1) / sizeof(list1[0]);
    bubble_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Bubble sort on int data, variable named 'list1', 15 elements."
158,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) {
                int temp = input_arr[j];
                input_arr[j] = input_arr[j + 1];
                input_arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int input_arr[] = {26, 7, 26, 23, 3, 75, 31, 72, 39, 93, 20, 23, -19, 96, 89};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    bubble_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Bubble sort on int data, variable named 'input_arr', 15 elements."
159,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int collection[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) {
                int temp = collection[j];
                collection[j] = collection[j + 1];
                collection[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int collection[] = {51, 38, -13, 24, -40, 23, -30, 38, 63, 15, 72, 4, 1, 87, 19};
    int n = sizeof(collection) / sizeof(collection[0]);
    bubble_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Bubble sort on int data, variable named 'collection', 15 elements."
160,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int entries[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (entries[j] > entries[j + 1]) {
                int temp = entries[j];
                entries[j] = entries[j + 1];
                entries[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int entries[] = {93, 19, -15, -23, 11, 12, -38, 85, 7, 9, -37, -25, 55, 34, 70, -25, -15, -49, 90, -10};
    int n = sizeof(entries) / sizeof(entries[0]);
    bubble_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","Bubble sort on int data, variable named 'entries', 20 elements."
161,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int collection[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) {
                int temp = collection[j];
                collection[j] = collection[j + 1];
                collection[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int collection[] = {71, 72, 1, 23, 32, 23, -35, -28, 96, 9, 86, -41, -6, 56, -5, -41, 51, 76, -3, 24};
    int n = sizeof(collection) / sizeof(collection[0]);
    bubble_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Bubble sort on int data, variable named 'collection', 20 elements."
162,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(int entries[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (entries[j] > entries[j + 1]) {
                int temp = entries[j];
                entries[j] = entries[j + 1];
                entries[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    int entries[] = {-41, -48, 26, 95, -23, 35, 22, 66, 89, 84, 76, -16, 79, 69, 19, -1, -22, 34, -9, 67};
    int n = sizeof(entries) / sizeof(entries[0]);
    bubble_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","Bubble sort on int data, variable named 'entries', 20 elements."
163,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double buffer[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) {
                double temp = buffer[j];
                buffer[j] = buffer[j + 1];
                buffer[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double buffer[] = {10.61, 2.16, 67.66, 74.1, 47.57};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    bubble_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","Bubble sort on float data, variable named 'buffer', 5 elements."
164,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double vals[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (vals[j] > vals[j + 1]) {
                double temp = vals[j];
                vals[j] = vals[j + 1];
                vals[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double vals[] = {2.99, 52.7, 56.01, 28.25, 30.9};
    int n = sizeof(vals) / sizeof(vals[0]);
    bubble_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","Bubble sort on float data, variable named 'vals', 5 elements."
165,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double list1[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) {
                double temp = list1[j];
                list1[j] = list1[j + 1];
                list1[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double list1[] = {-9.68, 59.64, 1.99, -3.27, 18.51};
    int n = sizeof(list1) / sizeof(list1[0]);
    bubble_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Bubble sort on float data, variable named 'list1', 5 elements."
166,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double items[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (items[j] > items[j + 1]) {
                double temp = items[j];
                items[j] = items[j + 1];
                items[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double items[] = {-19.19, 25.65, 33.16, 11.77, 19.23, 49.31, 48.17, 11.12};
    int n = sizeof(items) / sizeof(items[0]);
    bubble_sort(items, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)items[i]);
    return 0;
}","Bubble sort on float data, variable named 'items', 8 elements."
167,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double list1[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) {
                double temp = list1[j];
                list1[j] = list1[j + 1];
                list1[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double list1[] = {62.44, -12.61, -5.93, 16.51, 28.24, 39.8, 86.52, 63.72};
    int n = sizeof(list1) / sizeof(list1[0]);
    bubble_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Bubble sort on float data, variable named 'list1', 8 elements."
168,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double nums[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                double temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double nums[] = {62.14, 56.01, 91.94, 23.74, 6.28, 93.93, 36.9, 34.14};
    int n = sizeof(nums) / sizeof(nums[0]);
    bubble_sort(nums, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)nums[i]);
    return 0;
}","Bubble sort on float data, variable named 'nums', 8 elements."
169,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double elements[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) {
                double temp = elements[j];
                elements[j] = elements[j + 1];
                elements[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double elements[] = {24.46, 63.53, 88.62, 70.12, 75.44, 78.25, 70.66, 60.96, 50.9, 73.7};
    int n = sizeof(elements) / sizeof(elements[0]);
    bubble_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Bubble sort on float data, variable named 'elements', 10 elements."
170,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) {
                double temp = input_arr[j];
                input_arr[j] = input_arr[j + 1];
                input_arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double input_arr[] = {33.16, 63.75, -10.71, 47.14, -12.65, 45.17, 40.15, 48.15, -2.17, 19.05};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    bubble_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Bubble sort on float data, variable named 'input_arr', 10 elements."
171,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) {
                double temp = input_arr[j];
                input_arr[j] = input_arr[j + 1];
                input_arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double input_arr[] = {32.58, 60.96, 65.31, 38.17, 86.97, 33.01, -13.38, -4.3, 29.44, 47.11};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    bubble_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Bubble sort on float data, variable named 'input_arr', 10 elements."
172,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) {
                double temp = input_arr[j];
                input_arr[j] = input_arr[j + 1];
                input_arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double input_arr[] = {35.02, 76.02, 66.07, 27.12, 77.16, 68.75, 48.82, -14.61, 21.0, -12.41, 98.3, 91.22};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    bubble_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Bubble sort on float data, variable named 'input_arr', 12 elements."
173,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double data[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (data[j] > data[j + 1]) {
                double temp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double data[] = {97.35, 36.18, 14.16, 1.42, -3.88, 56.34, 66.79, 94.69, 24.56, 86.07, 33.38, 89.14};
    int n = sizeof(data) / sizeof(data[0]);
    bubble_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","Bubble sort on float data, variable named 'data', 12 elements."
174,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double collection[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) {
                double temp = collection[j];
                collection[j] = collection[j + 1];
                collection[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double collection[] = {24.7, 61.24, 58.75, 44.18, 57.77, 21.38, 1.24, 43.93, 42.93, 66.62, 6.5, -19.59};
    int n = sizeof(collection) / sizeof(collection[0]);
    bubble_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Bubble sort on float data, variable named 'collection', 12 elements."
175,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double arr[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                double temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double arr[] = {96.44, 35.1, 65.57, 30.47, 25.13, 7.33, 34.81, -1.54, 2.43, 84.15, 71.09, -16.17, 58.56, 53.18, 91.41};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)arr[i]);
    return 0;
}","Bubble sort on float data, variable named 'arr', 15 elements."
176,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double entries[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (entries[j] > entries[j + 1]) {
                double temp = entries[j];
                entries[j] = entries[j + 1];
                entries[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double entries[] = {-18.14, 4.52, -7.99, -16.0, 51.14, 63.69, -14.21, 68.12, 27.87, 7.89, 5.86, 82.78, -13.28, 39.96, 14.42};
    int n = sizeof(entries) / sizeof(entries[0]);
    bubble_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","Bubble sort on float data, variable named 'entries', 15 elements."
177,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double records[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (records[j] > records[j + 1]) {
                double temp = records[j];
                records[j] = records[j + 1];
                records[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double records[] = {89.05, 48.56, 48.72, 71.93, 77.39, 8.19, 84.27, 97.3, 42.03, 29.21, 12.74, 46.25, 50.41, 67.49, 0.84};
    int n = sizeof(records) / sizeof(records[0]);
    bubble_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","Bubble sort on float data, variable named 'records', 15 elements."
178,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double buffer[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) {
                double temp = buffer[j];
                buffer[j] = buffer[j + 1];
                buffer[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double buffer[] = {30.84, 38.98, 95.7, 92.05, 59.89, 73.51, 17.93, 29.54, -2.24, 24.8, 69.78, 36.35, 81.07, 15.79, 64.2, 75.89, 88.85, 46.92, 95.17, 46.32};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    bubble_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","Bubble sort on float data, variable named 'buffer', 20 elements."
179,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double values[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (values[j] > values[j + 1]) {
                double temp = values[j];
                values[j] = values[j + 1];
                values[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double values[] = {26.22, 10.34, 19.3, -10.59, 33.52, 24.16, 43.74, 78.7, -13.87, 24.88, 51.99, -15.29, -11.34, 75.75, 49.92, 59.9, 5.82, 4.86, 87.94, 16.08};
    int n = sizeof(values) / sizeof(values[0]);
    bubble_sort(values, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)values[i]);
    return 0;
}","Bubble sort on float data, variable named 'values', 20 elements."
180,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <stdio.h>

void bubble_sort(double entries[], int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (entries[j] > entries[j + 1]) {
                double temp = entries[j];
                entries[j] = entries[j + 1];
                entries[j + 1] = temp;
            }
        }
    }
}

int main(void) {
    double entries[] = {-18.18, 91.52, 94.49, -6.04, 98.95, 36.99, 8.87, 51.92, 4.34, 88.9, 45.7, 72.29, 25.3, 43.5, 22.75, 11.13, 41.03, 39.18, -8.27, 96.78};
    int n = sizeof(entries) / sizeof(entries[0]);
    bubble_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","Bubble sort on float data, variable named 'entries', 20 elements."
181,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<int> dataset = {31, 2, 44, 30, 55};
    bubbleSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'dataset', 5 elements."
182,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& arr) {
    int n = (int) arr.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) std::swap(arr[j], arr[j + 1]);
        }
    }
}

int main() {
    std::vector<int> arr = {94, 6, -13, -46, 16};
    bubbleSort(arr);
    for (int v : arr) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'arr', 5 elements."
183,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& input_arr) {
    int n = (int) input_arr.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) std::swap(input_arr[j], input_arr[j + 1]);
        }
    }
}

int main() {
    std::vector<int> input_arr = {99, 98, 56, 25, -11};
    bubbleSort(input_arr);
    for (int v : input_arr) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'input_arr', 5 elements."
184,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& items) {
    int n = (int) items.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (items[j] > items[j + 1]) std::swap(items[j], items[j + 1]);
        }
    }
}

int main() {
    std::vector<int> items = {34, 8, 47, 95, 12, 77, 90, 36};
    bubbleSort(items);
    for (int v : items) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'items', 8 elements."
185,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& nums) {
    int n = (int) nums.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (nums[j] > nums[j + 1]) std::swap(nums[j], nums[j + 1]);
        }
    }
}

int main() {
    std::vector<int> nums = {75, 75, 67, -7, 40, -7, -15, 89};
    bubbleSort(nums);
    for (int v : nums) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'nums', 8 elements."
186,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<int> dataset = {-3, 88, -35, 84, -42, -31, -38, -49};
    bubbleSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'dataset', 8 elements."
187,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) std::swap(collection[j], collection[j + 1]);
        }
    }
}

int main() {
    std::vector<int> collection = {-15, 9, -33, -12, -48, 5, 79, 66, 45, -35};
    bubbleSort(collection);
    for (int v : collection) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'collection', 10 elements."
188,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& elements) {
    int n = (int) elements.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) std::swap(elements[j], elements[j + 1]);
        }
    }
}

int main() {
    std::vector<int> elements = {73, 74, -46, -49, 86, 91, 55, -47, -46, 85};
    bubbleSort(elements);
    for (int v : elements) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'elements', 10 elements."
189,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& seq) {
    int n = (int) seq.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (seq[j] > seq[j + 1]) std::swap(seq[j], seq[j + 1]);
        }
    }
}

int main() {
    std::vector<int> seq = {20, 87, 23, -46, 78, 60, -5, -23, -26, 84};
    bubbleSort(seq);
    for (int v : seq) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'seq', 10 elements."
190,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& values) {
    int n = (int) values.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (values[j] > values[j + 1]) std::swap(values[j], values[j + 1]);
        }
    }
}

int main() {
    std::vector<int> values = {11, -1, 84, 14, 40, 18, 51, -30, 45, 53, 67, 94};
    bubbleSort(values);
    for (int v : values) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'values', 12 elements."
191,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& items) {
    int n = (int) items.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (items[j] > items[j + 1]) std::swap(items[j], items[j + 1]);
        }
    }
}

int main() {
    std::vector<int> items = {7, 26, -30, -42, -27, 53, 47, 46, 91, 71, -36, -48};
    bubbleSort(items);
    for (int v : items) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'items', 12 elements."
192,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& seq) {
    int n = (int) seq.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (seq[j] > seq[j + 1]) std::swap(seq[j], seq[j + 1]);
        }
    }
}

int main() {
    std::vector<int> seq = {-7, -29, 77, 61, 34, 94, -26, 85, -40, 8, 4, 95};
    bubbleSort(seq);
    for (int v : seq) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'seq', 12 elements."
193,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<int> dataset = {19, -39, -31, 21, 89, 94, -42, -5, 30, -46, 3, -14, 51, -31, 26};
    bubbleSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'dataset', 15 elements."
194,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& values) {
    int n = (int) values.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (values[j] > values[j + 1]) std::swap(values[j], values[j + 1]);
        }
    }
}

int main() {
    std::vector<int> values = {94, 11, 95, 49, 88, 34, 48, -15, -30, 78, 38, -37, -25, 61, 9};
    bubbleSort(values);
    for (int v : values) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'values', 15 elements."
195,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& records) {
    int n = (int) records.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (records[j] > records[j + 1]) std::swap(records[j], records[j + 1]);
        }
    }
}

int main() {
    std::vector<int> records = {-31, 37, 51, 33, -43, 19, 65, 75, 8, 41, 91, 46, 60, -3, 99};
    bubbleSort(records);
    for (int v : records) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'records', 15 elements."
196,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) std::swap(buffer[j], buffer[j + 1]);
        }
    }
}

int main() {
    std::vector<int> buffer = {47, -29, 25, 13, -32, -29, 18, -11, 47, -11, 49, 31, 42, -23, -27, -49, 28, 63, 42, 19};
    bubbleSort(buffer);
    for (int v : buffer) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'buffer', 20 elements."
197,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (data[j] > data[j + 1]) std::swap(data[j], data[j + 1]);
        }
    }
}

int main() {
    std::vector<int> data = {-17, -28, -3, 60, 64, 92, 92, 81, 54, -24, -44, -28, 40, 91, -27, 33, 48, -47, 24, 55};
    bubbleSort(data);
    for (int v : data) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'data', 20 elements."
198,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<int>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) std::swap(collection[j], collection[j + 1]);
        }
    }
}

int main() {
    std::vector<int> collection = {-29, 93, 12, 96, 83, -7, 47, -7, -15, 18, 27, 18, 76, -13, -34, -8, 61, 20, 57, 26};
    bubbleSort(collection);
    for (int v : collection) std::cout << v << "" "";
    return 0;
}","Bubble sort on int data, variable named 'collection', 20 elements."
199,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<double> dataset = {73.14, 22.97, 92.36, 65.79, 39.0};
    bubbleSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'dataset', 5 elements."
200,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& elements) {
    int n = (int) elements.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) std::swap(elements[j], elements[j + 1]);
        }
    }
}

int main() {
    std::vector<double> elements = {3.27, -7.27, 16.25, 92.91, 19.53};
    bubbleSort(elements);
    for (double v : elements) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'elements', 5 elements."
201,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& elements) {
    int n = (int) elements.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (elements[j] > elements[j + 1]) std::swap(elements[j], elements[j + 1]);
        }
    }
}

int main() {
    std::vector<double> elements = {25.21, 82.6, 32.39, 31.24, 78.0};
    bubbleSort(elements);
    for (double v : elements) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'elements', 5 elements."
202,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) std::swap(buffer[j], buffer[j + 1]);
        }
    }
}

int main() {
    std::vector<double> buffer = {95.93, -3.8, 18.16, 92.73, 3.9, 17.39, 94.78, 95.28};
    bubbleSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'buffer', 8 elements."
203,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& nums) {
    int n = (int) nums.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (nums[j] > nums[j + 1]) std::swap(nums[j], nums[j + 1]);
        }
    }
}

int main() {
    std::vector<double> nums = {67.45, 55.32, 95.16, 73.05, 18.78, 13.36, 73.52, 23.44};
    bubbleSort(nums);
    for (double v : nums) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'nums', 8 elements."
204,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (entries[j] > entries[j + 1]) std::swap(entries[j], entries[j + 1]);
        }
    }
}

int main() {
    std::vector<double> entries = {47.1, 50.48, 44.93, 61.12, 45.46, 93.41, 34.93, 64.3};
    bubbleSort(entries);
    for (double v : entries) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'entries', 8 elements."
205,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<double> dataset = {74.92, 78.92, -11.77, 80.89, 74.61, 60.08, -3.44, 16.04, 10.07, -1.66};
    bubbleSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'dataset', 10 elements."
206,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) std::swap(collection[j], collection[j + 1]);
        }
    }
}

int main() {
    std::vector<double> collection = {73.9, -11.2, 97.89, 37.03, 27.7, 40.29, 89.53, 62.31, 44.69, 74.1};
    bubbleSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'collection', 10 elements."
207,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) std::swap(list1[j], list1[j + 1]);
        }
    }
}

int main() {
    std::vector<double> list1 = {63.49, 76.66, 50.66, 88.81, -6.99, 9.54, 59.1, -0.21, 52.91, 47.02};
    bubbleSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'list1', 10 elements."
208,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) std::swap(buffer[j], buffer[j + 1]);
        }
    }
}

int main() {
    std::vector<double> buffer = {60.62, 27.55, 69.57, 94.92, 31.22, -18.74, 10.79, 40.77, 41.74, 49.08, 48.45, 33.05};
    bubbleSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'buffer', 12 elements."
209,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (collection[j] > collection[j + 1]) std::swap(collection[j], collection[j + 1]);
        }
    }
}

int main() {
    std::vector<double> collection = {35.1, 60.87, 62.16, -2.06, 98.73, 37.45, 15.16, 89.55, -9.78, 78.93, 66.89, 21.45};
    bubbleSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'collection', 12 elements."
210,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) std::swap(list1[j], list1[j + 1]);
        }
    }
}

int main() {
    std::vector<double> list1 = {34.18, 4.62, 37.47, 36.66, 32.14, 62.91, 17.95, 15.73, 76.41, -6.3, 81.05, 57.11};
    bubbleSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'list1', 12 elements."
211,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) std::swap(buffer[j], buffer[j + 1]);
        }
    }
}

int main() {
    std::vector<double> buffer = {75.21, 90.66, 68.12, 41.4, 45.68, 19.39, 30.74, 34.98, 74.93, 54.94, 2.18, 58.22, 27.07, 67.75, 85.09};
    bubbleSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'buffer', 15 elements."
212,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (dataset[j] > dataset[j + 1]) std::swap(dataset[j], dataset[j + 1]);
        }
    }
}

int main() {
    std::vector<double> dataset = {50.47, 26.27, 63.86, 4.49, 69.53, 76.24, -12.55, -7.89, 83.77, 2.25, 18.79, 34.45, 11.22, 82.65, 42.8};
    bubbleSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'dataset', 15 elements."
213,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (buffer[j] > buffer[j + 1]) std::swap(buffer[j], buffer[j + 1]);
        }
    }
}

int main() {
    std::vector<double> buffer = {17.3, 26.25, 26.71, -6.41, 21.89, 34.49, 0.53, 60.16, 75.27, 89.32, 50.23, 59.98, 17.27, 8.39, -6.08};
    bubbleSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'buffer', 15 elements."
214,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (list1[j] > list1[j + 1]) std::swap(list1[j], list1[j + 1]);
        }
    }
}

int main() {
    std::vector<double> list1 = {62.52, 40.79, 29.77, -3.59, 25.66, 2.1, 55.62, 62.52, 56.79, 98.99, 46.03, 38.27, -3.3, 17.44, 33.67, -13.62, 22.73, -18.86, -3.75, 77.01};
    bubbleSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'list1', 20 elements."
215,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& input_arr) {
    int n = (int) input_arr.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (input_arr[j] > input_arr[j + 1]) std::swap(input_arr[j], input_arr[j + 1]);
        }
    }
}

int main() {
    std::vector<double> input_arr = {40.15, 38.9, 61.48, 29.46, 79.95, 38.16, -10.16, -16.33, 70.57, 14.76, 12.71, 43.98, 0.02, 34.42, 68.36, 71.14, 45.42, -6.53, -6.41, 72.24};
    bubbleSort(input_arr);
    for (double v : input_arr) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'input_arr', 20 elements."
216,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"#include <iostream>
#include <vector>

void bubbleSort(std::vector<double>& records) {
    int n = (int) records.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (records[j] > records[j + 1]) std::swap(records[j], records[j + 1]);
        }
    }
}

int main() {
    std::vector<double> records = {97.92, 44.5, 70.06, 70.44, 32.52, 6.01, 30.59, 67.58, 57.79, 9.46, 84.1, -16.16, 11.28, 82.6, -9.65, 82.97, -6.03, 76.61, 4.98, 67.78};
    bubbleSort(records);
    for (double v : records) std::cout << v << "" "";
    return 0;
}","Bubble sort on float data, variable named 'records', 20 elements."
217,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<i32>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![39, 59, -8, -15, 2];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on int data, variable named 'seq', 5 elements."
218,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"fn bubble_sort(records: &mut Vec<i32>) {
    let n = records.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if records[j] > records[j + 1] {
                records.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut records = vec![2, -35, 95, 39, 86];
    bubble_sort(&mut records);
    println!(""{:?}"", records);
}","Bubble sort on int data, variable named 'records', 5 elements."
219,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using bubble sort.,"fn bubble_sort(nums: &mut Vec<i32>) {
    let n = nums.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if nums[j] > nums[j + 1] {
                nums.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut nums = vec![87, -7, 32, 24, 24];
    bubble_sort(&mut nums);
    println!(""{:?}"", nums);
}","Bubble sort on int data, variable named 'nums', 5 elements."
220,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"fn bubble_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if elements[j] > elements[j + 1] {
                elements.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut elements = vec![18, 81, -26, -16, 55, -35, 20, -18];
    bubble_sort(&mut elements);
    println!(""{:?}"", elements);
}","Bubble sort on int data, variable named 'elements', 8 elements."
221,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<i32>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![-17, 13, -13, 32, 13, 50, 75, -14];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on int data, variable named 'seq', 8 elements."
222,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using bubble sort.,"fn bubble_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if elements[j] > elements[j + 1] {
                elements.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut elements = vec![18, 56, 46, 65, -31, -27, 53, 81];
    bubble_sort(&mut elements);
    println!(""{:?}"", elements);
}","Bubble sort on int data, variable named 'elements', 8 elements."
223,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<i32>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![21, 44, 66, 74, 33, 98, -50, -27, 67, 41];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on int data, variable named 'seq', 10 elements."
224,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"fn bubble_sort(records: &mut Vec<i32>) {
    let n = records.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if records[j] > records[j + 1] {
                records.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut records = vec![-34, 86, 51, 5, 59, 4, 76, 18, 32, 22];
    bubble_sort(&mut records);
    println!(""{:?}"", records);
}","Bubble sort on int data, variable named 'records', 10 elements."
225,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using bubble sort.,"fn bubble_sort(list1: &mut Vec<i32>) {
    let n = list1.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if list1[j] > list1[j + 1] {
                list1.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut list1 = vec![90, 97, -17, 94, 74, 37, -38, -39, -25, 67];
    bubble_sort(&mut list1);
    println!(""{:?}"", list1);
}","Bubble sort on int data, variable named 'list1', 10 elements."
226,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"fn bubble_sort(arr: &mut Vec<i32>) {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut arr = vec![-19, -10, 62, 66, -50, 59, 1, -17, 27, -10, 20, -27];
    bubble_sort(&mut arr);
    println!(""{:?}"", arr);
}","Bubble sort on int data, variable named 'arr', 12 elements."
227,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"fn bubble_sort(buffer: &mut Vec<i32>) {
    let n = buffer.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if buffer[j] > buffer[j + 1] {
                buffer.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut buffer = vec![42, 14, -29, 45, -8, -37, 51, 28, 9, 59, -27, -26];
    bubble_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Bubble sort on int data, variable named 'buffer', 12 elements."
228,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using bubble sort.,"fn bubble_sort(arr: &mut Vec<i32>) {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut arr = vec![4, 72, -31, -17, 7, 82, 63, -48, -48, 37, -20, 58];
    bubble_sort(&mut arr);
    println!(""{:?}"", arr);
}","Bubble sort on int data, variable named 'arr', 12 elements."
229,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<i32>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![-17, 72, -32, 8, 48, -28, -24, -24, 30, 44, 26, -15, 47, -16, -14];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on int data, variable named 'seq', 15 elements."
230,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"fn bubble_sort(data: &mut Vec<i32>) {
    let n = data.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if data[j] > data[j + 1] {
                data.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut data = vec![85, 94, -48, -8, 62, 39, 4, -12, 55, 63, 5, -28, -25, -15, -19];
    bubble_sort(&mut data);
    println!(""{:?}"", data);
}","Bubble sort on int data, variable named 'data', 15 elements."
231,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using bubble sort.,"fn bubble_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if elements[j] > elements[j + 1] {
                elements.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut elements = vec![48, 39, 59, 30, -15, 13, 20, -29, 13, 91, 22, -44, 27, 2, 82];
    bubble_sort(&mut elements);
    println!(""{:?}"", elements);
}","Bubble sort on int data, variable named 'elements', 15 elements."
232,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"fn bubble_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if elements[j] > elements[j + 1] {
                elements.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut elements = vec![80, -2, 50, 25, -37, 11, 76, 48, -22, 11, 77, -32, 85, -47, 42, 31, -17, 49, 95, 57];
    bubble_sort(&mut elements);
    println!(""{:?}"", elements);
}","Bubble sort on int data, variable named 'elements', 20 elements."
233,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"fn bubble_sort(list1: &mut Vec<i32>) {
    let n = list1.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if list1[j] > list1[j + 1] {
                list1.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut list1 = vec![89, -6, 70, -32, -46, -33, -47, 17, 5, -40, -35, 51, 79, 23, 78, 56, 58, 52, -29, 87];
    bubble_sort(&mut list1);
    println!(""{:?}"", list1);
}","Bubble sort on int data, variable named 'list1', 20 elements."
234,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using bubble sort.,"fn bubble_sort(input_arr: &mut Vec<i32>) {
    let n = input_arr.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if input_arr[j] > input_arr[j + 1] {
                input_arr.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut input_arr = vec![-11, 21, -29, 29, -30, 80, 2, -11, 87, 33, 50, -34, 29, 61, 11, -36, 12, -28, 61, -21];
    bubble_sort(&mut input_arr);
    println!(""{:?}"", input_arr);
}","Bubble sort on int data, variable named 'input_arr', 20 elements."
235,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"fn bubble_sort(dataset: &mut Vec<f64>) {
    let n = dataset.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if dataset[j] > dataset[j + 1] {
                dataset.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut dataset = vec![52.86, -13.45, 59.26, 58.31, 0.9];
    bubble_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Bubble sort on float data, variable named 'dataset', 5 elements."
236,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"fn bubble_sort(arr: &mut Vec<f64>) {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if arr[j] > arr[j + 1] {
                arr.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut arr = vec![64.24, 63.48, -0.5, 93.41, 42.24];
    bubble_sort(&mut arr);
    println!(""{:?}"", arr);
}","Bubble sort on float data, variable named 'arr', 5 elements."
237,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using bubble sort.,"fn bubble_sort(vals: &mut Vec<f64>) {
    let n = vals.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if vals[j] > vals[j + 1] {
                vals.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut vals = vec![77.88, 10.85, 24.25, 69.22, 83.94];
    bubble_sort(&mut vals);
    println!(""{:?}"", vals);
}","Bubble sort on float data, variable named 'vals', 5 elements."
238,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<f64>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![85.48, 71.8, -16.51, 76.05, 12.37, -12.4, 64.77, 48.62];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on float data, variable named 'seq', 8 elements."
239,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"fn bubble_sort(data: &mut Vec<f64>) {
    let n = data.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if data[j] > data[j + 1] {
                data.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut data = vec![39.04, 40.78, -13.4, 82.26, -0.14, -1.28, 72.03, 86.42];
    bubble_sort(&mut data);
    println!(""{:?}"", data);
}","Bubble sort on float data, variable named 'data', 8 elements."
240,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using bubble sort.,"fn bubble_sort(buffer: &mut Vec<f64>) {
    let n = buffer.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if buffer[j] > buffer[j + 1] {
                buffer.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut buffer = vec![66.01, 7.18, 40.55, -14.76, 82.69, 9.1, 36.14, 25.57];
    bubble_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Bubble sort on float data, variable named 'buffer', 8 elements."
241,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"fn bubble_sort(values: &mut Vec<f64>) {
    let n = values.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if values[j] > values[j + 1] {
                values.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut values = vec![1.3, 94.28, -15.79, 75.57, 64.97, 58.03, 6.72, 9.54, 88.99, 18.07];
    bubble_sort(&mut values);
    println!(""{:?}"", values);
}","Bubble sort on float data, variable named 'values', 10 elements."
242,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"fn bubble_sort(records: &mut Vec<f64>) {
    let n = records.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if records[j] > records[j + 1] {
                records.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut records = vec![-10.73, 24.36, 39.74, 87.33, 1.34, 75.72, 96.79, 93.54, -11.8, 35.35];
    bubble_sort(&mut records);
    println!(""{:?}"", records);
}","Bubble sort on float data, variable named 'records', 10 elements."
243,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using bubble sort.,"fn bubble_sort(nums: &mut Vec<f64>) {
    let n = nums.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if nums[j] > nums[j + 1] {
                nums.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut nums = vec![72.05, 16.97, -9.72, 34.35, 23.9, 14.7, 73.36, 68.01, 8.87, 23.82];
    bubble_sort(&mut nums);
    println!(""{:?}"", nums);
}","Bubble sort on float data, variable named 'nums', 10 elements."
244,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"fn bubble_sort(dataset: &mut Vec<f64>) {
    let n = dataset.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if dataset[j] > dataset[j + 1] {
                dataset.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut dataset = vec![98.74, 72.33, 67.16, 45.04, 74.72, -2.08, 90.96, -17.15, 44.44, 55.68, 62.52, -18.86];
    bubble_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Bubble sort on float data, variable named 'dataset', 12 elements."
245,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"fn bubble_sort(list1: &mut Vec<f64>) {
    let n = list1.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if list1[j] > list1[j + 1] {
                list1.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut list1 = vec![-19.83, 58.22, 81.03, 66.54, -7.63, 43.05, 8.34, 38.55, -12.87, 98.64, 64.69, -8.93];
    bubble_sort(&mut list1);
    println!(""{:?}"", list1);
}","Bubble sort on float data, variable named 'list1', 12 elements."
246,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using bubble sort.,"fn bubble_sort(entries: &mut Vec<f64>) {
    let n = entries.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if entries[j] > entries[j + 1] {
                entries.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut entries = vec![7.55, 80.62, 29.15, 86.57, 34.56, 69.0, 49.11, 40.15, 55.83, 26.93, 50.44, -12.59];
    bubble_sort(&mut entries);
    println!(""{:?}"", entries);
}","Bubble sort on float data, variable named 'entries', 12 elements."
247,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"fn bubble_sort(buffer: &mut Vec<f64>) {
    let n = buffer.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if buffer[j] > buffer[j + 1] {
                buffer.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut buffer = vec![94.74, 8.18, 11.06, 17.49, 75.3, 63.39, 67.51, 17.85, 12.36, -11.11, 4.12, 72.81, 49.58, -1.51, -0.44];
    bubble_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Bubble sort on float data, variable named 'buffer', 15 elements."
248,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"fn bubble_sort(dataset: &mut Vec<f64>) {
    let n = dataset.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if dataset[j] > dataset[j + 1] {
                dataset.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut dataset = vec![17.37, -5.63, 22.64, 71.67, 33.78, 35.14, 81.45, -9.24, 76.1, 16.2, 63.86, 51.79, 5.59, 81.93, -2.35];
    bubble_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Bubble sort on float data, variable named 'dataset', 15 elements."
249,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using bubble sort.,"fn bubble_sort(seq: &mut Vec<f64>) {
    let n = seq.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if seq[j] > seq[j + 1] {
                seq.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut seq = vec![9.54, 22.33, 41.1, 60.58, 10.96, 97.89, -16.3, 28.12, 33.81, 69.02, 9.73, 34.98, 75.66, -3.36, -18.58];
    bubble_sort(&mut seq);
    println!(""{:?}"", seq);
}","Bubble sort on float data, variable named 'seq', 15 elements."
250,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"fn bubble_sort(records: &mut Vec<f64>) {
    let n = records.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if records[j] > records[j + 1] {
                records.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut records = vec![72.93, 6.45, 3.58, 27.67, 61.67, 91.57, -10.0, 49.75, 89.17, -11.08, 98.66, 3.53, 56.87, 76.31, -9.05, 80.83, 76.26, -5.42, 92.13, -13.97];
    bubble_sort(&mut records);
    println!(""{:?}"", records);
}","Bubble sort on float data, variable named 'records', 20 elements."
251,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"fn bubble_sort(entries: &mut Vec<f64>) {
    let n = entries.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if entries[j] > entries[j + 1] {
                entries.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut entries = vec![48.29, 77.78, 27.0, -16.49, 61.3, 0.56, 5.55, 2.27, 13.3, 85.13, -15.88, 53.68, 9.25, 15.12, 29.03, 45.53, -12.74, 13.29, -3.67, 3.74];
    bubble_sort(&mut entries);
    println!(""{:?}"", entries);
}","Bubble sort on float data, variable named 'entries', 20 elements."
252,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using bubble sort.,"fn bubble_sort(entries: &mut Vec<f64>) {
    let n = entries.len();
    for i in 0..n {
        for j in 0..n - i - 1 {
            if entries[j] > entries[j + 1] {
                entries.swap(j, j + 1);
            }
        }
    }
}

fn main() {
    let mut entries = vec![74.87, 9.65, 98.3, 44.7, -17.68, 25.52, 64.89, 37.08, 72.99, 20.94, 47.31, 18.27, 12.18, -16.9, 51.06, -16.51, 76.47, 13.43, 76.23, 36.13];
    bubble_sort(&mut entries);
    println!(""{:?}"", entries);
}","Bubble sort on float data, variable named 'entries', 20 elements."
253,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"def selection_sort(list1):
    n = len(list1)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if list1[j] < list1[min_idx]:
                min_idx = j
        list1[i], list1[min_idx] = list1[min_idx], list1[i]
    return list1

print(selection_sort([99, 9, -10, -25, 13]))","Selection sort on int data, variable named 'list1', 5 elements."
254,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"def selection_sort(buffer):
    n = len(buffer)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if buffer[j] < buffer[min_idx]:
                min_idx = j
        buffer[i], buffer[min_idx] = buffer[min_idx], buffer[i]
    return buffer

print(selection_sort([11, 18, 86, -36, 6]))","Selection sort on int data, variable named 'buffer', 5 elements."
255,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([49, 40, -6, -5, 10]))","Selection sort on int data, variable named 'elements', 5 elements."
256,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([31, 41, -43, 40, 95, 94, -14, 94]))","Selection sort on int data, variable named 'elements', 8 elements."
257,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"def selection_sort(items):
    n = len(items)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if items[j] < items[min_idx]:
                min_idx = j
        items[i], items[min_idx] = items[min_idx], items[i]
    return items

print(selection_sort([76, 88, 29, -6, 75, -41, -27, -36]))","Selection sort on int data, variable named 'items', 8 elements."
258,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"def selection_sort(items):
    n = len(items)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if items[j] < items[min_idx]:
                min_idx = j
        items[i], items[min_idx] = items[min_idx], items[i]
    return items

print(selection_sort([6, -45, 84, 72, -50, 34, 1, -17]))","Selection sort on int data, variable named 'items', 8 elements."
259,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"def selection_sort(list1):
    n = len(list1)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if list1[j] < list1[min_idx]:
                min_idx = j
        list1[i], list1[min_idx] = list1[min_idx], list1[i]
    return list1

print(selection_sort([-5, 32, -35, -45, -13, -14, -22, 84, 43, -32]))","Selection sort on int data, variable named 'list1', 10 elements."
260,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"def selection_sort(list1):
    n = len(list1)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if list1[j] < list1[min_idx]:
                min_idx = j
        list1[i], list1[min_idx] = list1[min_idx], list1[i]
    return list1

print(selection_sort([51, -25, 36, 27, 32, -16, -10, 61, 74, 31]))","Selection sort on int data, variable named 'list1', 10 elements."
261,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"def selection_sort(values):
    n = len(values)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if values[j] < values[min_idx]:
                min_idx = j
        values[i], values[min_idx] = values[min_idx], values[i]
    return values

print(selection_sort([93, 41, 7, -6, 46, 28, 25, -18, -5, -50]))","Selection sort on int data, variable named 'values', 10 elements."
262,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"def selection_sort(seq):
    n = len(seq)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if seq[j] < seq[min_idx]:
                min_idx = j
        seq[i], seq[min_idx] = seq[min_idx], seq[i]
    return seq

print(selection_sort([96, 50, 95, -42, -4, 31, 6, 94, -24, 77, -14, 34]))","Selection sort on int data, variable named 'seq', 12 elements."
263,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"def selection_sort(seq):
    n = len(seq)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if seq[j] < seq[min_idx]:
                min_idx = j
        seq[i], seq[min_idx] = seq[min_idx], seq[i]
    return seq

print(selection_sort([-31, 10, 38, 31, -8, -28, 35, 64, -48, 17, 3, 13]))","Selection sort on int data, variable named 'seq', 12 elements."
264,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"def selection_sort(seq):
    n = len(seq)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if seq[j] < seq[min_idx]:
                min_idx = j
        seq[i], seq[min_idx] = seq[min_idx], seq[i]
    return seq

print(selection_sort([-33, 39, 15, -23, -50, -38, 48, 62, 57, -8, 55, 76]))","Selection sort on int data, variable named 'seq', 12 elements."
265,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"def selection_sort(entries):
    n = len(entries)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if entries[j] < entries[min_idx]:
                min_idx = j
        entries[i], entries[min_idx] = entries[min_idx], entries[i]
    return entries

print(selection_sort([46, 39, 89, 46, -25, 72, 97, 7, -9, 65, -32, -42, 25, -45, 31]))","Selection sort on int data, variable named 'entries', 15 elements."
266,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if nums[j] < nums[min_idx]:
                min_idx = j
        nums[i], nums[min_idx] = nums[min_idx], nums[i]
    return nums

print(selection_sort([-24, -32, 37, -7, 46, -9, -31, 90, -27, 36, 73, -43, 60, -8, 61]))","Selection sort on int data, variable named 'nums', 15 elements."
267,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"def selection_sort(values):
    n = len(values)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if values[j] < values[min_idx]:
                min_idx = j
        values[i], values[min_idx] = values[min_idx], values[i]
    return values

print(selection_sort([-37, -25, 34, 2, -2, 54, 91, 88, 17, 22, 26, 10, -26, -38, 50]))","Selection sort on int data, variable named 'values', 15 elements."
268,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([90, 75, -11, -37, 42, -50, 59, -28, 25, 72, 1, -26, -44, 2, -7, 24, -30, 71, -21, 28]))","Selection sort on int data, variable named 'elements', 20 elements."
269,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"def selection_sort(vals):
    n = len(vals)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if vals[j] < vals[min_idx]:
                min_idx = j
        vals[i], vals[min_idx] = vals[min_idx], vals[i]
    return vals

print(selection_sort([51, 70, 75, 17, -27, 89, 49, -3, 44, 47, 44, -3, 64, -39, 17, 62, 69, 17, 7, 18]))","Selection sort on int data, variable named 'vals', 20 elements."
270,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([-35, -12, -26, -29, 38, 88, 55, 8, 91, -35, 49, 83, 57, 87, 71, 96, 10, 71, 26, -30]))","Selection sort on int data, variable named 'elements', 20 elements."
271,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"def selection_sort(collection):
    n = len(collection)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if collection[j] < collection[min_idx]:
                min_idx = j
        collection[i], collection[min_idx] = collection[min_idx], collection[i]
    return collection

print(selection_sort([87.43, 65.0, 39.75, 87.15, 75.25]))","Selection sort on float data, variable named 'collection', 5 elements."
272,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"def selection_sort(buffer):
    n = len(buffer)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if buffer[j] < buffer[min_idx]:
                min_idx = j
        buffer[i], buffer[min_idx] = buffer[min_idx], buffer[i]
    return buffer

print(selection_sort([96.95, -2.45, 92.96, 33.44, 92.94]))","Selection sort on float data, variable named 'buffer', 5 elements."
273,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"def selection_sort(values):
    n = len(values)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if values[j] < values[min_idx]:
                min_idx = j
        values[i], values[min_idx] = values[min_idx], values[i]
    return values

print(selection_sort([95.69, 76.21, -4.98, 30.38, 97.61]))","Selection sort on float data, variable named 'values', 5 elements."
274,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"def selection_sort(collection):
    n = len(collection)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if collection[j] < collection[min_idx]:
                min_idx = j
        collection[i], collection[min_idx] = collection[min_idx], collection[i]
    return collection

print(selection_sort([4.03, 77.89, -2.4, 50.81, 18.05, 66.53, 76.07, -9.64]))","Selection sort on float data, variable named 'collection', 8 elements."
275,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"def selection_sort(input_arr):
    n = len(input_arr)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if input_arr[j] < input_arr[min_idx]:
                min_idx = j
        input_arr[i], input_arr[min_idx] = input_arr[min_idx], input_arr[i]
    return input_arr

print(selection_sort([27.29, 18.81, 12.87, 34.52, 83.94, 73.6, 54.14, 42.18]))","Selection sort on float data, variable named 'input_arr', 8 elements."
276,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"def selection_sort(collection):
    n = len(collection)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if collection[j] < collection[min_idx]:
                min_idx = j
        collection[i], collection[min_idx] = collection[min_idx], collection[i]
    return collection

print(selection_sort([-6.61, -2.19, 47.42, 49.34, 94.81, -8.08, -7.43, 72.77]))","Selection sort on float data, variable named 'collection', 8 elements."
277,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"def selection_sort(vals):
    n = len(vals)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if vals[j] < vals[min_idx]:
                min_idx = j
        vals[i], vals[min_idx] = vals[min_idx], vals[i]
    return vals

print(selection_sort([14.05, 43.74, 20.92, 28.9, 25.58, 37.78, 52.47, -15.54, 12.77, -2.88]))","Selection sort on float data, variable named 'vals', 10 elements."
278,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([61.02, 27.8, 27.1, 84.6, 62.17, -14.13, 36.55, 11.96, 24.32, 20.21]))","Selection sort on float data, variable named 'elements', 10 elements."
279,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"def selection_sort(vals):
    n = len(vals)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if vals[j] < vals[min_idx]:
                min_idx = j
        vals[i], vals[min_idx] = vals[min_idx], vals[i]
    return vals

print(selection_sort([16.06, 13.36, 38.5, 62.85, -8.31, 83.4, -4.01, 95.93, 32.73, 78.27]))","Selection sort on float data, variable named 'vals', 10 elements."
280,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if nums[j] < nums[min_idx]:
                min_idx = j
        nums[i], nums[min_idx] = nums[min_idx], nums[i]
    return nums

print(selection_sort([66.73, 51.99, -9.37, 32.56, 88.7, 28.45, 37.65, 41.46, 24.5, -13.31, 74.19, -12.19]))","Selection sort on float data, variable named 'nums', 12 elements."
281,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"def selection_sort(seq):
    n = len(seq)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if seq[j] < seq[min_idx]:
                min_idx = j
        seq[i], seq[min_idx] = seq[min_idx], seq[i]
    return seq

print(selection_sort([40.31, -3.86, 81.3, 84.64, -16.56, 2.94, 79.12, 79.6, 9.69, 34.32, 89.25, 63.85]))","Selection sort on float data, variable named 'seq', 12 elements."
282,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if nums[j] < nums[min_idx]:
                min_idx = j
        nums[i], nums[min_idx] = nums[min_idx], nums[i]
    return nums

print(selection_sort([23.83, 35.24, 27.24, 89.85, 61.06, 8.79, 38.17, 33.09, 94.3, 36.48, 45.61, 20.97]))","Selection sort on float data, variable named 'nums', 12 elements."
283,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"def selection_sort(records):
    n = len(records)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if records[j] < records[min_idx]:
                min_idx = j
        records[i], records[min_idx] = records[min_idx], records[i]
    return records

print(selection_sort([86.44, 69.13, 61.97, 13.92, 26.0, -0.61, 48.1, 94.83, 82.0, 57.04, 60.65, 12.02, 28.73, -17.61, 72.86]))","Selection sort on float data, variable named 'records', 15 elements."
284,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"def selection_sort(vals):
    n = len(vals)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if vals[j] < vals[min_idx]:
                min_idx = j
        vals[i], vals[min_idx] = vals[min_idx], vals[i]
    return vals

print(selection_sort([61.18, 36.42, -4.25, 0.61, 75.3, 6.63, 52.39, 92.22, 64.82, 64.41, 12.77, 86.56, 81.34, 34.62, 5.97]))","Selection sort on float data, variable named 'vals', 15 elements."
285,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if nums[j] < nums[min_idx]:
                min_idx = j
        nums[i], nums[min_idx] = nums[min_idx], nums[i]
    return nums

print(selection_sort([60.59, 78.09, 27.26, -7.82, 40.87, 58.82, 80.35, 24.53, 57.03, 52.48, 15.52, -7.14, -12.4, 97.61, 56.23]))","Selection sort on float data, variable named 'nums', 15 elements."
286,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"def selection_sort(records):
    n = len(records)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if records[j] < records[min_idx]:
                min_idx = j
        records[i], records[min_idx] = records[min_idx], records[i]
    return records

print(selection_sort([12.95, 58.08, 93.31, 57.52, 2.41, 41.56, 8.6, -13.24, 82.02, 76.39, 28.09, 18.03, -3.35, -16.97, 39.19, 15.18, 87.92, 28.15, 67.67, 49.38]))","Selection sort on float data, variable named 'records', 20 elements."
287,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"def selection_sort(elements):
    n = len(elements)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if elements[j] < elements[min_idx]:
                min_idx = j
        elements[i], elements[min_idx] = elements[min_idx], elements[i]
    return elements

print(selection_sort([77.11, 20.84, 64.89, 61.67, 55.96, 36.61, 91.94, 22.66, 15.72, 0.23, 58.26, 46.43, 14.96, 36.02, 68.17, 66.3, 46.52, 88.6, 92.68, 87.05]))","Selection sort on float data, variable named 'elements', 20 elements."
288,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"def selection_sort(buffer):
    n = len(buffer)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if buffer[j] < buffer[min_idx]:
                min_idx = j
        buffer[i], buffer[min_idx] = buffer[min_idx], buffer[i]
    return buffer

print(selection_sort([-9.37, 22.28, 68.56, 16.54, 73.78, 19.43, 11.01, 14.99, 81.29, 35.99, 83.1, 49.45, 92.37, -11.53, 85.84, 39.56, 83.23, 25.42, 15.5, -13.57]))","Selection sort on float data, variable named 'buffer', 20 elements."
289,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(records) {
  const n = records.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (records[j] < records[minIdx]) minIdx = j;
    }
    [records[i], records[minIdx]] = [records[minIdx], records[i]];
  }
  return records;
}

console.log(selectionSort([-12, -15, 1, 37, 54]));","Selection sort on int data, variable named 'records', 5 elements."
290,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(elements) {
  const n = elements.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (elements[j] < elements[minIdx]) minIdx = j;
    }
    [elements[i], elements[minIdx]] = [elements[minIdx], elements[i]];
  }
  return elements;
}

console.log(selectionSort([67, -14, 30, -4, -30]));","Selection sort on int data, variable named 'elements', 5 elements."
291,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(dataset) {
  const n = dataset.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (dataset[j] < dataset[minIdx]) minIdx = j;
    }
    [dataset[i], dataset[minIdx]] = [dataset[minIdx], dataset[i]];
  }
  return dataset;
}

console.log(selectionSort([35, -5, 30, -36, -49]));","Selection sort on int data, variable named 'dataset', 5 elements."
292,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(dataset) {
  const n = dataset.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (dataset[j] < dataset[minIdx]) minIdx = j;
    }
    [dataset[i], dataset[minIdx]] = [dataset[minIdx], dataset[i]];
  }
  return dataset;
}

console.log(selectionSort([20, 3, -7, 97, -10, 75, -28, -17]));","Selection sort on int data, variable named 'dataset', 8 elements."
293,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(elements) {
  const n = elements.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (elements[j] < elements[minIdx]) minIdx = j;
    }
    [elements[i], elements[minIdx]] = [elements[minIdx], elements[i]];
  }
  return elements;
}

console.log(selectionSort([61, 59, 53, 59, 72, 48, -49, -41]));","Selection sort on int data, variable named 'elements', 8 elements."
294,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(input_arr) {
  const n = input_arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (input_arr[j] < input_arr[minIdx]) minIdx = j;
    }
    [input_arr[i], input_arr[minIdx]] = [input_arr[minIdx], input_arr[i]];
  }
  return input_arr;
}

console.log(selectionSort([1, 45, -47, 32, 85, -2, -46, -49]));","Selection sort on int data, variable named 'input_arr', 8 elements."
295,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

console.log(selectionSort([13, 7, 38, 29, -17, -24, 48, 78, 28, -8]));","Selection sort on int data, variable named 'buffer', 10 elements."
296,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(data) {
  const n = data.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (data[j] < data[minIdx]) minIdx = j;
    }
    [data[i], data[minIdx]] = [data[minIdx], data[i]];
  }
  return data;
}

console.log(selectionSort([-39, 26, 24, 66, 83, 84, 36, 61, -16, 37]));","Selection sort on int data, variable named 'data', 10 elements."
297,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

console.log(selectionSort([75, 41, -2, -8, 53, -46, 8, 7, -17, 4]));","Selection sort on int data, variable named 'entries', 10 elements."
298,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

console.log(selectionSort([-45, 79, -7, -19, 43, -41, 46, 15, 86, -38, -38, -23]));","Selection sort on int data, variable named 'seq', 12 elements."
299,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

console.log(selectionSort([-45, -38, -21, 56, 63, 47, -19, 90, 14, 71, -11, 2]));","Selection sort on int data, variable named 'buffer', 12 elements."
300,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

console.log(selectionSort([-48, 27, 57, -25, 83, 19, -15, 57, -24, 80, -20, 22]));","Selection sort on int data, variable named 'seq', 12 elements."
301,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(data) {
  const n = data.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (data[j] < data[minIdx]) minIdx = j;
    }
    [data[i], data[minIdx]] = [data[minIdx], data[i]];
  }
  return data;
}

console.log(selectionSort([-23, 77, 0, 1, 17, 83, 1, 41, 54, 25, -9, -40, 90, 77, 3]));","Selection sort on int data, variable named 'data', 15 elements."
302,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

console.log(selectionSort([73, 34, 10, -50, -47, -28, -22, 96, 76, -12, -27, 80, -31, -25, 15]));","Selection sort on int data, variable named 'seq', 15 elements."
303,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

console.log(selectionSort([9, 66, 25, 17, 68, -38, -25, -6, -40, 24, 42, 30, 59, -21, -26]));","Selection sort on int data, variable named 'buffer', 15 elements."
304,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(records) {
  const n = records.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (records[j] < records[minIdx]) minIdx = j;
    }
    [records[i], records[minIdx]] = [records[minIdx], records[i]];
  }
  return records;
}

console.log(selectionSort([-39, -48, -15, -7, 34, 41, 62, 18, -27, 45, 37, -4, -21, 52, 52, 66, 19, 48, 72, 57]));","Selection sort on int data, variable named 'records', 20 elements."
305,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

console.log(selectionSort([-8, -22, -17, -35, -10, -24, 56, 73, 95, 62, -4, 47, 41, -43, -17, 73, 74, -22, 55, 62]));","Selection sort on int data, variable named 'buffer', 20 elements."
306,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
  }
  return arr;
}

console.log(selectionSort([-34, 16, 30, -47, 84, 97, 94, 7, 36, 82, 83, -26, 60, 13, 73, 38, 48, -12, 92, -37]));","Selection sort on int data, variable named 'arr', 20 elements."
307,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
  }
  return arr;
}

console.log(selectionSort([56.56, -1.33, 81.01, 81.37, 83.46]));","Selection sort on float data, variable named 'arr', 5 elements."
308,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(data) {
  const n = data.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (data[j] < data[minIdx]) minIdx = j;
    }
    [data[i], data[minIdx]] = [data[minIdx], data[i]];
  }
  return data;
}

console.log(selectionSort([69.42, 18.16, 19.38, 13.1, 40.32]));","Selection sort on float data, variable named 'data', 5 elements."
309,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(input_arr) {
  const n = input_arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (input_arr[j] < input_arr[minIdx]) minIdx = j;
    }
    [input_arr[i], input_arr[minIdx]] = [input_arr[minIdx], input_arr[i]];
  }
  return input_arr;
}

console.log(selectionSort([56.55, 27.99, 7.96, 34.63, 75.35]));","Selection sort on float data, variable named 'input_arr', 5 elements."
310,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(dataset) {
  const n = dataset.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (dataset[j] < dataset[minIdx]) minIdx = j;
    }
    [dataset[i], dataset[minIdx]] = [dataset[minIdx], dataset[i]];
  }
  return dataset;
}

console.log(selectionSort([-9.53, 39.32, 17.61, 96.7, 68.68, -17.89, 28.01, -15.74]));","Selection sort on float data, variable named 'dataset', 8 elements."
311,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(input_arr) {
  const n = input_arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (input_arr[j] < input_arr[minIdx]) minIdx = j;
    }
    [input_arr[i], input_arr[minIdx]] = [input_arr[minIdx], input_arr[i]];
  }
  return input_arr;
}

console.log(selectionSort([-19.98, -9.18, 51.9, 53.67, 16.25, 40.49, 4.62, 59.91]));","Selection sort on float data, variable named 'input_arr', 8 elements."
312,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(list1) {
  const n = list1.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (list1[j] < list1[minIdx]) minIdx = j;
    }
    [list1[i], list1[minIdx]] = [list1[minIdx], list1[i]];
  }
  return list1;
}

console.log(selectionSort([23.24, -13.54, 6.53, 34.08, 46.66, 53.75, 36.3, 58.2]));","Selection sort on float data, variable named 'list1', 8 elements."
313,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

console.log(selectionSort([33.85, -8.4, 58.41, -19.74, 22.26, 55.41, 75.19, 45.18, 24.49, -7.35]));","Selection sort on float data, variable named 'seq', 10 elements."
314,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

console.log(selectionSort([-0.47, -3.29, 65.31, 65.87, -7.27, 52.69, 2.32, 90.7, 26.75, 34.39]));","Selection sort on float data, variable named 'entries', 10 elements."
315,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

console.log(selectionSort([2.68, 20.21, 70.1, -14.47, 55.36, 59.98, -5.34, 86.12, 34.43, 50.13]));","Selection sort on float data, variable named 'vals', 10 elements."
316,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(input_arr) {
  const n = input_arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (input_arr[j] < input_arr[minIdx]) minIdx = j;
    }
    [input_arr[i], input_arr[minIdx]] = [input_arr[minIdx], input_arr[i]];
  }
  return input_arr;
}

console.log(selectionSort([-3.98, 39.36, 43.11, -14.22, 91.3, 79.82, 37.47, 40.49, 89.62, 1.09, 48.85, 66.93]));","Selection sort on float data, variable named 'input_arr', 12 elements."
317,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(values) {
  const n = values.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (values[j] < values[minIdx]) minIdx = j;
    }
    [values[i], values[minIdx]] = [values[minIdx], values[i]];
  }
  return values;
}

console.log(selectionSort([-7.68, 58.25, 52.13, 18.3, 84.89, 29.82, 52.47, 62.41, 9.54, 27.35, 20.8, 15.01]));","Selection sort on float data, variable named 'values', 12 elements."
318,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

console.log(selectionSort([-4.13, 29.12, 63.3, 69.06, 15.57, 63.48, 82.42, 64.71, 91.33, 55.28, 3.91, 54.28]));","Selection sort on float data, variable named 'vals', 12 elements."
319,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(nums) {
  const n = nums.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (nums[j] < nums[minIdx]) minIdx = j;
    }
    [nums[i], nums[minIdx]] = [nums[minIdx], nums[i]];
  }
  return nums;
}

console.log(selectionSort([61.71, 89.62, -4.21, 64.54, 96.05, 1.16, 44.56, 55.79, 64.53, 70.53, 46.91, 49.35, 92.18, 64.5, 60.23]));","Selection sort on float data, variable named 'nums', 15 elements."
320,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

console.log(selectionSort([80.13, 14.03, 80.83, 76.19, 42.2, -16.99, -2.71, 59.76, 3.79, 69.27, -0.85, 14.11, 9.82, 79.89, 62.18]));","Selection sort on float data, variable named 'entries', 15 elements."
321,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(nums) {
  const n = nums.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (nums[j] < nums[minIdx]) minIdx = j;
    }
    [nums[i], nums[minIdx]] = [nums[minIdx], nums[i]];
  }
  return nums;
}

console.log(selectionSort([4.28, 44.4, 22.68, 33.86, 53.32, 60.39, 46.86, 6.69, 57.01, 26.28, 40.8, 74.82, 62.84, 62.46, -14.41]));","Selection sort on float data, variable named 'nums', 15 elements."
322,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(collection) {
  const n = collection.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (collection[j] < collection[minIdx]) minIdx = j;
    }
    [collection[i], collection[minIdx]] = [collection[minIdx], collection[i]];
  }
  return collection;
}

console.log(selectionSort([26.12, 93.85, 96.12, 17.21, 45.7, -18.46, 9.91, 53.85, 72.93, 83.54, 78.77, 88.47, 63.85, 57.07, 69.86, 45.05, 51.8, 72.36, 94.75, 15.01]));","Selection sort on float data, variable named 'collection', 20 elements."
323,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(values) {
  const n = values.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (values[j] < values[minIdx]) minIdx = j;
    }
    [values[i], values[minIdx]] = [values[minIdx], values[i]];
  }
  return values;
}

console.log(selectionSort([97.03, -11.14, 94.53, 67.47, -5.8, -15.16, 13.21, 11.44, -0.85, 80.68, -19.33, 35.49, 91.56, -15.25, 90.51, 51.03, 72.07, 54.42, 80.33, 15.84]));","Selection sort on float data, variable named 'values', 20 elements."
324,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

console.log(selectionSort([48.15, 22.61, 73.3, 17.83, 6.18, 1.88, -11.89, 40.11, 29.5, 43.91, -9.06, 6.32, 5.39, 19.49, 22.93, 5.99, 69.57, 43.13, 98.6, 78.02]));","Selection sort on float data, variable named 'vals', 20 elements."
325,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

module.exports = { selectionSort };
console.log(selectionSort([-48, -21, 38, 64, 11]));","Selection sort on int data, variable named 'buffer', 5 elements."
326,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

module.exports = { selectionSort };
console.log(selectionSort([12, -40, 32, 47, -21]));","Selection sort on int data, variable named 'entries', 5 elements."
327,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"function selectionSort(collection) {
  const n = collection.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (collection[j] < collection[minIdx]) minIdx = j;
    }
    [collection[i], collection[minIdx]] = [collection[minIdx], collection[i]];
  }
  return collection;
}

module.exports = { selectionSort };
console.log(selectionSort([15, 88, 22, -44, 82]));","Selection sort on int data, variable named 'collection', 5 elements."
328,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(records) {
  const n = records.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (records[j] < records[minIdx]) minIdx = j;
    }
    [records[i], records[minIdx]] = [records[minIdx], records[i]];
  }
  return records;
}

module.exports = { selectionSort };
console.log(selectionSort([45, 81, 80, 64, 74, -39, 25, -1]));","Selection sort on int data, variable named 'records', 8 elements."
329,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(list1) {
  const n = list1.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (list1[j] < list1[minIdx]) minIdx = j;
    }
    [list1[i], list1[minIdx]] = [list1[minIdx], list1[i]];
  }
  return list1;
}

module.exports = { selectionSort };
console.log(selectionSort([81, -29, -26, -8, 87, 86, -49, -34]));","Selection sort on int data, variable named 'list1', 8 elements."
330,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"function selectionSort(items) {
  const n = items.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (items[j] < items[minIdx]) minIdx = j;
    }
    [items[i], items[minIdx]] = [items[minIdx], items[i]];
  }
  return items;
}

module.exports = { selectionSort };
console.log(selectionSort([4, 58, -24, 2, 87, 61, -32, -11]));","Selection sort on int data, variable named 'items', 8 elements."
331,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
  }
  return arr;
}

module.exports = { selectionSort };
console.log(selectionSort([67, 34, -41, -28, -32, -37, -5, 14, 92, -32]));","Selection sort on int data, variable named 'arr', 10 elements."
332,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(elements) {
  const n = elements.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (elements[j] < elements[minIdx]) minIdx = j;
    }
    [elements[i], elements[minIdx]] = [elements[minIdx], elements[i]];
  }
  return elements;
}

module.exports = { selectionSort };
console.log(selectionSort([8, 16, 54, 49, 65, 53, 60, 30, -46, 49]));","Selection sort on int data, variable named 'elements', 10 elements."
333,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

module.exports = { selectionSort };
console.log(selectionSort([-20, 86, -49, -34, 99, -39, -32, 41, 78, -23]));","Selection sort on int data, variable named 'buffer', 10 elements."
334,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(nums) {
  const n = nums.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (nums[j] < nums[minIdx]) minIdx = j;
    }
    [nums[i], nums[minIdx]] = [nums[minIdx], nums[i]];
  }
  return nums;
}

module.exports = { selectionSort };
console.log(selectionSort([27, -28, 22, 62, 47, 51, -43, 71, -10, 86, 6, -16]));","Selection sort on int data, variable named 'nums', 12 elements."
335,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

module.exports = { selectionSort };
console.log(selectionSort([50, 89, 25, -14, 26, 45, -48, 91, 92, -14, -19, -40]));","Selection sort on int data, variable named 'seq', 12 elements."
336,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
  }
  return arr;
}

module.exports = { selectionSort };
console.log(selectionSort([96, 50, 87, 90, -29, 28, 3, 38, 4, 55, 81, -14]));","Selection sort on int data, variable named 'arr', 12 elements."
337,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(values) {
  const n = values.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (values[j] < values[minIdx]) minIdx = j;
    }
    [values[i], values[minIdx]] = [values[minIdx], values[i]];
  }
  return values;
}

module.exports = { selectionSort };
console.log(selectionSort([-3, 6, 14, -1, -21, -4, 95, -37, 90, 68, 90, -32, 24, -33, 14]));","Selection sort on int data, variable named 'values', 15 elements."
338,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(data) {
  const n = data.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (data[j] < data[minIdx]) minIdx = j;
    }
    [data[i], data[minIdx]] = [data[minIdx], data[i]];
  }
  return data;
}

module.exports = { selectionSort };
console.log(selectionSort([0, 98, 74, 34, 41, -18, 10, -25, 22, -33, -1, 31, 74, 65, 34]));","Selection sort on int data, variable named 'data', 15 elements."
339,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"function selectionSort(elements) {
  const n = elements.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (elements[j] < elements[minIdx]) minIdx = j;
    }
    [elements[i], elements[minIdx]] = [elements[minIdx], elements[i]];
  }
  return elements;
}

module.exports = { selectionSort };
console.log(selectionSort([28, 99, -11, 94, 95, 43, 30, 59, -7, -49, 30, 13, 6, 61, 20]));","Selection sort on int data, variable named 'elements', 15 elements."
340,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(records) {
  const n = records.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (records[j] < records[minIdx]) minIdx = j;
    }
    [records[i], records[minIdx]] = [records[minIdx], records[i]];
  }
  return records;
}

module.exports = { selectionSort };
console.log(selectionSort([42, -16, 34, 72, 68, 64, 41, 28, 74, 91, -23, -6, -30, 21, -15, 87, 0, 17, -31, -31]));","Selection sort on int data, variable named 'records', 20 elements."
341,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

module.exports = { selectionSort };
console.log(selectionSort([-46, 79, -43, 98, 98, 53, 4, -41, 91, 16, 89, 88, 70, -12, 43, 50, 7, 24, -16, 68]));","Selection sort on int data, variable named 'entries', 20 elements."
342,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"function selectionSort(input_arr) {
  const n = input_arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (input_arr[j] < input_arr[minIdx]) minIdx = j;
    }
    [input_arr[i], input_arr[minIdx]] = [input_arr[minIdx], input_arr[i]];
  }
  return input_arr;
}

module.exports = { selectionSort };
console.log(selectionSort([80, -27, 51, 43, 78, -48, 11, -8, 81, -15, 64, -10, -5, 94, 94, -13, 73, 41, -40, 6]));","Selection sort on int data, variable named 'input_arr', 20 elements."
343,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

module.exports = { selectionSort };
console.log(selectionSort([38.03, -12.52, 23.96, -14.91, 4.61]));","Selection sort on float data, variable named 'vals', 5 elements."
344,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

module.exports = { selectionSort };
console.log(selectionSort([74.18, 26.18, 89.23, 84.9, -15.25]));","Selection sort on float data, variable named 'entries', 5 elements."
345,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

module.exports = { selectionSort };
console.log(selectionSort([18.56, 63.74, 42.04, 78.73, 79.35]));","Selection sort on float data, variable named 'buffer', 5 elements."
346,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(nums) {
  const n = nums.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (nums[j] < nums[minIdx]) minIdx = j;
    }
    [nums[i], nums[minIdx]] = [nums[minIdx], nums[i]];
  }
  return nums;
}

module.exports = { selectionSort };
console.log(selectionSort([48.86, 47.85, 24.82, 25.04, 49.93, 86.89, -10.74, 9.94]));","Selection sort on float data, variable named 'nums', 8 elements."
347,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(entries) {
  const n = entries.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (entries[j] < entries[minIdx]) minIdx = j;
    }
    [entries[i], entries[minIdx]] = [entries[minIdx], entries[i]];
  }
  return entries;
}

module.exports = { selectionSort };
console.log(selectionSort([6.53, 28.3, 77.25, 21.06, 74.33, 85.57, -19.21, 84.96]));","Selection sort on float data, variable named 'entries', 8 elements."
348,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"function selectionSort(dataset) {
  const n = dataset.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (dataset[j] < dataset[minIdx]) minIdx = j;
    }
    [dataset[i], dataset[minIdx]] = [dataset[minIdx], dataset[i]];
  }
  return dataset;
}

module.exports = { selectionSort };
console.log(selectionSort([-0.29, -10.83, 56.57, 5.17, 2.24, 23.1, 65.36, -5.92]));","Selection sort on float data, variable named 'dataset', 8 elements."
349,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(items) {
  const n = items.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (items[j] < items[minIdx]) minIdx = j;
    }
    [items[i], items[minIdx]] = [items[minIdx], items[i]];
  }
  return items;
}

module.exports = { selectionSort };
console.log(selectionSort([29.34, 19.3, -6.51, 60.35, 37.0, 50.3, 57.02, 28.9, 9.0, -4.78]));","Selection sort on float data, variable named 'items', 10 elements."
350,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(elements) {
  const n = elements.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (elements[j] < elements[minIdx]) minIdx = j;
    }
    [elements[i], elements[minIdx]] = [elements[minIdx], elements[i]];
  }
  return elements;
}

module.exports = { selectionSort };
console.log(selectionSort([-0.83, 54.92, -15.34, 48.1, -13.35, 10.73, 1.42, 94.03, 51.32, 47.07]));","Selection sort on float data, variable named 'elements', 10 elements."
351,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIdx]) minIdx = j;
    }
    [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
  }
  return arr;
}

module.exports = { selectionSort };
console.log(selectionSort([84.54, 66.63, 77.74, 92.72, 5.77, 52.18, 36.1, 37.32, 6.1, 28.88]));","Selection sort on float data, variable named 'arr', 10 elements."
352,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(values) {
  const n = values.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (values[j] < values[minIdx]) minIdx = j;
    }
    [values[i], values[minIdx]] = [values[minIdx], values[i]];
  }
  return values;
}

module.exports = { selectionSort };
console.log(selectionSort([74.56, 77.63, 1.64, 58.5, 11.48, 66.18, 20.78, 33.96, 50.28, 7.35, 25.87, -7.08]));","Selection sort on float data, variable named 'values', 12 elements."
353,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(items) {
  const n = items.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (items[j] < items[minIdx]) minIdx = j;
    }
    [items[i], items[minIdx]] = [items[minIdx], items[i]];
  }
  return items;
}

module.exports = { selectionSort };
console.log(selectionSort([42.2, 88.21, 61.44, 78.36, 52.06, 1.11, 87.29, 51.38, 84.45, 43.24, 69.53, -8.91]));","Selection sort on float data, variable named 'items', 12 elements."
354,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

module.exports = { selectionSort };
console.log(selectionSort([-4.49, 51.81, 78.48, 86.74, 72.21, 57.26, 42.12, 24.07, -14.83, 43.05, 7.31, 75.47]));","Selection sort on float data, variable named 'buffer', 12 elements."
355,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

module.exports = { selectionSort };
console.log(selectionSort([71.47, 21.71, 75.75, 88.04, 79.63, 48.56, 30.63, 10.29, 71.14, 88.3, -10.03, 51.2, 44.7, 10.68, -19.35]));","Selection sort on float data, variable named 'vals', 15 elements."
356,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(seq) {
  const n = seq.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (seq[j] < seq[minIdx]) minIdx = j;
    }
    [seq[i], seq[minIdx]] = [seq[minIdx], seq[i]];
  }
  return seq;
}

module.exports = { selectionSort };
console.log(selectionSort([73.94, 48.78, -5.98, -19.14, 57.89, 61.84, 17.59, 23.11, -1.58, 57.54, 10.18, 81.74, 30.4, 23.51, 12.79]));","Selection sort on float data, variable named 'seq', 15 elements."
357,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"function selectionSort(buffer) {
  const n = buffer.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (buffer[j] < buffer[minIdx]) minIdx = j;
    }
    [buffer[i], buffer[minIdx]] = [buffer[minIdx], buffer[i]];
  }
  return buffer;
}

module.exports = { selectionSort };
console.log(selectionSort([27.3, 4.24, 45.7, 46.35, 1.27, 46.53, 37.57, 97.63, 48.74, 72.13, 27.38, -3.57, 82.8, -5.83, 7.34]));","Selection sort on float data, variable named 'buffer', 15 elements."
358,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(vals) {
  const n = vals.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (vals[j] < vals[minIdx]) minIdx = j;
    }
    [vals[i], vals[minIdx]] = [vals[minIdx], vals[i]];
  }
  return vals;
}

module.exports = { selectionSort };
console.log(selectionSort([63.22, -0.75, 5.52, 27.67, 20.27, 45.52, 62.95, 64.11, -0.87, 94.78, -19.37, -9.16, -2.71, 90.18, 31.81, -12.37, 6.39, -10.48, -15.51, 25.73]));","Selection sort on float data, variable named 'vals', 20 elements."
359,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(collection) {
  const n = collection.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (collection[j] < collection[minIdx]) minIdx = j;
    }
    [collection[i], collection[minIdx]] = [collection[minIdx], collection[i]];
  }
  return collection;
}

module.exports = { selectionSort };
console.log(selectionSort([53.06, 42.0, 64.68, 51.1, 92.54, 77.61, 56.19, 32.24, 4.0, 58.17, 75.67, 14.03, -16.0, 51.34, 41.38, 7.57, 0.17, -15.71, 8.47, -19.97]));","Selection sort on float data, variable named 'collection', 20 elements."
360,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"function selectionSort(values) {
  const n = values.length;
  for (let i = 0; i < n; i++) {
    let minIdx = i;
    for (let j = i + 1; j < n; j++) {
      if (values[j] < values[minIdx]) minIdx = j;
    }
    [values[i], values[minIdx]] = [values[minIdx], values[i]];
  }
  return values;
}

module.exports = { selectionSort };
console.log(selectionSort([-9.67, 12.84, 27.53, 59.69, 28.25, 3.84, -18.17, 63.73, 89.38, 45.4, 66.41, 46.53, 49.37, 21.35, 77.05, 6.93, 94.6, 34.12, 28.07, -19.45]));","Selection sort on float data, variable named 'values', 20 elements."
361,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] values) {
        int n = values.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (values[j] < values[minIdx]) minIdx = j;
            }
            int temp = values[i];
            values[i] = values[minIdx];
            values[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] values = {54, 79, -23, 93, -32};
        selectionSort(values);
        for (int v : values) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'values', 5 elements."
362,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (input_arr[j] < input_arr[minIdx]) minIdx = j;
            }
            int temp = input_arr[i];
            input_arr[i] = input_arr[minIdx];
            input_arr[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {25, 37, -21, 81, 15};
        selectionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'input_arr', 5 elements."
363,Java,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (entries[j] < entries[minIdx]) minIdx = j;
            }
            int temp = entries[i];
            entries[i] = entries[minIdx];
            entries[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] entries = {87, 97, 14, 63, 46};
        selectionSort(entries);
        for (int v : entries) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'entries', 5 elements."
364,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] elements) {
        int n = elements.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (elements[j] < elements[minIdx]) minIdx = j;
            }
            int temp = elements[i];
            elements[i] = elements[minIdx];
            elements[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] elements = {73, 12, 36, 67, 67, -43, 73, -21};
        selectionSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'elements', 8 elements."
365,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[minIdx]) minIdx = j;
            }
            int temp = nums[i];
            nums[i] = nums[minIdx];
            nums[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] nums = {-33, 47, 6, 8, 30, 55, 40, 82};
        selectionSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'nums', 8 elements."
366,Java,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (input_arr[j] < input_arr[minIdx]) minIdx = j;
            }
            int temp = input_arr[i];
            input_arr[i] = input_arr[minIdx];
            input_arr[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {-48, 17, 13, 23, -27, 52, 37, -31};
        selectionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'input_arr', 8 elements."
367,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] input_arr) {
        int n = input_arr.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (input_arr[j] < input_arr[minIdx]) minIdx = j;
            }
            int temp = input_arr[i];
            input_arr[i] = input_arr[minIdx];
            input_arr[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {-5, 71, 30, 40, 5, 96, 18, -4, -2, 77};
        selectionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'input_arr', 10 elements."
368,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] seq) {
        int n = seq.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (seq[j] < seq[minIdx]) minIdx = j;
            }
            int temp = seq[i];
            seq[i] = seq[minIdx];
            seq[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] seq = {1, 10, 11, 17, 2, 8, 1, 13, 41, -11};
        selectionSort(seq);
        for (int v : seq) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'seq', 10 elements."
369,Java,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (vals[j] < vals[minIdx]) minIdx = j;
            }
            int temp = vals[i];
            vals[i] = vals[minIdx];
            vals[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] vals = {-23, -20, -30, 76, -49, 88, -40, 73, 45, 30};
        selectionSort(vals);
        for (int v : vals) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'vals', 10 elements."
370,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] dataset) {
        int n = dataset.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (dataset[j] < dataset[minIdx]) minIdx = j;
            }
            int temp = dataset[i];
            dataset[i] = dataset[minIdx];
            dataset[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] dataset = {97, 20, 75, -4, 80, 21, 51, 6, 97, -18, -37, 84};
        selectionSort(dataset);
        for (int v : dataset) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'dataset', 12 elements."
371,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (vals[j] < vals[minIdx]) minIdx = j;
            }
            int temp = vals[i];
            vals[i] = vals[minIdx];
            vals[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] vals = {58, 72, 88, -42, 78, 38, 50, -6, 67, -20, 82, 67};
        selectionSort(vals);
        for (int v : vals) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'vals', 12 elements."
372,Java,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] list1) {
        int n = list1.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (list1[j] < list1[minIdx]) minIdx = j;
            }
            int temp = list1[i];
            list1[i] = list1[minIdx];
            list1[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] list1 = {-48, -47, 3, 47, 98, -25, 33, 42, 16, -3, 90, 17};
        selectionSort(list1);
        for (int v : list1) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'list1', 12 elements."
373,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] items) {
        int n = items.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (items[j] < items[minIdx]) minIdx = j;
            }
            int temp = items[i];
            items[i] = items[minIdx];
            items[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] items = {18, 70, 37, 43, -3, 77, 58, 3, 57, 45, 43, 52, 21, 65, -4};
        selectionSort(items);
        for (int v : items) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'items', 15 elements."
374,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] elements) {
        int n = elements.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (elements[j] < elements[minIdx]) minIdx = j;
            }
            int temp = elements[i];
            elements[i] = elements[minIdx];
            elements[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] elements = {-17, 97, 8, -25, 19, 10, 92, 60, 47, 0, -13, -12, 71, -48, -5};
        selectionSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'elements', 15 elements."
375,Java,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] collection) {
        int n = collection.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (collection[j] < collection[minIdx]) minIdx = j;
            }
            int temp = collection[i];
            collection[i] = collection[minIdx];
            collection[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] collection = {77, -16, 82, 86, 30, 74, 26, 14, 93, 95, -38, 51, -25, -9, -35};
        selectionSort(collection);
        for (int v : collection) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'collection', 15 elements."
376,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] items) {
        int n = items.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (items[j] < items[minIdx]) minIdx = j;
            }
            int temp = items[i];
            items[i] = items[minIdx];
            items[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] items = {15, 71, -26, 65, 35, 16, 42, 42, 93, 92, 15, 38, -45, 55, -19, 39, 0, 97, 97, 87};
        selectionSort(items);
        for (int v : items) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'items', 20 elements."
377,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] values) {
        int n = values.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (values[j] < values[minIdx]) minIdx = j;
            }
            int temp = values[i];
            values[i] = values[minIdx];
            values[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] values = {22, 40, 33, 80, 74, 64, -30, 47, 23, 68, -13, -8, 36, 57, 96, 53, -32, -30, -9, 37};
        selectionSort(values);
        for (int v : values) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'values', 20 elements."
378,Java,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"public class Main {
    static void selectionSort(int[] items) {
        int n = items.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (items[j] < items[minIdx]) minIdx = j;
            }
            int temp = items[i];
            items[i] = items[minIdx];
            items[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] items = {30, 31, 24, 18, 51, 19, 63, 42, 83, 65, 55, -8, -3, -45, -18, 10, 14, -30, 3, -8};
        selectionSort(items);
        for (int v : items) System.out.print(v + "" "");
    }
}","Selection sort on int data, variable named 'items', 20 elements."
379,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] collection) {
        int n = collection.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (collection[j] < collection[minIdx]) minIdx = j;
            }
            double temp = collection[i];
            collection[i] = collection[minIdx];
            collection[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] collection = {-7.74, -12.41, 84.56, 45.26, -16.86};
        selectionSort(collection);
        for (double v : collection) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'collection', 5 elements."
380,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] collection) {
        int n = collection.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (collection[j] < collection[minIdx]) minIdx = j;
            }
            double temp = collection[i];
            collection[i] = collection[minIdx];
            collection[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] collection = {42.35, 98.53, -7.63, 53.55, -9.97};
        selectionSort(collection);
        for (double v : collection) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'collection', 5 elements."
381,Java,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (entries[j] < entries[minIdx]) minIdx = j;
            }
            double temp = entries[i];
            entries[i] = entries[minIdx];
            entries[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] entries = {85.37, 16.82, 9.44, 13.82, 54.55};
        selectionSort(entries);
        for (double v : entries) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'entries', 5 elements."
382,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] values) {
        int n = values.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (values[j] < values[minIdx]) minIdx = j;
            }
            double temp = values[i];
            values[i] = values[minIdx];
            values[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] values = {42.68, 0.3, -15.82, 22.46, 88.92, 82.84, 35.6, 83.64};
        selectionSort(values);
        for (double v : values) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'values', 8 elements."
383,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] entries) {
        int n = entries.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (entries[j] < entries[minIdx]) minIdx = j;
            }
            double temp = entries[i];
            entries[i] = entries[minIdx];
            entries[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] entries = {12.42, 32.94, 95.38, 63.02, 1.07, 51.11, 55.09, 55.67};
        selectionSort(entries);
        for (double v : entries) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'entries', 8 elements."
384,Java,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] elements) {
        int n = elements.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (elements[j] < elements[minIdx]) minIdx = j;
            }
            double temp = elements[i];
            elements[i] = elements[minIdx];
            elements[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] elements = {31.76, 56.13, 43.52, 88.16, 37.32, 7.03, -9.34, 16.64};
        selectionSort(elements);
        for (double v : elements) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'elements', 8 elements."
385,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] collection) {
        int n = collection.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (collection[j] < collection[minIdx]) minIdx = j;
            }
            double temp = collection[i];
            collection[i] = collection[minIdx];
            collection[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] collection = {10.92, 16.13, -19.99, 77.03, 80.91, 20.92, 35.83, -19.01, 89.73, 92.69};
        selectionSort(collection);
        for (double v : collection) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'collection', 10 elements."
386,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] dataset) {
        int n = dataset.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (dataset[j] < dataset[minIdx]) minIdx = j;
            }
            double temp = dataset[i];
            dataset[i] = dataset[minIdx];
            dataset[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] dataset = {15.65, 71.14, 74.96, 51.04, 74.82, 45.24, 2.44, 84.98, 32.02, 9.74};
        selectionSort(dataset);
        for (double v : dataset) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'dataset', 10 elements."
387,Java,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] seq) {
        int n = seq.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (seq[j] < seq[minIdx]) minIdx = j;
            }
            double temp = seq[i];
            seq[i] = seq[minIdx];
            seq[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] seq = {67.72, 26.38, 25.02, 11.29, 30.25, 8.51, 70.98, 88.28, 76.1, 61.47};
        selectionSort(seq);
        for (double v : seq) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'seq', 10 elements."
388,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[minIdx]) minIdx = j;
            }
            double temp = nums[i];
            nums[i] = nums[minIdx];
            nums[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] nums = {57.17, 43.3, 11.99, 2.37, -11.85, -3.74, -6.87, 34.19, 33.88, 63.36, 38.55, 18.16};
        selectionSort(nums);
        for (double v : nums) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'nums', 12 elements."
389,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] values) {
        int n = values.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (values[j] < values[minIdx]) minIdx = j;
            }
            double temp = values[i];
            values[i] = values[minIdx];
            values[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] values = {-14.09, 43.66, 2.13, -7.83, 12.03, 65.11, 66.53, 7.7, -2.07, 38.74, 20.69, 17.08};
        selectionSort(values);
        for (double v : values) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'values', 12 elements."
390,Java,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (vals[j] < vals[minIdx]) minIdx = j;
            }
            double temp = vals[i];
            vals[i] = vals[minIdx];
            vals[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] vals = {39.31, 24.2, 62.94, -16.22, -10.45, 69.32, -2.62, 11.71, 26.7, 44.64, 1.61, 86.59};
        selectionSort(vals);
        for (double v : vals) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'vals', 12 elements."
391,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[minIdx]) minIdx = j;
            }
            double temp = nums[i];
            nums[i] = nums[minIdx];
            nums[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] nums = {77.25, 78.56, -5.49, 71.41, 9.63, 71.78, 32.71, 67.78, -16.01, 34.84, 71.75, 42.02, 96.87, 36.27, 61.09};
        selectionSort(nums);
        for (double v : nums) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'nums', 15 elements."
392,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] < nums[minIdx]) minIdx = j;
            }
            double temp = nums[i];
            nums[i] = nums[minIdx];
            nums[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] nums = {91.41, -1.13, 66.66, 68.62, 45.4, -5.47, 37.27, 15.56, 22.89, -13.8, 59.34, 95.82, 8.08, 31.67, -18.21};
        selectionSort(nums);
        for (double v : nums) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'nums', 15 elements."
393,Java,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] vals) {
        int n = vals.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (vals[j] < vals[minIdx]) minIdx = j;
            }
            double temp = vals[i];
            vals[i] = vals[minIdx];
            vals[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] vals = {12.86, -5.76, 73.91, -18.94, -15.0, 73.23, 36.56, 50.95, 24.2, -9.35, -1.23, -9.12, 53.62, 90.77, 98.64};
        selectionSort(vals);
        for (double v : vals) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'vals', 15 elements."
394,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] buffer) {
        int n = buffer.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (buffer[j] < buffer[minIdx]) minIdx = j;
            }
            double temp = buffer[i];
            buffer[i] = buffer[minIdx];
            buffer[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] buffer = {-12.85, 22.31, -1.68, 43.83, -7.22, 38.05, 17.69, 46.44, 56.71, 21.33, 86.12, 67.25, -17.46, 24.95, 66.2, 9.83, -15.3, 64.09, 46.52, 44.59};
        selectionSort(buffer);
        for (double v : buffer) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'buffer', 20 elements."
395,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] dataset) {
        int n = dataset.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (dataset[j] < dataset[minIdx]) minIdx = j;
            }
            double temp = dataset[i];
            dataset[i] = dataset[minIdx];
            dataset[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] dataset = {2.58, 2.21, 21.37, 67.16, 12.76, 78.93, 88.82, 45.99, -11.8, -1.55, 15.19, 11.34, 23.69, -19.91, 55.93, 25.11, 2.08, -17.77, 81.96, 72.35};
        selectionSort(dataset);
        for (double v : dataset) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'dataset', 20 elements."
396,Java,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"public class Main {
    static void selectionSort(double[] items) {
        int n = items.length;
        for (int i = 0; i < n; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (items[j] < items[minIdx]) minIdx = j;
            }
            double temp = items[i];
            items[i] = items[minIdx];
            items[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        double[] items = {18.16, -12.46, 95.09, 77.47, 2.59, 61.3, 71.12, -1.66, 13.69, 28.77, 18.32, -8.55, 58.41, -14.79, 91.6, 1.26, -16.28, -7.26, 2.8, -16.21};
        selectionSort(items);
        for (double v : items) System.out.print(v + "" "");
    }
}","Selection sort on float data, variable named 'items', 20 elements."
397,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int buffer[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (buffer[j] < buffer[min_idx]) min_idx = j;
        }
        int temp = buffer[i];
        buffer[i] = buffer[min_idx];
        buffer[min_idx] = temp;
    }
}

int main(void) {
    int buffer[] = {49, 75, 84, 15, -38};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    selection_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","Selection sort on int data, variable named 'buffer', 5 elements."
398,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[min_idx]) min_idx = j;
        }
        int temp = list1[i];
        list1[i] = list1[min_idx];
        list1[min_idx] = temp;
    }
}

int main(void) {
    int list1[] = {6, -32, -47, 3, 75};
    int n = sizeof(list1) / sizeof(list1[0]);
    selection_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Selection sort on int data, variable named 'list1', 5 elements."
399,C,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int entries[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[min_idx]) min_idx = j;
        }
        int temp = entries[i];
        entries[i] = entries[min_idx];
        entries[min_idx] = temp;
    }
}

int main(void) {
    int entries[] = {-30, 69, -35, 42, 92};
    int n = sizeof(entries) / sizeof(entries[0]);
    selection_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","Selection sort on int data, variable named 'entries', 5 elements."
400,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int seq[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (seq[j] < seq[min_idx]) min_idx = j;
        }
        int temp = seq[i];
        seq[i] = seq[min_idx];
        seq[min_idx] = temp;
    }
}

int main(void) {
    int seq[] = {56, 44, -36, 18, 85, -40, -32, 27};
    int n = sizeof(seq) / sizeof(seq[0]);
    selection_sort(seq, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)seq[i]);
    return 0;
}","Selection sort on int data, variable named 'seq', 8 elements."
401,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int data[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[min_idx]) min_idx = j;
        }
        int temp = data[i];
        data[i] = data[min_idx];
        data[min_idx] = temp;
    }
}

int main(void) {
    int data[] = {5, 82, -26, -25, 9, 86, 48, -2};
    int n = sizeof(data) / sizeof(data[0]);
    selection_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","Selection sort on int data, variable named 'data', 8 elements."
402,C,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int items[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (items[j] < items[min_idx]) min_idx = j;
        }
        int temp = items[i];
        items[i] = items[min_idx];
        items[min_idx] = temp;
    }
}

int main(void) {
    int items[] = {84, 13, 95, -5, 92, 92, 56, -23};
    int n = sizeof(items) / sizeof(items[0]);
    selection_sort(items, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)items[i]);
    return 0;
}","Selection sort on int data, variable named 'items', 8 elements."
403,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int vals[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (vals[j] < vals[min_idx]) min_idx = j;
        }
        int temp = vals[i];
        vals[i] = vals[min_idx];
        vals[min_idx] = temp;
    }
}

int main(void) {
    int vals[] = {97, 41, 67, 59, -24, -8, -4, 90, 52, 79};
    int n = sizeof(vals) / sizeof(vals[0]);
    selection_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","Selection sort on int data, variable named 'vals', 10 elements."
404,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[min_idx]) min_idx = j;
        }
        int temp = list1[i];
        list1[i] = list1[min_idx];
        list1[min_idx] = temp;
    }
}

int main(void) {
    int list1[] = {-10, 86, 63, 40, 30, 90, 33, 45, 55, 60};
    int n = sizeof(list1) / sizeof(list1[0]);
    selection_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Selection sort on int data, variable named 'list1', 10 elements."
405,C,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int records[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (records[j] < records[min_idx]) min_idx = j;
        }
        int temp = records[i];
        records[i] = records[min_idx];
        records[min_idx] = temp;
    }
}

int main(void) {
    int records[] = {32, 11, 94, 89, 4, 46, 90, 15, 42, 65};
    int n = sizeof(records) / sizeof(records[0]);
    selection_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","Selection sort on int data, variable named 'records', 10 elements."
406,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int dataset[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[min_idx]) min_idx = j;
        }
        int temp = dataset[i];
        dataset[i] = dataset[min_idx];
        dataset[min_idx] = temp;
    }
}

int main(void) {
    int dataset[] = {51, -50, -42, 22, -46, 82, -16, 27, -49, 26, 6, 4};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    selection_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","Selection sort on int data, variable named 'dataset', 12 elements."
407,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int records[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (records[j] < records[min_idx]) min_idx = j;
        }
        int temp = records[i];
        records[i] = records[min_idx];
        records[min_idx] = temp;
    }
}

int main(void) {
    int records[] = {30, -45, 20, 91, 80, 92, 96, 96, -11, -26, -41, 67};
    int n = sizeof(records) / sizeof(records[0]);
    selection_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","Selection sort on int data, variable named 'records', 12 elements."
408,C,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[min_idx]) min_idx = j;
        }
        int temp = list1[i];
        list1[i] = list1[min_idx];
        list1[min_idx] = temp;
    }
}

int main(void) {
    int list1[] = {-11, -15, 17, 43, 99, 13, 9, 15, 26, -27, 96, 52};
    int n = sizeof(list1) / sizeof(list1[0]);
    selection_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Selection sort on int data, variable named 'list1', 12 elements."
409,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[min_idx]) min_idx = j;
        }
        int temp = elements[i];
        elements[i] = elements[min_idx];
        elements[min_idx] = temp;
    }
}

int main(void) {
    int elements[] = {5, -31, 33, 73, -6, 74, 97, -26, 26, -41, 97, 47, -30, -36, 35};
    int n = sizeof(elements) / sizeof(elements[0]);
    selection_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Selection sort on int data, variable named 'elements', 15 elements."
410,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[min_idx]) min_idx = j;
        }
        int temp = list1[i];
        list1[i] = list1[min_idx];
        list1[min_idx] = temp;
    }
}

int main(void) {
    int list1[] = {61, 56, -20, 8, -48, 47, -37, 28, 84, -40, 31, 88, 94, -12, 33};
    int n = sizeof(list1) / sizeof(list1[0]);
    selection_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Selection sort on int data, variable named 'list1', 15 elements."
411,C,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[min_idx]) min_idx = j;
        }
        int temp = input_arr[i];
        input_arr[i] = input_arr[min_idx];
        input_arr[min_idx] = temp;
    }
}

int main(void) {
    int input_arr[] = {6, -11, -38, 50, 64, 97, 79, -27, 6, 60, 24, 50, -13, -17, 36};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    selection_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Selection sort on int data, variable named 'input_arr', 15 elements."
412,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int data[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[min_idx]) min_idx = j;
        }
        int temp = data[i];
        data[i] = data[min_idx];
        data[min_idx] = temp;
    }
}

int main(void) {
    int data[] = {71, 96, -38, 90, 52, 17, -29, 52, 78, 61, -17, -16, 73, 93, 0, 74, 51, 96, 0, 93};
    int n = sizeof(data) / sizeof(data[0]);
    selection_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","Selection sort on int data, variable named 'data', 20 elements."
413,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int elements[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[min_idx]) min_idx = j;
        }
        int temp = elements[i];
        elements[i] = elements[min_idx];
        elements[min_idx] = temp;
    }
}

int main(void) {
    int elements[] = {84, 13, 12, -32, 18, 60, 32, 97, -28, -22, 55, 58, 43, 39, -2, 32, 38, -44, 28, -7};
    int n = sizeof(elements) / sizeof(elements[0]);
    selection_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Selection sort on int data, variable named 'elements', 20 elements."
414,C,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(int list1[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[min_idx]) min_idx = j;
        }
        int temp = list1[i];
        list1[i] = list1[min_idx];
        list1[min_idx] = temp;
    }
}

int main(void) {
    int list1[] = {63, -13, 62, -39, 9, 1, 45, -11, -29, -22, -37, 12, -13, 23, -47, 37, -22, 28, 65, 70};
    int n = sizeof(list1) / sizeof(list1[0]);
    selection_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","Selection sort on int data, variable named 'list1', 20 elements."
415,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) min_idx = j;
        }
        double temp = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = temp;
    }
}

int main(void) {
    double arr[] = {19.49, 68.06, 5.21, 45.02, 69.29};
    int n = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)arr[i]);
    return 0;
}","Selection sort on float data, variable named 'arr', 5 elements."
416,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[min_idx]) min_idx = j;
        }
        double temp = input_arr[i];
        input_arr[i] = input_arr[min_idx];
        input_arr[min_idx] = temp;
    }
}

int main(void) {
    double input_arr[] = {37.48, 66.86, -3.18, 63.15, -17.81};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    selection_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Selection sort on float data, variable named 'input_arr', 5 elements."
417,C,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double elements[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[min_idx]) min_idx = j;
        }
        double temp = elements[i];
        elements[i] = elements[min_idx];
        elements[min_idx] = temp;
    }
}

int main(void) {
    double elements[] = {87.82, 42.69, 10.4, -12.85, 3.88};
    int n = sizeof(elements) / sizeof(elements[0]);
    selection_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Selection sort on float data, variable named 'elements', 5 elements."
418,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double seq[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (seq[j] < seq[min_idx]) min_idx = j;
        }
        double temp = seq[i];
        seq[i] = seq[min_idx];
        seq[min_idx] = temp;
    }
}

int main(void) {
    double seq[] = {53.54, -13.68, 57.92, -19.01, 26.25, 12.29, 81.4, 58.55};
    int n = sizeof(seq) / sizeof(seq[0]);
    selection_sort(seq, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)seq[i]);
    return 0;
}","Selection sort on float data, variable named 'seq', 8 elements."
419,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double records[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (records[j] < records[min_idx]) min_idx = j;
        }
        double temp = records[i];
        records[i] = records[min_idx];
        records[min_idx] = temp;
    }
}

int main(void) {
    double records[] = {-7.16, 14.81, 85.12, 26.0, 96.6, 40.52, 64.45, 87.56};
    int n = sizeof(records) / sizeof(records[0]);
    selection_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","Selection sort on float data, variable named 'records', 8 elements."
420,C,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double dataset[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[min_idx]) min_idx = j;
        }
        double temp = dataset[i];
        dataset[i] = dataset[min_idx];
        dataset[min_idx] = temp;
    }
}

int main(void) {
    double dataset[] = {83.15, 43.26, 2.18, 39.58, 34.5, 90.24, -17.44, 9.44};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    selection_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","Selection sort on float data, variable named 'dataset', 8 elements."
421,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[min_idx]) min_idx = j;
        }
        double temp = input_arr[i];
        input_arr[i] = input_arr[min_idx];
        input_arr[min_idx] = temp;
    }
}

int main(void) {
    double input_arr[] = {16.29, 38.3, 68.58, -17.81, 61.43, 22.29, 15.98, 98.52, 96.45, 12.83};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    selection_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Selection sort on float data, variable named 'input_arr', 10 elements."
422,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) min_idx = j;
        }
        double temp = arr[i];
        arr[i] = arr[min_idx];
        arr[min_idx] = temp;
    }
}

int main(void) {
    double arr[] = {54.47, 84.56, 85.96, 76.97, -16.49, 46.04, 13.34, -1.95, 86.76, 58.17};
    int n = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)arr[i]);
    return 0;
}","Selection sort on float data, variable named 'arr', 10 elements."
423,C,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double data[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[min_idx]) min_idx = j;
        }
        double temp = data[i];
        data[i] = data[min_idx];
        data[min_idx] = temp;
    }
}

int main(void) {
    double data[] = {66.86, 41.97, 60.68, 83.85, 61.7, 29.66, 48.17, 30.75, 17.17, 52.04};
    int n = sizeof(data) / sizeof(data[0]);
    selection_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","Selection sort on float data, variable named 'data', 10 elements."
424,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double dataset[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[min_idx]) min_idx = j;
        }
        double temp = dataset[i];
        dataset[i] = dataset[min_idx];
        dataset[min_idx] = temp;
    }
}

int main(void) {
    double dataset[] = {44.53, 4.6, -3.51, 44.42, 75.21, 82.65, 16.77, 63.91, 42.33, -3.9, 98.49, 96.12};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    selection_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","Selection sort on float data, variable named 'dataset', 12 elements."
425,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double values[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (values[j] < values[min_idx]) min_idx = j;
        }
        double temp = values[i];
        values[i] = values[min_idx];
        values[min_idx] = temp;
    }
}

int main(void) {
    double values[] = {58.09, 47.22, -1.19, -11.93, 43.42, 65.61, 1.91, 79.9, -2.68, -16.49, 17.92, 95.77};
    int n = sizeof(values) / sizeof(values[0]);
    selection_sort(values, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)values[i]);
    return 0;
}","Selection sort on float data, variable named 'values', 12 elements."
426,C,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double collection[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (collection[j] < collection[min_idx]) min_idx = j;
        }
        double temp = collection[i];
        collection[i] = collection[min_idx];
        collection[min_idx] = temp;
    }
}

int main(void) {
    double collection[] = {16.1, 68.73, 77.78, 55.78, 67.86, -1.92, 2.36, -4.35, -16.88, 97.33, 53.42, 52.07};
    int n = sizeof(collection) / sizeof(collection[0]);
    selection_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","Selection sort on float data, variable named 'collection', 12 elements."
427,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double elements[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[min_idx]) min_idx = j;
        }
        double temp = elements[i];
        elements[i] = elements[min_idx];
        elements[min_idx] = temp;
    }
}

int main(void) {
    double elements[] = {7.48, 7.63, 61.8, 22.75, 61.89, 36.72, 39.78, 51.96, 64.73, 24.5, 81.4, 38.48, -3.64, 3.0, -16.16};
    int n = sizeof(elements) / sizeof(elements[0]);
    selection_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","Selection sort on float data, variable named 'elements', 15 elements."
428,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double vals[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (vals[j] < vals[min_idx]) min_idx = j;
        }
        double temp = vals[i];
        vals[i] = vals[min_idx];
        vals[min_idx] = temp;
    }
}

int main(void) {
    double vals[] = {95.29, 90.13, 93.07, 6.48, 59.89, 4.14, 4.34, 1.07, 93.61, 32.27, 53.43, 61.86, 83.15, 85.62, 30.88};
    int n = sizeof(vals) / sizeof(vals[0]);
    selection_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","Selection sort on float data, variable named 'vals', 15 elements."
429,C,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double vals[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (vals[j] < vals[min_idx]) min_idx = j;
        }
        double temp = vals[i];
        vals[i] = vals[min_idx];
        vals[min_idx] = temp;
    }
}

int main(void) {
    double vals[] = {-15.02, 67.5, 25.26, 17.23, 52.77, 68.35, 50.66, 42.5, 84.22, 73.64, 41.96, 33.74, 78.41, -14.95, 98.5};
    int n = sizeof(vals) / sizeof(vals[0]);
    selection_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","Selection sort on float data, variable named 'vals', 15 elements."
430,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[min_idx]) min_idx = j;
        }
        double temp = input_arr[i];
        input_arr[i] = input_arr[min_idx];
        input_arr[min_idx] = temp;
    }
}

int main(void) {
    double input_arr[] = {44.01, 97.08, -15.33, 26.1, 71.05, 94.55, 2.59, 32.31, 85.24, 72.07, 14.02, -0.19, 15.04, 89.36, 62.1, 87.54, 35.17, 56.89, -9.24, 39.58};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    selection_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Selection sort on float data, variable named 'input_arr', 20 elements."
431,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double values[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (values[j] < values[min_idx]) min_idx = j;
        }
        double temp = values[i];
        values[i] = values[min_idx];
        values[min_idx] = temp;
    }
}

int main(void) {
    double values[] = {72.67, 91.6, 62.84, -3.9, 29.21, 33.66, 1.29, 50.25, 64.8, 4.03, 34.11, 9.76, 62.31, 87.95, 74.78, 65.49, -5.3, -6.41, 33.48, 23.19};
    int n = sizeof(values) / sizeof(values[0]);
    selection_sort(values, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)values[i]);
    return 0;
}","Selection sort on float data, variable named 'values', 20 elements."
432,C,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <stdio.h>

void selection_sort(double input_arr[], int n) {
    for (int i = 0; i < n; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[min_idx]) min_idx = j;
        }
        double temp = input_arr[i];
        input_arr[i] = input_arr[min_idx];
        input_arr[min_idx] = temp;
    }
}

int main(void) {
    double input_arr[] = {64.17, 66.5, 96.05, 52.84, -0.97, 45.49, -14.78, 0.34, 19.89, 83.69, 82.66, -0.71, -2.79, 71.53, -13.89, 16.66, 66.89, 94.35, 14.36, 1.5};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    selection_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","Selection sort on float data, variable named 'input_arr', 20 elements."
433,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[minIdx]) minIdx = j;
        }
        std::swap(entries[i], entries[minIdx]);
    }
}

int main() {
    std::vector<int> entries = {-17, 1, -50, 14, -47};
    selectionSort(entries);
    for (int v : entries) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'entries', 5 elements."
434,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[minIdx]) minIdx = j;
        }
        std::swap(dataset[i], dataset[minIdx]);
    }
}

int main() {
    std::vector<int> dataset = {77, 77, 89, -49, 76};
    selectionSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'dataset', 5 elements."
435,C++,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& items) {
    int n = (int) items.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (items[j] < items[minIdx]) minIdx = j;
        }
        std::swap(items[i], items[minIdx]);
    }
}

int main() {
    std::vector<int> items = {5, 71, 66, 54, 63};
    selectionSort(items);
    for (int v : items) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'items', 5 elements."
436,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[minIdx]) minIdx = j;
        }
        std::swap(data[i], data[minIdx]);
    }
}

int main() {
    std::vector<int> data = {-49, 12, 90, 21, 92, 3, -38, -3};
    selectionSort(data);
    for (int v : data) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'data', 8 elements."
437,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& values) {
    int n = (int) values.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (values[j] < values[minIdx]) minIdx = j;
        }
        std::swap(values[i], values[minIdx]);
    }
}

int main() {
    std::vector<int> values = {-36, 39, -41, -13, -42, 97, 26, 34};
    selectionSort(values);
    for (int v : values) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'values', 8 elements."
438,C++,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[minIdx]) minIdx = j;
        }
        std::swap(entries[i], entries[minIdx]);
    }
}

int main() {
    std::vector<int> entries = {-28, -38, -23, 56, -5, -9, 22, 96};
    selectionSort(entries);
    for (int v : entries) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'entries', 8 elements."
439,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& vals) {
    int n = (int) vals.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (vals[j] < vals[minIdx]) minIdx = j;
        }
        std::swap(vals[i], vals[minIdx]);
    }
}

int main() {
    std::vector<int> vals = {93, -5, 66, 98, 42, -41, -27, 26, 32, 44};
    selectionSort(vals);
    for (int v : vals) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'vals', 10 elements."
440,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[minIdx]) minIdx = j;
        }
        std::swap(entries[i], entries[minIdx]);
    }
}

int main() {
    std::vector<int> entries = {47, -33, 59, 90, -34, 24, 70, -16, -19, 20};
    selectionSort(entries);
    for (int v : entries) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'entries', 10 elements."
441,C++,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[minIdx]) minIdx = j;
        }
        std::swap(list1[i], list1[minIdx]);
    }
}

int main() {
    std::vector<int> list1 = {84, 55, 84, 3, 3, -36, -23, 96, 85, -28};
    selectionSort(list1);
    for (int v : list1) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'list1', 10 elements."
442,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[minIdx]) minIdx = j;
        }
        std::swap(dataset[i], dataset[minIdx]);
    }
}

int main() {
    std::vector<int> dataset = {23, 59, 31, 16, 84, 97, 40, -17, 94, 77, 83, 77};
    selectionSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'dataset', 12 elements."
443,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[minIdx]) minIdx = j;
        }
        std::swap(dataset[i], dataset[minIdx]);
    }
}

int main() {
    std::vector<int> dataset = {-4, 9, 24, -1, -50, -20, -44, 69, -20, 3, 56, 55};
    selectionSort(dataset);
    for (int v : dataset) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'dataset', 12 elements."
444,C++,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& arr) {
    int n = (int) arr.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        std::swap(arr[i], arr[minIdx]);
    }
}

int main() {
    std::vector<int> arr = {35, 39, 93, 4, -48, 1, 22, 15, -33, 28, 26, 79};
    selectionSort(arr);
    for (int v : arr) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'arr', 12 elements."
445,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& input_arr) {
    int n = (int) input_arr.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[minIdx]) minIdx = j;
        }
        std::swap(input_arr[i], input_arr[minIdx]);
    }
}

int main() {
    std::vector<int> input_arr = {32, -49, -21, 35, 37, 51, 95, -43, -6, -1, 34, 36, 72, 71, -41};
    selectionSort(input_arr);
    for (int v : input_arr) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'input_arr', 15 elements."
446,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& buffer) {
    int n = (int) buffer.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (buffer[j] < buffer[minIdx]) minIdx = j;
        }
        std::swap(buffer[i], buffer[minIdx]);
    }
}

int main() {
    std::vector<int> buffer = {-16, 73, -11, 67, 87, 35, 68, 55, -36, 83, 26, 94, 30, 92, 87};
    selectionSort(buffer);
    for (int v : buffer) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'buffer', 15 elements."
447,C++,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& arr) {
    int n = (int) arr.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        std::swap(arr[i], arr[minIdx]);
    }
}

int main() {
    std::vector<int> arr = {3, 97, 34, 40, -34, -12, 21, -43, 36, 46, 86, -8, 96, 49, -3};
    selectionSort(arr);
    for (int v : arr) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'arr', 15 elements."
448,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& elements) {
    int n = (int) elements.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[minIdx]) minIdx = j;
        }
        std::swap(elements[i], elements[minIdx]);
    }
}

int main() {
    std::vector<int> elements = {-21, 28, 30, -42, 19, 55, -28, 77, 10, 45, 65, 27, 5, 84, 27, -6, -22, 45, -41, 1};
    selectionSort(elements);
    for (int v : elements) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'elements', 20 elements."
449,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[minIdx]) minIdx = j;
        }
        std::swap(entries[i], entries[minIdx]);
    }
}

int main() {
    std::vector<int> entries = {-27, 63, 79, -44, 73, 78, -11, -2, 37, 73, 84, 29, 33, -14, -25, 82, -17, 2, -41, 67};
    selectionSort(entries);
    for (int v : entries) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'entries', 20 elements."
450,C++,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<int>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (collection[j] < collection[minIdx]) minIdx = j;
        }
        std::swap(collection[i], collection[minIdx]);
    }
}

int main() {
    std::vector<int> collection = {83, -21, -49, 29, -39, -28, 35, 69, -39, -24, 83, 29, -45, 97, 29, 3, 32, 1, -1, 23};
    selectionSort(collection);
    for (int v : collection) std::cout << v << "" "";
    return 0;
}","Selection sort on int data, variable named 'collection', 20 elements."
451,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& nums) {
    int n = (int) nums.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] < nums[minIdx]) minIdx = j;
        }
        std::swap(nums[i], nums[minIdx]);
    }
}

int main() {
    std::vector<double> nums = {43.34, 71.96, 59.86, 12.45, -1.26};
    selectionSort(nums);
    for (double v : nums) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'nums', 5 elements."
452,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[minIdx]) minIdx = j;
        }
        std::swap(data[i], data[minIdx]);
    }
}

int main() {
    std::vector<double> data = {-18.18, 54.13, 41.17, 4.58, 21.69};
    selectionSort(data);
    for (double v : data) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'data', 5 elements."
453,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[minIdx]) minIdx = j;
        }
        std::swap(list1[i], list1[minIdx]);
    }
}

int main() {
    std::vector<double> list1 = {12.26, 92.25, 75.68, 48.32, 0.38};
    selectionSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'list1', 5 elements."
454,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& nums) {
    int n = (int) nums.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] < nums[minIdx]) minIdx = j;
        }
        std::swap(nums[i], nums[minIdx]);
    }
}

int main() {
    std::vector<double> nums = {52.98, 20.31, 32.79, -4.52, 36.02, 60.38, -7.39, -13.6};
    selectionSort(nums);
    for (double v : nums) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'nums', 8 elements."
455,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (collection[j] < collection[minIdx]) minIdx = j;
        }
        std::swap(collection[i], collection[minIdx]);
    }
}

int main() {
    std::vector<double> collection = {26.64, 63.86, 86.06, 54.91, 62.12, 33.05, 22.32, 19.55};
    selectionSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'collection', 8 elements."
456,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& items) {
    int n = (int) items.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (items[j] < items[minIdx]) minIdx = j;
        }
        std::swap(items[i], items[minIdx]);
    }
}

int main() {
    std::vector<double> items = {64.83, 59.83, 43.48, 95.87, 69.93, 35.42, -4.32, 76.73};
    selectionSort(items);
    for (double v : items) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'items', 8 elements."
457,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& entries) {
    int n = (int) entries.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (entries[j] < entries[minIdx]) minIdx = j;
        }
        std::swap(entries[i], entries[minIdx]);
    }
}

int main() {
    std::vector<double> entries = {63.13, -8.43, 16.94, 56.69, 71.21, 35.99, 92.75, -2.9, 86.59, 10.71};
    selectionSort(entries);
    for (double v : entries) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'entries', 10 elements."
458,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& list1) {
    int n = (int) list1.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (list1[j] < list1[minIdx]) minIdx = j;
        }
        std::swap(list1[i], list1[minIdx]);
    }
}

int main() {
    std::vector<double> list1 = {26.66, 63.25, 59.16, 73.86, 85.01, 33.94, -16.4, 36.56, 21.82, 34.89};
    selectionSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'list1', 10 elements."
459,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& values) {
    int n = (int) values.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (values[j] < values[minIdx]) minIdx = j;
        }
        std::swap(values[i], values[minIdx]);
    }
}

int main() {
    std::vector<double> values = {13.59, 21.49, 48.39, 40.45, 28.28, 65.0, -7.27, 46.18, -11.56, 15.95};
    selectionSort(values);
    for (double v : values) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'values', 10 elements."
460,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[minIdx]) minIdx = j;
        }
        std::swap(dataset[i], dataset[minIdx]);
    }
}

int main() {
    std::vector<double> dataset = {27.7, 29.2, 53.88, 45.21, 95.89, 25.67, 20.54, 76.86, 50.33, 73.33, 31.81, 73.69};
    selectionSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'dataset', 12 elements."
461,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& input_arr) {
    int n = (int) input_arr.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (input_arr[j] < input_arr[minIdx]) minIdx = j;
        }
        std::swap(input_arr[i], input_arr[minIdx]);
    }
}

int main() {
    std::vector<double> input_arr = {62.6, 0.6, 59.68, 67.98, 64.72, 79.57, -6.4, 50.93, 18.72, -8.38, 32.98, 16.66};
    selectionSort(input_arr);
    for (double v : input_arr) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'input_arr', 12 elements."
462,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& collection) {
    int n = (int) collection.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (collection[j] < collection[minIdx]) minIdx = j;
        }
        std::swap(collection[i], collection[minIdx]);
    }
}

int main() {
    std::vector<double> collection = {-11.72, -7.06, 76.87, 71.79, 25.09, 38.82, 58.56, -9.23, 77.23, 85.58, 87.49, 55.7};
    selectionSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'collection', 12 elements."
463,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& arr) {
    int n = (int) arr.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        std::swap(arr[i], arr[minIdx]);
    }
}

int main() {
    std::vector<double> arr = {70.09, 58.64, 33.9, 14.69, 53.25, 33.21, 4.47, 84.41, 15.67, 74.53, 60.87, 89.3, 91.46, 65.42, 88.9};
    selectionSort(arr);
    for (double v : arr) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'arr', 15 elements."
464,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[minIdx]) minIdx = j;
        }
        std::swap(data[i], data[minIdx]);
    }
}

int main() {
    std::vector<double> data = {49.34, 52.77, 40.74, 80.87, 81.45, -12.57, 87.23, 95.18, -19.9, 46.64, 96.46, -6.95, 13.58, -16.29, 31.37};
    selectionSort(data);
    for (double v : data) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'data', 15 elements."
465,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& elements) {
    int n = (int) elements.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (elements[j] < elements[minIdx]) minIdx = j;
        }
        std::swap(elements[i], elements[minIdx]);
    }
}

int main() {
    std::vector<double> elements = {26.92, 17.86, 25.55, 25.41, 44.87, 58.84, 36.51, 2.4, 25.77, 90.01, 79.96, -1.64, 98.7, 59.74, -4.02};
    selectionSort(elements);
    for (double v : elements) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'elements', 15 elements."
466,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[minIdx]) minIdx = j;
        }
        std::swap(data[i], data[minIdx]);
    }
}

int main() {
    std::vector<double> data = {57.16, -2.86, 85.3, 58.29, 96.02, -3.84, -3.67, 75.91, 82.36, 86.34, 62.75, 90.71, 54.17, 34.07, 30.47, 77.59, 25.78, 6.86, 30.55, -19.12};
    selectionSort(data);
    for (double v : data) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'data', 20 elements."
467,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& dataset) {
    int n = (int) dataset.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (dataset[j] < dataset[minIdx]) minIdx = j;
        }
        std::swap(dataset[i], dataset[minIdx]);
    }
}

int main() {
    std::vector<double> dataset = {80.77, 8.17, 39.71, 28.89, 44.99, 23.67, 96.41, 47.61, 63.88, -6.53, 37.3, 62.17, -3.09, 67.02, 97.05, 97.06, 72.69, 35.33, -10.69, 85.9};
    selectionSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'dataset', 20 elements."
468,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"#include <iostream>
#include <vector>

void selectionSort(std::vector<double>& data) {
    int n = (int) data.size();
    for (int i = 0; i < n; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (data[j] < data[minIdx]) minIdx = j;
        }
        std::swap(data[i], data[minIdx]);
    }
}

int main() {
    std::vector<double> data = {9.18, 55.05, 58.98, 59.58, 61.4, 44.16, 48.98, 52.95, 87.53, 43.67, -18.72, 34.03, 87.82, 48.3, 19.45, 22.0, 96.35, 15.06, -0.07, 62.71};
    selectionSort(data);
    for (double v : data) std::cout << v << "" "";
    return 0;
}","Selection sort on float data, variable named 'data', 20 elements."
469,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"fn selection_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if elements[j] < elements[min_idx] {
                min_idx = j;
            }
        }
        elements.swap(i, min_idx);
    }
}

fn main() {
    let mut elements = vec![27, 94, 16, -35, 71];
    selection_sort(&mut elements);
    println!(""{:?}"", elements);
}","Selection sort on int data, variable named 'elements', 5 elements."
470,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"fn selection_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if elements[j] < elements[min_idx] {
                min_idx = j;
            }
        }
        elements.swap(i, min_idx);
    }
}

fn main() {
    let mut elements = vec![-7, 96, -37, 24, -44];
    selection_sort(&mut elements);
    println!(""{:?}"", elements);
}","Selection sort on int data, variable named 'elements', 5 elements."
471,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using selection sort.,"fn selection_sort(nums: &mut Vec<i32>) {
    let n = nums.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if nums[j] < nums[min_idx] {
                min_idx = j;
            }
        }
        nums.swap(i, min_idx);
    }
}

fn main() {
    let mut nums = vec![74, -29, -18, 79, -31];
    selection_sort(&mut nums);
    println!(""{:?}"", nums);
}","Selection sort on int data, variable named 'nums', 5 elements."
472,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"fn selection_sort(records: &mut Vec<i32>) {
    let n = records.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if records[j] < records[min_idx] {
                min_idx = j;
            }
        }
        records.swap(i, min_idx);
    }
}

fn main() {
    let mut records = vec![21, 14, -17, 21, 20, 15, -47, -22];
    selection_sort(&mut records);
    println!(""{:?}"", records);
}","Selection sort on int data, variable named 'records', 8 elements."
473,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"fn selection_sort(elements: &mut Vec<i32>) {
    let n = elements.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if elements[j] < elements[min_idx] {
                min_idx = j;
            }
        }
        elements.swap(i, min_idx);
    }
}

fn main() {
    let mut elements = vec![-6, -12, 64, 44, -6, 16, 10, 74];
    selection_sort(&mut elements);
    println!(""{:?}"", elements);
}","Selection sort on int data, variable named 'elements', 8 elements."
474,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using selection sort.,"fn selection_sort(values: &mut Vec<i32>) {
    let n = values.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if values[j] < values[min_idx] {
                min_idx = j;
            }
        }
        values.swap(i, min_idx);
    }
}

fn main() {
    let mut values = vec![85, -42, 37, -29, -13, -11, 76, 55];
    selection_sort(&mut values);
    println!(""{:?}"", values);
}","Selection sort on int data, variable named 'values', 8 elements."
475,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"fn selection_sort(vals: &mut Vec<i32>) {
    let n = vals.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if vals[j] < vals[min_idx] {
                min_idx = j;
            }
        }
        vals.swap(i, min_idx);
    }
}

fn main() {
    let mut vals = vec![48, 10, 62, -8, 3, 97, 38, -37, 17, -21];
    selection_sort(&mut vals);
    println!(""{:?}"", vals);
}","Selection sort on int data, variable named 'vals', 10 elements."
476,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"fn selection_sort(arr: &mut Vec<i32>) {
    let n = arr.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if arr[j] < arr[min_idx] {
                min_idx = j;
            }
        }
        arr.swap(i, min_idx);
    }
}

fn main() {
    let mut arr = vec![-8, 68, 52, 71, 27, 71, 86, 9, 47, 49];
    selection_sort(&mut arr);
    println!(""{:?}"", arr);
}","Selection sort on int data, variable named 'arr', 10 elements."
477,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using selection sort.,"fn selection_sort(dataset: &mut Vec<i32>) {
    let n = dataset.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if dataset[j] < dataset[min_idx] {
                min_idx = j;
            }
        }
        dataset.swap(i, min_idx);
    }
}

fn main() {
    let mut dataset = vec![17, -13, 85, 61, -47, 23, 64, 47, 30, 85];
    selection_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Selection sort on int data, variable named 'dataset', 10 elements."
478,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"fn selection_sort(buffer: &mut Vec<i32>) {
    let n = buffer.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if buffer[j] < buffer[min_idx] {
                min_idx = j;
            }
        }
        buffer.swap(i, min_idx);
    }
}

fn main() {
    let mut buffer = vec![-40, -26, 86, 40, 60, 19, 35, 19, 18, -25, 15, 99];
    selection_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Selection sort on int data, variable named 'buffer', 12 elements."
479,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"fn selection_sort(collection: &mut Vec<i32>) {
    let n = collection.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if collection[j] < collection[min_idx] {
                min_idx = j;
            }
        }
        collection.swap(i, min_idx);
    }
}

fn main() {
    let mut collection = vec![68, 11, -1, 83, 36, -4, 30, 90, -48, -48, -33, -47];
    selection_sort(&mut collection);
    println!(""{:?}"", collection);
}","Selection sort on int data, variable named 'collection', 12 elements."
480,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using selection sort.,"fn selection_sort(collection: &mut Vec<i32>) {
    let n = collection.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if collection[j] < collection[min_idx] {
                min_idx = j;
            }
        }
        collection.swap(i, min_idx);
    }
}

fn main() {
    let mut collection = vec![-25, 84, -24, 64, 39, 6, 22, 14, -1, -42, -44, -27];
    selection_sort(&mut collection);
    println!(""{:?}"", collection);
}","Selection sort on int data, variable named 'collection', 12 elements."
481,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"fn selection_sort(arr: &mut Vec<i32>) {
    let n = arr.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if arr[j] < arr[min_idx] {
                min_idx = j;
            }
        }
        arr.swap(i, min_idx);
    }
}

fn main() {
    let mut arr = vec![5, -19, -20, -28, -17, 46, 94, -3, -22, -3, 14, 25, 69, -31, 66];
    selection_sort(&mut arr);
    println!(""{:?}"", arr);
}","Selection sort on int data, variable named 'arr', 15 elements."
482,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"fn selection_sort(entries: &mut Vec<i32>) {
    let n = entries.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if entries[j] < entries[min_idx] {
                min_idx = j;
            }
        }
        entries.swap(i, min_idx);
    }
}

fn main() {
    let mut entries = vec![20, 59, 32, 15, -9, -32, 20, -35, 47, 49, 35, -35, 16, 17, -5];
    selection_sort(&mut entries);
    println!(""{:?}"", entries);
}","Selection sort on int data, variable named 'entries', 15 elements."
483,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using selection sort.,"fn selection_sort(dataset: &mut Vec<i32>) {
    let n = dataset.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if dataset[j] < dataset[min_idx] {
                min_idx = j;
            }
        }
        dataset.swap(i, min_idx);
    }
}

fn main() {
    let mut dataset = vec![-33, 75, 1, 50, -5, 75, -23, -14, 88, 60, 5, -23, 63, 16, -24];
    selection_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Selection sort on int data, variable named 'dataset', 15 elements."
484,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"fn selection_sort(arr: &mut Vec<i32>) {
    let n = arr.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if arr[j] < arr[min_idx] {
                min_idx = j;
            }
        }
        arr.swap(i, min_idx);
    }
}

fn main() {
    let mut arr = vec![-32, -32, 96, 14, 64, -46, 77, -12, -50, -41, 49, 18, -12, 34, 50, 97, -50, 81, 75, 72];
    selection_sort(&mut arr);
    println!(""{:?}"", arr);
}","Selection sort on int data, variable named 'arr', 20 elements."
485,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"fn selection_sort(collection: &mut Vec<i32>) {
    let n = collection.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if collection[j] < collection[min_idx] {
                min_idx = j;
            }
        }
        collection.swap(i, min_idx);
    }
}

fn main() {
    let mut collection = vec![53, -33, 88, 7, -50, 48, 73, -19, 95, 87, 41, 35, 27, 52, -36, -27, 43, 86, 37, -30];
    selection_sort(&mut collection);
    println!(""{:?}"", collection);
}","Selection sort on int data, variable named 'collection', 20 elements."
486,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using selection sort.,"fn selection_sort(records: &mut Vec<i32>) {
    let n = records.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if records[j] < records[min_idx] {
                min_idx = j;
            }
        }
        records.swap(i, min_idx);
    }
}

fn main() {
    let mut records = vec![67, 24, 1, -5, 91, -40, 48, -2, 26, 49, -23, 41, 74, -29, 62, -2, -15, -41, -1, -44];
    selection_sort(&mut records);
    println!(""{:?}"", records);
}","Selection sort on int data, variable named 'records', 20 elements."
487,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"fn selection_sort(seq: &mut Vec<f64>) {
    let n = seq.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if seq[j] < seq[min_idx] {
                min_idx = j;
            }
        }
        seq.swap(i, min_idx);
    }
}

fn main() {
    let mut seq = vec![98.57, 8.38, 26.26, 74.34, 56.57];
    selection_sort(&mut seq);
    println!(""{:?}"", seq);
}","Selection sort on float data, variable named 'seq', 5 elements."
488,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"fn selection_sort(dataset: &mut Vec<f64>) {
    let n = dataset.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if dataset[j] < dataset[min_idx] {
                min_idx = j;
            }
        }
        dataset.swap(i, min_idx);
    }
}

fn main() {
    let mut dataset = vec![43.54, 79.28, 33.47, 98.5, -15.59];
    selection_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Selection sort on float data, variable named 'dataset', 5 elements."
489,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using selection sort.,"fn selection_sort(arr: &mut Vec<f64>) {
    let n = arr.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if arr[j] < arr[min_idx] {
                min_idx = j;
            }
        }
        arr.swap(i, min_idx);
    }
}

fn main() {
    let mut arr = vec![20.19, 65.8, 28.26, 5.19, 57.81];
    selection_sort(&mut arr);
    println!(""{:?}"", arr);
}","Selection sort on float data, variable named 'arr', 5 elements."
490,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"fn selection_sort(input_arr: &mut Vec<f64>) {
    let n = input_arr.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if input_arr[j] < input_arr[min_idx] {
                min_idx = j;
            }
        }
        input_arr.swap(i, min_idx);
    }
}

fn main() {
    let mut input_arr = vec![34.55, 60.69, 84.04, -2.27, 48.94, 90.05, -15.61, -3.15];
    selection_sort(&mut input_arr);
    println!(""{:?}"", input_arr);
}","Selection sort on float data, variable named 'input_arr', 8 elements."
491,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"fn selection_sort(buffer: &mut Vec<f64>) {
    let n = buffer.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if buffer[j] < buffer[min_idx] {
                min_idx = j;
            }
        }
        buffer.swap(i, min_idx);
    }
}

fn main() {
    let mut buffer = vec![-17.73, 87.95, 53.59, 8.88, 57.21, -18.29, 55.29, 87.65];
    selection_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Selection sort on float data, variable named 'buffer', 8 elements."
492,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using selection sort.,"fn selection_sort(records: &mut Vec<f64>) {
    let n = records.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if records[j] < records[min_idx] {
                min_idx = j;
            }
        }
        records.swap(i, min_idx);
    }
}

fn main() {
    let mut records = vec![74.45, 34.29, 0.31, 50.33, 77.32, -7.35, 39.16, 75.1];
    selection_sort(&mut records);
    println!(""{:?}"", records);
}","Selection sort on float data, variable named 'records', 8 elements."
493,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"fn selection_sort(items: &mut Vec<f64>) {
    let n = items.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if items[j] < items[min_idx] {
                min_idx = j;
            }
        }
        items.swap(i, min_idx);
    }
}

fn main() {
    let mut items = vec![-12.49, 4.11, 20.14, 79.47, 67.81, 27.84, -5.62, 61.41, 44.96, 18.27];
    selection_sort(&mut items);
    println!(""{:?}"", items);
}","Selection sort on float data, variable named 'items', 10 elements."
494,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"fn selection_sort(vals: &mut Vec<f64>) {
    let n = vals.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if vals[j] < vals[min_idx] {
                min_idx = j;
            }
        }
        vals.swap(i, min_idx);
    }
}

fn main() {
    let mut vals = vec![5.37, -14.58, 0.64, -12.48, 12.59, 70.15, -0.0, 24.02, -0.36, 8.99];
    selection_sort(&mut vals);
    println!(""{:?}"", vals);
}","Selection sort on float data, variable named 'vals', 10 elements."
495,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using selection sort.,"fn selection_sort(elements: &mut Vec<f64>) {
    let n = elements.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if elements[j] < elements[min_idx] {
                min_idx = j;
            }
        }
        elements.swap(i, min_idx);
    }
}

fn main() {
    let mut elements = vec![-15.16, -8.1, 80.84, 52.88, 72.54, -18.14, 37.95, -19.24, 1.35, -9.39];
    selection_sort(&mut elements);
    println!(""{:?}"", elements);
}","Selection sort on float data, variable named 'elements', 10 elements."
496,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"fn selection_sort(buffer: &mut Vec<f64>) {
    let n = buffer.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if buffer[j] < buffer[min_idx] {
                min_idx = j;
            }
        }
        buffer.swap(i, min_idx);
    }
}

fn main() {
    let mut buffer = vec![50.65, 13.76, 62.53, 74.28, 36.65, -4.9, -2.97, 12.24, 33.6, 8.47, 0.77, 62.31];
    selection_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Selection sort on float data, variable named 'buffer', 12 elements."
497,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"fn selection_sort(elements: &mut Vec<f64>) {
    let n = elements.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if elements[j] < elements[min_idx] {
                min_idx = j;
            }
        }
        elements.swap(i, min_idx);
    }
}

fn main() {
    let mut elements = vec![1.42, 39.49, 93.09, 54.64, 73.13, 21.39, -19.46, 8.04, -6.02, 43.09, -8.61, 23.07];
    selection_sort(&mut elements);
    println!(""{:?}"", elements);
}","Selection sort on float data, variable named 'elements', 12 elements."
498,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using selection sort.,"fn selection_sort(vals: &mut Vec<f64>) {
    let n = vals.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if vals[j] < vals[min_idx] {
                min_idx = j;
            }
        }
        vals.swap(i, min_idx);
    }
}

fn main() {
    let mut vals = vec![97.43, 40.4, 35.24, 54.55, 4.76, -13.68, -6.59, -2.24, 80.41, 88.47, 39.2, -0.99];
    selection_sort(&mut vals);
    println!(""{:?}"", vals);
}","Selection sort on float data, variable named 'vals', 12 elements."
499,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"fn selection_sort(entries: &mut Vec<f64>) {
    let n = entries.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if entries[j] < entries[min_idx] {
                min_idx = j;
            }
        }
        entries.swap(i, min_idx);
    }
}

fn main() {
    let mut entries = vec![-14.87, 56.74, 13.92, 31.73, 19.78, 75.81, 70.25, -14.85, 68.11, 90.06, 0.93, 73.47, 37.72, -6.19, 86.51];
    selection_sort(&mut entries);
    println!(""{:?}"", entries);
}","Selection sort on float data, variable named 'entries', 15 elements."
500,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"fn selection_sort(seq: &mut Vec<f64>) {
    let n = seq.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if seq[j] < seq[min_idx] {
                min_idx = j;
            }
        }
        seq.swap(i, min_idx);
    }
}

fn main() {
    let mut seq = vec![32.93, 48.99, 29.87, 68.9, 86.91, 7.38, -6.89, 7.11, 8.22, 29.1, 3.79, 86.07, -11.25, 49.63, -13.53];
    selection_sort(&mut seq);
    println!(""{:?}"", seq);
}","Selection sort on float data, variable named 'seq', 15 elements."
501,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using selection sort.,"fn selection_sort(collection: &mut Vec<f64>) {
    let n = collection.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if collection[j] < collection[min_idx] {
                min_idx = j;
            }
        }
        collection.swap(i, min_idx);
    }
}

fn main() {
    let mut collection = vec![-2.75, 90.42, 34.14, 26.09, -3.77, 65.66, 55.21, 96.09, 4.06, -4.86, 62.37, -12.9, -3.76, 81.35, 34.57];
    selection_sort(&mut collection);
    println!(""{:?}"", collection);
}","Selection sort on float data, variable named 'collection', 15 elements."
502,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"fn selection_sort(values: &mut Vec<f64>) {
    let n = values.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if values[j] < values[min_idx] {
                min_idx = j;
            }
        }
        values.swap(i, min_idx);
    }
}

fn main() {
    let mut values = vec![70.48, 6.16, 15.12, -1.34, 74.55, 93.38, 87.76, 48.8, 45.78, 7.33, 28.99, 42.09, 82.6, 5.76, 36.35, 35.07, -18.27, 30.95, 83.84, 9.49];
    selection_sort(&mut values);
    println!(""{:?}"", values);
}","Selection sort on float data, variable named 'values', 20 elements."
503,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"fn selection_sort(collection: &mut Vec<f64>) {
    let n = collection.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if collection[j] < collection[min_idx] {
                min_idx = j;
            }
        }
        collection.swap(i, min_idx);
    }
}

fn main() {
    let mut collection = vec![48.96, 86.13, 50.42, -2.27, 48.27, -19.4, 96.64, -15.23, 36.01, 71.46, -16.0, 43.2, 37.03, 74.96, 77.73, 33.84, 8.62, 46.46, -18.52, 67.08];
    selection_sort(&mut collection);
    println!(""{:?}"", collection);
}","Selection sort on float data, variable named 'collection', 20 elements."
504,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using selection sort.,"fn selection_sort(items: &mut Vec<f64>) {
    let n = items.len();
    for i in 0..n {
        let mut min_idx = i;
        for j in (i + 1)..n {
            if items[j] < items[min_idx] {
                min_idx = j;
            }
        }
        items.swap(i, min_idx);
    }
}

fn main() {
    let mut items = vec![-4.21, 15.2, 57.07, -9.2, 37.09, 16.28, 63.69, 82.09, 68.93, -17.09, 34.13, 71.85, 84.03, 28.24, 73.99, 24.08, 35.25, 55.37, 82.39, -11.59];
    selection_sort(&mut items);
    println!(""{:?}"", items);
}","Selection sort on float data, variable named 'items', 20 elements."
505,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"def insertion_sort(entries):
    for i in range(1, len(entries)):
        key = entries[i]
        j = i - 1
        while j >= 0 and entries[j] > key:
            entries[j + 1] = entries[j]
            j -= 1
        entries[j + 1] = key
    return entries

print(insertion_sort([35, 85, -42, 25, 59]))","Insertion sort on int data, variable named 'entries', 5 elements."
506,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"def insertion_sort(vals):
    for i in range(1, len(vals)):
        key = vals[i]
        j = i - 1
        while j >= 0 and vals[j] > key:
            vals[j + 1] = vals[j]
            j -= 1
        vals[j + 1] = key
    return vals

print(insertion_sort([19, 88, 97, 3, -30]))","Insertion sort on int data, variable named 'vals', 5 elements."
507,Python,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"def insertion_sort(elements):
    for i in range(1, len(elements)):
        key = elements[i]
        j = i - 1
        while j >= 0 and elements[j] > key:
            elements[j + 1] = elements[j]
            j -= 1
        elements[j + 1] = key
    return elements

print(insertion_sort([35, -36, 81, 43, -37]))","Insertion sort on int data, variable named 'elements', 5 elements."
508,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([48, 43, 69, -40, 43, 43, -6, 93]))","Insertion sort on int data, variable named 'data', 8 elements."
509,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"def insertion_sort(seq):
    for i in range(1, len(seq)):
        key = seq[i]
        j = i - 1
        while j >= 0 and seq[j] > key:
            seq[j + 1] = seq[j]
            j -= 1
        seq[j + 1] = key
    return seq

print(insertion_sort([-33, 93, 2, -15, 35, 11, 88, -21]))","Insertion sort on int data, variable named 'seq', 8 elements."
510,Python,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"def insertion_sort(buffer):
    for i in range(1, len(buffer)):
        key = buffer[i]
        j = i - 1
        while j >= 0 and buffer[j] > key:
            buffer[j + 1] = buffer[j]
            j -= 1
        buffer[j + 1] = key
    return buffer

print(insertion_sort([72, 98, 3, 7, 32, 40, 18, 78]))","Insertion sort on int data, variable named 'buffer', 8 elements."
511,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"def insertion_sort(buffer):
    for i in range(1, len(buffer)):
        key = buffer[i]
        j = i - 1
        while j >= 0 and buffer[j] > key:
            buffer[j + 1] = buffer[j]
            j -= 1
        buffer[j + 1] = key
    return buffer

print(insertion_sort([58, 20, -37, -34, 45, 38, 65, 74, 78, 84]))","Insertion sort on int data, variable named 'buffer', 10 elements."
512,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"def insertion_sort(records):
    for i in range(1, len(records)):
        key = records[i]
        j = i - 1
        while j >= 0 and records[j] > key:
            records[j + 1] = records[j]
            j -= 1
        records[j + 1] = key
    return records

print(insertion_sort([-19, 70, 86, 86, 24, 65, 44, -34, -2, 67]))","Insertion sort on int data, variable named 'records', 10 elements."
513,Python,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([-30, 50, -5, 23, -31, -23, -8, 20, -22, -13]))","Insertion sort on int data, variable named 'data', 10 elements."
514,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"def insertion_sort(dataset):
    for i in range(1, len(dataset)):
        key = dataset[i]
        j = i - 1
        while j >= 0 and dataset[j] > key:
            dataset[j + 1] = dataset[j]
            j -= 1
        dataset[j + 1] = key
    return dataset

print(insertion_sort([-12, 2, 83, -45, 25, 56, 88, -17, 71, 38, 57, 63]))","Insertion sort on int data, variable named 'dataset', 12 elements."
515,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"def insertion_sort(seq):
    for i in range(1, len(seq)):
        key = seq[i]
        j = i - 1
        while j >= 0 and seq[j] > key:
            seq[j + 1] = seq[j]
            j -= 1
        seq[j + 1] = key
    return seq

print(insertion_sort([-45, 24, -2, -34, -45, 9, 83, 35, 55, 98, 37, 33]))","Insertion sort on int data, variable named 'seq', 12 elements."
516,Python,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"def insertion_sort(dataset):
    for i in range(1, len(dataset)):
        key = dataset[i]
        j = i - 1
        while j >= 0 and dataset[j] > key:
            dataset[j + 1] = dataset[j]
            j -= 1
        dataset[j + 1] = key
    return dataset

print(insertion_sort([85, 90, 63, 67, 27, 95, -17, 28, -7, 16, 8, 73]))","Insertion sort on int data, variable named 'dataset', 12 elements."
517,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"def insertion_sort(list1):
    for i in range(1, len(list1)):
        key = list1[i]
        j = i - 1
        while j >= 0 and list1[j] > key:
            list1[j + 1] = list1[j]
            j -= 1
        list1[j + 1] = key
    return list1

print(insertion_sort([23, -38, -13, 40, 22, 66, -8, -9, 87, 23, -4, -6, -11, -9, 10]))","Insertion sort on int data, variable named 'list1', 15 elements."
518,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([-40, 31, 97, -18, 62, 16, 44, -3, 2, 93, -42, 31, 38, -13, 45]))","Insertion sort on int data, variable named 'data', 15 elements."
519,Python,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"def insertion_sort(dataset):
    for i in range(1, len(dataset)):
        key = dataset[i]
        j = i - 1
        while j >= 0 and dataset[j] > key:
            dataset[j + 1] = dataset[j]
            j -= 1
        dataset[j + 1] = key
    return dataset

print(insertion_sort([88, -9, 86, 27, -19, -44, 53, 77, -13, 67, 31, -11, -49, 89, 79]))","Insertion sort on int data, variable named 'dataset', 15 elements."
520,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"def insertion_sort(list1):
    for i in range(1, len(list1)):
        key = list1[i]
        j = i - 1
        while j >= 0 and list1[j] > key:
            list1[j + 1] = list1[j]
            j -= 1
        list1[j + 1] = key
    return list1

print(insertion_sort([25, 71, 24, 96, -13, 94, 63, 36, -22, 72, -40, -15, 91, -21, 28, -44, 52, 6, 64, 41]))","Insertion sort on int data, variable named 'list1', 20 elements."
521,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([33, -36, -1, 99, 84, 6, 21, 0, -45, -29, 87, 64, -28, 81, 50, -1, 75, 31, 80, -36]))","Insertion sort on int data, variable named 'data', 20 elements."
522,Python,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"def insertion_sort(entries):
    for i in range(1, len(entries)):
        key = entries[i]
        j = i - 1
        while j >= 0 and entries[j] > key:
            entries[j + 1] = entries[j]
            j -= 1
        entries[j + 1] = key
    return entries

print(insertion_sort([42, 51, -13, 59, 44, 48, 45, -47, 22, 38, 39, 28, 64, 93, -28, 5, 63, 56, 63, 23]))","Insertion sort on int data, variable named 'entries', 20 elements."
523,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"def insertion_sort(values):
    for i in range(1, len(values)):
        key = values[i]
        j = i - 1
        while j >= 0 and values[j] > key:
            values[j + 1] = values[j]
            j -= 1
        values[j + 1] = key
    return values

print(insertion_sort([75.88, 95.47, 30.44, 86.68, -3.39]))","Insertion sort on float data, variable named 'values', 5 elements."
524,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"def insertion_sort(elements):
    for i in range(1, len(elements)):
        key = elements[i]
        j = i - 1
        while j >= 0 and elements[j] > key:
            elements[j + 1] = elements[j]
            j -= 1
        elements[j + 1] = key
    return elements

print(insertion_sort([51.15, -2.91, 16.08, 97.62, 42.51]))","Insertion sort on float data, variable named 'elements', 5 elements."
525,Python,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"def insertion_sort(list1):
    for i in range(1, len(list1)):
        key = list1[i]
        j = i - 1
        while j >= 0 and list1[j] > key:
            list1[j + 1] = list1[j]
            j -= 1
        list1[j + 1] = key
    return list1

print(insertion_sort([-12.13, 94.25, 69.98, -9.47, 28.73]))","Insertion sort on float data, variable named 'list1', 5 elements."
526,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"def insertion_sort(entries):
    for i in range(1, len(entries)):
        key = entries[i]
        j = i - 1
        while j >= 0 and entries[j] > key:
            entries[j + 1] = entries[j]
            j -= 1
        entries[j + 1] = key
    return entries

print(insertion_sort([12.53, 0.81, 34.99, 47.58, 88.87, 3.71, 79.04, 14.45]))","Insertion sort on float data, variable named 'entries', 8 elements."
527,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"def insertion_sort(dataset):
    for i in range(1, len(dataset)):
        key = dataset[i]
        j = i - 1
        while j >= 0 and dataset[j] > key:
            dataset[j + 1] = dataset[j]
            j -= 1
        dataset[j + 1] = key
    return dataset

print(insertion_sort([-14.97, 78.32, 79.32, 16.17, 46.55, 35.15, -16.81, -19.71]))","Insertion sort on float data, variable named 'dataset', 8 elements."
528,Python,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"def insertion_sort(nums):
    for i in range(1, len(nums)):
        key = nums[i]
        j = i - 1
        while j >= 0 and nums[j] > key:
            nums[j + 1] = nums[j]
            j -= 1
        nums[j + 1] = key
    return nums

print(insertion_sort([15.72, 56.23, 55.75, -5.22, 59.24, 14.23, 1.35, 87.91]))","Insertion sort on float data, variable named 'nums', 8 elements."
529,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"def insertion_sort(buffer):
    for i in range(1, len(buffer)):
        key = buffer[i]
        j = i - 1
        while j >= 0 and buffer[j] > key:
            buffer[j + 1] = buffer[j]
            j -= 1
        buffer[j + 1] = key
    return buffer

print(insertion_sort([9.13, -5.8, 12.99, 98.33, -12.06, 68.72, 49.15, 47.3, 83.33, 54.73]))","Insertion sort on float data, variable named 'buffer', 10 elements."
530,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"def insertion_sort(dataset):
    for i in range(1, len(dataset)):
        key = dataset[i]
        j = i - 1
        while j >= 0 and dataset[j] > key:
            dataset[j + 1] = dataset[j]
            j -= 1
        dataset[j + 1] = key
    return dataset

print(insertion_sort([95.94, 77.38, 24.41, 67.22, -17.91, 10.88, 49.22, -2.61, 34.86, 62.5]))","Insertion sort on float data, variable named 'dataset', 10 elements."
531,Python,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"def insertion_sort(list1):
    for i in range(1, len(list1)):
        key = list1[i]
        j = i - 1
        while j >= 0 and list1[j] > key:
            list1[j + 1] = list1[j]
            j -= 1
        list1[j + 1] = key
    return list1

print(insertion_sort([-0.57, 12.45, 29.92, 88.54, 22.36, 14.49, 43.02, 91.42, 41.15, 71.21]))","Insertion sort on float data, variable named 'list1', 10 elements."
532,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"def insertion_sort(values):
    for i in range(1, len(values)):
        key = values[i]
        j = i - 1
        while j >= 0 and values[j] > key:
            values[j + 1] = values[j]
            j -= 1
        values[j + 1] = key
    return values

print(insertion_sort([71.0, 51.25, -0.11, 18.39, 17.63, 80.55, 75.19, 12.3, 63.06, 23.14, 43.6, 21.84]))","Insertion sort on float data, variable named 'values', 12 elements."
533,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"def insertion_sort(values):
    for i in range(1, len(values)):
        key = values[i]
        j = i - 1
        while j >= 0 and values[j] > key:
            values[j + 1] = values[j]
            j -= 1
        values[j + 1] = key
    return values

print(insertion_sort([-18.47, 41.66, 24.39, 37.7, 20.5, 88.38, -7.81, -1.61, 6.31, 2.42, 86.75, 53.0]))","Insertion sort on float data, variable named 'values', 12 elements."
534,Python,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"def insertion_sort(records):
    for i in range(1, len(records)):
        key = records[i]
        j = i - 1
        while j >= 0 and records[j] > key:
            records[j + 1] = records[j]
            j -= 1
        records[j + 1] = key
    return records

print(insertion_sort([93.35, 80.68, 64.79, 63.57, 75.51, 29.66, 89.01, -6.13, -4.38, -17.93, 21.44, 62.24]))","Insertion sort on float data, variable named 'records', 12 elements."
535,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"def insertion_sort(values):
    for i in range(1, len(values)):
        key = values[i]
        j = i - 1
        while j >= 0 and values[j] > key:
            values[j + 1] = values[j]
            j -= 1
        values[j + 1] = key
    return values

print(insertion_sort([77.23, 85.88, 51.12, 70.87, 20.7, 64.48, -16.58, 76.93, 6.46, 81.96, -3.06, 6.96, -5.08, -4.5, -10.65]))","Insertion sort on float data, variable named 'values', 15 elements."
536,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"def insertion_sort(seq):
    for i in range(1, len(seq)):
        key = seq[i]
        j = i - 1
        while j >= 0 and seq[j] > key:
            seq[j + 1] = seq[j]
            j -= 1
        seq[j + 1] = key
    return seq

print(insertion_sort([70.8, -6.71, -17.76, 37.63, 31.32, 3.37, -16.1, 58.51, 50.59, 35.82, 88.11, -14.85, 15.9, -18.78, -8.52]))","Insertion sort on float data, variable named 'seq', 15 elements."
537,Python,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([89.49, 4.44, 87.24, 1.99, 21.83, -9.2, 80.66, 92.08, 92.91, 21.39, -0.89, 39.58, 66.7, 8.78, 47.86]))","Insertion sort on float data, variable named 'data', 15 elements."
538,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"def insertion_sort(data):
    for i in range(1, len(data)):
        key = data[i]
        j = i - 1
        while j >= 0 and data[j] > key:
            data[j + 1] = data[j]
            j -= 1
        data[j + 1] = key
    return data

print(insertion_sort([77.53, 70.83, 42.93, 65.18, 94.75, 0.44, 69.73, -19.48, 66.32, 89.98, 89.54, 81.3, 36.49, 63.08, 2.03, 60.15, -7.23, 79.33, 96.77, 30.47]))","Insertion sort on float data, variable named 'data', 20 elements."
539,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"def insertion_sort(input_arr):
    for i in range(1, len(input_arr)):
        key = input_arr[i]
        j = i - 1
        while j >= 0 and input_arr[j] > key:
            input_arr[j + 1] = input_arr[j]
            j -= 1
        input_arr[j + 1] = key
    return input_arr

print(insertion_sort([7.08, -6.57, 97.17, -5.29, -6.87, -3.83, 70.71, 63.86, 46.3, -15.17, 19.05, -6.23, 13.75, 51.45, 17.13, 96.17, 32.83, 45.92, 14.58, 81.79]))","Insertion sort on float data, variable named 'input_arr', 20 elements."
540,Python,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"def insertion_sort(items):
    for i in range(1, len(items)):
        key = items[i]
        j = i - 1
        while j >= 0 and items[j] > key:
            items[j + 1] = items[j]
            j -= 1
        items[j + 1] = key
    return items

print(insertion_sort([81.96, 86.48, 75.49, 91.75, 23.73, -18.48, 60.22, 59.98, 27.17, 42.2, 60.51, -5.81, 26.98, 62.71, 96.33, 68.23, 86.2, 0.08, 23.28, 3.69]))","Insertion sort on float data, variable named 'items', 20 elements."
541,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints 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;
}

console.log(insertionSort([53, -19, 9, 58, 77]));","Insertion sort on int data, variable named 'items', 5 elements."
542,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"function insertionSort(nums) {
  for (let i = 1; i < nums.length; i++) {
    const key = nums[i];
    let j = i - 1;
    while (j >= 0 && nums[j] > key) {
      nums[j + 1] = nums[j];
      j--;
    }
    nums[j + 1] = key;
  }
  return nums;
}

console.log(insertionSort([98, 19, 52, 41, 71]));","Insertion sort on int data, variable named 'nums', 5 elements."
543,JavaScript,Sorting Algorithm,intermediate,Sort a 5-element array of ints 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;
}

console.log(insertionSort([53, 74, 80, 21, -13]));","Insertion sort on int data, variable named 'buffer', 5 elements."
544,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints 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;
}

console.log(insertionSort([66, -23, -19, 14, 75, 77, 9, -16]));","Insertion sort on int data, variable named 'vals', 8 elements."
545,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints 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;
}

console.log(insertionSort([-25, -37, -33, 77, -44, -5, 47, 33]));","Insertion sort on int data, variable named 'arr', 8 elements."
546,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

console.log(insertionSort([27, -26, -31, 83, 76, 69, 1, 25]));","Insertion sort on int data, variable named 'values', 8 elements."
547,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints 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;
}

console.log(insertionSort([77, 75, 79, 16, 88, 37, 88, 89, -46, -42]));","Insertion sort on int data, variable named 'buffer', 10 elements."
548,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints 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;
}

console.log(insertionSort([-20, 48, 65, 30, 46, 63, 67, -41, -42, -5]));","Insertion sort on int data, variable named 'collection', 10 elements."
549,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of ints 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;
}

console.log(insertionSort([27, -8, 75, 60, -16, 29, 49, 74, -22, 95]));","Insertion sort on int data, variable named 'input_arr', 10 elements."
550,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints 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;
}

console.log(insertionSort([75, 91, 88, 96, 70, 71, 93, -10, 79, -36, 50, 17]));","Insertion sort on int data, variable named 'buffer', 12 elements."
551,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"function insertionSort(dataset) {
  for (let i = 1; i < dataset.length; i++) {
    const key = dataset[i];
    let j = i - 1;
    while (j >= 0 && dataset[j] > key) {
      dataset[j + 1] = dataset[j];
      j--;
    }
    dataset[j + 1] = key;
  }
  return dataset;
}

console.log(insertionSort([46, 40, 22, 32, -35, -43, -39, -18, 43, 39, 99, -44]));","Insertion sort on int data, variable named 'dataset', 12 elements."
552,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of ints 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;
}

console.log(insertionSort([37, 47, -26, 59, 38, 41, 55, 39, -36, 12, 13, 10]));","Insertion sort on int data, variable named 'vals', 12 elements."
553,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints 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;
}

console.log(insertionSort([29, -29, -34, 28, -21, 36, -7, -45, 87, 33, -41, 67, 58, 95, 81]));","Insertion sort on int data, variable named 'buffer', 15 elements."
554,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

console.log(insertionSort([57, 18, -45, 70, -45, 31, 46, 96, 49, 32, 96, -25, 75, -25, 2]));","Insertion sort on int data, variable named 'entries', 15 elements."
555,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of ints 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;
}

console.log(insertionSort([77, 78, 36, -8, 26, 43, 61, 1, 77, -31, 87, 4, 23, 17, -38]));","Insertion sort on int data, variable named 'list1', 15 elements."
556,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"function insertionSort(nums) {
  for (let i = 1; i < nums.length; i++) {
    const key = nums[i];
    let j = i - 1;
    while (j >= 0 && nums[j] > key) {
      nums[j + 1] = nums[j];
      j--;
    }
    nums[j + 1] = key;
  }
  return nums;
}

console.log(insertionSort([96, 52, 7, -27, 98, -26, 36, 19, -33, 95, 85, 71, 59, 3, 38, -31, 27, 79, 26, 60]));","Insertion sort on int data, variable named 'nums', 20 elements."
557,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints 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;
}

console.log(insertionSort([88, 30, 1, 56, 52, 14, 81, 66, 90, -4, -46, 82, -3, 97, 77, 4, 69, 18, 86, 61]));","Insertion sort on int data, variable named 'buffer', 20 elements."
558,JavaScript,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

console.log(insertionSort([94, -35, 83, 1, 43, 68, -13, 11, -12, 26, 61, 55, 31, -34, 2, 55, 18, 23, -9, 15]));","Insertion sort on int data, variable named 'entries', 20 elements."
559,JavaScript,Sorting Algorithm,intermediate,Sort a 5-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;
}

console.log(insertionSort([51.55, 28.3, -6.49, 2.84, 9.22]));","Insertion sort on float data, variable named 'buffer', 5 elements."
560,JavaScript,Sorting Algorithm,intermediate,Sort a 5-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;
}

console.log(insertionSort([16.95, 37.76, 97.96, 30.22, 87.77]));","Insertion sort on float data, variable named 'records', 5 elements."
561,JavaScript,Sorting Algorithm,intermediate,Sort a 5-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;
}

console.log(insertionSort([-1.04, -3.76, 10.75, 75.62, 58.38]));","Insertion sort on float data, variable named 'items', 5 elements."
562,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

console.log(insertionSort([56.67, -14.97, 65.97, 73.09, -13.42, 86.68, 17.35, 15.46]));","Insertion sort on float data, variable named 'values', 8 elements."
563,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"function insertionSort(data) {
  for (let i = 1; i < data.length; i++) {
    const key = data[i];
    let j = i - 1;
    while (j >= 0 && data[j] > key) {
      data[j + 1] = data[j];
      j--;
    }
    data[j + 1] = key;
  }
  return data;
}

console.log(insertionSort([87.17, 28.43, 23.25, 58.23, -9.25, 92.24, 66.18, -3.27]));","Insertion sort on float data, variable named 'data', 8 elements."
564,JavaScript,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"function insertionSort(data) {
  for (let i = 1; i < data.length; i++) {
    const key = data[i];
    let j = i - 1;
    while (j >= 0 && data[j] > key) {
      data[j + 1] = data[j];
      j--;
    }
    data[j + 1] = key;
  }
  return data;
}

console.log(insertionSort([47.95, 39.53, -5.64, 59.04, 49.07, 72.24, 42.51, 39.08]));","Insertion sort on float data, variable named 'data', 8 elements."
565,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"function insertionSort(data) {
  for (let i = 1; i < data.length; i++) {
    const key = data[i];
    let j = i - 1;
    while (j >= 0 && data[j] > key) {
      data[j + 1] = data[j];
      j--;
    }
    data[j + 1] = key;
  }
  return data;
}

console.log(insertionSort([8.33, -5.45, 76.0, 19.19, 49.53, 26.4, 69.06, 8.08, 30.32, -2.83]));","Insertion sort on float data, variable named 'data', 10 elements."
566,JavaScript,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

console.log(insertionSort([5.48, 12.67, 28.6, 82.69, -13.34, 43.48, 63.25, -6.56, 44.94, 36.51]));","Insertion sort on float data, variable named 'values', 10 elements."
567,JavaScript,Sorting Algorithm,intermediate,Sort a 10-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;
}

console.log(insertionSort([94.63, 84.65, 91.5, 23.2, 65.16, 77.74, -17.49, 95.05, 52.09, 80.14]));","Insertion sort on float data, variable named 'items', 10 elements."
568,JavaScript,Sorting Algorithm,intermediate,Sort a 12-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;
}

console.log(insertionSort([75.07, -13.49, 89.18, 59.92, 10.1, 25.78, 56.03, 63.37, 87.48, 61.54, 43.65, 8.13]));","Insertion sort on float data, variable named 'buffer', 12 elements."
569,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"function insertionSort(dataset) {
  for (let i = 1; i < dataset.length; i++) {
    const key = dataset[i];
    let j = i - 1;
    while (j >= 0 && dataset[j] > key) {
      dataset[j + 1] = dataset[j];
      j--;
    }
    dataset[j + 1] = key;
  }
  return dataset;
}

console.log(insertionSort([26.23, 88.26, 26.76, 96.38, 10.41, -9.26, 77.9, 8.02, 5.04, 85.94, 88.99, 55.13]));","Insertion sort on float data, variable named 'dataset', 12 elements."
570,JavaScript,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

console.log(insertionSort([76.66, 56.69, 73.93, 12.61, -10.47, 72.76, 38.51, 67.7, 90.25, 19.59, 30.26, 89.31]));","Insertion sort on float data, variable named 'entries', 12 elements."
571,JavaScript,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"function insertionSort(data) {
  for (let i = 1; i < data.length; i++) {
    const key = data[i];
    let j = i - 1;
    while (j >= 0 && data[j] > key) {
      data[j + 1] = data[j];
      j--;
    }
    data[j + 1] = key;
  }
  return data;
}

console.log(insertionSort([78.1, 63.12, 40.25, 21.87, 51.65, 76.8, 67.8, 33.94, -16.75, -13.8, 56.35, 54.99, 74.13, -3.81, 27.68]));","Insertion sort on float data, variable named 'data', 15 elements."
572,JavaScript,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;
}

console.log(insertionSort([16.36, 48.52, -6.81, 9.7, 64.91, 71.35, 57.25, -4.52, 50.69, 28.83, 91.79, 33.73, 83.95, -4.11, 0.64]));","Insertion sort on float data, variable named 'buffer', 15 elements."
573,JavaScript,Sorting Algorithm,intermediate,Sort a 15-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;
}

console.log(insertionSort([78.39, 75.14, 3.64, 29.33, 1.64, 84.29, 92.43, 85.24, 6.71, 92.82, 89.85, 57.01, 54.57, 87.91, 95.92]));","Insertion sort on float data, variable named 'elements', 15 elements."
574,JavaScript,Sorting Algorithm,intermediate,Sort a 20-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;
}

console.log(insertionSort([11.15, 81.37, -14.08, 53.54, 51.45, -2.24, 94.01, 0.24, 47.5, -18.32, 42.57, 72.03, 90.47, 78.44, 38.8, 6.71, 4.17, 92.58, 76.8, 11.68]));","Insertion sort on float data, variable named 'items', 20 elements."
575,JavaScript,Sorting Algorithm,intermediate,Sort a 20-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;
}

console.log(insertionSort([38.81, -4.51, 81.9, 51.41, 98.43, 13.67, 60.59, 29.78, 28.61, -2.63, 14.53, 11.15, 53.5, 87.97, 23.99, 61.43, 34.52, -18.77, -4.15, 18.47]));","Insertion sort on float data, variable named 'seq', 20 elements."
576,JavaScript,Sorting Algorithm,intermediate,Sort a 20-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;
}

console.log(insertionSort([27.31, 5.25, 25.64, 30.37, 51.07, -11.31, 46.28, -13.8, 90.8, 36.04, 22.16, 52.16, 59.82, 75.47, 64.44, 76.37, -19.36, 40.04, 25.33, 96.33]));","Insertion sort on float data, variable named 'seq', 20 elements."
577,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints 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(insertionSort([44, -17, 93, -40, 98]));","Insertion sort on int data, variable named 'buffer', 5 elements."
578,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

module.exports = { insertionSort };
console.log(insertionSort([16, -7, 78, 76, 36]));","Insertion sort on int data, variable named 'values', 5 elements."
579,Node.js,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

module.exports = { insertionSort };
console.log(insertionSort([69, -17, -28, 31, 85]));","Insertion sort on int data, variable named 'entries', 5 elements."
580,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints 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 = { insertionSort };
console.log(insertionSort([-14, 16, -21, 30, -39, -18, 77, 21]));","Insertion sort on int data, variable named 'collection', 8 elements."
581,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints 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([42, 60, 22, 17, 17, 82, 30, 61]));","Insertion sort on int data, variable named 'seq', 8 elements."
582,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

module.exports = { insertionSort };
console.log(insertionSort([-8, 30, 75, -12, 92, 62, -37, -2]));","Insertion sort on int data, variable named 'entries', 8 elements."
583,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

module.exports = { insertionSort };
console.log(insertionSort([-37, 8, -4, -41, 70, 16, -9, 69, 61, -21]));","Insertion sort on int data, variable named 'values', 10 elements."
584,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

module.exports = { insertionSort };
console.log(insertionSort([76, -40, 63, 41, 93, 74, 67, 76, -22, -13]));","Insertion sort on int data, variable named 'entries', 10 elements."
585,Node.js,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"function insertionSort(data) {
  for (let i = 1; i < data.length; i++) {
    const key = data[i];
    let j = i - 1;
    while (j >= 0 && data[j] > key) {
      data[j + 1] = data[j];
      j--;
    }
    data[j + 1] = key;
  }
  return data;
}

module.exports = { insertionSort };
console.log(insertionSort([39, -27, 2, 22, -4, -7, 80, 19, 94, 99]));","Insertion sort on int data, variable named 'data', 10 elements."
586,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints 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([99, -49, 84, 96, -4, 56, -31, 13, 77, -26, 34, -44]));","Insertion sort on int data, variable named 'items', 12 elements."
587,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"function insertionSort(nums) {
  for (let i = 1; i < nums.length; i++) {
    const key = nums[i];
    let j = i - 1;
    while (j >= 0 && nums[j] > key) {
      nums[j + 1] = nums[j];
      j--;
    }
    nums[j + 1] = key;
  }
  return nums;
}

module.exports = { insertionSort };
console.log(insertionSort([-19, 50, 45, -23, 32, -11, -43, -30, 67, 72, 66, 18]));","Insertion sort on int data, variable named 'nums', 12 elements."
588,Node.js,Sorting Algorithm,intermediate,Sort a 12-element array of ints 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 };
console.log(insertionSort([-49, 34, -39, 65, 33, 95, -17, 4, -38, 22, 32, -36]));","Insertion sort on int data, variable named 'elements', 12 elements."
589,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints 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([-32, 90, 47, -27, 52, 15, -5, 11, 52, -28, -45, 3, -9, 49, 53]));","Insertion sort on int data, variable named 'seq', 15 elements."
590,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"function insertionSort(nums) {
  for (let i = 1; i < nums.length; i++) {
    const key = nums[i];
    let j = i - 1;
    while (j >= 0 && nums[j] > key) {
      nums[j + 1] = nums[j];
      j--;
    }
    nums[j + 1] = key;
  }
  return nums;
}

module.exports = { insertionSort };
console.log(insertionSort([-11, -20, 26, 75, 60, 29, -17, 41, -26, 44, 81, 1, 75, 64, 49]));","Insertion sort on int data, variable named 'nums', 15 elements."
591,Node.js,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"function insertionSort(dataset) {
  for (let i = 1; i < dataset.length; i++) {
    const key = dataset[i];
    let j = i - 1;
    while (j >= 0 && dataset[j] > key) {
      dataset[j + 1] = dataset[j];
      j--;
    }
    dataset[j + 1] = key;
  }
  return dataset;
}

module.exports = { insertionSort };
console.log(insertionSort([18, 94, 58, -27, 58, 44, -3, 61, 59, -27, -40, 81, 37, 68, 7]));","Insertion sort on int data, variable named 'dataset', 15 elements."
592,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints 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(insertionSort([-11, 76, 84, 84, -29, 24, 69, 61, -30, 72, 26, -12, -18, 26, 13, 83, 59, 25, 95, -38]));","Insertion sort on int data, variable named 'buffer', 20 elements."
593,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints 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 };
console.log(insertionSort([-31, -39, 81, -23, 80, 58, 55, -26, 68, 95, 14, 40, 15, 99, -30, 78, -46, -21, 68, -5]));","Insertion sort on int data, variable named 'input_arr', 20 elements."
594,Node.js,Sorting Algorithm,intermediate,Sort a 20-element array of ints 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([-4, 50, -39, -29, 56, 26, 30, 66, 65, 17, 37, -3, 4, -3, -30, 16, -23, 61, 86, -46]));","Insertion sort on int data, variable named 'vals', 20 elements."
595,Node.js,Sorting Algorithm,intermediate,Sort a 5-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([27.0, -18.42, 58.04, 34.76, 28.21]));","Insertion sort on float data, variable named 'arr', 5 elements."
596,Node.js,Sorting Algorithm,intermediate,Sort a 5-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(insertionSort([94.93, 51.62, 37.92, 53.6, 95.9]));","Insertion sort on float data, variable named 'buffer', 5 elements."
597,Node.js,Sorting Algorithm,intermediate,Sort a 5-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([62.19, 94.61, 60.34, 75.75, -9.57]));","Insertion sort on float data, variable named 'list1', 5 elements."
598,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"function insertionSort(values) {
  for (let i = 1; i < values.length; i++) {
    const key = values[i];
    let j = i - 1;
    while (j >= 0 && values[j] > key) {
      values[j + 1] = values[j];
      j--;
    }
    values[j + 1] = key;
  }
  return values;
}

module.exports = { insertionSort };
console.log(insertionSort([-18.35, -6.68, -18.11, 95.49, 82.22, 4.9, 57.19, 57.32]));","Insertion sort on float data, variable named 'values', 8 elements."
599,Node.js,Sorting Algorithm,intermediate,Sort a 8-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 = { insertionSort };
console.log(insertionSort([80.21, 82.12, 44.09, -9.75, 71.6, -2.37, 30.2, -6.14]));","Insertion sort on float data, variable named 'collection', 8 elements."
600,Node.js,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"function insertionSort(entries) {
  for (let i = 1; i < entries.length; i++) {
    const key = entries[i];
    let j = i - 1;
    while (j >= 0 && entries[j] > key) {
      entries[j + 1] = entries[j];
      j--;
    }
    entries[j + 1] = key;
  }
  return entries;
}

module.exports = { insertionSort };
console.log(insertionSort([-1.86, 63.61, 94.7, 36.11, 82.32, 49.64, 3.96, 47.76]));","Insertion sort on float data, variable named 'entries', 8 elements."
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(insertionSort([26.62, 19.73, -7.78, 80.87, 31.38, 29.47, 38.99, 48.86, 67.0, 98.88]));","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, 52.77, 60.76, 77.19, 38.06, 65.0, 42.87, 30.22]));","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.84, 11.87, 57.15, 85.81, -6.08, 54.1, 56.9, 33.35, 31.91, -0.8]));","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, 6.14, 88.18, 20.36, 51.65, 80.25, 58.18, -4.39, 14.91, 64.65]));","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 = { insertionSort };
console.log(insertionSort([79.14, 60.1, 67.42, 74.72, 75.17, 80.5, 54.0, 13.61, 69.16, 59.38, -4.64, 3.74]));","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 };
console.log(insertionSort([38.57, 74.42, 92.22, 38.75, 7.93, 46.26, 98.91, 22.7, 11.04, 60.55, 0.79, 82.28]));","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 };
console.log(insertionSort([-16.2, -12.42, 31.24, 53.49, -5.64, 6.67, 10.68, 20.5, 22.27, -14.45, 84.45, 11.83, -2.01, 62.13, 41.33]));","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(insertionSort([-7.61, -14.0, 92.61, 75.08, 94.56, 69.94, 95.98, 73.02, 52.55, 82.15, -7.88, 46.93, 40.37, -0.12, -5.95]));","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.41, -1.31, 14.76, 32.54, 40.2, 67.17, -8.18, 57.0, 19.82, -3.61, 80.98, 32.25, 29.47, 71.51, 9.19]));","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.12, 0.38, 11.66, 65.11, 29.39, 54.9, 9.21, 69.63, 43.03, 73.68, -3.58, 31.03, 89.24, 86.87, 93.27, 41.42, 61.18, 92.31, 32.67]));","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.94, 92.29, -9.91, 17.46, 96.85, -0.45, -12.69, 70.34, 58.56, 56.33, 87.4, -13.12, 55.16, 64.89, 58.58, 41.85, 15.19, 27.84, 61.02]));","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 };
console.log(insertionSort([83.95, 65.86, 17.33, 20.95, 78.41, 87.12, 52.64, -2.52, 28.07, 56.62, 85.62, 54.3, 53.56, 32.62, 21.08, 76.61, 57.2, 72.27, 84.84, -9.97]));","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--;
            }
            input_arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {35, 49, -18, 83, 88};
        insertionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] nums = {4, -27, 80, 91, 29};
        insertionSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","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--;
            }
            input_arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {37, -10, -45, -43, 88};
        insertionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","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--;
            }
            elements[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] elements = {16, 11, 27, 58, 79, -22, -35, 45};
        insertionSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] nums = {79, 40, -19, -38, -19, 64, 26, 96};
        insertionSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] seq = {-49, 66, 36, 10, 98, 94, 86, 9};
        insertionSort(seq);
        for (int v : seq) System.out.print(v + "" "");
    }
}","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] = key;
        }
    }

    public static void main(String[] args) {
        int[] list1 = {26, 22, 96, -15, 46, 83, 13, -24, 33, 82};
        insertionSort(list1);
        for (int v : list1) System.out.print(v + "" "");
    }
}","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--;
            }
            elements[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] elements = {-1, 42, 66, -25, -13, 58, 55, -30, -27, -35};
        insertionSort(elements);
        for (int v : elements) System.out.print(v + "" "");
    }
}","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--;
            }
            collection[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] collection = {-17, 71, 4, 64, -31, 44, 84, 53, 93, 82};
        insertionSort(collection);
        for (int v : collection) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] vals = {51, 17, 99, 77, 58, 62, 75, 56, -9, -14, 79, -18};
        insertionSort(vals);
        for (int v : vals) System.out.print(v + "" "");
    }
}","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--;
            }
            dataset[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] dataset = {67, -17, 81, 85, -20, 4, 66, 71, -42, -10, 93, 44};
        insertionSort(dataset);
        for (int v : dataset) System.out.print(v + "" "");
    }
}","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--;
            }
            entries[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] entries = {-20, 54, -22, -20, 44, 96, 24, -40, 83, -11, -20, 45};
        insertionSort(entries);
        for (int v : entries) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] nums = {45, 27, 25, 74, -43, -14, -14, 57, -38, 28, 22, 5, -4, 75, -50};
        insertionSort(nums);
        for (int v : nums) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        int[] data = {90, 39, -33, -39, 56, 73, 96, 29, 94, 65, 36, 46, 71, -17, -15};
        insertionSort(data);
        for (int v : data) System.out.print(v + "" "");
    }
}","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--;
            }
            input_arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] input_arr = {67, 65, 64, -12, 33, -28, 54, 49, 9, 51, 36, 88, -39, 63, 21};
        insertionSort(input_arr);
        for (int v : input_arr) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] buffer = {-28, -8, -44, 96, 29, 93, -19, 93, -29, -1, 88, 97, -37, 95, 83, -2, 71, 78, -46, -20};
        insertionSort(buffer);
        for (int v : buffer) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] buffer = {86, -4, -46, 20, 2, 12, 98, 63, -29, 86, 32, 52, -39, 75, -45, 37, 61, -4, 56, -44};
        insertionSort(buffer);
        for (int v : buffer) System.out.print(v + "" "");
    }
}","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--;
            }
            records[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] records = {85, 31, 47, 15, -27, -21, -25, 88, -7, 23, -14, -4, 15, -28, -11, 28, 54, -7, -35, 33};
        insertionSort(records);
        for (int v : records) System.out.print(v + "" "");
    }
}","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--;
            }
            values[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] values = {-16.77, -13.04, 26.4, 18.08, 29.13};
        insertionSort(values);
        for (double v : values) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] list1 = {10.69, 92.05, 87.04, -13.83, 8.52};
        insertionSort(list1);
        for (double v : list1) System.out.print(v + "" "");
    }
}","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--;
            }
            elements[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] elements = {49.74, 38.66, 69.53, 25.82, -6.31};
        insertionSort(elements);
        for (double v : elements) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        double[] arr = {17.88, 45.82, -12.21, -16.56, 55.39, 88.73, -17.78, 45.93};
        insertionSort(arr);
        for (double v : arr) System.out.print(v + "" "");
    }
}","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--;
            }
            elements[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] elements = {60.34, 9.31, 46.01, 73.44, 16.25, 28.4, -10.01, 55.66};
        insertionSort(elements);
        for (double v : elements) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] items = {73.16, -3.06, 44.31, 0.01, 9.17, 93.36, 94.4, 46.06};
        insertionSort(items);
        for (double v : items) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        double[] arr = {-19.88, 35.29, 78.7, 14.42, 95.68, -19.94, 91.09, 37.38, 51.15, 79.9};
        insertionSort(arr);
        for (double v : arr) System.out.print(v + "" "");
    }
}","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--;
            }
            collection[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] collection = {98.91, 80.25, 5.32, 80.04, 13.48, -0.79, 43.56, -11.68, -9.32, 63.11};
        insertionSort(collection);
        for (double v : collection) System.out.print(v + "" "");
    }
}","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--;
            }
            records[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] records = {-3.38, 46.22, 13.26, 31.4, 52.64, 93.93, 17.88, 61.17, 20.77, 11.1};
        insertionSort(records);
        for (double v : records) System.out.print(v + "" "");
    }
}","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] = key;
        }
    }

    public static void main(String[] args) {
        double[] vals = {64.22, 12.49, 58.81, 18.27, 5.06, 94.12, 19.09, 88.77, -4.09, 89.75, 52.45, -19.49};
        insertionSort(vals);
        for (double v : vals) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        double[] arr = {60.05, 29.17, 86.54, 63.69, 70.73, 44.04, 73.69, 57.24, -10.77, -16.32, 79.02, 59.92};
        insertionSort(arr);
        for (double v : arr) System.out.print(v + "" "");
    }
}","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--;
            }
            buffer[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] buffer = {-5.31, 95.67, 24.79, 51.56, 26.02, 79.86, 76.61, 97.07, -5.15, 24.09, 2.97, -18.89};
        insertionSort(buffer);
        for (double v : buffer) System.out.print(v + "" "");
    }
}","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;
        }
    }

    public static void main(String[] args) {
        double[] seq = {-17.65, 13.46, 89.65, 22.58, -9.29, 53.0, 16.08, 65.42, 7.88, 38.76, 23.2, 13.41, 87.64, 64.13, 4.88};
        insertionSort(seq);
        for (double v : seq) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] items = {97.13, 55.97, -6.8, 13.0, 39.54, 0.29, 3.06, 67.92, 59.99, 51.75, 0.89, 49.99, 68.77, -4.84, 91.09};
        insertionSort(items);
        for (double v : items) System.out.print(v + "" "");
    }
}","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--;
            }
            records[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] records = {7.13, 42.25, 73.09, 2.83, 60.68, 98.04, 62.47, 43.42, 10.1, 46.65, 34.02, 91.61, 56.27, 92.23, -13.83};
        insertionSort(records);
        for (double v : records) System.out.print(v + "" "");
    }
}","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[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] list1 = {31.47, 98.42, 12.61, 60.94, 35.52, 23.02, 70.32, 85.17, 6.72, 13.07, 29.99, 33.41, -19.39, 3.16, -10.26, 48.05, -16.98, 67.76, 96.39, 30.43};
        insertionSort(list1);
        for (double v : list1) System.out.print(v + "" "");
    }
}","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] = key;
        }
    }

    public static void main(String[] args) {
        double[] data = {89.12, 3.43, 19.18, -12.52, 54.41, -16.68, 31.4, -17.14, 74.87, 91.27, 80.02, 9.41, 36.36, 94.1, 79.07, 77.77, 41.84, 8.17, -11.32, 51.4};
        insertionSort(data);
        for (double v : data) System.out.print(v + "" "");
    }
}","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--;
            }
            dataset[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        double[] dataset = {70.93, 54.42, 48.89, -9.82, -12.78, -16.03, 17.28, 80.88, -12.26, -4.82, 89.37, 32.59, 15.88, 54.52, -12.17, 60.63, 46.55, 15.1, 25.39, -8.6};
        insertionSort(dataset);
        for (double v : dataset) System.out.print(v + "" "");
    }
}","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[] = {55, 9, -48, 66, 48};
    int n = sizeof(vals) / sizeof(vals[0]);
    insertion_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","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) {
    int dataset[] = {59, -25, 36, -44, 66};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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 main(void) {
    int input_arr[] = {34, -1, -23, -24, -47};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    insertion_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","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(void) {
    int elements[] = {-33, -1, 96, -18, 80, 15, 40, 57};
    int n = sizeof(elements) / sizeof(elements[0]);
    insertion_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","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) {
    int dataset[] = {63, -3, 12, -15, -39, -35, -18, 29};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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(void) {
    int elements[] = {61, 81, 41, 29, 99, 88, -13, -13};
    int n = sizeof(elements) / sizeof(elements[0]);
    insertion_sort(elements, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)elements[i]);
    return 0;
}","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) {
    int dataset[] = {29, 37, 24, 44, -48, 82, -13, -36, 10, 79};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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) {
    int records[] = {93, -37, 58, 38, 0, 1, 1, -33, 37, -2};
    int n = sizeof(records) / sizeof(records[0]);
    insertion_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","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) {
    int buffer[] = {71, 69, 34, 98, 94, 35, 26, 57, 34, -9};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    insertion_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","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[] = {66, -40, 76, 6, -50, 7, 8, 69, 4, 11, 73, 34};
    int n = sizeof(data) / sizeof(data[0]);
    insertion_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","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[] = {46, 2, 52, -3, -49, 42, -48, -32, 41, -43, 92, -21};
    int n = sizeof(vals) / sizeof(vals[0]);
    insertion_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","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) {
    int values[] = {24, 62, -1, 99, 42, -39, -43, 0, 0, 22, -6, 6};
    int n = sizeof(values) / sizeof(values[0]);
    insertion_sort(values, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)values[i]);
    return 0;
}","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) {
    int entries[] = {17, -6, 36, 91, 12, -5, 0, -45, -5, 17, -25, -45, -15, 47, -22};
    int n = sizeof(entries) / sizeof(entries[0]);
    insertion_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","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 list1[] = {3, 28, 66, 11, 44, 45, -7, 84, 61, -34, -20, -14, -17, -2, -1};
    int n = sizeof(list1) / sizeof(list1[0]);
    insertion_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","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 main(void) {
    int input_arr[] = {46, 45, 31, 59, 12, -39, -2, 87, 25, -12, 33, 13, -37, 21, -18};
    int n = sizeof(input_arr) / sizeof(input_arr[0]);
    insertion_sort(input_arr, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)input_arr[i]);
    return 0;
}","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) {
    int records[] = {80, 99, 75, 3, -30, 70, -34, -8, 80, 49, 80, 45, 77, 82, 68, -5, 32, 45, 84, 73};
    int n = sizeof(records) / sizeof(records[0]);
    insertion_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","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, 18, 98, 52, 99, -41, 3, 6, 1, 65, 10, 51, 5, 28, 58, 46, 96, -10, 45};
    int n = sizeof(seq) / sizeof(seq[0]);
    insertion_sort(seq, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)seq[i]);
    return 0;
}","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[] = {90, -29, -16, -29, 25, 63, 82, 40, 8, 99, -40, 69, 81, 36, 59, 65, 69, 60, 54, 44};
    int n = sizeof(nums) / sizeof(nums[0]);
    insertion_sort(nums, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)nums[i]);
    return 0;
}","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 vals[] = {39.21, 12.49, -17.06, 32.56, 11.61};
    int n = sizeof(vals) / sizeof(vals[0]);
    insertion_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","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 data[] = {22.73, -10.19, 80.27, 41.02, 56.59};
    int n = sizeof(data) / sizeof(data[0]);
    insertion_sort(data, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)data[i]);
    return 0;
}","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 vals[] = {12.89, 7.1, -5.89, 22.87, 44.98};
    int n = sizeof(vals) / sizeof(vals[0]);
    insertion_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","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) {
    double list1[] = {3.4, 19.18, 16.02, 77.05, 61.34, 12.66, 63.97, 98.76};
    int n = sizeof(list1) / sizeof(list1[0]);
    insertion_sort(list1, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)list1[i]);
    return 0;
}","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(void) {
    double records[] = {69.53, 68.04, 88.57, -18.98, 15.64, 77.85, 73.19, 28.05};
    int n = sizeof(records) / sizeof(records[0]);
    insertion_sort(records, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)records[i]);
    return 0;
}","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;
    }
}

int main(void) {
    double collection[] = {77.8, 70.18, -18.59, 57.84, 97.72, 93.23, 82.99, 7.08};
    int n = sizeof(collection) / sizeof(collection[0]);
    insertion_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","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[] = {69.15, 36.46, 41.38, 73.53, 70.16, 65.98, 34.91, 74.24, 17.26, 2.35};
    int n = sizeof(seq) / sizeof(seq[0]);
    insertion_sort(seq, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)seq[i]);
    return 0;
}","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 vals[] = {92.09, 29.7, 32.2, 81.5, -16.42, -3.46, 83.98, 16.36, 67.8, 39.48};
    int n = sizeof(vals) / sizeof(vals[0]);
    insertion_sort(vals, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)vals[i]);
    return 0;
}","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) {
    double buffer[] = {79.28, 20.44, 29.88, 61.61, 28.0, 72.66, 43.97, 18.8, -17.23, 73.46};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    insertion_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","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(void) {
    double entries[] = {-3.44, 96.29, 98.32, 47.61, 75.1, 88.74, 48.29, 26.52, 25.38, 92.89, -12.42, 25.99};
    int n = sizeof(entries) / sizeof(entries[0]);
    insertion_sort(entries, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)entries[i]);
    return 0;
}","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(void) {
    double dataset[] = {-7.07, 47.77, 33.73, 86.47, -8.9, -7.59, 45.8, -16.18, 61.99, 38.14, 2.22, -11.73};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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;
    }
}

int main(void) {
    double collection[] = {13.77, 7.73, 58.49, -11.67, -13.16, 41.71, 0.45, 82.31, 28.89, -1.31, -6.82, 43.84};
    int n = sizeof(collection) / sizeof(collection[0]);
    insertion_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","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(void) {
    double dataset[] = {68.43, 26.29, 87.53, 4.57, 83.58, 16.86, 77.33, 59.11, -1.11, 48.44, 16.93, 4.15, 65.3, 34.62, 4.0};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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) {
    double values[] = {33.04, 78.13, 51.98, 9.37, 19.14, 47.74, 38.42, 35.06, -15.35, -9.16, 56.91, 89.35, 21.27, 80.27, 74.29};
    int n = sizeof(values) / sizeof(values[0]);
    insertion_sort(values, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)values[i]);
    return 0;
}","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;
    }
}

int main(void) {
    double collection[] = {52.95, 76.39, 0.84, 9.65, 87.1, 67.26, 34.48, 88.39, 1.83, 47.67, 26.83, 92.54, 8.52, 83.59, 12.58};
    int n = sizeof(collection) / sizeof(collection[0]);
    insertion_sort(collection, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)collection[i]);
    return 0;
}","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) {
    double buffer[] = {43.99, 59.33, -12.06, 66.46, 87.37, 88.14, 28.94, 70.66, -5.57, 23.88, 69.89, 40.02, 72.76, 28.8, -0.38, 4.68, -14.69, -16.82, 56.03, 60.4};
    int n = sizeof(buffer) / sizeof(buffer[0]);
    insertion_sort(buffer, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)buffer[i]);
    return 0;
}","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(void) {
    double dataset[] = {25.36, 68.77, 81.84, 27.2, -18.72, -6.35, 89.14, 18.93, 69.09, 37.69, -11.88, 45.26, 8.83, 93.05, -3.31, 77.63, 80.15, 0.3, -17.85, -8.04};
    int n = sizeof(dataset) / sizeof(dataset[0]);
    insertion_sort(dataset, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)dataset[i]);
    return 0;
}","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 nums[] = {-5.23, 68.23, 0.05, 59.9, -18.67, 12.52, 32.44, 1.17, 65.02, 86.23, 43.34, 32.6, -14.32, 55.54, 42.22, 58.84, 58.54, -7.77, 62.15, 32.83};
    int n = sizeof(nums) / sizeof(nums[0]);
    insertion_sort(nums, n);
    for (int i = 0; i < n; i++) printf(""%g "", (double)nums[i]);
    return 0;
}","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--;
        }
        elements[j + 1] = key;
    }
}

int main() {
    std::vector<int> elements = {-49, -38, 46, 1, 13};
    insertionSort(elements);
    for (int v : elements) std::cout << v << "" "";
    return 0;
}","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] = key;
    }
}

int main() {
    std::vector<int> list1 = {11, 1, -27, -46, 57};
    insertionSort(list1);
    for (int v : list1) std::cout << v << "" "";
    return 0;
}","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;
    }
}

int main() {
    std::vector<int> arr = {-47, 36, -1, -34, 6};
    insertionSort(arr);
    for (int v : arr) std::cout << v << "" "";
    return 0;
}","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--;
        }
        entries[j + 1] = key;
    }
}

int main() {
    std::vector<int> entries = {-26, -8, -8, -39, 56, 81, -23, 33};
    insertionSort(entries);
    for (int v : entries) std::cout << v << "" "";
    return 0;
}","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] = key;
    }
}

int main() {
    std::vector<int> list1 = {93, -2, 3, 88, 51, 59, -20, 9};
    insertionSort(list1);
    for (int v : list1) std::cout << v << "" "";
    return 0;
}","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] = key;
    }
}

int main() {
    std::vector<int> items = {-23, 41, 32, -6, -47, 52, 30, -47};
    insertionSort(items);
    for (int v : items) std::cout << v << "" "";
    return 0;
}","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--;
        }
        collection[j + 1] = key;
    }
}

int main() {
    std::vector<int> collection = {4, 67, 6, -34, 21, 44, -39, -33, 5, 55};
    insertionSort(collection);
    for (int v : collection) std::cout << v << "" "";
    return 0;
}","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;
    }
}

int main() {
    std::vector<int> nums = {77, -24, 87, 95, -7, 14, -26, 33, 49, -16};
    insertionSort(nums);
    for (int v : nums) std::cout << v << "" "";
    return 0;
}","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] = key;
    }
}

int main() {
    std::vector<int> list1 = {-6, 31, 73, -33, 35, -46, 99, 64, 47, 80};
    insertionSort(list1);
    for (int v : list1) std::cout << v << "" "";
    return 0;
}","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 + 1] = key;
    }
}

int main() {
    std::vector<int> buffer = {9, 78, -47, 9, -45, -19, 29, 10, 59, 12, -30, -35};
    insertionSort(buffer);
    for (int v : buffer) std::cout << v << "" "";
    return 0;
}","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 + 1] = key;
    }
}

int main() {
    std::vector<int> values = {45, 77, 25, 1, -12, 46, 2, -41, 10, 63, 34, -16};
    insertionSort(values);
    for (int v : values) std::cout << v << "" "";
    return 0;
}","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;
    }
}

int main() {
    std::vector<int> nums = {31, -40, 83, 56, 23, -44, 8, 34, 37, 12, 2, 88};
    insertionSort(nums);
    for (int v : nums) std::cout << v << "" "";
    return 0;
}","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;
    }
}

int main() {
    std::vector<int> arr = {13, 6, 47, 83, 32, -4, 63, -49, -34, 75, -33, -1, -37, -14, 2};
    insertionSort(arr);
    for (int v : arr) std::cout << v << "" "";
    return 0;
}","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 + 1] = key;
    }
}

int main() {
    std::vector<int> values = {-27, -6, 90, 2, 10, 79, -30, 59, 69, 29, -8, 0, 12, 58, -5};
    insertionSort(values);
    for (int v : values) std::cout << v << "" "";
    return 0;
}","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--;
        }
        elements[j + 1] = key;
    }
}

int main() {
    std::vector<int> elements = {13, 27, 23, 97, 64, 1, 19, 73, -30, 42, 51, 46, -8, 70, 62};
    insertionSort(elements);
    for (int v : elements) std::cout << v << "" "";
    return 0;
}","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--;
        }
        collection[j + 1] = key;
    }
}

int main() {
    std::vector<int> collection = {79, 60, -11, 73, -45, 47, 59, -29, 26, 87, -11, 91, -6, 15, 47, 68, 28, 66, 22, 46};
    insertionSort(collection);
    for (int v : collection) std::cout << v << "" "";
    return 0;
}","Insertion sort on int data, variable named 'collection', 20 elements."
701,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>& input_arr) {
    for (size_t i = 1; i < input_arr.size(); i++) {
        int key = input_arr[i];
        int j = (int) i - 1;
        while (j >= 0 && input_arr[j] > key) {
            input_arr[j + 1] = input_arr[j];
            j--;
        }
        input_arr[j + 1] = key;
    }
}

int main() {
    std::vector<int> input_arr = {73, -32, 35, -16, 70, 0, -11, -2, -49, -47, 78, 45, 75, 53, 56, 51, 45, 48, 75, 28};
    insertionSort(input_arr);
    for (int v : input_arr) std::cout << v << "" "";
    return 0;
}","Insertion sort on int data, variable named 'input_arr', 20 elements."
702,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>& 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 + 1] = key;
    }
}

int main() {
    std::vector<int> buffer = {-32, 54, -41, -19, 48, 94, -9, -1, 61, 15, 39, 80, 75, 44, -36, 48, 58, 13, 12, 72};
    insertionSort(buffer);
    for (int v : buffer) std::cout << v << "" "";
    return 0;
}","Insertion sort on int data, variable named 'buffer', 20 elements."
703,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& arr) {
    for (size_t i = 1; i < arr.size(); i++) {
        double key = arr[i];
        int j = (int) i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    std::vector<double> arr = {89.65, 23.01, 64.08, -16.64, 59.22};
    insertionSort(arr);
    for (double v : arr) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'arr', 5 elements."
704,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& values) {
    for (size_t i = 1; i < values.size(); i++) {
        double key = values[i];
        int j = (int) i - 1;
        while (j >= 0 && values[j] > key) {
            values[j + 1] = values[j];
            j--;
        }
        values[j + 1] = key;
    }
}

int main() {
    std::vector<double> values = {11.1, 34.2, 61.05, 10.26, 51.66};
    insertionSort(values);
    for (double v : values) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'values', 5 elements."
705,C++,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& buffer) {
    for (size_t i = 1; i < buffer.size(); i++) {
        double key = buffer[i];
        int j = (int) i - 1;
        while (j >= 0 && buffer[j] > key) {
            buffer[j + 1] = buffer[j];
            j--;
        }
        buffer[j + 1] = key;
    }
}

int main() {
    std::vector<double> buffer = {80.14, -18.53, 71.75, 56.68, 89.11};
    insertionSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'buffer', 5 elements."
706,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& collection) {
    for (size_t i = 1; i < collection.size(); i++) {
        double key = collection[i];
        int j = (int) i - 1;
        while (j >= 0 && collection[j] > key) {
            collection[j + 1] = collection[j];
            j--;
        }
        collection[j + 1] = key;
    }
}

int main() {
    std::vector<double> collection = {64.02, 95.92, -10.44, 88.28, 84.24, -0.27, 30.8, 62.33};
    insertionSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'collection', 8 elements."
707,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& input_arr) {
    for (size_t i = 1; i < input_arr.size(); i++) {
        double key = input_arr[i];
        int j = (int) i - 1;
        while (j >= 0 && input_arr[j] > key) {
            input_arr[j + 1] = input_arr[j];
            j--;
        }
        input_arr[j + 1] = key;
    }
}

int main() {
    std::vector<double> input_arr = {95.15, 58.36, 25.55, 16.65, 28.98, 84.29, 66.59, -9.42};
    insertionSort(input_arr);
    for (double v : input_arr) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'input_arr', 8 elements."
708,C++,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& buffer) {
    for (size_t i = 1; i < buffer.size(); i++) {
        double key = buffer[i];
        int j = (int) i - 1;
        while (j >= 0 && buffer[j] > key) {
            buffer[j + 1] = buffer[j];
            j--;
        }
        buffer[j + 1] = key;
    }
}

int main() {
    std::vector<double> buffer = {48.14, 74.91, 76.89, 12.01, 4.93, 69.05, 63.18, -19.24};
    insertionSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'buffer', 8 elements."
709,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& values) {
    for (size_t i = 1; i < values.size(); i++) {
        double key = values[i];
        int j = (int) i - 1;
        while (j >= 0 && values[j] > key) {
            values[j + 1] = values[j];
            j--;
        }
        values[j + 1] = key;
    }
}

int main() {
    std::vector<double> values = {77.15, -19.81, -11.69, 62.86, 42.47, 57.89, 67.23, 0.31, 24.58, 63.78};
    insertionSort(values);
    for (double v : values) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'values', 10 elements."
710,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& items) {
    for (size_t i = 1; i < items.size(); i++) {
        double key = items[i];
        int j = (int) i - 1;
        while (j >= 0 && items[j] > key) {
            items[j + 1] = items[j];
            j--;
        }
        items[j + 1] = key;
    }
}

int main() {
    std::vector<double> items = {37.89, 39.81, -6.88, 47.48, 5.3, 3.91, 69.24, 76.29, 2.83, 96.97};
    insertionSort(items);
    for (double v : items) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'items', 10 elements."
711,C++,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& records) {
    for (size_t i = 1; i < records.size(); i++) {
        double key = records[i];
        int j = (int) i - 1;
        while (j >= 0 && records[j] > key) {
            records[j + 1] = records[j];
            j--;
        }
        records[j + 1] = key;
    }
}

int main() {
    std::vector<double> records = {28.65, 54.59, 54.31, 83.34, -0.23, 14.88, 24.95, 12.93, 20.72, 49.69};
    insertionSort(records);
    for (double v : records) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'records', 10 elements."
712,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& dataset) {
    for (size_t i = 1; i < dataset.size(); i++) {
        double key = dataset[i];
        int j = (int) i - 1;
        while (j >= 0 && dataset[j] > key) {
            dataset[j + 1] = dataset[j];
            j--;
        }
        dataset[j + 1] = key;
    }
}

int main() {
    std::vector<double> dataset = {37.74, 70.5, -18.87, 11.66, 93.67, 59.17, 73.92, -15.02, 5.12, 74.22, 24.7, 41.89};
    insertionSort(dataset);
    for (double v : dataset) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'dataset', 12 elements."
713,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& vals) {
    for (size_t i = 1; i < vals.size(); i++) {
        double key = vals[i];
        int j = (int) i - 1;
        while (j >= 0 && vals[j] > key) {
            vals[j + 1] = vals[j];
            j--;
        }
        vals[j + 1] = key;
    }
}

int main() {
    std::vector<double> vals = {11.63, 37.83, 70.07, 51.92, 20.05, 61.14, 20.83, 17.51, 8.51, 22.98, 27.42, 52.69};
    insertionSort(vals);
    for (double v : vals) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'vals', 12 elements."
714,C++,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& list1) {
    for (size_t i = 1; i < list1.size(); i++) {
        double key = list1[i];
        int j = (int) i - 1;
        while (j >= 0 && list1[j] > key) {
            list1[j + 1] = list1[j];
            j--;
        }
        list1[j + 1] = key;
    }
}

int main() {
    std::vector<double> list1 = {83.9, 75.95, -19.63, 83.59, 27.82, 79.42, 90.08, -16.94, -5.38, 43.14, 93.18, 69.42};
    insertionSort(list1);
    for (double v : list1) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'list1', 12 elements."
715,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& items) {
    for (size_t i = 1; i < items.size(); i++) {
        double key = items[i];
        int j = (int) i - 1;
        while (j >= 0 && items[j] > key) {
            items[j + 1] = items[j];
            j--;
        }
        items[j + 1] = key;
    }
}

int main() {
    std::vector<double> items = {23.84, 53.58, 58.41, 36.55, 29.16, 2.36, 97.36, 93.95, 76.7, -18.02, 22.86, -14.56, 76.1, 18.74, 32.87};
    insertionSort(items);
    for (double v : items) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'items', 15 elements."
716,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& elements) {
    for (size_t i = 1; i < elements.size(); i++) {
        double key = elements[i];
        int j = (int) i - 1;
        while (j >= 0 && elements[j] > key) {
            elements[j + 1] = elements[j];
            j--;
        }
        elements[j + 1] = key;
    }
}

int main() {
    std::vector<double> elements = {37.66, 67.97, 74.48, 21.45, 91.75, 92.04, 36.66, 58.34, 63.24, -8.05, 25.8, 52.25, 64.72, 83.51, 84.27};
    insertionSort(elements);
    for (double v : elements) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'elements', 15 elements."
717,C++,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& vals) {
    for (size_t i = 1; i < vals.size(); i++) {
        double key = vals[i];
        int j = (int) i - 1;
        while (j >= 0 && vals[j] > key) {
            vals[j + 1] = vals[j];
            j--;
        }
        vals[j + 1] = key;
    }
}

int main() {
    std::vector<double> vals = {81.96, 40.05, -4.78, 74.82, 15.86, 60.09, 45.3, 84.1, -0.0, 33.11, -6.23, 58.85, 8.67, 5.19, 69.64};
    insertionSort(vals);
    for (double v : vals) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'vals', 15 elements."
718,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& buffer) {
    for (size_t i = 1; i < buffer.size(); i++) {
        double key = buffer[i];
        int j = (int) i - 1;
        while (j >= 0 && buffer[j] > key) {
            buffer[j + 1] = buffer[j];
            j--;
        }
        buffer[j + 1] = key;
    }
}

int main() {
    std::vector<double> buffer = {63.29, -7.45, 98.21, -16.52, 90.55, 18.85, 25.64, 13.36, 65.58, 59.25, 93.23, 59.8, 59.19, 89.81, 55.39, 38.54, 74.67, 19.6, 6.63, 48.54};
    insertionSort(buffer);
    for (double v : buffer) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'buffer', 20 elements."
719,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& entries) {
    for (size_t i = 1; i < entries.size(); i++) {
        double key = entries[i];
        int j = (int) i - 1;
        while (j >= 0 && entries[j] > key) {
            entries[j + 1] = entries[j];
            j--;
        }
        entries[j + 1] = key;
    }
}

int main() {
    std::vector<double> entries = {51.48, 56.63, 24.86, 65.38, 67.58, 25.42, 56.41, 46.87, 81.88, 76.21, 6.6, -6.23, -9.57, -9.39, 68.13, 91.53, 68.61, -6.18, 23.76, 81.55};
    insertionSort(entries);
    for (double v : entries) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'entries', 20 elements."
720,C++,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"#include <iostream>
#include <vector>

void insertionSort(std::vector<double>& collection) {
    for (size_t i = 1; i < collection.size(); i++) {
        double key = collection[i];
        int j = (int) i - 1;
        while (j >= 0 && collection[j] > key) {
            collection[j + 1] = collection[j];
            j--;
        }
        collection[j + 1] = key;
    }
}

int main() {
    std::vector<double> collection = {48.65, -19.8, -12.64, 43.74, 80.81, 96.6, 18.04, 23.44, 60.84, 74.79, 41.85, 51.59, 6.43, 27.04, 44.06, 34.81, -2.78, 92.2, 79.63, 39.48};
    insertionSort(collection);
    for (double v : collection) std::cout << v << "" "";
    return 0;
}","Insertion sort on float data, variable named 'collection', 20 elements."
721,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"fn insertion_sort(dataset: &mut Vec<i32>) {
    for i in 1..dataset.len() {
        let key = dataset[i];
        let mut j = i as i32 - 1;
        while j >= 0 && dataset[j as usize] > key {
            dataset[(j + 1) as usize] = dataset[j as usize];
            j -= 1;
        }
        dataset[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut dataset = vec![-13, 22, -13, -42, 31];
    insertion_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Insertion sort on int data, variable named 'dataset', 5 elements."
722,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"fn insertion_sort(nums: &mut Vec<i32>) {
    for i in 1..nums.len() {
        let key = nums[i];
        let mut j = i as i32 - 1;
        while j >= 0 && nums[j as usize] > key {
            nums[(j + 1) as usize] = nums[j as usize];
            j -= 1;
        }
        nums[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut nums = vec![78, -19, 20, 96, 72];
    insertion_sort(&mut nums);
    println!(""{:?}"", nums);
}","Insertion sort on int data, variable named 'nums', 5 elements."
723,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of ints in ascending order using insertion sort.,"fn insertion_sort(buffer: &mut Vec<i32>) {
    for i in 1..buffer.len() {
        let key = buffer[i];
        let mut j = i as i32 - 1;
        while j >= 0 && buffer[j as usize] > key {
            buffer[(j + 1) as usize] = buffer[j as usize];
            j -= 1;
        }
        buffer[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut buffer = vec![5, 76, 24, 46, -35];
    insertion_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Insertion sort on int data, variable named 'buffer', 5 elements."
724,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"fn insertion_sort(vals: &mut Vec<i32>) {
    for i in 1..vals.len() {
        let key = vals[i];
        let mut j = i as i32 - 1;
        while j >= 0 && vals[j as usize] > key {
            vals[(j + 1) as usize] = vals[j as usize];
            j -= 1;
        }
        vals[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut vals = vec![35, -11, 3, 7, -37, -5, 74, 50];
    insertion_sort(&mut vals);
    println!(""{:?}"", vals);
}","Insertion sort on int data, variable named 'vals', 8 elements."
725,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"fn insertion_sort(nums: &mut Vec<i32>) {
    for i in 1..nums.len() {
        let key = nums[i];
        let mut j = i as i32 - 1;
        while j >= 0 && nums[j as usize] > key {
            nums[(j + 1) as usize] = nums[j as usize];
            j -= 1;
        }
        nums[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut nums = vec![-10, -45, 90, 50, 36, 58, 71, 39];
    insertion_sort(&mut nums);
    println!(""{:?}"", nums);
}","Insertion sort on int data, variable named 'nums', 8 elements."
726,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of ints in ascending order using insertion sort.,"fn insertion_sort(vals: &mut Vec<i32>) {
    for i in 1..vals.len() {
        let key = vals[i];
        let mut j = i as i32 - 1;
        while j >= 0 && vals[j as usize] > key {
            vals[(j + 1) as usize] = vals[j as usize];
            j -= 1;
        }
        vals[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut vals = vec![50, 50, -32, 85, 22, 22, -1, 90];
    insertion_sort(&mut vals);
    println!(""{:?}"", vals);
}","Insertion sort on int data, variable named 'vals', 8 elements."
727,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"fn insertion_sort(collection: &mut Vec<i32>) {
    for i in 1..collection.len() {
        let key = collection[i];
        let mut j = i as i32 - 1;
        while j >= 0 && collection[j as usize] > key {
            collection[(j + 1) as usize] = collection[j as usize];
            j -= 1;
        }
        collection[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut collection = vec![-26, -17, 32, 98, -37, 27, 67, -9, 97, -15];
    insertion_sort(&mut collection);
    println!(""{:?}"", collection);
}","Insertion sort on int data, variable named 'collection', 10 elements."
728,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"fn insertion_sort(dataset: &mut Vec<i32>) {
    for i in 1..dataset.len() {
        let key = dataset[i];
        let mut j = i as i32 - 1;
        while j >= 0 && dataset[j as usize] > key {
            dataset[(j + 1) as usize] = dataset[j as usize];
            j -= 1;
        }
        dataset[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut dataset = vec![73, 24, -13, 3, 5, 0, -48, 42, 97, -24];
    insertion_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Insertion sort on int data, variable named 'dataset', 10 elements."
729,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of ints in ascending order using insertion sort.,"fn insertion_sort(buffer: &mut Vec<i32>) {
    for i in 1..buffer.len() {
        let key = buffer[i];
        let mut j = i as i32 - 1;
        while j >= 0 && buffer[j as usize] > key {
            buffer[(j + 1) as usize] = buffer[j as usize];
            j -= 1;
        }
        buffer[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut buffer = vec![-13, 46, 59, -7, -36, -26, 41, 71, -5, -37];
    insertion_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Insertion sort on int data, variable named 'buffer', 10 elements."
730,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"fn insertion_sort(data: &mut Vec<i32>) {
    for i in 1..data.len() {
        let key = data[i];
        let mut j = i as i32 - 1;
        while j >= 0 && data[j as usize] > key {
            data[(j + 1) as usize] = data[j as usize];
            j -= 1;
        }
        data[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut data = vec![81, 36, 61, -12, 53, 12, -42, -20, 11, 51, 75, 27];
    insertion_sort(&mut data);
    println!(""{:?}"", data);
}","Insertion sort on int data, variable named 'data', 12 elements."
731,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"fn insertion_sort(seq: &mut Vec<i32>) {
    for i in 1..seq.len() {
        let key = seq[i];
        let mut j = i as i32 - 1;
        while j >= 0 && seq[j as usize] > key {
            seq[(j + 1) as usize] = seq[j as usize];
            j -= 1;
        }
        seq[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut seq = vec![-6, 46, -28, 68, 47, 20, 63, 44, -48, -20, -21, -29];
    insertion_sort(&mut seq);
    println!(""{:?}"", seq);
}","Insertion sort on int data, variable named 'seq', 12 elements."
732,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of ints in ascending order using insertion sort.,"fn insertion_sort(data: &mut Vec<i32>) {
    for i in 1..data.len() {
        let key = data[i];
        let mut j = i as i32 - 1;
        while j >= 0 && data[j as usize] > key {
            data[(j + 1) as usize] = data[j as usize];
            j -= 1;
        }
        data[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut data = vec![75, 80, 7, -45, 96, 96, 72, 20, -26, -4, 48, 73];
    insertion_sort(&mut data);
    println!(""{:?}"", data);
}","Insertion sort on int data, variable named 'data', 12 elements."
733,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"fn insertion_sort(buffer: &mut Vec<i32>) {
    for i in 1..buffer.len() {
        let key = buffer[i];
        let mut j = i as i32 - 1;
        while j >= 0 && buffer[j as usize] > key {
            buffer[(j + 1) as usize] = buffer[j as usize];
            j -= 1;
        }
        buffer[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut buffer = vec![61, 26, 96, -18, -25, 33, -34, 87, -3, 53, -45, 50, 92, 87, 85];
    insertion_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Insertion sort on int data, variable named 'buffer', 15 elements."
734,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"fn insertion_sort(dataset: &mut Vec<i32>) {
    for i in 1..dataset.len() {
        let key = dataset[i];
        let mut j = i as i32 - 1;
        while j >= 0 && dataset[j as usize] > key {
            dataset[(j + 1) as usize] = dataset[j as usize];
            j -= 1;
        }
        dataset[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut dataset = vec![-34, 82, 99, 87, -19, 3, -20, -4, -4, -49, 92, 64, 30, -19, -40];
    insertion_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Insertion sort on int data, variable named 'dataset', 15 elements."
735,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of ints in ascending order using insertion sort.,"fn insertion_sort(values: &mut Vec<i32>) {
    for i in 1..values.len() {
        let key = values[i];
        let mut j = i as i32 - 1;
        while j >= 0 && values[j as usize] > key {
            values[(j + 1) as usize] = values[j as usize];
            j -= 1;
        }
        values[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut values = vec![97, 2, -9, -28, 93, 15, -42, -29, -19, 79, 26, 43, 89, -7, 58];
    insertion_sort(&mut values);
    println!(""{:?}"", values);
}","Insertion sort on int data, variable named 'values', 15 elements."
736,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"fn insertion_sort(buffer: &mut Vec<i32>) {
    for i in 1..buffer.len() {
        let key = buffer[i];
        let mut j = i as i32 - 1;
        while j >= 0 && buffer[j as usize] > key {
            buffer[(j + 1) as usize] = buffer[j as usize];
            j -= 1;
        }
        buffer[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut buffer = vec![-50, 13, 26, -39, 82, 25, 86, 63, -15, 97, 75, 30, 83, 40, 87, 80, 3, -25, -39, 10];
    insertion_sort(&mut buffer);
    println!(""{:?}"", buffer);
}","Insertion sort on int data, variable named 'buffer', 20 elements."
737,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"fn insertion_sort(arr: &mut Vec<i32>) {
    for i in 1..arr.len() {
        let key = arr[i];
        let mut j = i as i32 - 1;
        while j >= 0 && arr[j as usize] > key {
            arr[(j + 1) as usize] = arr[j as usize];
            j -= 1;
        }
        arr[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut arr = vec![-2, -14, 26, 5, -16, 91, 5, 41, 21, -18, 58, -31, 90, 15, 16, 47, -9, 52, 66, -29];
    insertion_sort(&mut arr);
    println!(""{:?}"", arr);
}","Insertion sort on int data, variable named 'arr', 20 elements."
738,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of ints in ascending order using insertion sort.,"fn insertion_sort(nums: &mut Vec<i32>) {
    for i in 1..nums.len() {
        let key = nums[i];
        let mut j = i as i32 - 1;
        while j >= 0 && nums[j as usize] > key {
            nums[(j + 1) as usize] = nums[j as usize];
            j -= 1;
        }
        nums[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut nums = vec![58, -14, 87, 2, -32, 18, -1, 45, 94, 80, -9, 57, -11, 30, 61, 47, -44, 13, -31, 19];
    insertion_sort(&mut nums);
    println!(""{:?}"", nums);
}","Insertion sort on int data, variable named 'nums', 20 elements."
739,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"fn insertion_sort(data: &mut Vec<f64>) {
    for i in 1..data.len() {
        let key = data[i];
        let mut j = i as i32 - 1;
        while j >= 0 && data[j as usize] > key {
            data[(j + 1) as usize] = data[j as usize];
            j -= 1;
        }
        data[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut data = vec![43.24, 61.39, 28.41, 19.19, -9.41];
    insertion_sort(&mut data);
    println!(""{:?}"", data);
}","Insertion sort on float data, variable named 'data', 5 elements."
740,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"fn insertion_sort(entries: &mut Vec<f64>) {
    for i in 1..entries.len() {
        let key = entries[i];
        let mut j = i as i32 - 1;
        while j >= 0 && entries[j as usize] > key {
            entries[(j + 1) as usize] = entries[j as usize];
            j -= 1;
        }
        entries[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut entries = vec![19.69, 12.52, 83.39, 6.87, -18.83];
    insertion_sort(&mut entries);
    println!(""{:?}"", entries);
}","Insertion sort on float data, variable named 'entries', 5 elements."
741,Rust,Sorting Algorithm,intermediate,Sort a 5-element array of floats in ascending order using insertion sort.,"fn insertion_sort(collection: &mut Vec<f64>) {
    for i in 1..collection.len() {
        let key = collection[i];
        let mut j = i as i32 - 1;
        while j >= 0 && collection[j as usize] > key {
            collection[(j + 1) as usize] = collection[j as usize];
            j -= 1;
        }
        collection[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut collection = vec![96.56, 6.44, 93.26, 73.15, -5.3];
    insertion_sort(&mut collection);
    println!(""{:?}"", collection);
}","Insertion sort on float data, variable named 'collection', 5 elements."
742,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"fn insertion_sort(input_arr: &mut Vec<f64>) {
    for i in 1..input_arr.len() {
        let key = input_arr[i];
        let mut j = i as i32 - 1;
        while j >= 0 && input_arr[j as usize] > key {
            input_arr[(j + 1) as usize] = input_arr[j as usize];
            j -= 1;
        }
        input_arr[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut input_arr = vec![66.67, 16.48, 77.74, 38.26, 42.95, 63.35, 82.98, 45.63];
    insertion_sort(&mut input_arr);
    println!(""{:?}"", input_arr);
}","Insertion sort on float data, variable named 'input_arr', 8 elements."
743,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"fn insertion_sort(elements: &mut Vec<f64>) {
    for i in 1..elements.len() {
        let key = elements[i];
        let mut j = i as i32 - 1;
        while j >= 0 && elements[j as usize] > key {
            elements[(j + 1) as usize] = elements[j as usize];
            j -= 1;
        }
        elements[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut elements = vec![-8.21, -14.29, 17.84, 69.47, 1.5, 75.92, 60.66, 73.86];
    insertion_sort(&mut elements);
    println!(""{:?}"", elements);
}","Insertion sort on float data, variable named 'elements', 8 elements."
744,Rust,Sorting Algorithm,intermediate,Sort a 8-element array of floats in ascending order using insertion sort.,"fn insertion_sort(input_arr: &mut Vec<f64>) {
    for i in 1..input_arr.len() {
        let key = input_arr[i];
        let mut j = i as i32 - 1;
        while j >= 0 && input_arr[j as usize] > key {
            input_arr[(j + 1) as usize] = input_arr[j as usize];
            j -= 1;
        }
        input_arr[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut input_arr = vec![50.76, 81.11, 36.75, -4.82, -18.87, 41.11, -1.5, -4.96];
    insertion_sort(&mut input_arr);
    println!(""{:?}"", input_arr);
}","Insertion sort on float data, variable named 'input_arr', 8 elements."
745,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"fn insertion_sort(collection: &mut Vec<f64>) {
    for i in 1..collection.len() {
        let key = collection[i];
        let mut j = i as i32 - 1;
        while j >= 0 && collection[j as usize] > key {
            collection[(j + 1) as usize] = collection[j as usize];
            j -= 1;
        }
        collection[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut collection = vec![47.54, 11.82, 89.29, 56.06, 24.05, 72.53, 60.71, 29.77, 34.48, 32.24];
    insertion_sort(&mut collection);
    println!(""{:?}"", collection);
}","Insertion sort on float data, variable named 'collection', 10 elements."
746,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"fn insertion_sort(list1: &mut Vec<f64>) {
    for i in 1..list1.len() {
        let key = list1[i];
        let mut j = i as i32 - 1;
        while j >= 0 && list1[j as usize] > key {
            list1[(j + 1) as usize] = list1[j as usize];
            j -= 1;
        }
        list1[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut list1 = vec![75.02, 39.77, 12.82, 30.9, 92.06, 84.89, 76.87, 16.32, 82.09, 92.75];
    insertion_sort(&mut list1);
    println!(""{:?}"", list1);
}","Insertion sort on float data, variable named 'list1', 10 elements."
747,Rust,Sorting Algorithm,intermediate,Sort a 10-element array of floats in ascending order using insertion sort.,"fn insertion_sort(collection: &mut Vec<f64>) {
    for i in 1..collection.len() {
        let key = collection[i];
        let mut j = i as i32 - 1;
        while j >= 0 && collection[j as usize] > key {
            collection[(j + 1) as usize] = collection[j as usize];
            j -= 1;
        }
        collection[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut collection = vec![71.7, 80.58, 55.53, -10.87, 8.56, -8.86, 48.46, -9.93, 14.02, 90.62];
    insertion_sort(&mut collection);
    println!(""{:?}"", collection);
}","Insertion sort on float data, variable named 'collection', 10 elements."
748,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"fn insertion_sort(vals: &mut Vec<f64>) {
    for i in 1..vals.len() {
        let key = vals[i];
        let mut j = i as i32 - 1;
        while j >= 0 && vals[j as usize] > key {
            vals[(j + 1) as usize] = vals[j as usize];
            j -= 1;
        }
        vals[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut vals = vec![84.05, 94.5, 30.45, 40.53, 66.96, 37.08, 41.29, 98.76, 85.68, 63.05, 28.25, 53.34];
    insertion_sort(&mut vals);
    println!(""{:?}"", vals);
}","Insertion sort on float data, variable named 'vals', 12 elements."
749,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"fn insertion_sort(entries: &mut Vec<f64>) {
    for i in 1..entries.len() {
        let key = entries[i];
        let mut j = i as i32 - 1;
        while j >= 0 && entries[j as usize] > key {
            entries[(j + 1) as usize] = entries[j as usize];
            j -= 1;
        }
        entries[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut entries = vec![78.94, -19.13, 30.57, 43.58, 21.06, 98.31, 58.68, 89.53, 98.9, 92.45, 61.41, -14.96];
    insertion_sort(&mut entries);
    println!(""{:?}"", entries);
}","Insertion sort on float data, variable named 'entries', 12 elements."
750,Rust,Sorting Algorithm,intermediate,Sort a 12-element array of floats in ascending order using insertion sort.,"fn insertion_sort(dataset: &mut Vec<f64>) {
    for i in 1..dataset.len() {
        let key = dataset[i];
        let mut j = i as i32 - 1;
        while j >= 0 && dataset[j as usize] > key {
            dataset[(j + 1) as usize] = dataset[j as usize];
            j -= 1;
        }
        dataset[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut dataset = vec![94.79, 60.27, 84.95, 42.3, 6.78, -11.06, 79.89, 41.13, 93.35, 30.3, 25.11, 24.42];
    insertion_sort(&mut dataset);
    println!(""{:?}"", dataset);
}","Insertion sort on float data, variable named 'dataset', 12 elements."
751,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"fn insertion_sort(data: &mut Vec<f64>) {
    for i in 1..data.len() {
        let key = data[i];
        let mut j = i as i32 - 1;
        while j >= 0 && data[j as usize] > key {
            data[(j + 1) as usize] = data[j as usize];
            j -= 1;
        }
        data[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut data = vec![20.22, 60.81, 78.98, 81.24, 82.08, 14.52, 37.49, 11.51, -19.73, 55.11, 26.84, 89.84, 90.56, 94.14, 41.35];
    insertion_sort(&mut data);
    println!(""{:?}"", data);
}","Insertion sort on float data, variable named 'data', 15 elements."
752,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"fn insertion_sort(entries: &mut Vec<f64>) {
    for i in 1..entries.len() {
        let key = entries[i];
        let mut j = i as i32 - 1;
        while j >= 0 && entries[j as usize] > key {
            entries[(j + 1) as usize] = entries[j as usize];
            j -= 1;
        }
        entries[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut entries = vec![-15.78, 35.1, 53.51, 38.1, 22.33, 53.25, 19.1, 22.11, -19.39, 85.93, 2.15, 22.19, -7.94, 38.55, -9.92];
    insertion_sort(&mut entries);
    println!(""{:?}"", entries);
}","Insertion sort on float data, variable named 'entries', 15 elements."
753,Rust,Sorting Algorithm,intermediate,Sort a 15-element array of floats in ascending order using insertion sort.,"fn insertion_sort(input_arr: &mut Vec<f64>) {
    for i in 1..input_arr.len() {
        let key = input_arr[i];
        let mut j = i as i32 - 1;
        while j >= 0 && input_arr[j as usize] > key {
            input_arr[(j + 1) as usize] = input_arr[j as usize];
            j -= 1;
        }
        input_arr[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut input_arr = vec![86.92, 28.88, 88.66, -19.18, 71.56, 9.77, 36.01, 24.54, 23.37, 86.17, 43.83, 12.07, 97.73, 58.1, 32.28];
    insertion_sort(&mut input_arr);
    println!(""{:?}"", input_arr);
}","Insertion sort on float data, variable named 'input_arr', 15 elements."
754,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"fn insertion_sort(values: &mut Vec<f64>) {
    for i in 1..values.len() {
        let key = values[i];
        let mut j = i as i32 - 1;
        while j >= 0 && values[j as usize] > key {
            values[(j + 1) as usize] = values[j as usize];
            j -= 1;
        }
        values[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut values = vec![22.09, 31.64, 22.75, 83.59, 3.62, 2.56, -15.21, 26.95, 68.53, 87.22, -0.92, 3.68, 37.04, 59.16, 11.63, 30.11, 45.46, 75.18, 65.0, 18.66];
    insertion_sort(&mut values);
    println!(""{:?}"", values);
}","Insertion sort on float data, variable named 'values', 20 elements."
755,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"fn insertion_sort(vals: &mut Vec<f64>) {
    for i in 1..vals.len() {
        let key = vals[i];
        let mut j = i as i32 - 1;
        while j >= 0 && vals[j as usize] > key {
            vals[(j + 1) as usize] = vals[j as usize];
            j -= 1;
        }
        vals[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut vals = vec![72.86, 27.59, 66.39, 68.29, 78.25, -4.36, 93.96, 74.33, -4.99, 20.95, -18.38, 61.45, -13.81, 78.75, 31.13, 51.05, -19.04, 37.14, 13.58, -10.17];
    insertion_sort(&mut vals);
    println!(""{:?}"", vals);
}","Insertion sort on float data, variable named 'vals', 20 elements."
756,Rust,Sorting Algorithm,intermediate,Sort a 20-element array of floats in ascending order using insertion sort.,"fn insertion_sort(collection: &mut Vec<f64>) {
    for i in 1..collection.len() {
        let key = collection[i];
        let mut j = i as i32 - 1;
        while j >= 0 && collection[j as usize] > key {
            collection[(j + 1) as usize] = collection[j as usize];
            j -= 1;
        }
        collection[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut collection = vec![9.48, -1.85, 40.84, 9.69, 71.24, 82.84, 98.32, 9.44, 77.65, 3.61, 64.07, 76.38, 63.44, 39.78, 1.56, 98.11, 50.35, 55.5, 7.3, -4.26];
    insertion_sort(&mut collection);
    println!(""{:?}"", collection);
}","Insertion sort on float data, variable named 'collection', 20 elements."
757,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(36)
s.push(25)
s.push(19)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
758,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(79)
s.push(26)
s.push(12)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
759,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class Box_Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = Box_Stack()
s.push(53)
s.push(68)
s.push(40)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
760,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class CollStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = CollStack()
s.push(30)
s.push(29)
s.push(44)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
761,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = Box_Stack()
s.push(8)
s.push(66)
print(s.pop())
s.push(83)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
762,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(15)
s.push(35)
print(s.pop())
s.push(36)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
763,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class CollStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = CollStack()
s.push(54)
s.push(32)
print(s.pop())
s.push(7)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
764,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(1)
s.push(7)
print(s.pop())
s.push(96)
print(s.pop())","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
765,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class SStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = SStack()
s.push(37)
s.push(61)
s.push(36)
s.push(78)
print(s.pop())
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
766,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class SStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = SStack()
s.push(33)
s.push(63)
s.push(47)
s.push(43)
print(s.pop())
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
767,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(86)
s.push(2)
s.push(88)
s.push(71)
print(s.pop())
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
768,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(47)
s.push(95)
s.push(47)
s.push(96)
print(s.pop())
print(s.pop())","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
769,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(78)
print(s.pop())
s.push(31)
s.push(84)","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
770,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(27)
print(s.pop())
s.push(50)
s.push(12)","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
771,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(17)
print(s.pop())
s.push(96)
s.push(78)","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
772,Python,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(6)
print(s.pop())
s.push(84)
s.push(25)","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
773,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class SStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = SStack()
s.push(70.76)
s.push(92.62)
s.push(8.41)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
774,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(30.85)
s.push(47.95)
s.push(76.34)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
775,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class SStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = SStack()
s.push(5.34)
s.push(19.98)
s.push(55.5)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
776,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(97.54)
s.push(89.6)
s.push(45.4)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
777,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class Box_Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = Box_Stack()
s.push(7.7)
s.push(42.48)
print(s.pop())
s.push(50.88)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
778,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(28.14)
s.push(96.78)
print(s.pop())
s.push(95.62)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
779,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class CollStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = CollStack()
s.push(19.83)
s.push(81.64)
print(s.pop())
s.push(53.71)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
780,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(17.39)
s.push(75.32)
print(s.pop())
s.push(78.16)
print(s.pop())","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
781,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(21.49)
s.push(1.36)
s.push(57.62)
s.push(59.62)
print(s.pop())
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
782,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(46.09)
s.push(71.07)
s.push(52.98)
s.push(31.04)
print(s.pop())
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
783,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(12.79)
s.push(23.17)
s.push(53.82)
s.push(29.89)
print(s.pop())
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
784,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(92.8)
s.push(27.77)
s.push(79.27)
s.push(64.6)
print(s.pop())
print(s.pop())","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
785,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class ContainerStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = ContainerStack()
s.push(12.5)
print(s.pop())
s.push(63.64)
s.push(97.25)","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
786,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class BufStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = BufStack()
s.push(9.24)
print(s.pop())
s.push(55.38)
s.push(72.49)","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
787,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class Box_Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = Box_Stack()
s.push(89.94)
print(s.pop())
s.push(98.54)
s.push(62.97)","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
788,Python,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class QStack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1]

s = QStack()
s.push(82.57)
print(s.pop())
s.push(96.56)
s.push(18.5)","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
789,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(69);
s.push(85);
s.push(100);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
790,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new ContainerStack();
s.push(14);
s.push(93);
s.push(96);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
791,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(84);
s.push(33);
s.push(81);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
792,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new ContainerStack();
s.push(71);
s.push(27);
s.push(57);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
793,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new BufStack();
s.push(35);
s.push(27);
console.log(s.pop());
s.push(81);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
794,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(20);
s.push(58);
console.log(s.pop());
s.push(94);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
795,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(48);
s.push(19);
console.log(s.pop());
s.push(12);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
796,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(59);
s.push(24);
console.log(s.pop());
s.push(25);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
797,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(94);
s.push(24);
s.push(83);
s.push(37);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
798,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(23);
s.push(51);
s.push(88);
s.push(78);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
799,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(10);
s.push(55);
s.push(32);
s.push(59);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
800,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(93);
s.push(68);
s.push(18);
s.push(94);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
801,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new ContainerStack();
s.push(13);
console.log(s.pop());
s.push(50);
s.push(3);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
802,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(2);
console.log(s.pop());
s.push(83);
s.push(6);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
803,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(32);
console.log(s.pop());
s.push(11);
s.push(35);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
804,JavaScript,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(81);
console.log(s.pop());
s.push(2);
s.push(2);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
805,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(54.69);
s.push(82.01);
s.push(85.42);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
806,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(48.56);
s.push(56.72);
s.push(44.99);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
807,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new BufStack();
s.push(48.41);
s.push(25.14);
s.push(54.81);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
808,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new ContainerStack();
s.push(13.18);
s.push(82.67);
s.push(11.18);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
809,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new ContainerStack();
s.push(88.76);
s.push(42.11);
console.log(s.pop());
s.push(23.21);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
810,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(15.59);
s.push(65.88);
console.log(s.pop());
s.push(88.02);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
811,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new CollStack();
s.push(82.46);
s.push(12.13);
console.log(s.pop());
s.push(11.9);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
812,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new BufStack();
s.push(36.37);
s.push(61.95);
console.log(s.pop());
s.push(92.41);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
813,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(60.85);
s.push(18.63);
s.push(53.52);
s.push(60.36);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
814,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new CollStack();
s.push(69.03);
s.push(62.85);
s.push(29.41);
s.push(87.66);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
815,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new BufStack();
s.push(93.36);
s.push(81.26);
s.push(71.42);
s.push(8.56);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
816,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(78.0);
s.push(15.51);
s.push(15.63);
s.push(45.22);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
817,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new QStack();
s.push(12.2);
console.log(s.pop());
s.push(72.94);
s.push(15.32);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
818,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new BufStack();
s.push(99.48);
console.log(s.pop());
s.push(39.12);
s.push(32.61);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
819,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new Box_Stack();
s.push(48.65);
console.log(s.pop());
s.push(60.57);
s.push(64.02);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
820,JavaScript,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

const s = new SStack();
s.push(80.41);
console.log(s.pop());
s.push(25.34);
s.push(42.45);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
821,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(69);
s.push(69);
s.push(64);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
822,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { ContainerStack };
const s = new ContainerStack();
s.push(30);
s.push(50);
s.push(11);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
823,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(54);
s.push(68);
s.push(74);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
824,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(96);
s.push(29);
s.push(90);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
825,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { SStack };
const s = new SStack();
s.push(47);
s.push(1);
console.log(s.pop());
s.push(3);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
826,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { ContainerStack };
const s = new ContainerStack();
s.push(61);
s.push(18);
console.log(s.pop());
s.push(8);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
827,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { BufStack };
const s = new BufStack();
s.push(100);
s.push(18);
console.log(s.pop());
s.push(59);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
828,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { ContainerStack };
const s = new ContainerStack();
s.push(54);
s.push(32);
console.log(s.pop());
s.push(29);
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
829,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(18);
s.push(16);
s.push(90);
s.push(91);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
830,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(4);
s.push(90);
s.push(55);
s.push(48);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
831,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(85);
s.push(75);
s.push(10);
s.push(62);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
832,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(19);
s.push(47);
s.push(19);
s.push(11);
console.log(s.pop());
console.log(s.pop());","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
833,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(73);
console.log(s.pop());
s.push(20);
s.push(98);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
834,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { SStack };
const s = new SStack();
s.push(61);
console.log(s.pop());
s.push(18);
s.push(96);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
835,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class ContainerStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { ContainerStack };
const s = new ContainerStack();
s.push(90);
console.log(s.pop());
s.push(61);
s.push(53);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
836,Node.js,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(44);
console.log(s.pop());
s.push(83);
s.push(89);","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
837,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(29.39);
s.push(16.43);
s.push(88.23);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
838,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { SStack };
const s = new SStack();
s.push(50.83);
s.push(2.08);
s.push(83.44);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
839,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(55.86);
s.push(83.12);
s.push(92.0);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
840,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(23.5);
s.push(93.21);
s.push(27.91);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
841,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(97.81);
s.push(13.39);
console.log(s.pop());
s.push(62.29);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
842,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { SStack };
const s = new SStack();
s.push(82.43);
s.push(97.62);
console.log(s.pop());
s.push(8.64);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
843,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(32.01);
s.push(64.55);
console.log(s.pop());
s.push(17.32);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
844,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","class CollStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { CollStack };
const s = new CollStack();
s.push(43.0);
s.push(27.72);
console.log(s.pop());
s.push(36.91);
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
845,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { BufStack };
const s = new BufStack();
s.push(3.78);
s.push(28.94);
s.push(54.62);
s.push(7.47);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
846,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { BufStack };
const s = new BufStack();
s.push(19.59);
s.push(20.97);
s.push(92.99);
s.push(24.79);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
847,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(56.81);
s.push(79.23);
s.push(5.52);
s.push(32.14);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
848,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { BufStack };
const s = new BufStack();
s.push(75.42);
s.push(95.92);
s.push(50.52);
s.push(32.13);
console.log(s.pop());
console.log(s.pop());","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
849,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class SStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { SStack };
const s = new SStack();
s.push(70.56);
console.log(s.pop());
s.push(41.32);
s.push(74.4);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
850,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class QStack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { QStack };
const s = new QStack();
s.push(50.72);
console.log(s.pop());
s.push(3.34);
s.push(79.81);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
851,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(59.05);
console.log(s.pop());
s.push(29.72);
s.push(16.0);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
852,Node.js,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","class Box_Stack {
  #items = [];
  push(item) { this.#items.push(item); }
  pop() { return this.#items.pop(); }
  peek() { return this.#items[this.#items.length - 1]; }
}

module.exports = { Box_Stack };
const s = new Box_Stack();
s.push(8.8);
console.log(s.pop());
s.push(95.33);
s.push(23.93);","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
853,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> s = new ArrayDeque<>();
                s.push(88);
        s.push(84);
        s.push(19);
        System.out.println(s.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
854,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> coll = new ArrayDeque<>();
                coll.push(21);
        coll.push(65);
        coll.push(67);
        System.out.println(coll.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
855,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> container = new ArrayDeque<>();
                container.push(84);
        container.push(67);
        container.push(99);
        System.out.println(container.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
856,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> box_ = new ArrayDeque<>();
                box_.push(17);
        box_.push(44);
        box_.push(38);
        System.out.println(box_.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
857,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> container = new ArrayDeque<>();
                container.push(56);
        container.push(6);
        System.out.println(container.pop());
        container.push(100);
        System.out.println(container.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
858,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> box_ = new ArrayDeque<>();
                box_.push(31);
        box_.push(27);
        System.out.println(box_.pop());
        box_.push(78);
        System.out.println(box_.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
859,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> s = new ArrayDeque<>();
                s.push(73);
        s.push(81);
        System.out.println(s.pop());
        s.push(13);
        System.out.println(s.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
860,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> s = new ArrayDeque<>();
                s.push(99);
        s.push(40);
        System.out.println(s.pop());
        s.push(12);
        System.out.println(s.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
861,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> q = new ArrayDeque<>();
                q.push(59);
        q.push(41);
        q.push(22);
        q.push(38);
        System.out.println(q.pop());
        System.out.println(q.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
862,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> buf = new ArrayDeque<>();
                buf.push(74);
        buf.push(47);
        buf.push(46);
        buf.push(12);
        System.out.println(buf.pop());
        System.out.println(buf.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
863,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> coll = new ArrayDeque<>();
                coll.push(99);
        coll.push(59);
        coll.push(34);
        coll.push(61);
        System.out.println(coll.pop());
        System.out.println(coll.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
864,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> box_ = new ArrayDeque<>();
                box_.push(84);
        box_.push(18);
        box_.push(16);
        box_.push(73);
        System.out.println(box_.pop());
        System.out.println(box_.pop());
    }
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
865,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> buf = new ArrayDeque<>();
                buf.push(37);
        System.out.println(buf.pop());
        buf.push(53);
        buf.push(80);
    }
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
866,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> coll = new ArrayDeque<>();
                coll.push(17);
        System.out.println(coll.pop());
        coll.push(47);
        coll.push(66);
    }
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
867,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> container = new ArrayDeque<>();
                container.push(41);
        System.out.println(container.pop());
        container.push(11);
        container.push(88);
    }
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
868,Java,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> box_ = new ArrayDeque<>();
                box_.push(65);
        System.out.println(box_.pop());
        box_.push(34);
        box_.push(88);
    }
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
869,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> q = new ArrayDeque<>();
                q.push(62.44);
        q.push(64.74);
        q.push(74.36);
        System.out.println(q.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
870,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> container = new ArrayDeque<>();
                container.push(1.79);
        container.push(85.45);
        container.push(29.78);
        System.out.println(container.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
871,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> box_ = new ArrayDeque<>();
                box_.push(85.53);
        box_.push(23.08);
        box_.push(87.54);
        System.out.println(box_.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
872,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> buf = new ArrayDeque<>();
                buf.push(47.12);
        buf.push(64.61);
        buf.push(90.11);
        System.out.println(buf.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'pop']."
873,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> q = new ArrayDeque<>();
                q.push(18.85);
        q.push(11.73);
        System.out.println(q.pop());
        q.push(40.3);
        System.out.println(q.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
874,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> box_ = new ArrayDeque<>();
                box_.push(33.54);
        box_.push(32.41);
        System.out.println(box_.pop());
        box_.push(49.14);
        System.out.println(box_.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
875,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> box_ = new ArrayDeque<>();
                box_.push(12.32);
        box_.push(46.0);
        System.out.println(box_.pop());
        box_.push(94.9);
        System.out.println(box_.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
876,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> s = new ArrayDeque<>();
                s.push(32.7);
        s.push(4.1);
        System.out.println(s.pop());
        s.push(38.65);
        System.out.println(s.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
877,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> buf = new ArrayDeque<>();
                buf.push(79.17);
        buf.push(97.88);
        buf.push(22.13);
        buf.push(21.94);
        System.out.println(buf.pop());
        System.out.println(buf.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
878,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> box_ = new ArrayDeque<>();
                box_.push(27.71);
        box_.push(63.93);
        box_.push(9.28);
        box_.push(7.86);
        System.out.println(box_.pop());
        System.out.println(box_.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
879,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> coll = new ArrayDeque<>();
                coll.push(45.69);
        coll.push(42.55);
        coll.push(22.2);
        coll.push(89.41);
        System.out.println(coll.pop());
        System.out.println(coll.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
880,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> box_ = new ArrayDeque<>();
                box_.push(34.86);
        box_.push(75.56);
        box_.push(17.29);
        box_.push(35.58);
        System.out.println(box_.pop());
        System.out.println(box_.pop());
    }
}","Stack with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
881,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> coll = new ArrayDeque<>();
                coll.push(78.6);
        System.out.println(coll.pop());
        coll.push(44.24);
        coll.push(91.35);
    }
}","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
882,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> container = new ArrayDeque<>();
                container.push(39.52);
        System.out.println(container.pop());
        container.push(78.52);
        container.push(60.12);
    }
}","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
883,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> q = new ArrayDeque<>();
                q.push(72.55);
        System.out.println(q.pop());
        q.push(15.32);
        q.push(66.74);
    }
}","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
884,Java,Data Structures,intermediate,"Implement a stack of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Deque<Double> coll = new ArrayDeque<>();
                coll.push(74.54);
        System.out.println(coll.pop());
        coll.push(32.34);
        coll.push(15.9);
    }
}","Stack with float elements, ops=['push', 'pop', 'push', 'push']."
885,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack box_ = { .top = -1 };
        push(&box_, 19);
    push(&box_, 64);
    push(&box_, 41);
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
886,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack coll = { .top = -1 };
        push(&coll, 53);
    push(&coll, 34);
    push(&coll, 67);
    printf(""%g\n"", (double)pop(&coll));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
887,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack q = { .top = -1 };
        push(&q, 58);
    push(&q, 17);
    push(&q, 82);
    printf(""%g\n"", (double)pop(&q));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
888,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack coll = { .top = -1 };
        push(&coll, 75);
    push(&coll, 13);
    push(&coll, 5);
    printf(""%g\n"", (double)pop(&coll));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'pop']."
889,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack coll = { .top = -1 };
        push(&coll, 25);
    push(&coll, 54);
    printf(""%g\n"", (double)pop(&coll));
    push(&coll, 70);
    printf(""%g\n"", (double)pop(&coll));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
890,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack s = { .top = -1 };
        push(&s, 77);
    push(&s, 49);
    printf(""%g\n"", (double)pop(&s));
    push(&s, 45);
    printf(""%g\n"", (double)pop(&s));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
891,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack s = { .top = -1 };
        push(&s, 87);
    push(&s, 74);
    printf(""%g\n"", (double)pop(&s));
    push(&s, 48);
    printf(""%g\n"", (double)pop(&s));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
892,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack q = { .top = -1 };
        push(&q, 39);
    push(&q, 40);
    printf(""%g\n"", (double)pop(&q));
    push(&q, 16);
    printf(""%g\n"", (double)pop(&q));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
893,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack box_ = { .top = -1 };
        push(&box_, 84);
    push(&box_, 59);
    push(&box_, 53);
    push(&box_, 53);
    printf(""%g\n"", (double)pop(&box_));
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
894,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack container = { .top = -1 };
        push(&container, 55);
    push(&container, 67);
    push(&container, 98);
    push(&container, 43);
    printf(""%g\n"", (double)pop(&container));
    printf(""%g\n"", (double)pop(&container));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
895,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack box_ = { .top = -1 };
        push(&box_, 55);
    push(&box_, 48);
    push(&box_, 23);
    push(&box_, 71);
    printf(""%g\n"", (double)pop(&box_));
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
896,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack container = { .top = -1 };
        push(&container, 56);
    push(&container, 49);
    push(&container, 37);
    push(&container, 85);
    printf(""%g\n"", (double)pop(&container));
    printf(""%g\n"", (double)pop(&container));
    return 0;
}","Stack with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
897,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack box_ = { .top = -1 };
        push(&box_, 82);
    printf(""%g\n"", (double)pop(&box_));
    push(&box_, 90);
    push(&box_, 80);
    return 0;
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
898,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack q = { .top = -1 };
        push(&q, 12);
    printf(""%g\n"", (double)pop(&q));
    push(&q, 12);
    push(&q, 84);
    return 0;
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
899,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack q = { .top = -1 };
        push(&q, 79);
    printf(""%g\n"", (double)pop(&q));
    push(&q, 14);
    push(&q, 64);
    return 0;
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
900,C,Data Structures,intermediate,"Implement a stack of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int top; } Stack;

void push(Stack* s, int value) { s->items[++s->top] = value; }
int pop(Stack* s) { return s->items[s->top--]; }

int main(void) {
    Stack coll = { .top = -1 };
        push(&coll, 97);
    printf(""%g\n"", (double)pop(&coll));
    push(&coll, 70);
    push(&coll, 13);
    return 0;
}","Stack with int elements, ops=['push', 'pop', 'push', 'push']."
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(&coll, 4.23);
    printf(""%g\n"", (double)pop(&coll));
    return 0;
}","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(&box_, 55.61);
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","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(&box_, 79.58);
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","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(&coll, 1.75);
    printf(""%g\n"", (double)pop(&coll));
    return 0;
}","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"", (double)pop(&s));
    push(&s, 31.43);
    printf(""%g\n"", (double)pop(&s));
    return 0;
}","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(""%g\n"", (double)pop(&box_));
    push(&box_, 4.23);
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","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(""%g\n"", (double)pop(&buf));
    push(&buf, 32.43);
    printf(""%g\n"", (double)pop(&buf));
    return 0;
}","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.94);
    printf(""%g\n"", (double)pop(&container));
    push(&container, 20.07);
    printf(""%g\n"", (double)pop(&container));
    return 0;
}","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);
    push(&q, 63.99);
    printf(""%g\n"", (double)pop(&q));
    printf(""%g\n"", (double)pop(&q));
    return 0;
}","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, 10.86);
    push(&buf, 80.32);
    printf(""%g\n"", (double)pop(&buf));
    printf(""%g\n"", (double)pop(&buf));
    return 0;
}","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(&box_, 26.76);
    push(&box_, 55.74);
    printf(""%g\n"", (double)pop(&box_));
    printf(""%g\n"", (double)pop(&box_));
    return 0;
}","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);
    push(&q, 16.15);
    printf(""%g\n"", (double)pop(&q));
    printf(""%g\n"", (double)pop(&q));
    return 0;
}","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));
    push(&q, 73.68);
    push(&q, 98.36);
    return 0;
}","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(&coll));
    push(&coll, 24.73);
    push(&coll, 89.89);
    return 0;
}","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));
    push(&buf, 72.9);
    push(&buf, 80.9);
    return 0;
}","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(&box_));
    push(&box_, 28.22);
    push(&box_, 93.56);
    return 0;
}","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 0;
}","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.pop();
    return 0;
}","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']."
1000,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']."
1001,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","from collections import deque

buf = deque()
buf.append(88.91)
buf.append(39.71)
print(buf.popleft())
buf.append(99.4)
print(buf.popleft())","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1002,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","from collections import deque

q = deque()
q.append(58.37)
q.append(70.48)
print(q.popleft())
q.append(13.17)
print(q.popleft())","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1003,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","from collections import deque

container = deque()
container.append(96.85)
container.append(79.44)
print(container.popleft())
container.append(96.98)
print(container.popleft())","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1004,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","from collections import deque

coll = deque()
coll.append(15.57)
coll.append(68.41)
print(coll.popleft())
coll.append(29.69)
print(coll.popleft())","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1005,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","from collections import deque

s = deque()
s.append(31.06)
s.append(29.54)
s.append(80.18)
s.append(2.54)
print(s.popleft())
print(s.popleft())","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1006,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","from collections import deque

container = deque()
container.append(13.22)
container.append(49.35)
container.append(1.5)
container.append(35.87)
print(container.popleft())
print(container.popleft())","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1007,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","from collections import deque

s = deque()
s.append(35.67)
s.append(29.04)
s.append(86.04)
s.append(66.87)
print(s.popleft())
print(s.popleft())","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1008,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","from collections import deque

q = deque()
q.append(71.61)
q.append(15.12)
q.append(73.57)
q.append(43.77)
print(q.popleft())
print(q.popleft())","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1009,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","from collections import deque

q = deque()
q.append(47.84)
print(q.popleft())
q.append(81.36)
q.append(64.07)","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1010,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","from collections import deque

box_ = deque()
box_.append(40.51)
print(box_.popleft())
box_.append(89.41)
box_.append(92.1)","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1011,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","from collections import deque

container = deque()
container.append(31.76)
print(container.popleft())
container.append(68.21)
container.append(32.93)","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1012,Python,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","from collections import deque

container = deque()
container.append(14.78)
print(container.popleft())
container.append(25.75)
container.append(42.21)","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1013,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const s = new SQueue();
s.enqueue(39);
s.enqueue(40);
s.enqueue(11);
console.log(s.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1014,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(81);
container.enqueue(60);
container.enqueue(70);
console.log(container.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1015,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(56);
box_.enqueue(13);
box_.enqueue(18);
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1016,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(89);
box_.enqueue(41);
box_.enqueue(65);
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1017,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(46);
coll.enqueue(60);
console.log(coll.dequeue());
coll.enqueue(55);
console.log(coll.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1018,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(53);
box_.enqueue(60);
console.log(box_.dequeue());
box_.enqueue(72);
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1019,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(12);
box_.enqueue(97);
console.log(box_.dequeue());
box_.enqueue(79);
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1020,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const s = new SQueue();
s.enqueue(75);
s.enqueue(66);
console.log(s.dequeue());
s.enqueue(17);
console.log(s.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1021,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(73);
container.enqueue(38);
container.enqueue(7);
container.enqueue(97);
console.log(container.dequeue());
console.log(container.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1022,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(86);
box_.enqueue(1);
box_.enqueue(60);
box_.enqueue(98);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1023,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const q = new QQueue();
q.enqueue(11);
q.enqueue(8);
q.enqueue(35);
q.enqueue(84);
console.log(q.dequeue());
console.log(q.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1024,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(13);
container.enqueue(38);
container.enqueue(73);
container.enqueue(62);
console.log(container.dequeue());
console.log(container.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1025,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const q = new QQueue();
q.enqueue(16);
console.log(q.dequeue());
q.enqueue(75);
q.enqueue(87);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1026,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(95);
console.log(container.dequeue());
container.enqueue(7);
container.enqueue(90);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1027,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const s = new SQueue();
s.enqueue(67);
console.log(s.dequeue());
s.enqueue(72);
s.enqueue(95);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1028,JavaScript,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(18);
console.log(box_.dequeue());
box_.enqueue(87);
box_.enqueue(82);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1029,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const s = new SQueue();
s.enqueue(30.79);
s.enqueue(31.78);
s.enqueue(98.93);
console.log(s.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1030,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(62.74);
box_.enqueue(20.87);
box_.enqueue(7.65);
console.log(box_.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1031,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const q = new QQueue();
q.enqueue(52.46);
q.enqueue(25.47);
q.enqueue(11.26);
console.log(q.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1032,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(44.94);
container.enqueue(6.51);
container.enqueue(13.06);
console.log(container.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1033,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const s = new SQueue();
s.enqueue(82.21);
s.enqueue(84.33);
console.log(s.dequeue());
s.enqueue(82.35);
console.log(s.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1034,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(62.1);
coll.enqueue(43.8);
console.log(coll.dequeue());
coll.enqueue(19.3);
console.log(coll.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1035,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(24.83);
coll.enqueue(51.64);
console.log(coll.dequeue());
coll.enqueue(20.83);
console.log(coll.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1036,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class BufQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const buf = new BufQueue();
buf.enqueue(67.09);
buf.enqueue(95.95);
console.log(buf.dequeue());
buf.enqueue(67.1);
console.log(buf.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1037,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(80.19);
coll.enqueue(46.93);
coll.enqueue(81.54);
coll.enqueue(15.67);
console.log(coll.dequeue());
console.log(coll.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1038,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const box_ = new Box_Queue();
box_.enqueue(2.09);
box_.enqueue(30.97);
box_.enqueue(64.87);
box_.enqueue(89.43);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1039,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class BufQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const buf = new BufQueue();
buf.enqueue(96.32);
buf.enqueue(47.32);
buf.enqueue(72.58);
buf.enqueue(28.41);
console.log(buf.dequeue());
console.log(buf.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1040,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const container = new ContainerQueue();
container.enqueue(21.87);
container.enqueue(90.35);
container.enqueue(52.98);
container.enqueue(51.79);
console.log(container.dequeue());
console.log(container.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1041,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(72.2);
console.log(coll.dequeue());
coll.enqueue(71.8);
coll.enqueue(78.88);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1042,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class BufQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const buf = new BufQueue();
buf.enqueue(78.71);
console.log(buf.dequeue());
buf.enqueue(92.42);
buf.enqueue(7.75);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1043,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(48.89);
console.log(coll.dequeue());
coll.enqueue(60.98);
coll.enqueue(18.86);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1044,JavaScript,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

const coll = new CollQueue();
coll.enqueue(92.81);
console.log(coll.dequeue());
coll.enqueue(53.02);
coll.enqueue(13.81);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1045,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class BufQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { BufQueue };
const buf = new BufQueue();
buf.enqueue(76);
buf.enqueue(75);
buf.enqueue(45);
console.log(buf.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1046,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { ContainerQueue };
const container = new ContainerQueue();
container.enqueue(52);
container.enqueue(9);
container.enqueue(6);
console.log(container.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1047,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(21);
coll.enqueue(30);
coll.enqueue(13);
console.log(coll.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1048,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(64);
q.enqueue(87);
q.enqueue(61);
console.log(q.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1049,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { SQueue };
const s = new SQueue();
s.enqueue(99);
s.enqueue(94);
console.log(s.dequeue());
s.enqueue(14);
console.log(s.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1050,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(50);
coll.enqueue(97);
console.log(coll.dequeue());
coll.enqueue(9);
console.log(coll.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1051,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { ContainerQueue };
const container = new ContainerQueue();
container.enqueue(33);
container.enqueue(15);
console.log(container.dequeue());
container.enqueue(96);
console.log(container.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1052,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(98);
box_.enqueue(48);
console.log(box_.dequeue());
box_.enqueue(81);
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1053,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { SQueue };
const s = new SQueue();
s.enqueue(42);
s.enqueue(14);
s.enqueue(90);
s.enqueue(58);
console.log(s.dequeue());
console.log(s.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1054,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(74);
coll.enqueue(72);
coll.enqueue(26);
coll.enqueue(26);
console.log(coll.dequeue());
console.log(coll.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1055,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(87);
box_.enqueue(37);
box_.enqueue(29);
box_.enqueue(26);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1056,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(68);
box_.enqueue(25);
box_.enqueue(12);
box_.enqueue(75);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1057,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(13);
console.log(coll.dequeue());
coll.enqueue(5);
coll.enqueue(18);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1058,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(47);
console.log(q.dequeue());
q.enqueue(53);
q.enqueue(73);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1059,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { ContainerQueue };
const container = new ContainerQueue();
container.enqueue(10);
console.log(container.dequeue());
container.enqueue(24);
container.enqueue(88);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1060,Node.js,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(94);
console.log(coll.dequeue());
coll.enqueue(68);
coll.enqueue(64);","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1061,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class SQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { SQueue };
const s = new SQueue();
s.enqueue(83.41);
s.enqueue(57.47);
s.enqueue(47.9);
console.log(s.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1062,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { ContainerQueue };
const container = new ContainerQueue();
container.enqueue(90.08);
container.enqueue(85.49);
container.enqueue(80.36);
console.log(container.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1063,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(38.24);
coll.enqueue(8.02);
coll.enqueue(8.74);
console.log(coll.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1064,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","class BufQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { BufQueue };
const buf = new BufQueue();
buf.enqueue(10.99);
buf.enqueue(50.37);
buf.enqueue(6.1);
console.log(buf.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1065,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(23.18);
q.enqueue(94.12);
console.log(q.dequeue());
q.enqueue(25.89);
console.log(q.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1066,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(87.37);
q.enqueue(16.63);
console.log(q.dequeue());
q.enqueue(53.91);
console.log(q.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1067,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class ContainerQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { ContainerQueue };
const container = new ContainerQueue();
container.enqueue(93.25);
container.enqueue(50.5);
console.log(container.dequeue());
container.enqueue(6.61);
console.log(container.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1068,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(58.69);
q.enqueue(93.76);
console.log(q.dequeue());
q.enqueue(65.67);
console.log(q.dequeue());","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1069,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(26.83);
box_.enqueue(34.12);
box_.enqueue(76.71);
box_.enqueue(14.79);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1070,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class CollQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { CollQueue };
const coll = new CollQueue();
coll.enqueue(91.32);
coll.enqueue(7.17);
coll.enqueue(49.86);
coll.enqueue(80.76);
console.log(coll.dequeue());
console.log(coll.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1071,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(35.24);
q.enqueue(8.01);
q.enqueue(42.21);
q.enqueue(74.19);
console.log(q.dequeue());
console.log(q.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1072,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(94.71);
box_.enqueue(27.78);
box_.enqueue(5.13);
box_.enqueue(4.52);
console.log(box_.dequeue());
console.log(box_.dequeue());","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1073,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(48.28);
console.log(box_.dequeue());
box_.enqueue(87.77);
box_.enqueue(23.55);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1074,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class QQueue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { QQueue };
const q = new QQueue();
q.enqueue(3.61);
console.log(q.dequeue());
q.enqueue(20.42);
q.enqueue(61.21);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1075,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(68.51);
console.log(box_.dequeue());
box_.enqueue(55.7);
box_.enqueue(6.16);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1076,Node.js,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","class Box_Queue {
  #items = [];
  enqueue(item) { this.#items.push(item); }
  dequeue() { return this.#items.shift(); }
}

module.exports = { Box_Queue };
const box_ = new Box_Queue();
box_.enqueue(69.85);
console.log(box_.dequeue());
box_.enqueue(43.26);
box_.enqueue(14.64);","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1077,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> box_ = new LinkedList<>();
                box_.add(16);
        box_.add(79);
        box_.add(48);
        System.out.println(box_.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1078,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> s = new LinkedList<>();
                s.add(44);
        s.add(56);
        s.add(8);
        System.out.println(s.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1079,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> s = new LinkedList<>();
                s.add(12);
        s.add(76);
        s.add(2);
        System.out.println(s.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1080,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> box_ = new LinkedList<>();
                box_.add(96);
        box_.add(97);
        box_.add(69);
        System.out.println(box_.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1081,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
                q.add(2);
        q.add(93);
        System.out.println(q.poll());
        q.add(8);
        System.out.println(q.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1082,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
                q.add(17);
        q.add(57);
        System.out.println(q.poll());
        q.add(37);
        System.out.println(q.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1083,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buf = new LinkedList<>();
                buf.add(45);
        buf.add(78);
        System.out.println(buf.poll());
        buf.add(32);
        System.out.println(buf.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1084,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> s = new LinkedList<>();
                s.add(78);
        s.add(51);
        System.out.println(s.poll());
        s.add(85);
        System.out.println(s.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1085,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> coll = new LinkedList<>();
                coll.add(10);
        coll.add(10);
        coll.add(33);
        coll.add(70);
        System.out.println(coll.poll());
        System.out.println(coll.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1086,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> coll = new LinkedList<>();
                coll.add(95);
        coll.add(46);
        coll.add(29);
        coll.add(57);
        System.out.println(coll.poll());
        System.out.println(coll.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1087,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buf = new LinkedList<>();
                buf.add(100);
        buf.add(71);
        buf.add(38);
        buf.add(84);
        System.out.println(buf.poll());
        System.out.println(buf.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1088,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buf = new LinkedList<>();
                buf.add(41);
        buf.add(90);
        buf.add(70);
        buf.add(65);
        System.out.println(buf.poll());
        System.out.println(buf.poll());
    }
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1089,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buf = new LinkedList<>();
                buf.add(53);
        System.out.println(buf.poll());
        buf.add(80);
        buf.add(63);
    }
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1090,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> buf = new LinkedList<>();
                buf.add(11);
        System.out.println(buf.poll());
        buf.add(18);
        buf.add(67);
    }
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1091,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> s = new LinkedList<>();
                s.add(40);
        System.out.println(s.poll());
        s.add(71);
        s.add(27);
    }
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1092,Java,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
                q.add(48);
        System.out.println(q.poll());
        q.add(19);
        q.add(5);
    }
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1093,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> s = new LinkedList<>();
                s.add(70.14);
        s.add(65.34);
        s.add(45.92);
        System.out.println(s.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1094,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> box_ = new LinkedList<>();
                box_.add(83.8);
        box_.add(27.76);
        box_.add(59.24);
        System.out.println(box_.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1095,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> q = new LinkedList<>();
                q.add(6.91);
        q.add(85.6);
        q.add(39.01);
        System.out.println(q.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1096,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> box_ = new LinkedList<>();
                box_.add(39.08);
        box_.add(5.4);
        box_.add(21.37);
        System.out.println(box_.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1097,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> box_ = new LinkedList<>();
                box_.add(53.72);
        box_.add(66.38);
        System.out.println(box_.poll());
        box_.add(76.54);
        System.out.println(box_.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1098,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> container = new LinkedList<>();
                container.add(75.69);
        container.add(34.29);
        System.out.println(container.poll());
        container.add(26.99);
        System.out.println(container.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1099,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> s = new LinkedList<>();
                s.add(75.97);
        s.add(34.75);
        System.out.println(s.poll());
        s.add(43.97);
        System.out.println(s.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1100,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> coll = new LinkedList<>();
                coll.add(92.93);
        coll.add(75.49);
        System.out.println(coll.poll());
        coll.add(55.78);
        System.out.println(coll.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1101,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> coll = new LinkedList<>();
                coll.add(29.45);
        coll.add(99.1);
        coll.add(53.94);
        coll.add(42.96);
        System.out.println(coll.poll());
        System.out.println(coll.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1102,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> buf = new LinkedList<>();
                buf.add(17.09);
        buf.add(38.75);
        buf.add(74.82);
        buf.add(92.54);
        System.out.println(buf.poll());
        System.out.println(buf.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1103,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> coll = new LinkedList<>();
                coll.add(95.15);
        coll.add(9.47);
        coll.add(25.74);
        coll.add(54.74);
        System.out.println(coll.poll());
        System.out.println(coll.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1104,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> container = new LinkedList<>();
                container.add(28.15);
        container.add(27.61);
        container.add(25.8);
        container.add(65.65);
        System.out.println(container.poll());
        System.out.println(container.poll());
    }
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1105,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> buf = new LinkedList<>();
                buf.add(57.28);
        System.out.println(buf.poll());
        buf.add(27.19);
        buf.add(18.7);
    }
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1106,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> box_ = new LinkedList<>();
                box_.add(2.71);
        System.out.println(box_.poll());
        box_.add(4.66);
        box_.add(36.51);
    }
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1107,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> coll = new LinkedList<>();
                coll.add(84.59);
        System.out.println(coll.poll());
        coll.add(6.8);
        coll.add(93.94);
    }
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1108,Java,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","import java.util.*;

public class Main {
    public static void main(String[] args) {
        Queue<Double> buf = new LinkedList<>();
                buf.add(89.81);
        System.out.println(buf.poll());
        buf.add(95.38);
        buf.add(44.6);
    }
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1109,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 99);
    enqueue(&buf, 36);
    enqueue(&buf, 34);
    printf(""%g\n"", (double)dequeue(&buf));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1110,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 30);
    enqueue(&s, 81);
    enqueue(&s, 23);
    printf(""%g\n"", (double)dequeue(&s));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1111,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 84);
    enqueue(&container, 7);
    enqueue(&container, 30);
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1112,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue coll = { .front = 0, .rear = 0 };
        enqueue(&coll, 5);
    enqueue(&coll, 24);
    enqueue(&coll, 88);
    printf(""%g\n"", (double)dequeue(&coll));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1113,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue box_ = { .front = 0, .rear = 0 };
        enqueue(&box_, 75);
    enqueue(&box_, 41);
    printf(""%g\n"", (double)dequeue(&box_));
    enqueue(&box_, 71);
    printf(""%g\n"", (double)dequeue(&box_));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1114,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 8);
    enqueue(&s, 92);
    printf(""%g\n"", (double)dequeue(&s));
    enqueue(&s, 33);
    printf(""%g\n"", (double)dequeue(&s));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1115,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue coll = { .front = 0, .rear = 0 };
        enqueue(&coll, 46);
    enqueue(&coll, 70);
    printf(""%g\n"", (double)dequeue(&coll));
    enqueue(&coll, 6);
    printf(""%g\n"", (double)dequeue(&coll));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1116,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 45);
    enqueue(&s, 14);
    printf(""%g\n"", (double)dequeue(&s));
    enqueue(&s, 65);
    printf(""%g\n"", (double)dequeue(&s));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1117,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue q = { .front = 0, .rear = 0 };
        enqueue(&q, 66);
    enqueue(&q, 10);
    enqueue(&q, 31);
    enqueue(&q, 27);
    printf(""%g\n"", (double)dequeue(&q));
    printf(""%g\n"", (double)dequeue(&q));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1118,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 88);
    enqueue(&buf, 54);
    enqueue(&buf, 10);
    enqueue(&buf, 83);
    printf(""%g\n"", (double)dequeue(&buf));
    printf(""%g\n"", (double)dequeue(&buf));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1119,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 4);
    enqueue(&s, 42);
    enqueue(&s, 78);
    enqueue(&s, 47);
    printf(""%g\n"", (double)dequeue(&s));
    printf(""%g\n"", (double)dequeue(&s));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1120,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue coll = { .front = 0, .rear = 0 };
        enqueue(&coll, 48);
    enqueue(&coll, 61);
    enqueue(&coll, 38);
    enqueue(&coll, 80);
    printf(""%g\n"", (double)dequeue(&coll));
    printf(""%g\n"", (double)dequeue(&coll));
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1121,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 6);
    printf(""%g\n"", (double)dequeue(&buf));
    enqueue(&buf, 20);
    enqueue(&buf, 76);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1122,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue q = { .front = 0, .rear = 0 };
        enqueue(&q, 14);
    printf(""%g\n"", (double)dequeue(&q));
    enqueue(&q, 28);
    enqueue(&q, 41);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1123,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 92);
    printf(""%g\n"", (double)dequeue(&container));
    enqueue(&container, 95);
    enqueue(&container, 66);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1124,C,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { int items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, int value) { q->items[q->rear++] = value; }
int dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 92);
    printf(""%g\n"", (double)dequeue(&container));
    enqueue(&container, 28);
    enqueue(&container, 49);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1125,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 4.23);
    enqueue(&container, 72.9);
    enqueue(&container, 38.73);
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1126,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue q = { .front = 0, .rear = 0 };
        enqueue(&q, 95.56);
    enqueue(&q, 95.9);
    enqueue(&q, 99.24);
    printf(""%g\n"", (double)dequeue(&q));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1127,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 63.4);
    enqueue(&container, 73.66);
    enqueue(&container, 54.36);
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1128,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 80.02);
    enqueue(&container, 61.1);
    enqueue(&container, 66.26);
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1129,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 27.65);
    enqueue(&buf, 83.76);
    printf(""%g\n"", (double)dequeue(&buf));
    enqueue(&buf, 25.16);
    printf(""%g\n"", (double)dequeue(&buf));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1130,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 23.86);
    enqueue(&buf, 32.17);
    printf(""%g\n"", (double)dequeue(&buf));
    enqueue(&buf, 69.61);
    printf(""%g\n"", (double)dequeue(&buf));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1131,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue box_ = { .front = 0, .rear = 0 };
        enqueue(&box_, 36.83);
    enqueue(&box_, 35.85);
    printf(""%g\n"", (double)dequeue(&box_));
    enqueue(&box_, 91.55);
    printf(""%g\n"", (double)dequeue(&box_));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1132,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 23.8);
    enqueue(&container, 78.84);
    printf(""%g\n"", (double)dequeue(&container));
    enqueue(&container, 82.95);
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1133,C,Data Structures,intermediate,"Implement a queue 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 front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue container = { .front = 0, .rear = 0 };
        enqueue(&container, 25.25);
    enqueue(&container, 91.02);
    enqueue(&container, 67.74);
    enqueue(&container, 66.92);
    printf(""%g\n"", (double)dequeue(&container));
    printf(""%g\n"", (double)dequeue(&container));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1134,C,Data Structures,intermediate,"Implement a queue 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 front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 32.07);
    enqueue(&buf, 9.07);
    enqueue(&buf, 42.68);
    enqueue(&buf, 98.34);
    printf(""%g\n"", (double)dequeue(&buf));
    printf(""%g\n"", (double)dequeue(&buf));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1135,C,Data Structures,intermediate,"Implement a queue 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 front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 90.09);
    enqueue(&s, 87.76);
    enqueue(&s, 2.54);
    enqueue(&s, 12.96);
    printf(""%g\n"", (double)dequeue(&s));
    printf(""%g\n"", (double)dequeue(&s));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1136,C,Data Structures,intermediate,"Implement a queue 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 front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue box_ = { .front = 0, .rear = 0 };
        enqueue(&box_, 74.54);
    enqueue(&box_, 13.51);
    enqueue(&box_, 4.37);
    enqueue(&box_, 43.71);
    printf(""%g\n"", (double)dequeue(&box_));
    printf(""%g\n"", (double)dequeue(&box_));
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1137,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 51.97);
    printf(""%g\n"", (double)dequeue(&s));
    enqueue(&s, 39.42);
    enqueue(&s, 42.81);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1138,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue s = { .front = 0, .rear = 0 };
        enqueue(&s, 40.83);
    printf(""%g\n"", (double)dequeue(&s));
    enqueue(&s, 71.49);
    enqueue(&s, 12.78);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1139,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue buf = { .front = 0, .rear = 0 };
        enqueue(&buf, 59.56);
    printf(""%g\n"", (double)dequeue(&buf));
    enqueue(&buf, 99.42);
    enqueue(&buf, 5.48);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1140,C,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <stdio.h>
#define MAX 100

typedef struct { double items[MAX]; int front, rear; } Queue;

void enqueue(Queue* q, double value) { q->items[q->rear++] = value; }
double dequeue(Queue* q) { return q->items[q->front++]; }

int main(void) {
    Queue coll = { .front = 0, .rear = 0 };
        enqueue(&coll, 92.15);
    printf(""%g\n"", (double)dequeue(&coll));
    enqueue(&coll, 91.16);
    enqueue(&coll, 63.45);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1141,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> coll;
        coll.push(56);
    coll.push(38);
    coll.push(97);
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1142,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> coll;
        coll.push(18);
    coll.push(94);
    coll.push(24);
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1143,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> container;
        container.push(66);
    container.push(11);
    container.push(20);
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1144,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> container;
        container.push(76);
    container.push(48);
    container.push(87);
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1145,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> box_;
        box_.push(49);
    box_.push(42);
    std::cout << box_.front() << std::endl; box_.pop();
    box_.push(23);
    std::cout << box_.front() << std::endl; box_.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1146,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> coll;
        coll.push(76);
    coll.push(36);
    std::cout << coll.front() << std::endl; coll.pop();
    coll.push(13);
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1147,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> buf;
        buf.push(64);
    buf.push(44);
    std::cout << buf.front() << std::endl; buf.pop();
    buf.push(73);
    std::cout << buf.front() << std::endl; buf.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1148,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> container;
        container.push(75);
    container.push(66);
    std::cout << container.front() << std::endl; container.pop();
    container.push(37);
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1149,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> box_;
        box_.push(41);
    box_.push(97);
    box_.push(23);
    box_.push(19);
    std::cout << box_.front() << std::endl; box_.pop();
    std::cout << box_.front() << std::endl; box_.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1150,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> coll;
        coll.push(27);
    coll.push(56);
    coll.push(67);
    coll.push(36);
    std::cout << coll.front() << std::endl; coll.pop();
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1151,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> buf;
        buf.push(13);
    buf.push(45);
    buf.push(37);
    buf.push(22);
    std::cout << buf.front() << std::endl; buf.pop();
    std::cout << buf.front() << std::endl; buf.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1152,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> buf;
        buf.push(63);
    buf.push(57);
    buf.push(29);
    buf.push(22);
    std::cout << buf.front() << std::endl; buf.pop();
    std::cout << buf.front() << std::endl; buf.pop();
    return 0;
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1153,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> container;
        container.push(97);
    std::cout << container.front() << std::endl; container.pop();
    container.push(30);
    container.push(86);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1154,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> buf;
        buf.push(19);
    std::cout << buf.front() << std::endl; buf.pop();
    buf.push(27);
    buf.push(71);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1155,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> container;
        container.push(97);
    std::cout << container.front() << std::endl; container.pop();
    container.push(4);
    container.push(77);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1156,C++,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<int> q;
        q.push(70);
    std::cout << q.front() << std::endl; q.pop();
    q.push(25);
    q.push(1);
    return 0;
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1157,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> box_;
        box_.push(83.42);
    box_.push(3.55);
    box_.push(21.11);
    std::cout << box_.front() << std::endl; box_.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1158,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> container;
        container.push(43.22);
    container.push(45.04);
    container.push(13.49);
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1159,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> q;
        q.push(71.91);
    q.push(92.0);
    q.push(12.87);
    std::cout << q.front() << std::endl; q.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1160,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> box_;
        box_.push(27.04);
    box_.push(86.59);
    box_.push(99.31);
    std::cout << box_.front() << std::endl; box_.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1161,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> q;
        q.push(96.88);
    q.push(80.56);
    std::cout << q.front() << std::endl; q.pop();
    q.push(23.02);
    std::cout << q.front() << std::endl; q.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1162,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> s;
        s.push(51.2);
    s.push(28.33);
    std::cout << s.front() << std::endl; s.pop();
    s.push(51.77);
    std::cout << s.front() << std::endl; s.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1163,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> coll;
        coll.push(69.11);
    coll.push(89.33);
    std::cout << coll.front() << std::endl; coll.pop();
    coll.push(10.94);
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1164,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> container;
        container.push(32.44);
    container.push(84.3);
    std::cout << container.front() << std::endl; container.pop();
    container.push(87.88);
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1165,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> coll;
        coll.push(63.1);
    coll.push(25.35);
    coll.push(59.05);
    coll.push(87.34);
    std::cout << coll.front() << std::endl; coll.pop();
    std::cout << coll.front() << std::endl; coll.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1166,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> box_;
        box_.push(15.99);
    box_.push(81.57);
    box_.push(73.62);
    box_.push(28.98);
    std::cout << box_.front() << std::endl; box_.pop();
    std::cout << box_.front() << std::endl; box_.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1167,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> container;
        container.push(85.86);
    container.push(75.2);
    container.push(1.32);
    container.push(7.66);
    std::cout << container.front() << std::endl; container.pop();
    std::cout << container.front() << std::endl; container.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1168,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> s;
        s.push(4.84);
    s.push(69.11);
    s.push(61.72);
    s.push(63.47);
    std::cout << s.front() << std::endl; s.pop();
    std::cout << s.front() << std::endl; s.pop();
    return 0;
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1169,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> container;
        container.push(66.04);
    std::cout << container.front() << std::endl; container.pop();
    container.push(30.71);
    container.push(23.96);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1170,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> buf;
        buf.push(67.13);
    std::cout << buf.front() << std::endl; buf.pop();
    buf.push(63.37);
    buf.push(60.19);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1171,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> container;
        container.push(48.61);
    std::cout << container.front() << std::endl; container.pop();
    container.push(12.12);
    container.push(88.21);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1172,C++,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","#include <iostream>
#include <queue>

int main() {
    std::queue<double> buf;
        buf.push(42.54);
    std::cout << buf.front() << std::endl; buf.pop();
    buf.push(25.49);
    buf.push(43.06);
    return 0;
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1173,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<i32> = VecDeque::new();
        s.push_back(60);
    s.push_back(41);
    s.push_back(85);
    println!(""{:?}"", s.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1174,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut buf: VecDeque<i32> = VecDeque::new();
        buf.push_back(90);
    buf.push_back(51);
    buf.push_back(91);
    println!(""{:?}"", buf.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1175,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut box_: VecDeque<i32> = VecDeque::new();
        box_.push_back(63);
    box_.push_back(77);
    box_.push_back(53);
    println!(""{:?}"", box_.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1176,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<i32> = VecDeque::new();
        s.push_back(4);
    s.push_back(38);
    s.push_back(35);
    println!(""{:?}"", s.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'pop']."
1177,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<i32> = VecDeque::new();
        s.push_back(53);
    s.push_back(8);
    println!(""{:?}"", s.pop_front());
    s.push_back(99);
    println!(""{:?}"", s.pop_front());
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1178,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut buf: VecDeque<i32> = VecDeque::new();
        buf.push_back(87);
    buf.push_back(41);
    println!(""{:?}"", buf.pop_front());
    buf.push_back(51);
    println!(""{:?}"", buf.pop_front());
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1179,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut box_: VecDeque<i32> = VecDeque::new();
        box_.push_back(52);
    box_.push_back(34);
    println!(""{:?}"", box_.pop_front());
    box_.push_back(35);
    println!(""{:?}"", box_.pop_front());
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1180,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<i32> = VecDeque::new();
        coll.push_back(29);
    coll.push_back(44);
    println!(""{:?}"", coll.pop_front());
    coll.push_back(6);
    println!(""{:?}"", coll.pop_front());
}","Queue with int elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1181,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut box_: VecDeque<i32> = VecDeque::new();
        box_.push_back(53);
    box_.push_back(29);
    box_.push_back(74);
    box_.push_back(22);
    println!(""{:?}"", box_.pop_front());
    println!(""{:?}"", box_.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1182,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<i32> = VecDeque::new();
        coll.push_back(15);
    coll.push_back(79);
    coll.push_back(79);
    coll.push_back(43);
    println!(""{:?}"", coll.pop_front());
    println!(""{:?}"", coll.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1183,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut container: VecDeque<i32> = VecDeque::new();
        container.push_back(3);
    container.push_back(93);
    container.push_back(3);
    container.push_back(49);
    println!(""{:?}"", container.pop_front());
    println!(""{:?}"", container.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1184,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<i32> = VecDeque::new();
        coll.push_back(43);
    coll.push_back(46);
    coll.push_back(99);
    coll.push_back(99);
    println!(""{:?}"", coll.pop_front());
    println!(""{:?}"", coll.pop_front());
}","Queue with int elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1185,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<i32> = VecDeque::new();
        coll.push_back(7);
    println!(""{:?}"", coll.pop_front());
    coll.push_back(27);
    coll.push_back(47);
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1186,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut container: VecDeque<i32> = VecDeque::new();
        container.push_back(26);
    println!(""{:?}"", container.pop_front());
    container.push_back(69);
    container.push_back(51);
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1187,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<i32> = VecDeque::new();
        coll.push_back(30);
    println!(""{:?}"", coll.pop_front());
    coll.push_back(21);
    coll.push_back(48);
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1188,Rust,Data Structures,intermediate,"Implement a queue of ints and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut buf: VecDeque<i32> = VecDeque::new();
        buf.push_back(53);
    println!(""{:?}"", buf.pop_front());
    buf.push_back(71);
    buf.push_back(94);
}","Queue with int elements, ops=['push', 'pop', 'push', 'push']."
1189,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<f64> = VecDeque::new();
        s.push_back(94.06);
    s.push_back(4.57);
    s.push_back(2.98);
    println!(""{:?}"", s.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1190,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(50.65);
    q.push_back(79.34);
    q.push_back(5.19);
    println!(""{:?}"", q.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1191,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(23.77);
    q.push_back(77.47);
    q.push_back(25.48);
    println!(""{:?}"", q.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1192,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(81.49);
    q.push_back(38.41);
    q.push_back(40.67);
    println!(""{:?}"", q.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'pop']."
1193,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut buf: VecDeque<f64> = VecDeque::new();
        buf.push_back(86.34);
    buf.push_back(8.58);
    println!(""{:?}"", buf.pop_front());
    buf.push_back(70.65);
    println!(""{:?}"", buf.pop_front());
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1194,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(2.46);
    q.push_back(83.19);
    println!(""{:?}"", q.pop_front());
    q.push_back(16.03);
    println!(""{:?}"", q.pop_front());
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1195,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut box_: VecDeque<f64> = VecDeque::new();
        box_.push_back(20.23);
    box_.push_back(60.96);
    println!(""{:?}"", box_.pop_front());
    box_.push_back(33.05);
    println!(""{:?}"", box_.pop_front());
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1196,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, pop, push, pop.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(30.91);
    q.push_back(46.43);
    println!(""{:?}"", q.pop_front());
    q.push_back(96.96);
    println!(""{:?}"", q.pop_front());
}","Queue with float elements, ops=['push', 'push', 'pop', 'push', 'pop']."
1197,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut box_: VecDeque<f64> = VecDeque::new();
        box_.push_back(29.83);
    box_.push_back(10.21);
    box_.push_back(96.72);
    box_.push_back(56.54);
    println!(""{:?}"", box_.pop_front());
    println!(""{:?}"", box_.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1198,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut container: VecDeque<f64> = VecDeque::new();
        container.push_back(51.15);
    container.push_back(38.86);
    container.push_back(99.32);
    container.push_back(73.03);
    println!(""{:?}"", container.pop_front());
    println!(""{:?}"", container.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1199,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut coll: VecDeque<f64> = VecDeque::new();
        coll.push_back(11.72);
    coll.push_back(23.18);
    coll.push_back(97.54);
    coll.push_back(40.34);
    println!(""{:?}"", coll.pop_front());
    println!(""{:?}"", coll.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1200,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, push, push, push, pop, pop.","use std::collections::VecDeque;

fn main() {
    let mut container: VecDeque<f64> = VecDeque::new();
        container.push_back(11.79);
    container.push_back(31.75);
    container.push_back(15.23);
    container.push_back(63.36);
    println!(""{:?}"", container.pop_front());
    println!(""{:?}"", container.pop_front());
}","Queue with float elements, ops=['push', 'push', 'push', 'push', 'pop', 'pop']."
1201,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<f64> = VecDeque::new();
        s.push_back(86.62);
    println!(""{:?}"", s.pop_front());
    s.push_back(25.75);
    s.push_back(14.99);
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1202,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut container: VecDeque<f64> = VecDeque::new();
        container.push_back(83.97);
    println!(""{:?}"", container.pop_front());
    container.push_back(84.13);
    container.push_back(76.3);
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1203,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut q: VecDeque<f64> = VecDeque::new();
        q.push_back(76.97);
    println!(""{:?}"", q.pop_front());
    q.push_back(31.83);
    q.push_back(34.45);
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1204,Rust,Data Structures,intermediate,"Implement a queue of floats and run the operation sequence: push, pop, push, push.","use std::collections::VecDeque;

fn main() {
    let mut s: VecDeque<f64> = VecDeque::new();
        s.push_back(4.61);
    println!(""{:?}"", s.pop_front());
    s.push_back(60.27);
    s.push_back(87.27);
}","Queue with float elements, ops=['push', 'pop', 'push', 'push']."
1205,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","def compute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(compute_palindrome('racecar'))","Palindrome Check operation, function named 'compute_palindrome'."
1206,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('racecar'))","Palindrome Check operation, function named 'perform_palindrome'."
1207,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","def handle_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(handle_palindrome('hello world'))","Palindrome Check operation, function named 'handle_palindrome'."
1208,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","def apply_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(apply_palindrome('hello world'))","Palindrome Check operation, function named 'apply_palindrome'."
1209,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","def execute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(execute_palindrome('A man a plan a canal Panama'))","Palindrome Check operation, function named 'execute_palindrome'."
1210,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","def apply_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(apply_palindrome('A man a plan a canal Panama'))","Palindrome Check operation, function named 'apply_palindrome'."
1211,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('Rust is fun'))","Palindrome Check operation, function named 'run_palindrome'."
1212,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","def execute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(execute_palindrome('Rust is fun'))","Palindrome Check operation, function named 'execute_palindrome'."
1213,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('level'))","Palindrome Check operation, function named 'run_palindrome'."
1214,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","def compute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(compute_palindrome('level'))","Palindrome Check operation, function named 'compute_palindrome'."
1215,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('OpenAI Claude'))","Palindrome Check operation, function named 'perform_palindrome'."
1216,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","def handle_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(handle_palindrome('OpenAI Claude'))","Palindrome Check operation, function named 'handle_palindrome'."
1217,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","def compute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(compute_palindrome('was it a car or a cat i saw'))","Palindrome Check operation, function named 'compute_palindrome'."
1218,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('was it a car or a cat i saw'))","Palindrome Check operation, function named 'run_palindrome'."
1219,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('noon'))","Palindrome Check operation, function named 'perform_palindrome'."
1220,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('noon'))","Palindrome Check operation, function named 'run_palindrome'."
1221,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","def execute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(execute_palindrome('data science'))","Palindrome Check operation, function named 'execute_palindrome'."
1222,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","def apply_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(apply_palindrome('step on no pets'))","Palindrome Check operation, function named 'apply_palindrome'."
1223,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('step on no pets'))","Palindrome Check operation, function named 'perform_palindrome'."
1224,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('coding'))","Palindrome Check operation, function named 'perform_palindrome'."
1225,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('coding'))","Palindrome Check operation, function named 'process_palindrome'."
1226,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('madam im adam'))","Palindrome Check operation, function named 'process_palindrome'."
1227,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('madam im adam'))","Palindrome Check operation, function named 'run_palindrome'."
1228,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('kayak'))","Palindrome Check operation, function named 'perform_palindrome'."
1229,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('kayak'))","Palindrome Check operation, function named 'process_palindrome'."
1230,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('the quick brown fox'))","Palindrome Check operation, function named 'run_palindrome'."
1231,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","def handle_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(handle_palindrome('the quick brown fox'))","Palindrome Check operation, function named 'handle_palindrome'."
1232,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","def apply_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(apply_palindrome('civic'))","Palindrome Check operation, function named 'apply_palindrome'."
1233,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('civic'))","Palindrome Check operation, function named 'process_palindrome'."
1234,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","def handle_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(handle_palindrome('never odd or even'))","Palindrome Check operation, function named 'handle_palindrome'."
1235,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","def execute_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(execute_palindrome('never odd or even'))","Palindrome Check operation, function named 'execute_palindrome'."
1236,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","def perform_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(perform_palindrome('python programming'))","Palindrome Check operation, function named 'perform_palindrome'."
1237,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('python programming'))","Palindrome Check operation, function named 'process_palindrome'."
1238,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","def handle_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(handle_palindrome('deified'))","Palindrome Check operation, function named 'handle_palindrome'."
1239,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","def run_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(run_palindrome('algorithms and data structures'))","Palindrome Check operation, function named 'run_palindrome'."
1240,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","def apply_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(apply_palindrome('algorithms and data structures'))","Palindrome Check operation, function named 'apply_palindrome'."
1241,Python,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","def process_palindrome(s):
    cleaned = s.lower().replace("" "", """")
    return cleaned == cleaned[::-1]

print(process_palindrome('rotor'))","Palindrome Check operation, function named 'process_palindrome'."
1242,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(run_palindrome(""racecar""));","Palindrome Check operation, function named 'run_palindrome'."
1243,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(handle_palindrome(""hello world""));","Palindrome Check operation, function named 'handle_palindrome'."
1244,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""hello world""));","Palindrome Check operation, function named 'perform_palindrome'."
1245,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","function apply_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(apply_palindrome(""A man a plan a canal Panama""));","Palindrome Check operation, function named 'apply_palindrome'."
1246,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""A man a plan a canal Panama""));","Palindrome Check operation, function named 'execute_palindrome'."
1247,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(run_palindrome(""Rust is fun""));","Palindrome Check operation, function named 'run_palindrome'."
1248,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(handle_palindrome(""Rust is fun""));","Palindrome Check operation, function named 'handle_palindrome'."
1249,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""level""));","Palindrome Check operation, function named 'perform_palindrome'."
1250,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","function apply_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(apply_palindrome(""level""));","Palindrome Check operation, function named 'apply_palindrome'."
1251,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""OpenAI Claude""));","Palindrome Check operation, function named 'execute_palindrome'."
1252,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(run_palindrome(""OpenAI Claude""));","Palindrome Check operation, function named 'run_palindrome'."
1253,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(run_palindrome(""was it a car or a cat i saw""));","Palindrome Check operation, function named 'run_palindrome'."
1254,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(process_palindrome(""was it a car or a cat i saw""));","Palindrome Check operation, function named 'process_palindrome'."
1255,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""noon""));","Palindrome Check operation, function named 'compute_palindrome'."
1256,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(process_palindrome(""noon""));","Palindrome Check operation, function named 'process_palindrome'."
1257,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(run_palindrome(""data science""));","Palindrome Check operation, function named 'run_palindrome'."
1258,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""data science""));","Palindrome Check operation, function named 'compute_palindrome'."
1259,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""step on no pets""));","Palindrome Check operation, function named 'perform_palindrome'."
1260,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""coding""));","Palindrome Check operation, function named 'compute_palindrome'."
1261,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""coding""));","Palindrome Check operation, function named 'execute_palindrome'."
1262,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""madam im adam""));","Palindrome Check operation, function named 'compute_palindrome'."
1263,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""madam im adam""));","Palindrome Check operation, function named 'execute_palindrome'."
1264,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""kayak""));","Palindrome Check operation, function named 'compute_palindrome'."
1265,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""kayak""));","Palindrome Check operation, function named 'execute_palindrome'."
1266,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""the quick brown fox""));","Palindrome Check operation, function named 'perform_palindrome'."
1267,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(handle_palindrome(""the quick brown fox""));","Palindrome Check operation, function named 'handle_palindrome'."
1268,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(handle_palindrome(""civic""));","Palindrome Check operation, function named 'handle_palindrome'."
1269,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""civic""));","Palindrome Check operation, function named 'compute_palindrome'."
1270,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""never odd or even""));","Palindrome Check operation, function named 'execute_palindrome'."
1271,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""never odd or even""));","Palindrome Check operation, function named 'perform_palindrome'."
1272,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(handle_palindrome(""python programming""));","Palindrome Check operation, function named 'handle_palindrome'."
1273,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","function apply_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(apply_palindrome(""python programming""));","Palindrome Check operation, function named 'apply_palindrome'."
1274,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""deified""));","Palindrome Check operation, function named 'execute_palindrome'."
1275,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(perform_palindrome(""deified""));","Palindrome Check operation, function named 'perform_palindrome'."
1276,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""algorithms and data structures""));","Palindrome Check operation, function named 'compute_palindrome'."
1277,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""algorithms and data structures""));","Palindrome Check operation, function named 'execute_palindrome'."
1278,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(execute_palindrome(""rotor""));","Palindrome Check operation, function named 'execute_palindrome'."
1279,JavaScript,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

console.log(compute_palindrome(""rotor""));","Palindrome Check operation, function named 'compute_palindrome'."
1280,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""racecar""));","Palindrome Check operation, function named 'run_palindrome'."
1281,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""hello world""));","Palindrome Check operation, function named 'handle_palindrome'."
1282,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { compute_palindrome };
console.log(compute_palindrome(""hello world""));","Palindrome Check operation, function named 'compute_palindrome'."
1283,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { perform_palindrome };
console.log(perform_palindrome(""A man a plan a canal Panama""));","Palindrome Check operation, function named 'perform_palindrome'."
1284,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","function apply_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { apply_palindrome };
console.log(apply_palindrome(""Rust is fun""));","Palindrome Check operation, function named 'apply_palindrome'."
1285,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""Rust is fun""));","Palindrome Check operation, function named 'handle_palindrome'."
1286,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""level""));","Palindrome Check operation, function named 'handle_palindrome'."
1287,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { execute_palindrome };
console.log(execute_palindrome(""level""));","Palindrome Check operation, function named 'execute_palindrome'."
1288,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { perform_palindrome };
console.log(perform_palindrome(""OpenAI Claude""));","Palindrome Check operation, function named 'perform_palindrome'."
1289,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","function apply_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { apply_palindrome };
console.log(apply_palindrome(""OpenAI Claude""));","Palindrome Check operation, function named 'apply_palindrome'."
1290,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""was it a car or a cat i saw""));","Palindrome Check operation, function named 'run_palindrome'."
1291,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""was it a car or a cat i saw""));","Palindrome Check operation, function named 'process_palindrome'."
1292,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { compute_palindrome };
console.log(compute_palindrome(""noon""));","Palindrome Check operation, function named 'compute_palindrome'."
1293,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""noon""));","Palindrome Check operation, function named 'run_palindrome'."
1294,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""data science""));","Palindrome Check operation, function named 'handle_palindrome'."
1295,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""step on no pets""));","Palindrome Check operation, function named 'run_palindrome'."
1296,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""step on no pets""));","Palindrome Check operation, function named 'process_palindrome'."
1297,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""coding""));","Palindrome Check operation, function named 'process_palindrome'."
1298,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { compute_palindrome };
console.log(compute_palindrome(""coding""));","Palindrome Check operation, function named 'compute_palindrome'."
1299,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { perform_palindrome };
console.log(perform_palindrome(""madam im adam""));","Palindrome Check operation, function named 'perform_palindrome'."
1300,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""madam im adam""));","Palindrome Check operation, function named 'handle_palindrome'."
1301,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""kayak""));","Palindrome Check operation, function named 'handle_palindrome'."
1302,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { perform_palindrome };
console.log(perform_palindrome(""kayak""));","Palindrome Check operation, function named 'perform_palindrome'."
1303,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""the quick brown fox""));","Palindrome Check operation, function named 'process_palindrome'."
1304,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { execute_palindrome };
console.log(execute_palindrome(""the quick brown fox""));","Palindrome Check operation, function named 'execute_palindrome'."
1305,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""civic""));","Palindrome Check operation, function named 'run_palindrome'."
1306,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { compute_palindrome };
console.log(compute_palindrome(""civic""));","Palindrome Check operation, function named 'compute_palindrome'."
1307,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""never odd or even""));","Palindrome Check operation, function named 'process_palindrome'."
1308,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { execute_palindrome };
console.log(execute_palindrome(""python programming""));","Palindrome Check operation, function named 'execute_palindrome'."
1309,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","function run_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { run_palindrome };
console.log(run_palindrome(""python programming""));","Palindrome Check operation, function named 'run_palindrome'."
1310,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { execute_palindrome };
console.log(execute_palindrome(""deified""));","Palindrome Check operation, function named 'execute_palindrome'."
1311,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","function handle_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { handle_palindrome };
console.log(handle_palindrome(""deified""));","Palindrome Check operation, function named 'handle_palindrome'."
1312,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","function process_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { process_palindrome };
console.log(process_palindrome(""algorithms and data structures""));","Palindrome Check operation, function named 'process_palindrome'."
1313,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","function compute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { compute_palindrome };
console.log(compute_palindrome(""algorithms and data structures""));","Palindrome Check operation, function named 'compute_palindrome'."
1314,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","function perform_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { perform_palindrome };
console.log(perform_palindrome(""rotor""));","Palindrome Check operation, function named 'perform_palindrome'."
1315,Node.js,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","function execute_palindrome(s) {
  const cleaned = s.toLowerCase().replaceAll("" "", """");
  return cleaned === cleaned.split("""").reverse().join("""");
}

module.exports = { execute_palindrome };
console.log(execute_palindrome(""rotor""));","Palindrome Check operation, function named 'execute_palindrome'."
1316,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""racecar""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1317,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""racecar""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1318,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","public class Main {
    static boolean perform_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(perform_palindrome(""hello world""));
    }
}","Palindrome Check operation, function named 'perform_palindrome'."
1319,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","public class Main {
    static boolean process_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(process_palindrome(""hello world""));
    }
}","Palindrome Check operation, function named 'process_palindrome'."
1320,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""A man a plan a canal Panama""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1321,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""A man a plan a canal Panama""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1322,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""Rust is fun""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1323,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","public class Main {
    static boolean apply_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(apply_palindrome(""Rust is fun""));
    }
}","Palindrome Check operation, function named 'apply_palindrome'."
1324,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","public class Main {
    static boolean apply_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(apply_palindrome(""level""));
    }
}","Palindrome Check operation, function named 'apply_palindrome'."
1325,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","public class Main {
    static boolean run_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(run_palindrome(""level""));
    }
}","Palindrome Check operation, function named 'run_palindrome'."
1326,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""OpenAI Claude""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1327,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","public class Main {
    static boolean perform_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(perform_palindrome(""OpenAI Claude""));
    }
}","Palindrome Check operation, function named 'perform_palindrome'."
1328,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""was it a car or a cat i saw""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1329,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""noon""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1330,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","public class Main {
    static boolean apply_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(apply_palindrome(""noon""));
    }
}","Palindrome Check operation, function named 'apply_palindrome'."
1331,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","public class Main {
    static boolean run_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(run_palindrome(""data science""));
    }
}","Palindrome Check operation, function named 'run_palindrome'."
1332,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""data science""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1333,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""step on no pets""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1334,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","public class Main {
    static boolean perform_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(perform_palindrome(""coding""));
    }
}","Palindrome Check operation, function named 'perform_palindrome'."
1335,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""madam im adam""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1336,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","public class Main {
    static boolean process_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(process_palindrome(""madam im adam""));
    }
}","Palindrome Check operation, function named 'process_palindrome'."
1337,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""kayak""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1338,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""kayak""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1339,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","public class Main {
    static boolean process_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(process_palindrome(""the quick brown fox""));
    }
}","Palindrome Check operation, function named 'process_palindrome'."
1340,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","public class Main {
    static boolean perform_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(perform_palindrome(""the quick brown fox""));
    }
}","Palindrome Check operation, function named 'perform_palindrome'."
1341,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""civic""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1342,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""civic""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1343,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""never odd or even""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1344,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","public class Main {
    static boolean compute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(compute_palindrome(""never odd or even""));
    }
}","Palindrome Check operation, function named 'compute_palindrome'."
1345,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""python programming""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1346,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","public class Main {
    static boolean process_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(process_palindrome(""python programming""));
    }
}","Palindrome Check operation, function named 'process_palindrome'."
1347,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","public class Main {
    static boolean handle_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(handle_palindrome(""deified""));
    }
}","Palindrome Check operation, function named 'handle_palindrome'."
1348,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","public class Main {
    static boolean apply_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(apply_palindrome(""deified""));
    }
}","Palindrome Check operation, function named 'apply_palindrome'."
1349,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","public class Main {
    static boolean execute_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(execute_palindrome(""algorithms and data structures""));
    }
}","Palindrome Check operation, function named 'execute_palindrome'."
1350,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","public class Main {
    static boolean perform_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(perform_palindrome(""rotor""));
    }
}","Palindrome Check operation, function named 'perform_palindrome'."
1351,Java,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","public class Main {
    static boolean apply_palindrome(String s) {
        String cleaned = s.toLowerCase().replace("" "", """");
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

    public static void main(String[] args) {
        System.out.println(apply_palindrome(""rotor""));
    }
}","Palindrome Check operation, function named 'apply_palindrome'."
1352,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""racecar""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1353,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

int compute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", compute_palindrome(""racecar""));
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1354,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""hello world""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1355,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""hello world""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1356,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""A man a plan a canal Panama""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1357,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""A man a plan a canal Panama""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1358,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""Rust is fun""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1359,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>

int compute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", compute_palindrome(""Rust is fun""));
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1360,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""level""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1361,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","#include <stdio.h>
#include <string.h>

int perform_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", perform_palindrome(""level""));
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1362,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""OpenAI Claude""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1363,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""OpenAI Claude""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1364,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

int perform_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", perform_palindrome(""was it a car or a cat i saw""));
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1365,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""was it a car or a cat i saw""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1366,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","#include <stdio.h>
#include <string.h>

int handle_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", handle_palindrome(""noon""));
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1367,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","#include <stdio.h>
#include <string.h>

int process_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", process_palindrome(""data science""));
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1368,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""data science""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1369,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>

int handle_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", handle_palindrome(""step on no pets""));
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1370,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","#include <stdio.h>
#include <string.h>

int process_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", process_palindrome(""coding""));
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1371,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""coding""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1372,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""madam im adam""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1373,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>

int handle_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", handle_palindrome(""madam im adam""));
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1374,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","#include <stdio.h>
#include <string.h>

int handle_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", handle_palindrome(""kayak""));
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1375,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""the quick brown fox""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1376,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""the quick brown fox""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1377,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","#include <stdio.h>
#include <string.h>

int process_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", process_palindrome(""civic""));
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1378,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","#include <stdio.h>
#include <string.h>

int compute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", compute_palindrome(""civic""));
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1379,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>

int process_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", process_palindrome(""never odd or even""));
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1380,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

int handle_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", handle_palindrome(""python programming""));
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1381,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

int execute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", execute_palindrome(""python programming""));
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1382,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","#include <stdio.h>
#include <string.h>

int apply_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", apply_palindrome(""deified""));
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1383,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""deified""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1384,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""algorithms and data structures""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1385,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

int perform_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", perform_palindrome(""algorithms and data structures""));
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1386,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

int run_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", run_palindrome(""rotor""));
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1387,C,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

int compute_palindrome(const char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) return 0;
    }
    return 1;
}

int main(void) {
    printf(""%d\n"", compute_palindrome(""rotor""));
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1388,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","#include <iostream>
#include <algorithm>
#include <string>

bool compute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << compute_palindrome(""racecar"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1389,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""racecar"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1390,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""hello world"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1391,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","#include <iostream>
#include <algorithm>
#include <string>

bool process_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << process_palindrome(""hello world"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1392,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <algorithm>
#include <string>

bool handle_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << handle_palindrome(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1393,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1394,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""Rust is fun"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1395,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""level"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1396,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""level"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1397,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","#include <iostream>
#include <algorithm>
#include <string>

bool perform_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << perform_palindrome(""OpenAI Claude"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1398,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""OpenAI Claude"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1399,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <algorithm>
#include <string>

bool compute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << compute_palindrome(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1400,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""noon"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1401,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""noon"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1402,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","#include <iostream>
#include <algorithm>
#include <string>

bool compute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << compute_palindrome(""data science"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1403,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""data science"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1404,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","#include <iostream>
#include <algorithm>
#include <string>

bool process_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << process_palindrome(""step on no pets"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1405,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""step on no pets"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1406,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""coding"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1407,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","#include <iostream>
#include <algorithm>
#include <string>

bool handle_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << handle_palindrome(""coding"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1408,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","#include <iostream>
#include <algorithm>
#include <string>

bool handle_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << handle_palindrome(""madam im adam"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1409,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","#include <iostream>
#include <algorithm>
#include <string>

bool perform_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << perform_palindrome(""madam im adam"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1410,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""kayak"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1411,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","#include <iostream>
#include <algorithm>
#include <string>

bool compute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << compute_palindrome(""kayak"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1412,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","#include <iostream>
#include <algorithm>
#include <string>

bool perform_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << perform_palindrome(""the quick brown fox"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1413,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","#include <iostream>
#include <algorithm>
#include <string>

bool handle_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << handle_palindrome(""the quick brown fox"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'handle_palindrome'."
1414,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""civic"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1415,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""civic"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1416,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""never odd or even"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1417,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""never odd or even"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1418,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""python programming"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1419,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","#include <iostream>
#include <algorithm>
#include <string>

bool perform_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << perform_palindrome(""python programming"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1420,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","#include <iostream>
#include <algorithm>
#include <string>

bool apply_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << apply_palindrome(""deified"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'apply_palindrome'."
1421,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","#include <iostream>
#include <algorithm>
#include <string>

bool compute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << compute_palindrome(""deified"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'compute_palindrome'."
1422,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","#include <iostream>
#include <algorithm>
#include <string>

bool perform_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << perform_palindrome(""algorithms and data structures"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'perform_palindrome'."
1423,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","#include <iostream>
#include <algorithm>
#include <string>

bool process_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << process_palindrome(""algorithms and data structures"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'process_palindrome'."
1424,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","#include <iostream>
#include <algorithm>
#include <string>

bool execute_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << execute_palindrome(""rotor"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'execute_palindrome'."
1425,C++,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","#include <iostream>
#include <algorithm>
#include <string>

bool run_palindrome(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::string reversed(s.rbegin(), s.rend());
    return s == reversed;
}

int main() {
    std::cout << run_palindrome(""rotor"") << std::endl;
    return 0;
}","Palindrome Check operation, function named 'run_palindrome'."
1426,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","fn perform_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", perform_palindrome(""racecar""));
}","Palindrome Check operation, function named 'perform_palindrome'."
1427,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""racecar"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""racecar""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1428,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""hello world""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1429,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""hello world"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""hello world""));
}","Palindrome Check operation, function named 'process_palindrome'."
1430,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","fn apply_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", apply_palindrome(""A man a plan a canal Panama""));
}","Palindrome Check operation, function named 'apply_palindrome'."
1431,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""A man a plan a canal Panama"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""A man a plan a canal Panama""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1432,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","fn apply_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", apply_palindrome(""Rust is fun""));
}","Palindrome Check operation, function named 'apply_palindrome'."
1433,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""Rust is fun"".","fn run_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", run_palindrome(""Rust is fun""));
}","Palindrome Check operation, function named 'run_palindrome'."
1434,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","fn apply_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", apply_palindrome(""level""));
}","Palindrome Check operation, function named 'apply_palindrome'."
1435,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""level"".","fn perform_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", perform_palindrome(""level""));
}","Palindrome Check operation, function named 'perform_palindrome'."
1436,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""OpenAI Claude""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1437,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""OpenAI Claude"".","fn perform_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", perform_palindrome(""OpenAI Claude""));
}","Palindrome Check operation, function named 'perform_palindrome'."
1438,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","fn run_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", run_palindrome(""was it a car or a cat i saw""));
}","Palindrome Check operation, function named 'run_palindrome'."
1439,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""was it a car or a cat i saw"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""was it a car or a cat i saw""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1440,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""noon"".","fn execute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", execute_palindrome(""noon""));
}","Palindrome Check operation, function named 'execute_palindrome'."
1441,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""data science""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1442,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""data science"".","fn run_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", run_palindrome(""data science""));
}","Palindrome Check operation, function named 'run_palindrome'."
1443,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""step on no pets""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1444,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""step on no pets"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""step on no pets""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1445,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","fn perform_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", perform_palindrome(""coding""));
}","Palindrome Check operation, function named 'perform_palindrome'."
1446,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""coding"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""coding""));
}","Palindrome Check operation, function named 'process_palindrome'."
1447,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""madam im adam""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1448,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""madam im adam"".","fn run_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", run_palindrome(""madam im adam""));
}","Palindrome Check operation, function named 'run_palindrome'."
1449,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""kayak""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1450,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""kayak"".","fn execute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", execute_palindrome(""kayak""));
}","Palindrome Check operation, function named 'execute_palindrome'."
1451,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","fn handle_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", handle_palindrome(""the quick brown fox""));
}","Palindrome Check operation, function named 'handle_palindrome'."
1452,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""the quick brown fox"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""the quick brown fox""));
}","Palindrome Check operation, function named 'process_palindrome'."
1453,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","fn execute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", execute_palindrome(""civic""));
}","Palindrome Check operation, function named 'execute_palindrome'."
1454,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""civic"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""civic""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1455,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""never odd or even""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1456,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""never odd or even"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""never odd or even""));
}","Palindrome Check operation, function named 'process_palindrome'."
1457,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""python programming"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""python programming""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1458,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","fn execute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", execute_palindrome(""deified""));
}","Palindrome Check operation, function named 'execute_palindrome'."
1459,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""deified"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""deified""));
}","Palindrome Check operation, function named 'process_palindrome'."
1460,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","fn execute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", execute_palindrome(""algorithms and data structures""));
}","Palindrome Check operation, function named 'execute_palindrome'."
1461,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""algorithms and data structures"".","fn compute_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", compute_palindrome(""algorithms and data structures""));
}","Palindrome Check operation, function named 'compute_palindrome'."
1462,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","fn process_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", process_palindrome(""rotor""));
}","Palindrome Check operation, function named 'process_palindrome'."
1463,Rust,String Manipulation,intermediate,"Perform 'palindrome check' on the string ""rotor"".","fn perform_palindrome(s: &str) -> bool {
    let cleaned: String = s.to_lowercase().chars().filter(|c| *c != ' ').collect();
    let reversed: String = cleaned.chars().rev().collect();
    cleaned == reversed
}

fn main() {
    println!(""{}"", perform_palindrome(""rotor""));
}","Palindrome Check operation, function named 'perform_palindrome'."
1464,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","def compute_reverse(s):
    return s[::-1]

print(compute_reverse('racecar'))","Reverse operation, function named 'compute_reverse'."
1465,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('racecar'))","Reverse operation, function named 'perform_reverse'."
1466,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","def run_reverse(s):
    return s[::-1]

print(run_reverse('hello world'))","Reverse operation, function named 'run_reverse'."
1467,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('A man a plan a canal Panama'))","Reverse operation, function named 'process_reverse'."
1468,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('A man a plan a canal Panama'))","Reverse operation, function named 'perform_reverse'."
1469,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('Rust is fun'))","Reverse operation, function named 'perform_reverse'."
1470,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","def compute_reverse(s):
    return s[::-1]

print(compute_reverse('Rust is fun'))","Reverse operation, function named 'compute_reverse'."
1471,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","def compute_reverse(s):
    return s[::-1]

print(compute_reverse('level'))","Reverse operation, function named 'compute_reverse'."
1472,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('level'))","Reverse operation, function named 'perform_reverse'."
1473,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('OpenAI Claude'))","Reverse operation, function named 'process_reverse'."
1474,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","def execute_reverse(s):
    return s[::-1]

print(execute_reverse('OpenAI Claude'))","Reverse operation, function named 'execute_reverse'."
1475,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('was it a car or a cat i saw'))","Reverse operation, function named 'apply_reverse'."
1476,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('was it a car or a cat i saw'))","Reverse operation, function named 'process_reverse'."
1477,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('noon'))","Reverse operation, function named 'apply_reverse'."
1478,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('noon'))","Reverse operation, function named 'perform_reverse'."
1479,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","def run_reverse(s):
    return s[::-1]

print(run_reverse('data science'))","Reverse operation, function named 'run_reverse'."
1480,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","def execute_reverse(s):
    return s[::-1]

print(execute_reverse('data science'))","Reverse operation, function named 'execute_reverse'."
1481,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('step on no pets'))","Reverse operation, function named 'perform_reverse'."
1482,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","def run_reverse(s):
    return s[::-1]

print(run_reverse('step on no pets'))","Reverse operation, function named 'run_reverse'."
1483,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","def run_reverse(s):
    return s[::-1]

print(run_reverse('coding'))","Reverse operation, function named 'run_reverse'."
1484,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","def handle_reverse(s):
    return s[::-1]

print(handle_reverse('coding'))","Reverse operation, function named 'handle_reverse'."
1485,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","def run_reverse(s):
    return s[::-1]

print(run_reverse('madam im adam'))","Reverse operation, function named 'run_reverse'."
1486,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('madam im adam'))","Reverse operation, function named 'perform_reverse'."
1487,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('kayak'))","Reverse operation, function named 'apply_reverse'."
1488,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('kayak'))","Reverse operation, function named 'perform_reverse'."
1489,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('the quick brown fox'))","Reverse operation, function named 'apply_reverse'."
1490,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","def execute_reverse(s):
    return s[::-1]

print(execute_reverse('the quick brown fox'))","Reverse operation, function named 'execute_reverse'."
1491,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('civic'))","Reverse operation, function named 'apply_reverse'."
1492,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('civic'))","Reverse operation, function named 'process_reverse'."
1493,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('never odd or even'))","Reverse operation, function named 'process_reverse'."
1494,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","def compute_reverse(s):
    return s[::-1]

print(compute_reverse('never odd or even'))","Reverse operation, function named 'compute_reverse'."
1495,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","def process_reverse(s):
    return s[::-1]

print(process_reverse('python programming'))","Reverse operation, function named 'process_reverse'."
1496,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","def execute_reverse(s):
    return s[::-1]

print(execute_reverse('python programming'))","Reverse operation, function named 'execute_reverse'."
1497,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('deified'))","Reverse operation, function named 'perform_reverse'."
1498,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","def handle_reverse(s):
    return s[::-1]

print(handle_reverse('deified'))","Reverse operation, function named 'handle_reverse'."
1499,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","def perform_reverse(s):
    return s[::-1]

print(perform_reverse('algorithms and data structures'))","Reverse operation, function named 'perform_reverse'."
1500,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","def handle_reverse(s):
    return s[::-1]

print(handle_reverse('rotor'))","Reverse operation, function named 'handle_reverse'."
1501,Python,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","def apply_reverse(s):
    return s[::-1]

print(apply_reverse('rotor'))","Reverse operation, function named 'apply_reverse'."
1502,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""racecar""));","Reverse operation, function named 'apply_reverse'."
1503,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(handle_reverse(""racecar""));","Reverse operation, function named 'handle_reverse'."
1504,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""hello world""));","Reverse operation, function named 'process_reverse'."
1505,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(run_reverse(""hello world""));","Reverse operation, function named 'run_reverse'."
1506,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""A man a plan a canal Panama""));","Reverse operation, function named 'apply_reverse'."
1507,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""Rust is fun""));","Reverse operation, function named 'process_reverse'."
1508,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(run_reverse(""level""));","Reverse operation, function named 'run_reverse'."
1509,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""level""));","Reverse operation, function named 'perform_reverse'."
1510,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""OpenAI Claude""));","Reverse operation, function named 'perform_reverse'."
1511,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""OpenAI Claude""));","Reverse operation, function named 'process_reverse'."
1512,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(compute_reverse(""was it a car or a cat i saw""));","Reverse operation, function named 'compute_reverse'."
1513,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""was it a car or a cat i saw""));","Reverse operation, function named 'process_reverse'."
1514,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""noon""));","Reverse operation, function named 'apply_reverse'."
1515,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(execute_reverse(""noon""));","Reverse operation, function named 'execute_reverse'."
1516,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(compute_reverse(""data science""));","Reverse operation, function named 'compute_reverse'."
1517,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""data science""));","Reverse operation, function named 'apply_reverse'."
1518,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(handle_reverse(""step on no pets""));","Reverse operation, function named 'handle_reverse'."
1519,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""step on no pets""));","Reverse operation, function named 'perform_reverse'."
1520,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(execute_reverse(""coding""));","Reverse operation, function named 'execute_reverse'."
1521,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""coding""));","Reverse operation, function named 'perform_reverse'."
1522,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""madam im adam""));","Reverse operation, function named 'process_reverse'."
1523,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(compute_reverse(""madam im adam""));","Reverse operation, function named 'compute_reverse'."
1524,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""kayak""));","Reverse operation, function named 'apply_reverse'."
1525,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""kayak""));","Reverse operation, function named 'perform_reverse'."
1526,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""the quick brown fox""));","Reverse operation, function named 'apply_reverse'."
1527,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(compute_reverse(""the quick brown fox""));","Reverse operation, function named 'compute_reverse'."
1528,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""civic""));","Reverse operation, function named 'perform_reverse'."
1529,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(handle_reverse(""civic""));","Reverse operation, function named 'handle_reverse'."
1530,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(execute_reverse(""never odd or even""));","Reverse operation, function named 'execute_reverse'."
1531,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""never odd or even""));","Reverse operation, function named 'perform_reverse'."
1532,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(compute_reverse(""python programming""));","Reverse operation, function named 'compute_reverse'."
1533,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(execute_reverse(""python programming""));","Reverse operation, function named 'execute_reverse'."
1534,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(process_reverse(""deified""));","Reverse operation, function named 'process_reverse'."
1535,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""deified""));","Reverse operation, function named 'perform_reverse'."
1536,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(run_reverse(""algorithms and data structures""));","Reverse operation, function named 'run_reverse'."
1537,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(apply_reverse(""rotor""));","Reverse operation, function named 'apply_reverse'."
1538,JavaScript,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

console.log(perform_reverse(""rotor""));","Reverse operation, function named 'perform_reverse'."
1539,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""racecar""));","Reverse operation, function named 'perform_reverse'."
1540,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""racecar""));","Reverse operation, function named 'process_reverse'."
1541,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""hello world""));","Reverse operation, function named 'process_reverse'."
1542,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { handle_reverse };
console.log(handle_reverse(""hello world""));","Reverse operation, function named 'handle_reverse'."
1543,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { apply_reverse };
console.log(apply_reverse(""A man a plan a canal Panama""));","Reverse operation, function named 'apply_reverse'."
1544,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""Rust is fun""));","Reverse operation, function named 'execute_reverse'."
1545,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { handle_reverse };
console.log(handle_reverse(""Rust is fun""));","Reverse operation, function named 'handle_reverse'."
1546,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""level""));","Reverse operation, function named 'perform_reverse'."
1547,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { compute_reverse };
console.log(compute_reverse(""level""));","Reverse operation, function named 'compute_reverse'."
1548,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""OpenAI Claude""));","Reverse operation, function named 'process_reverse'."
1549,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { handle_reverse };
console.log(handle_reverse(""OpenAI Claude""));","Reverse operation, function named 'handle_reverse'."
1550,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { run_reverse };
console.log(run_reverse(""was it a car or a cat i saw""));","Reverse operation, function named 'run_reverse'."
1551,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""was it a car or a cat i saw""));","Reverse operation, function named 'process_reverse'."
1552,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { compute_reverse };
console.log(compute_reverse(""noon""));","Reverse operation, function named 'compute_reverse'."
1553,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""noon""));","Reverse operation, function named 'execute_reverse'."
1554,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { handle_reverse };
console.log(handle_reverse(""data science""));","Reverse operation, function named 'handle_reverse'."
1555,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""data science""));","Reverse operation, function named 'perform_reverse'."
1556,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""step on no pets""));","Reverse operation, function named 'execute_reverse'."
1557,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { run_reverse };
console.log(run_reverse(""step on no pets""));","Reverse operation, function named 'run_reverse'."
1558,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","function handle_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { handle_reverse };
console.log(handle_reverse(""coding""));","Reverse operation, function named 'handle_reverse'."
1559,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""coding""));","Reverse operation, function named 'perform_reverse'."
1560,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""madam im adam""));","Reverse operation, function named 'perform_reverse'."
1561,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { apply_reverse };
console.log(apply_reverse(""madam im adam""));","Reverse operation, function named 'apply_reverse'."
1562,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { apply_reverse };
console.log(apply_reverse(""kayak""));","Reverse operation, function named 'apply_reverse'."
1563,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""kayak""));","Reverse operation, function named 'process_reverse'."
1564,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { compute_reverse };
console.log(compute_reverse(""the quick brown fox""));","Reverse operation, function named 'compute_reverse'."
1565,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""civic""));","Reverse operation, function named 'execute_reverse'."
1566,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { compute_reverse };
console.log(compute_reverse(""civic""));","Reverse operation, function named 'compute_reverse'."
1567,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""never odd or even""));","Reverse operation, function named 'process_reverse'."
1568,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","function compute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { compute_reverse };
console.log(compute_reverse(""never odd or even""));","Reverse operation, function named 'compute_reverse'."
1569,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { run_reverse };
console.log(run_reverse(""python programming""));","Reverse operation, function named 'run_reverse'."
1570,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""python programming""));","Reverse operation, function named 'execute_reverse'."
1571,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","function apply_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { apply_reverse };
console.log(apply_reverse(""deified""));","Reverse operation, function named 'apply_reverse'."
1572,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","function perform_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { perform_reverse };
console.log(perform_reverse(""deified""));","Reverse operation, function named 'perform_reverse'."
1573,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""algorithms and data structures""));","Reverse operation, function named 'process_reverse'."
1574,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","function execute_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { execute_reverse };
console.log(execute_reverse(""algorithms and data structures""));","Reverse operation, function named 'execute_reverse'."
1575,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","function run_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { run_reverse };
console.log(run_reverse(""rotor""));","Reverse operation, function named 'run_reverse'."
1576,Node.js,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","function process_reverse(s) {
  return s.split("""").reverse().join("""");
}

module.exports = { process_reverse };
console.log(process_reverse(""rotor""));","Reverse operation, function named 'process_reverse'."
1577,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""racecar""));
    }
}","Reverse operation, function named 'process_reverse'."
1578,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""hello world""));
    }
}","Reverse operation, function named 'handle_reverse'."
1579,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""hello world""));
    }
}","Reverse operation, function named 'perform_reverse'."
1580,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""A man a plan a canal Panama""));
    }
}","Reverse operation, function named 'process_reverse'."
1581,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""A man a plan a canal Panama""));
    }
}","Reverse operation, function named 'handle_reverse'."
1582,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""Rust is fun""));
    }
}","Reverse operation, function named 'compute_reverse'."
1583,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","public class Main {
    static String execute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(execute_reverse(""Rust is fun""));
    }
}","Reverse operation, function named 'execute_reverse'."
1584,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""level""));
    }
}","Reverse operation, function named 'perform_reverse'."
1585,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""level""));
    }
}","Reverse operation, function named 'process_reverse'."
1586,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","public class Main {
    static String apply_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(apply_reverse(""OpenAI Claude""));
    }
}","Reverse operation, function named 'apply_reverse'."
1587,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""OpenAI Claude""));
    }
}","Reverse operation, function named 'handle_reverse'."
1588,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","public class Main {
    static String apply_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(apply_reverse(""was it a car or a cat i saw""));
    }
}","Reverse operation, function named 'apply_reverse'."
1589,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""was it a car or a cat i saw""));
    }
}","Reverse operation, function named 'process_reverse'."
1590,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""noon""));
    }
}","Reverse operation, function named 'handle_reverse'."
1591,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""noon""));
    }
}","Reverse operation, function named 'perform_reverse'."
1592,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""data science""));
    }
}","Reverse operation, function named 'compute_reverse'."
1593,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","public class Main {
    static String run_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(run_reverse(""data science""));
    }
}","Reverse operation, function named 'run_reverse'."
1594,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""step on no pets""));
    }
}","Reverse operation, function named 'process_reverse'."
1595,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""step on no pets""));
    }
}","Reverse operation, function named 'perform_reverse'."
1596,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""coding""));
    }
}","Reverse operation, function named 'handle_reverse'."
1597,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""coding""));
    }
}","Reverse operation, function named 'compute_reverse'."
1598,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","public class Main {
    static String apply_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(apply_reverse(""madam im adam""));
    }
}","Reverse operation, function named 'apply_reverse'."
1599,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""madam im adam""));
    }
}","Reverse operation, function named 'perform_reverse'."
1600,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""kayak""));
    }
}","Reverse operation, function named 'perform_reverse'."
1601,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","public class Main {
    static String apply_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(apply_reverse(""kayak""));
    }
}","Reverse operation, function named 'apply_reverse'."
1602,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""the quick brown fox""));
    }
}","Reverse operation, function named 'handle_reverse'."
1603,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""the quick brown fox""));
    }
}","Reverse operation, function named 'perform_reverse'."
1604,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","public class Main {
    static String apply_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(apply_reverse(""civic""));
    }
}","Reverse operation, function named 'apply_reverse'."
1605,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""civic""));
    }
}","Reverse operation, function named 'perform_reverse'."
1606,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""never odd or even""));
    }
}","Reverse operation, function named 'handle_reverse'."
1607,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""never odd or even""));
    }
}","Reverse operation, function named 'compute_reverse'."
1608,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","public class Main {
    static String process_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(process_reverse(""python programming""));
    }
}","Reverse operation, function named 'process_reverse'."
1609,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","public class Main {
    static String run_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(run_reverse(""python programming""));
    }
}","Reverse operation, function named 'run_reverse'."
1610,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","public class Main {
    static String perform_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(perform_reverse(""deified""));
    }
}","Reverse operation, function named 'perform_reverse'."
1611,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""deified""));
    }
}","Reverse operation, function named 'compute_reverse'."
1612,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""algorithms and data structures""));
    }
}","Reverse operation, function named 'handle_reverse'."
1613,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","public class Main {
    static String compute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(compute_reverse(""algorithms and data structures""));
    }
}","Reverse operation, function named 'compute_reverse'."
1614,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","public class Main {
    static String handle_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(handle_reverse(""rotor""));
    }
}","Reverse operation, function named 'handle_reverse'."
1615,Java,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","public class Main {
    static String execute_reverse(String s) {
        return new StringBuilder(s).reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println(execute_reverse(""rotor""));
    }
}","Reverse operation, function named 'execute_reverse'."
1616,C,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""racecar"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1617,C,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""racecar"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1618,C,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""hello world"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1619,C,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

void apply_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""hello world"";
    apply_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1620,C,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""A man a plan a canal Panama"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1621,C,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""A man a plan a canal Panama"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1622,C,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""Rust is fun"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1623,C,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""level"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1624,C,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

void perform_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""OpenAI Claude"";
    perform_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1625,C,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""OpenAI Claude"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1626,C,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""was it a car or a cat i saw"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1627,C,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

void process_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""was it a car or a cat i saw"";
    process_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'process_reverse'."
1628,C,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""noon"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1629,C,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""noon"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1630,C,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","#include <stdio.h>
#include <string.h>

void execute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""data science"";
    execute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1631,C,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""data science"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1632,C,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""step on no pets"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1633,C,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>

void apply_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""step on no pets"";
    apply_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1634,C,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","#include <stdio.h>
#include <string.h>

void perform_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""coding"";
    perform_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1635,C,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","#include <stdio.h>
#include <string.h>

void execute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""coding"";
    execute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1636,C,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""madam im adam"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1637,C,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>

void apply_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""madam im adam"";
    apply_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1638,C,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","#include <stdio.h>
#include <string.h>

void perform_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""kayak"";
    perform_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1639,C,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

void apply_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""the quick brown fox"";
    apply_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1640,C,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""the quick brown fox"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1641,C,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","#include <stdio.h>
#include <string.h>

void process_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""civic"";
    process_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'process_reverse'."
1642,C,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","#include <stdio.h>
#include <string.h>

void apply_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""civic"";
    apply_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1643,C,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>

void execute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""never odd or even"";
    execute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1644,C,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""never odd or even"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1645,C,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""python programming"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1646,C,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

void execute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""python programming"";
    execute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1647,C,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","#include <stdio.h>
#include <string.h>

void execute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""deified"";
    execute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1648,C,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","#include <stdio.h>
#include <string.h>

void handle_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""deified"";
    handle_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1649,C,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

void perform_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""algorithms and data structures"";
    perform_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1650,C,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

void run_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""algorithms and data structures"";
    run_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'run_reverse'."
1651,C,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

void compute_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""rotor"";
    compute_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1652,C,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

void perform_reverse(char* s) {
    int len = (int) strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char t = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = t;
    }
}

int main(void) {
    char s[] = ""rotor"";
    perform_reverse(s);
    printf(""%s\n"", s);
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1653,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","#include <iostream>
#include <string>
#include <algorithm>

std::string apply_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << apply_reverse(""racecar"") << std::endl;
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1654,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""racecar"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1655,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","#include <iostream>
#include <string>
#include <algorithm>

std::string apply_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << apply_reverse(""hello world"") << std::endl;
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1656,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""hello world"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1657,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <string>
#include <algorithm>

std::string handle_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << handle_reverse(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1658,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1659,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""Rust is fun"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1660,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""Rust is fun"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1661,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""level"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1662,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","#include <iostream>
#include <string>
#include <algorithm>

std::string apply_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << apply_reverse(""level"") << std::endl;
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1663,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""OpenAI Claude"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1664,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","#include <iostream>
#include <string>
#include <algorithm>

std::string apply_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << apply_reverse(""OpenAI Claude"") << std::endl;
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1665,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1666,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <string>
#include <algorithm>

std::string process_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << process_reverse(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Reverse operation, function named 'process_reverse'."
1667,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""noon"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1668,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","#include <iostream>
#include <string>
#include <algorithm>

std::string apply_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << apply_reverse(""noon"") << std::endl;
    return 0;
}","Reverse operation, function named 'apply_reverse'."
1669,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","#include <iostream>
#include <string>
#include <algorithm>

std::string handle_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << handle_reverse(""data science"") << std::endl;
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1670,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""data science"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1671,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","#include <iostream>
#include <string>
#include <algorithm>

std::string handle_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << handle_reverse(""step on no pets"") << std::endl;
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1672,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","#include <iostream>
#include <string>
#include <algorithm>

std::string run_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << run_reverse(""step on no pets"") << std::endl;
    return 0;
}","Reverse operation, function named 'run_reverse'."
1673,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""coding"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1674,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","#include <iostream>
#include <string>
#include <algorithm>

std::string process_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << process_reverse(""coding"") << std::endl;
    return 0;
}","Reverse operation, function named 'process_reverse'."
1675,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","#include <iostream>
#include <string>
#include <algorithm>

std::string process_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << process_reverse(""madam im adam"") << std::endl;
    return 0;
}","Reverse operation, function named 'process_reverse'."
1676,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""madam im adam"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1677,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""kayak"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1678,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","#include <iostream>
#include <string>
#include <algorithm>

std::string handle_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << handle_reverse(""the quick brown fox"") << std::endl;
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1679,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","#include <iostream>
#include <string>
#include <algorithm>

std::string run_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << run_reverse(""the quick brown fox"") << std::endl;
    return 0;
}","Reverse operation, function named 'run_reverse'."
1680,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","#include <iostream>
#include <string>
#include <algorithm>

std::string handle_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << handle_reverse(""civic"") << std::endl;
    return 0;
}","Reverse operation, function named 'handle_reverse'."
1681,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","#include <iostream>
#include <string>
#include <algorithm>

std::string run_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << run_reverse(""civic"") << std::endl;
    return 0;
}","Reverse operation, function named 'run_reverse'."
1682,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""never odd or even"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1683,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""never odd or even"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1684,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""python programming"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1685,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""python programming"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1686,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","#include <iostream>
#include <string>
#include <algorithm>

std::string run_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << run_reverse(""deified"") << std::endl;
    return 0;
}","Reverse operation, function named 'run_reverse'."
1687,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""deified"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1688,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","#include <iostream>
#include <string>
#include <algorithm>

std::string execute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << execute_reverse(""algorithms and data structures"") << std::endl;
    return 0;
}","Reverse operation, function named 'execute_reverse'."
1689,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","#include <iostream>
#include <string>
#include <algorithm>

std::string process_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << process_reverse(""algorithms and data structures"") << std::endl;
    return 0;
}","Reverse operation, function named 'process_reverse'."
1690,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","#include <iostream>
#include <string>
#include <algorithm>

std::string compute_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << compute_reverse(""rotor"") << std::endl;
    return 0;
}","Reverse operation, function named 'compute_reverse'."
1691,C++,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","#include <iostream>
#include <string>
#include <algorithm>

std::string perform_reverse(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << perform_reverse(""rotor"") << std::endl;
    return 0;
}","Reverse operation, function named 'perform_reverse'."
1692,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","fn process_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", process_reverse(""racecar""));
}","Reverse operation, function named 'process_reverse'."
1693,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""racecar"".","fn perform_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", perform_reverse(""racecar""));
}","Reverse operation, function named 'perform_reverse'."
1694,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""hello world""));
}","Reverse operation, function named 'compute_reverse'."
1695,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""hello world"".","fn apply_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", apply_reverse(""hello world""));
}","Reverse operation, function named 'apply_reverse'."
1696,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","fn process_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", process_reverse(""A man a plan a canal Panama""));
}","Reverse operation, function named 'process_reverse'."
1697,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""A man a plan a canal Panama"".","fn handle_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", handle_reverse(""A man a plan a canal Panama""));
}","Reverse operation, function named 'handle_reverse'."
1698,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""Rust is fun"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""Rust is fun""));
}","Reverse operation, function named 'run_reverse'."
1699,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""level"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""level""));
}","Reverse operation, function named 'compute_reverse'."
1700,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","fn perform_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", perform_reverse(""OpenAI Claude""));
}","Reverse operation, function named 'perform_reverse'."
1701,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""OpenAI Claude"".","fn process_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", process_reverse(""OpenAI Claude""));
}","Reverse operation, function named 'process_reverse'."
1702,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","fn handle_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", handle_reverse(""was it a car or a cat i saw""));
}","Reverse operation, function named 'handle_reverse'."
1703,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""was it a car or a cat i saw"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""was it a car or a cat i saw""));
}","Reverse operation, function named 'compute_reverse'."
1704,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""noon""));
}","Reverse operation, function named 'compute_reverse'."
1705,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""noon"".","fn handle_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", handle_reverse(""noon""));
}","Reverse operation, function named 'handle_reverse'."
1706,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""data science""));
}","Reverse operation, function named 'run_reverse'."
1707,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""data science"".","fn execute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", execute_reverse(""data science""));
}","Reverse operation, function named 'execute_reverse'."
1708,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","fn handle_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", handle_reverse(""step on no pets""));
}","Reverse operation, function named 'handle_reverse'."
1709,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""step on no pets"".","fn apply_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", apply_reverse(""step on no pets""));
}","Reverse operation, function named 'apply_reverse'."
1710,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","fn process_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", process_reverse(""coding""));
}","Reverse operation, function named 'process_reverse'."
1711,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""coding"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""coding""));
}","Reverse operation, function named 'run_reverse'."
1712,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","fn apply_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", apply_reverse(""madam im adam""));
}","Reverse operation, function named 'apply_reverse'."
1713,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""madam im adam"".","fn execute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", execute_reverse(""madam im adam""));
}","Reverse operation, function named 'execute_reverse'."
1714,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""kayak""));
}","Reverse operation, function named 'run_reverse'."
1715,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""kayak"".","fn execute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", execute_reverse(""kayak""));
}","Reverse operation, function named 'execute_reverse'."
1716,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","fn execute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", execute_reverse(""the quick brown fox""));
}","Reverse operation, function named 'execute_reverse'."
1717,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""the quick brown fox"".","fn perform_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", perform_reverse(""the quick brown fox""));
}","Reverse operation, function named 'perform_reverse'."
1718,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""civic""));
}","Reverse operation, function named 'run_reverse'."
1719,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""civic"".","fn perform_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", perform_reverse(""civic""));
}","Reverse operation, function named 'perform_reverse'."
1720,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""never odd or even"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""never odd or even""));
}","Reverse operation, function named 'run_reverse'."
1721,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","fn apply_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", apply_reverse(""python programming""));
}","Reverse operation, function named 'apply_reverse'."
1722,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""python programming"".","fn handle_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", handle_reverse(""python programming""));
}","Reverse operation, function named 'handle_reverse'."
1723,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""deified""));
}","Reverse operation, function named 'compute_reverse'."
1724,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""deified"".","fn perform_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", perform_reverse(""deified""));
}","Reverse operation, function named 'perform_reverse'."
1725,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""algorithms and data structures""));
}","Reverse operation, function named 'compute_reverse'."
1726,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""algorithms and data structures"".","fn execute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", execute_reverse(""algorithms and data structures""));
}","Reverse operation, function named 'execute_reverse'."
1727,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","fn compute_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", compute_reverse(""rotor""));
}","Reverse operation, function named 'compute_reverse'."
1728,Rust,String Manipulation,beginner,"Perform 'reverse' on the string ""rotor"".","fn run_reverse(s: &str) -> String {
    s.chars().rev().collect()
}

fn main() {
    println!(""{}"", run_reverse(""rotor""));
}","Reverse operation, function named 'run_reverse'."
1729,Python,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","def perform_word(s):
    return len(s.split())

print(perform_word('racecar'))","Word Count operation, function named 'perform_word'."
1730,Python,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","def run_word(s):
    return len(s.split())

print(run_word('racecar'))","Word Count operation, function named 'run_word'."
1731,Python,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","def compute_word(s):
    return len(s.split())

print(compute_word('hello world'))","Word Count operation, function named 'compute_word'."
1732,Python,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","def process_word(s):
    return len(s.split())

print(process_word('hello world'))","Word Count operation, function named 'process_word'."
1733,Python,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","def handle_word(s):
    return len(s.split())

print(handle_word('A man a plan a canal Panama'))","Word Count operation, function named 'handle_word'."
1734,Python,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","def apply_word(s):
    return len(s.split())

print(apply_word('A man a plan a canal Panama'))","Word Count operation, function named 'apply_word'."
1735,Python,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","def execute_word(s):
    return len(s.split())

print(execute_word('Rust is fun'))","Word Count operation, function named 'execute_word'."
1736,Python,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","def process_word(s):
    return len(s.split())

print(process_word('Rust is fun'))","Word Count operation, function named 'process_word'."
1737,Python,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","def run_word(s):
    return len(s.split())

print(run_word('level'))","Word Count operation, function named 'run_word'."
1738,Python,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","def apply_word(s):
    return len(s.split())

print(apply_word('OpenAI Claude'))","Word Count operation, function named 'apply_word'."
1739,Python,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","def compute_word(s):
    return len(s.split())

print(compute_word('OpenAI Claude'))","Word Count operation, function named 'compute_word'."
1740,Python,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","def execute_word(s):
    return len(s.split())

print(execute_word('was it a car or a cat i saw'))","Word Count operation, function named 'execute_word'."
1741,Python,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","def run_word(s):
    return len(s.split())

print(run_word('was it a car or a cat i saw'))","Word Count operation, function named 'run_word'."
1742,Python,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","def execute_word(s):
    return len(s.split())

print(execute_word('noon'))","Word Count operation, function named 'execute_word'."
1743,Python,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","def process_word(s):
    return len(s.split())

print(process_word('noon'))","Word Count operation, function named 'process_word'."
1744,Python,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","def handle_word(s):
    return len(s.split())

print(handle_word('data science'))","Word Count operation, function named 'handle_word'."
1745,Python,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","def execute_word(s):
    return len(s.split())

print(execute_word('data science'))","Word Count operation, function named 'execute_word'."
1746,Python,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","def handle_word(s):
    return len(s.split())

print(handle_word('step on no pets'))","Word Count operation, function named 'handle_word'."
1747,Python,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","def compute_word(s):
    return len(s.split())

print(compute_word('step on no pets'))","Word Count operation, function named 'compute_word'."
1748,Python,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","def execute_word(s):
    return len(s.split())

print(execute_word('coding'))","Word Count operation, function named 'execute_word'."
1749,Python,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","def perform_word(s):
    return len(s.split())

print(perform_word('coding'))","Word Count operation, function named 'perform_word'."
1750,Python,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","def execute_word(s):
    return len(s.split())

print(execute_word('madam im adam'))","Word Count operation, function named 'execute_word'."
1751,Python,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","def handle_word(s):
    return len(s.split())

print(handle_word('madam im adam'))","Word Count operation, function named 'handle_word'."
1752,Python,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","def execute_word(s):
    return len(s.split())

print(execute_word('kayak'))","Word Count operation, function named 'execute_word'."
1753,Python,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","def apply_word(s):
    return len(s.split())

print(apply_word('kayak'))","Word Count operation, function named 'apply_word'."
1754,Python,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","def handle_word(s):
    return len(s.split())

print(handle_word('the quick brown fox'))","Word Count operation, function named 'handle_word'."
1755,Python,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","def perform_word(s):
    return len(s.split())

print(perform_word('civic'))","Word Count operation, function named 'perform_word'."
1756,Python,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","def compute_word(s):
    return len(s.split())

print(compute_word('civic'))","Word Count operation, function named 'compute_word'."
1757,Python,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","def apply_word(s):
    return len(s.split())

print(apply_word('never odd or even'))","Word Count operation, function named 'apply_word'."
1758,Python,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","def process_word(s):
    return len(s.split())

print(process_word('never odd or even'))","Word Count operation, function named 'process_word'."
1759,Python,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","def process_word(s):
    return len(s.split())

print(process_word('python programming'))","Word Count operation, function named 'process_word'."
1760,Python,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","def compute_word(s):
    return len(s.split())

print(compute_word('python programming'))","Word Count operation, function named 'compute_word'."
1761,Python,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","def apply_word(s):
    return len(s.split())

print(apply_word('deified'))","Word Count operation, function named 'apply_word'."
1762,Python,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","def handle_word(s):
    return len(s.split())

print(handle_word('algorithms and data structures'))","Word Count operation, function named 'handle_word'."
1763,Python,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","def apply_word(s):
    return len(s.split())

print(apply_word('algorithms and data structures'))","Word Count operation, function named 'apply_word'."
1764,Python,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","def compute_word(s):
    return len(s.split())

print(compute_word('rotor'))","Word Count operation, function named 'compute_word'."
1765,Python,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","def run_word(s):
    return len(s.split())

print(run_word('rotor'))","Word Count operation, function named 'run_word'."
1766,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""racecar""));","Word Count operation, function named 'run_word'."
1767,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""racecar""));","Word Count operation, function named 'handle_word'."
1768,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""hello world""));","Word Count operation, function named 'run_word'."
1769,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(process_word(""hello world""));","Word Count operation, function named 'process_word'."
1770,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""A man a plan a canal Panama""));","Word Count operation, function named 'perform_word'."
1771,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""A man a plan a canal Panama""));","Word Count operation, function named 'handle_word'."
1772,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""Rust is fun""));","Word Count operation, function named 'handle_word'."
1773,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(compute_word(""level""));","Word Count operation, function named 'compute_word'."
1774,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(process_word(""OpenAI Claude""));","Word Count operation, function named 'process_word'."
1775,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""OpenAI Claude""));","Word Count operation, function named 'handle_word'."
1776,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""was it a car or a cat i saw""));","Word Count operation, function named 'handle_word'."
1777,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(apply_word(""was it a car or a cat i saw""));","Word Count operation, function named 'apply_word'."
1778,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""noon""));","Word Count operation, function named 'handle_word'."
1779,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""noon""));","Word Count operation, function named 'run_word'."
1780,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(process_word(""data science""));","Word Count operation, function named 'process_word'."
1781,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""data science""));","Word Count operation, function named 'perform_word'."
1782,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""step on no pets""));","Word Count operation, function named 'handle_word'."
1783,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""coding""));","Word Count operation, function named 'perform_word'."
1784,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(execute_word(""coding""));","Word Count operation, function named 'execute_word'."
1785,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(apply_word(""madam im adam""));","Word Count operation, function named 'apply_word'."
1786,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(compute_word(""kayak""));","Word Count operation, function named 'compute_word'."
1787,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(process_word(""kayak""));","Word Count operation, function named 'process_word'."
1788,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""the quick brown fox""));","Word Count operation, function named 'run_word'."
1789,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""the quick brown fox""));","Word Count operation, function named 'handle_word'."
1790,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(compute_word(""civic""));","Word Count operation, function named 'compute_word'."
1791,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(process_word(""civic""));","Word Count operation, function named 'process_word'."
1792,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""never odd or even""));","Word Count operation, function named 'run_word'."
1793,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(execute_word(""never odd or even""));","Word Count operation, function named 'execute_word'."
1794,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""python programming""));","Word Count operation, function named 'perform_word'."
1795,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""python programming""));","Word Count operation, function named 'run_word'."
1796,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""deified""));","Word Count operation, function named 'perform_word'."
1797,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(handle_word(""deified""));","Word Count operation, function named 'handle_word'."
1798,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""algorithms and data structures""));","Word Count operation, function named 'run_word'."
1799,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(perform_word(""algorithms and data structures""));","Word Count operation, function named 'perform_word'."
1800,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(run_word(""rotor""));","Word Count operation, function named 'run_word'."
1801,JavaScript,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

console.log(apply_word(""rotor""));","Word Count operation, function named 'apply_word'."
1802,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""racecar""));","Word Count operation, function named 'run_word'."
1803,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { perform_word };
console.log(perform_word(""racecar""));","Word Count operation, function named 'perform_word'."
1804,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""hello world""));","Word Count operation, function named 'handle_word'."
1805,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""hello world""));","Word Count operation, function named 'apply_word'."
1806,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { process_word };
console.log(process_word(""A man a plan a canal Panama""));","Word Count operation, function named 'process_word'."
1807,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""A man a plan a canal Panama""));","Word Count operation, function named 'run_word'."
1808,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""Rust is fun""));","Word Count operation, function named 'handle_word'."
1809,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { compute_word };
console.log(compute_word(""Rust is fun""));","Word Count operation, function named 'compute_word'."
1810,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""level""));","Word Count operation, function named 'apply_word'."
1811,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""level""));","Word Count operation, function named 'handle_word'."
1812,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""OpenAI Claude""));","Word Count operation, function named 'run_word'."
1813,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""OpenAI Claude""));","Word Count operation, function named 'apply_word'."
1814,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { compute_word };
console.log(compute_word(""was it a car or a cat i saw""));","Word Count operation, function named 'compute_word'."
1815,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""noon""));","Word Count operation, function named 'apply_word'."
1816,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { perform_word };
console.log(perform_word(""noon""));","Word Count operation, function named 'perform_word'."
1817,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { perform_word };
console.log(perform_word(""data science""));","Word Count operation, function named 'perform_word'."
1818,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""data science""));","Word Count operation, function named 'apply_word'."
1819,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""step on no pets""));","Word Count operation, function named 'run_word'."
1820,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { execute_word };
console.log(execute_word(""step on no pets""));","Word Count operation, function named 'execute_word'."
1821,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""coding""));","Word Count operation, function named 'run_word'."
1822,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { execute_word };
console.log(execute_word(""coding""));","Word Count operation, function named 'execute_word'."
1823,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { process_word };
console.log(process_word(""madam im adam""));","Word Count operation, function named 'process_word'."
1824,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { compute_word };
console.log(compute_word(""madam im adam""));","Word Count operation, function named 'compute_word'."
1825,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","function run_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { run_word };
console.log(run_word(""kayak""));","Word Count operation, function named 'run_word'."
1826,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { perform_word };
console.log(perform_word(""kayak""));","Word Count operation, function named 'perform_word'."
1827,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","function perform_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { perform_word };
console.log(perform_word(""the quick brown fox""));","Word Count operation, function named 'perform_word'."
1828,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { execute_word };
console.log(execute_word(""the quick brown fox""));","Word Count operation, function named 'execute_word'."
1829,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { process_word };
console.log(process_word(""civic""));","Word Count operation, function named 'process_word'."
1830,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""civic""));","Word Count operation, function named 'handle_word'."
1831,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { execute_word };
console.log(execute_word(""never odd or even""));","Word Count operation, function named 'execute_word'."
1832,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""never odd or even""));","Word Count operation, function named 'handle_word'."
1833,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""python programming""));","Word Count operation, function named 'apply_word'."
1834,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","function handle_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { handle_word };
console.log(handle_word(""python programming""));","Word Count operation, function named 'handle_word'."
1835,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { compute_word };
console.log(compute_word(""deified""));","Word Count operation, function named 'compute_word'."
1836,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","function compute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { compute_word };
console.log(compute_word(""algorithms and data structures""));","Word Count operation, function named 'compute_word'."
1837,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","function execute_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { execute_word };
console.log(execute_word(""algorithms and data structures""));","Word Count operation, function named 'execute_word'."
1838,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","function apply_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { apply_word };
console.log(apply_word(""rotor""));","Word Count operation, function named 'apply_word'."
1839,Node.js,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","function process_word(s) {
  return s.split("" "").filter(Boolean).length;
}

module.exports = { process_word };
console.log(process_word(""rotor""));","Word Count operation, function named 'process_word'."
1840,Java,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","public class Main {
    static int execute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(execute_word(""racecar""));
    }
}","Word Count operation, function named 'execute_word'."
1841,Java,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","public class Main {
    static int apply_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(apply_word(""hello world""));
    }
}","Word Count operation, function named 'apply_word'."
1842,Java,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""hello world""));
    }
}","Word Count operation, function named 'run_word'."
1843,Java,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""A man a plan a canal Panama""));
    }
}","Word Count operation, function named 'process_word'."
1844,Java,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","public class Main {
    static int perform_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(perform_word(""A man a plan a canal Panama""));
    }
}","Word Count operation, function named 'perform_word'."
1845,Java,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""Rust is fun""));
    }
}","Word Count operation, function named 'handle_word'."
1846,Java,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""level""));
    }
}","Word Count operation, function named 'run_word'."
1847,Java,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""level""));
    }
}","Word Count operation, function named 'handle_word'."
1848,Java,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""OpenAI Claude""));
    }
}","Word Count operation, function named 'process_word'."
1849,Java,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""OpenAI Claude""));
    }
}","Word Count operation, function named 'handle_word'."
1850,Java,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","public class Main {
    static int compute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(compute_word(""was it a car or a cat i saw""));
    }
}","Word Count operation, function named 'compute_word'."
1851,Java,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""was it a car or a cat i saw""));
    }
}","Word Count operation, function named 'run_word'."
1852,Java,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""noon""));
    }
}","Word Count operation, function named 'process_word'."
1853,Java,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","public class Main {
    static int compute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(compute_word(""noon""));
    }
}","Word Count operation, function named 'compute_word'."
1854,Java,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""data science""));
    }
}","Word Count operation, function named 'run_word'."
1855,Java,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","public class Main {
    static int perform_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(perform_word(""data science""));
    }
}","Word Count operation, function named 'perform_word'."
1856,Java,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""step on no pets""));
    }
}","Word Count operation, function named 'handle_word'."
1857,Java,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""step on no pets""));
    }
}","Word Count operation, function named 'run_word'."
1858,Java,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""coding""));
    }
}","Word Count operation, function named 'handle_word'."
1859,Java,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","public class Main {
    static int compute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(compute_word(""coding""));
    }
}","Word Count operation, function named 'compute_word'."
1860,Java,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","public class Main {
    static int compute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(compute_word(""madam im adam""));
    }
}","Word Count operation, function named 'compute_word'."
1861,Java,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""madam im adam""));
    }
}","Word Count operation, function named 'run_word'."
1862,Java,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","public class Main {
    static int perform_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(perform_word(""kayak""));
    }
}","Word Count operation, function named 'perform_word'."
1863,Java,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","public class Main {
    static int apply_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(apply_word(""kayak""));
    }
}","Word Count operation, function named 'apply_word'."
1864,Java,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""the quick brown fox""));
    }
}","Word Count operation, function named 'run_word'."
1865,Java,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""the quick brown fox""));
    }
}","Word Count operation, function named 'process_word'."
1866,Java,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","public class Main {
    static int compute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(compute_word(""civic""));
    }
}","Word Count operation, function named 'compute_word'."
1867,Java,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""civic""));
    }
}","Word Count operation, function named 'run_word'."
1868,Java,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","public class Main {
    static int handle_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(handle_word(""never odd or even""));
    }
}","Word Count operation, function named 'handle_word'."
1869,Java,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""python programming""));
    }
}","Word Count operation, function named 'run_word'."
1870,Java,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","public class Main {
    static int perform_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(perform_word(""python programming""));
    }
}","Word Count operation, function named 'perform_word'."
1871,Java,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","public class Main {
    static int execute_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(execute_word(""deified""));
    }
}","Word Count operation, function named 'execute_word'."
1872,Java,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","public class Main {
    static int apply_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(apply_word(""deified""));
    }
}","Word Count operation, function named 'apply_word'."
1873,Java,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""algorithms and data structures""));
    }
}","Word Count operation, function named 'process_word'."
1874,Java,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","public class Main {
    static int run_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(run_word(""algorithms and data structures""));
    }
}","Word Count operation, function named 'run_word'."
1875,Java,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","public class Main {
    static int apply_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(apply_word(""rotor""));
    }
}","Word Count operation, function named 'apply_word'."
1876,Java,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","public class Main {
    static int process_word(String s) {
        return s.trim().split(""\\s+"").length;
    }

    public static void main(String[] args) {
        System.out.println(process_word(""rotor""));
    }
}","Word Count operation, function named 'process_word'."
1877,C,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

int compute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_word(""racecar""));
    return 0;
}","Word Count operation, function named 'compute_word'."
1878,C,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""racecar""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1879,C,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""hello world""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1880,C,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","#include <stdio.h>
#include <string.h>

int process_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_word(""hello world""));
    return 0;
}","Word Count operation, function named 'process_word'."
1881,C,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""A man a plan a canal Panama""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1882,C,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""A man a plan a canal Panama""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1883,C,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""Rust is fun""));
    return 0;
}","Word Count operation, function named 'run_word'."
1884,C,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""Rust is fun""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1885,C,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""level""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1886,C,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","#include <stdio.h>
#include <string.h>

int process_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_word(""level""));
    return 0;
}","Word Count operation, function named 'process_word'."
1887,C,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

int handle_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_word(""OpenAI Claude""));
    return 0;
}","Word Count operation, function named 'handle_word'."
1888,C,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>

int compute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_word(""OpenAI Claude""));
    return 0;
}","Word Count operation, function named 'compute_word'."
1889,C,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

int handle_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_word(""was it a car or a cat i saw""));
    return 0;
}","Word Count operation, function named 'handle_word'."
1890,C,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>

int execute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_word(""was it a car or a cat i saw""));
    return 0;
}","Word Count operation, function named 'execute_word'."
1891,C,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","#include <stdio.h>
#include <string.h>

int execute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_word(""noon""));
    return 0;
}","Word Count operation, function named 'execute_word'."
1892,C,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""noon""));
    return 0;
}","Word Count operation, function named 'run_word'."
1893,C,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""data science""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1894,C,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""data science""));
    return 0;
}","Word Count operation, function named 'run_word'."
1895,C,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>

int process_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_word(""step on no pets""));
    return 0;
}","Word Count operation, function named 'process_word'."
1896,C,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""step on no pets""));
    return 0;
}","Word Count operation, function named 'run_word'."
1897,C,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""coding""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1898,C,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""madam im adam""));
    return 0;
}","Word Count operation, function named 'run_word'."
1899,C,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""kayak""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1900,C,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","#include <stdio.h>
#include <string.h>

int process_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_word(""kayak""));
    return 0;
}","Word Count operation, function named 'process_word'."
1901,C,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

int compute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_word(""the quick brown fox""));
    return 0;
}","Word Count operation, function named 'compute_word'."
1902,C,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""the quick brown fox""));
    return 0;
}","Word Count operation, function named 'run_word'."
1903,C,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","#include <stdio.h>
#include <string.h>

int compute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_word(""civic""));
    return 0;
}","Word Count operation, function named 'compute_word'."
1904,C,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""civic""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1905,C,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>

int perform_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_word(""never odd or even""));
    return 0;
}","Word Count operation, function named 'perform_word'."
1906,C,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>

int process_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_word(""never odd or even""));
    return 0;
}","Word Count operation, function named 'process_word'."
1907,C,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

int execute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_word(""python programming""));
    return 0;
}","Word Count operation, function named 'execute_word'."
1908,C,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""python programming""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1909,C,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""deified""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1910,C,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""deified""));
    return 0;
}","Word Count operation, function named 'run_word'."
1911,C,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

int execute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_word(""algorithms and data structures""));
    return 0;
}","Word Count operation, function named 'execute_word'."
1912,C,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>

int compute_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_word(""algorithms and data structures""));
    return 0;
}","Word Count operation, function named 'compute_word'."
1913,C,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

int apply_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_word(""rotor""));
    return 0;
}","Word Count operation, function named 'apply_word'."
1914,C,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","#include <stdio.h>
#include <string.h>

int run_word(const char* s) {
    int count = 0;
    int in_word = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        if (s[i] != ' ' && !in_word) { in_word = 1; count++; }
        else if (s[i] == ' ') { in_word = 0; }
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_word(""rotor""));
    return 0;
}","Word Count operation, function named 'run_word'."
1915,C++,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","#include <iostream>
#include <sstream>
#include <string>

int perform_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << perform_word(""racecar"") << std::endl;
    return 0;
}","Word Count operation, function named 'perform_word'."
1916,C++,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""racecar"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1917,C++,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""hello world"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1918,C++,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""hello world"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1919,C++,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1920,C++,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1921,C++,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""Rust is fun"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1922,C++,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","#include <iostream>
#include <sstream>
#include <string>

int handle_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << handle_word(""Rust is fun"") << std::endl;
    return 0;
}","Word Count operation, function named 'handle_word'."
1923,C++,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""level"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1924,C++,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""level"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1925,C++,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""OpenAI Claude"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1926,C++,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""OpenAI Claude"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1927,C++,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1928,C++,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <sstream>
#include <string>

int perform_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << perform_word(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Word Count operation, function named 'perform_word'."
1929,C++,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""noon"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1930,C++,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","#include <iostream>
#include <sstream>
#include <string>

int handle_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << handle_word(""noon"") << std::endl;
    return 0;
}","Word Count operation, function named 'handle_word'."
1931,C++,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""data science"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1932,C++,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""data science"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1933,C++,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","#include <iostream>
#include <sstream>
#include <string>

int perform_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << perform_word(""step on no pets"") << std::endl;
    return 0;
}","Word Count operation, function named 'perform_word'."
1934,C++,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""step on no pets"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1935,C++,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""coding"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1936,C++,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","#include <iostream>
#include <sstream>
#include <string>

int handle_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << handle_word(""coding"") << std::endl;
    return 0;
}","Word Count operation, function named 'handle_word'."
1937,C++,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""madam im adam"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1938,C++,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""madam im adam"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1939,C++,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""kayak"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1940,C++,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","#include <iostream>
#include <sstream>
#include <string>

int perform_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << perform_word(""kayak"") << std::endl;
    return 0;
}","Word Count operation, function named 'perform_word'."
1941,C++,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""the quick brown fox"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1942,C++,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""the quick brown fox"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1943,C++,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""civic"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1944,C++,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""civic"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1945,C++,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""never odd or even"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1946,C++,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""never odd or even"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1947,C++,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""python programming"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1948,C++,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","#include <iostream>
#include <sstream>
#include <string>

int apply_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << apply_word(""deified"") << std::endl;
    return 0;
}","Word Count operation, function named 'apply_word'."
1949,C++,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""deified"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1950,C++,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","#include <iostream>
#include <sstream>
#include <string>

int run_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << run_word(""algorithms and data structures"") << std::endl;
    return 0;
}","Word Count operation, function named 'run_word'."
1951,C++,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","#include <iostream>
#include <sstream>
#include <string>

int compute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << compute_word(""algorithms and data structures"") << std::endl;
    return 0;
}","Word Count operation, function named 'compute_word'."
1952,C++,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","#include <iostream>
#include <sstream>
#include <string>

int process_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << process_word(""rotor"") << std::endl;
    return 0;
}","Word Count operation, function named 'process_word'."
1953,C++,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","#include <iostream>
#include <sstream>
#include <string>

int execute_word(const std::string& s) {
    std::istringstream iss(s);
    int count = 0;
    std::string word;
    while (iss >> word) count++;
    return count;
}

int main() {
    std::cout << execute_word(""rotor"") << std::endl;
    return 0;
}","Word Count operation, function named 'execute_word'."
1954,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""racecar""));
}","Word Count operation, function named 'perform_word'."
1955,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""racecar"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""racecar""));
}","Word Count operation, function named 'compute_word'."
1956,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""hello world""));
}","Word Count operation, function named 'compute_word'."
1957,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""hello world"".","fn run_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", run_word(""hello world""));
}","Word Count operation, function named 'run_word'."
1958,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""A man a plan a canal Panama""));
}","Word Count operation, function named 'compute_word'."
1959,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""A man a plan a canal Panama"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""A man a plan a canal Panama""));
}","Word Count operation, function named 'perform_word'."
1960,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""Rust is fun""));
}","Word Count operation, function named 'compute_word'."
1961,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""Rust is fun"".","fn apply_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", apply_word(""Rust is fun""));
}","Word Count operation, function named 'apply_word'."
1962,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","fn apply_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", apply_word(""level""));
}","Word Count operation, function named 'apply_word'."
1963,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""level"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""level""));
}","Word Count operation, function named 'process_word'."
1964,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","fn execute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", execute_word(""OpenAI Claude""));
}","Word Count operation, function named 'execute_word'."
1965,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""OpenAI Claude"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""OpenAI Claude""));
}","Word Count operation, function named 'compute_word'."
1966,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","fn handle_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", handle_word(""was it a car or a cat i saw""));
}","Word Count operation, function named 'handle_word'."
1967,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""was it a car or a cat i saw"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""was it a car or a cat i saw""));
}","Word Count operation, function named 'compute_word'."
1968,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""noon""));
}","Word Count operation, function named 'compute_word'."
1969,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""noon"".","fn run_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", run_word(""noon""));
}","Word Count operation, function named 'run_word'."
1970,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""data science""));
}","Word Count operation, function named 'process_word'."
1971,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""data science"".","fn run_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", run_word(""data science""));
}","Word Count operation, function named 'run_word'."
1972,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""step on no pets"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""step on no pets""));
}","Word Count operation, function named 'compute_word'."
1973,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""coding""));
}","Word Count operation, function named 'perform_word'."
1974,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""coding"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""coding""));
}","Word Count operation, function named 'process_word'."
1975,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","fn execute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", execute_word(""madam im adam""));
}","Word Count operation, function named 'execute_word'."
1976,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""madam im adam"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""madam im adam""));
}","Word Count operation, function named 'process_word'."
1977,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","fn compute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", compute_word(""kayak""));
}","Word Count operation, function named 'compute_word'."
1978,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""kayak"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""kayak""));
}","Word Count operation, function named 'perform_word'."
1979,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""the quick brown fox""));
}","Word Count operation, function named 'process_word'."
1980,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""the quick brown fox"".","fn execute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", execute_word(""the quick brown fox""));
}","Word Count operation, function named 'execute_word'."
1981,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""civic""));
}","Word Count operation, function named 'perform_word'."
1982,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""civic"".","fn run_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", run_word(""civic""));
}","Word Count operation, function named 'run_word'."
1983,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""never odd or even"".","fn handle_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", handle_word(""never odd or even""));
}","Word Count operation, function named 'handle_word'."
1984,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""python programming""));
}","Word Count operation, function named 'process_word'."
1985,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""python programming"".","fn execute_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", execute_word(""python programming""));
}","Word Count operation, function named 'execute_word'."
1986,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","fn process_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", process_word(""deified""));
}","Word Count operation, function named 'process_word'."
1987,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""deified"".","fn handle_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", handle_word(""deified""));
}","Word Count operation, function named 'handle_word'."
1988,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""algorithms and data structures""));
}","Word Count operation, function named 'perform_word'."
1989,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""algorithms and data structures"".","fn handle_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", handle_word(""algorithms and data structures""));
}","Word Count operation, function named 'handle_word'."
1990,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","fn perform_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", perform_word(""rotor""));
}","Word Count operation, function named 'perform_word'."
1991,Rust,String Manipulation,beginner,"Perform 'word count' on the string ""rotor"".","fn run_word(s: &str) -> usize {
    s.split_whitespace().count()
}

fn main() {
    println!(""{}"", run_word(""rotor""));
}","Word Count operation, function named 'run_word'."
1992,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('racecar'))","Vowel Count operation, function named 'run_vowel'."
1993,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('racecar'))","Vowel Count operation, function named 'compute_vowel'."
1994,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('hello world'))","Vowel Count operation, function named 'compute_vowel'."
1995,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('hello world'))","Vowel Count operation, function named 'run_vowel'."
1996,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('A man a plan a canal Panama'))","Vowel Count operation, function named 'perform_vowel'."
1997,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","def execute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(execute_vowel('A man a plan a canal Panama'))","Vowel Count operation, function named 'execute_vowel'."
1998,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","def handle_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(handle_vowel('Rust is fun'))","Vowel Count operation, function named 'handle_vowel'."
1999,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","def apply_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(apply_vowel('Rust is fun'))","Vowel Count operation, function named 'apply_vowel'."
2000,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","def apply_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(apply_vowel('level'))","Vowel Count operation, function named 'apply_vowel'."
2001,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('level'))","Vowel Count operation, function named 'perform_vowel'."
2002,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","def apply_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(apply_vowel('OpenAI Claude'))","Vowel Count operation, function named 'apply_vowel'."
2003,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","def execute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(execute_vowel('OpenAI Claude'))","Vowel Count operation, function named 'execute_vowel'."
2004,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","def execute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(execute_vowel('was it a car or a cat i saw'))","Vowel Count operation, function named 'execute_vowel'."
2005,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('was it a car or a cat i saw'))","Vowel Count operation, function named 'run_vowel'."
2006,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","def process_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(process_vowel('noon'))","Vowel Count operation, function named 'process_vowel'."
2007,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('data science'))","Vowel Count operation, function named 'compute_vowel'."
2008,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","def process_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(process_vowel('step on no pets'))","Vowel Count operation, function named 'process_vowel'."
2009,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","def handle_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(handle_vowel('step on no pets'))","Vowel Count operation, function named 'handle_vowel'."
2010,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","def execute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(execute_vowel('coding'))","Vowel Count operation, function named 'execute_vowel'."
2011,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('coding'))","Vowel Count operation, function named 'perform_vowel'."
2012,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('madam im adam'))","Vowel Count operation, function named 'perform_vowel'."
2013,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","def apply_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(apply_vowel('madam im adam'))","Vowel Count operation, function named 'apply_vowel'."
2014,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","def process_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(process_vowel('kayak'))","Vowel Count operation, function named 'process_vowel'."
2015,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('kayak'))","Vowel Count operation, function named 'run_vowel'."
2016,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","def execute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(execute_vowel('the quick brown fox'))","Vowel Count operation, function named 'execute_vowel'."
2017,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('the quick brown fox'))","Vowel Count operation, function named 'perform_vowel'."
2018,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","def process_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(process_vowel('civic'))","Vowel Count operation, function named 'process_vowel'."
2019,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('civic'))","Vowel Count operation, function named 'compute_vowel'."
2020,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('never odd or even'))","Vowel Count operation, function named 'perform_vowel'."
2021,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('python programming'))","Vowel Count operation, function named 'compute_vowel'."
2022,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('python programming'))","Vowel Count operation, function named 'run_vowel'."
2023,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","def run_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(run_vowel('deified'))","Vowel Count operation, function named 'run_vowel'."
2024,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","def process_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(process_vowel('deified'))","Vowel Count operation, function named 'process_vowel'."
2025,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","def handle_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(handle_vowel('algorithms and data structures'))","Vowel Count operation, function named 'handle_vowel'."
2026,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('algorithms and data structures'))","Vowel Count operation, function named 'perform_vowel'."
2027,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","def compute_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(compute_vowel('rotor'))","Vowel Count operation, function named 'compute_vowel'."
2028,Python,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","def perform_vowel(s):
    return sum(1 for c in s.lower() if c in ""aeiou"")

print(perform_vowel('rotor'))","Vowel Count operation, function named 'perform_vowel'."
2029,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""racecar""));","Vowel Count operation, function named 'perform_vowel'."
2030,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(process_vowel(""hello world""));","Vowel Count operation, function named 'process_vowel'."
2031,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""hello world""));","Vowel Count operation, function named 'apply_vowel'."
2032,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(run_vowel(""A man a plan a canal Panama""));","Vowel Count operation, function named 'run_vowel'."
2033,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(process_vowel(""A man a plan a canal Panama""));","Vowel Count operation, function named 'process_vowel'."
2034,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""Rust is fun""));","Vowel Count operation, function named 'apply_vowel'."
2035,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(handle_vowel(""Rust is fun""));","Vowel Count operation, function named 'handle_vowel'."
2036,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""level""));","Vowel Count operation, function named 'execute_vowel'."
2037,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""level""));","Vowel Count operation, function named 'compute_vowel'."
2038,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""OpenAI Claude""));","Vowel Count operation, function named 'compute_vowel'."
2039,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""OpenAI Claude""));","Vowel Count operation, function named 'execute_vowel'."
2040,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""was it a car or a cat i saw""));","Vowel Count operation, function named 'execute_vowel'."
2041,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""noon""));","Vowel Count operation, function named 'apply_vowel'."
2042,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(handle_vowel(""data science""));","Vowel Count operation, function named 'handle_vowel'."
2043,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""data science""));","Vowel Count operation, function named 'perform_vowel'."
2044,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""step on no pets""));","Vowel Count operation, function named 'apply_vowel'."
2045,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(process_vowel(""step on no pets""));","Vowel Count operation, function named 'process_vowel'."
2046,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""coding""));","Vowel Count operation, function named 'compute_vowel'."
2047,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""coding""));","Vowel Count operation, function named 'execute_vowel'."
2048,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(run_vowel(""madam im adam""));","Vowel Count operation, function named 'run_vowel'."
2049,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(handle_vowel(""madam im adam""));","Vowel Count operation, function named 'handle_vowel'."
2050,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""kayak""));","Vowel Count operation, function named 'apply_vowel'."
2051,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(run_vowel(""kayak""));","Vowel Count operation, function named 'run_vowel'."
2052,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""the quick brown fox""));","Vowel Count operation, function named 'compute_vowel'."
2053,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""the quick brown fox""));","Vowel Count operation, function named 'perform_vowel'."
2054,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""civic""));","Vowel Count operation, function named 'perform_vowel'."
2055,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(apply_vowel(""civic""));","Vowel Count operation, function named 'apply_vowel'."
2056,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(handle_vowel(""never odd or even""));","Vowel Count operation, function named 'handle_vowel'."
2057,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""never odd or even""));","Vowel Count operation, function named 'compute_vowel'."
2058,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""python programming""));","Vowel Count operation, function named 'execute_vowel'."
2059,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""python programming""));","Vowel Count operation, function named 'perform_vowel'."
2060,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(process_vowel(""deified""));","Vowel Count operation, function named 'process_vowel'."
2061,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(execute_vowel(""deified""));","Vowel Count operation, function named 'execute_vowel'."
2062,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(run_vowel(""algorithms and data structures""));","Vowel Count operation, function named 'run_vowel'."
2063,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(handle_vowel(""algorithms and data structures""));","Vowel Count operation, function named 'handle_vowel'."
2064,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(perform_vowel(""rotor""));","Vowel Count operation, function named 'perform_vowel'."
2065,JavaScript,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

console.log(compute_vowel(""rotor""));","Vowel Count operation, function named 'compute_vowel'."
2066,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""racecar""));","Vowel Count operation, function named 'compute_vowel'."
2067,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { process_vowel };
console.log(process_vowel(""racecar""));","Vowel Count operation, function named 'process_vowel'."
2068,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""hello world""));","Vowel Count operation, function named 'run_vowel'."
2069,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { handle_vowel };
console.log(handle_vowel(""hello world""));","Vowel Count operation, function named 'handle_vowel'."
2070,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { process_vowel };
console.log(process_vowel(""A man a plan a canal Panama""));","Vowel Count operation, function named 'process_vowel'."
2071,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { apply_vowel };
console.log(apply_vowel(""A man a plan a canal Panama""));","Vowel Count operation, function named 'apply_vowel'."
2072,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""Rust is fun""));","Vowel Count operation, function named 'run_vowel'."
2073,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { perform_vowel };
console.log(perform_vowel(""Rust is fun""));","Vowel Count operation, function named 'perform_vowel'."
2074,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { handle_vowel };
console.log(handle_vowel(""level""));","Vowel Count operation, function named 'handle_vowel'."
2075,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""level""));","Vowel Count operation, function named 'compute_vowel'."
2076,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""OpenAI Claude""));","Vowel Count operation, function named 'compute_vowel'."
2077,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""OpenAI Claude""));","Vowel Count operation, function named 'run_vowel'."
2078,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""was it a car or a cat i saw""));","Vowel Count operation, function named 'execute_vowel'."
2079,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { apply_vowel };
console.log(apply_vowel(""was it a car or a cat i saw""));","Vowel Count operation, function named 'apply_vowel'."
2080,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { perform_vowel };
console.log(perform_vowel(""noon""));","Vowel Count operation, function named 'perform_vowel'."
2081,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""noon""));","Vowel Count operation, function named 'compute_vowel'."
2082,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { process_vowel };
console.log(process_vowel(""data science""));","Vowel Count operation, function named 'process_vowel'."
2083,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { handle_vowel };
console.log(handle_vowel(""data science""));","Vowel Count operation, function named 'handle_vowel'."
2084,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { handle_vowel };
console.log(handle_vowel(""step on no pets""));","Vowel Count operation, function named 'handle_vowel'."
2085,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { process_vowel };
console.log(process_vowel(""step on no pets""));","Vowel Count operation, function named 'process_vowel'."
2086,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { perform_vowel };
console.log(perform_vowel(""coding""));","Vowel Count operation, function named 'perform_vowel'."
2087,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""coding""));","Vowel Count operation, function named 'compute_vowel'."
2088,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","function handle_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { handle_vowel };
console.log(handle_vowel(""madam im adam""));","Vowel Count operation, function named 'handle_vowel'."
2089,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","function process_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { process_vowel };
console.log(process_vowel(""madam im adam""));","Vowel Count operation, function named 'process_vowel'."
2090,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""kayak""));","Vowel Count operation, function named 'execute_vowel'."
2091,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""kayak""));","Vowel Count operation, function named 'compute_vowel'."
2092,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { perform_vowel };
console.log(perform_vowel(""the quick brown fox""));","Vowel Count operation, function named 'perform_vowel'."
2093,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""civic""));","Vowel Count operation, function named 'execute_vowel'."
2094,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","function apply_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { apply_vowel };
console.log(apply_vowel(""civic""));","Vowel Count operation, function named 'apply_vowel'."
2095,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""never odd or even""));","Vowel Count operation, function named 'run_vowel'."
2096,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""never odd or even""));","Vowel Count operation, function named 'execute_vowel'."
2097,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""python programming""));","Vowel Count operation, function named 'run_vowel'."
2098,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","function perform_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { perform_vowel };
console.log(perform_vowel(""python programming""));","Vowel Count operation, function named 'perform_vowel'."
2099,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""deified""));","Vowel Count operation, function named 'execute_vowel'."
2100,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","function compute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { compute_vowel };
console.log(compute_vowel(""deified""));","Vowel Count operation, function named 'compute_vowel'."
2101,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""algorithms and data structures""));","Vowel Count operation, function named 'execute_vowel'."
2102,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""algorithms and data structures""));","Vowel Count operation, function named 'run_vowel'."
2103,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","function run_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { run_vowel };
console.log(run_vowel(""rotor""));","Vowel Count operation, function named 'run_vowel'."
2104,Node.js,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","function execute_vowel(s) {
  return [...s.toLowerCase()].filter(c => ""aeiou"".includes(c)).length;
}

module.exports = { execute_vowel };
console.log(execute_vowel(""rotor""));","Vowel Count operation, function named 'execute_vowel'."
2105,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","public class Main {
    static int process_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(process_vowel(""racecar""));
    }
}","Vowel Count operation, function named 'process_vowel'."
2106,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""racecar""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2107,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""hello world""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2108,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""A man a plan a canal Panama""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2109,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","public class Main {
    static int apply_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(apply_vowel(""A man a plan a canal Panama""));
    }
}","Vowel Count operation, function named 'apply_vowel'."
2110,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""Rust is fun""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2111,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","public class Main {
    static int handle_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(handle_vowel(""Rust is fun""));
    }
}","Vowel Count operation, function named 'handle_vowel'."
2112,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""level""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2113,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","public class Main {
    static int apply_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(apply_vowel(""level""));
    }
}","Vowel Count operation, function named 'apply_vowel'."
2114,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""OpenAI Claude""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2115,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""OpenAI Claude""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2116,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","public class Main {
    static int handle_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(handle_vowel(""was it a car or a cat i saw""));
    }
}","Vowel Count operation, function named 'handle_vowel'."
2117,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","public class Main {
    static int execute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(execute_vowel(""was it a car or a cat i saw""));
    }
}","Vowel Count operation, function named 'execute_vowel'."
2118,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""noon""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2119,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","public class Main {
    static int handle_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(handle_vowel(""noon""));
    }
}","Vowel Count operation, function named 'handle_vowel'."
2120,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""data science""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2121,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""data science""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2122,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""step on no pets""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2123,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""step on no pets""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2124,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","public class Main {
    static int process_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(process_vowel(""coding""));
    }
}","Vowel Count operation, function named 'process_vowel'."
2125,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""coding""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2126,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","public class Main {
    static int apply_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(apply_vowel(""madam im adam""));
    }
}","Vowel Count operation, function named 'apply_vowel'."
2127,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","public class Main {
    static int execute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(execute_vowel(""madam im adam""));
    }
}","Vowel Count operation, function named 'execute_vowel'."
2128,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","public class Main {
    static int process_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(process_vowel(""kayak""));
    }
}","Vowel Count operation, function named 'process_vowel'."
2129,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""kayak""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2130,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""the quick brown fox""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2131,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","public class Main {
    static int execute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(execute_vowel(""the quick brown fox""));
    }
}","Vowel Count operation, function named 'execute_vowel'."
2132,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""civic""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2133,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","public class Main {
    static int process_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(process_vowel(""civic""));
    }
}","Vowel Count operation, function named 'process_vowel'."
2134,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","public class Main {
    static int handle_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(handle_vowel(""never odd or even""));
    }
}","Vowel Count operation, function named 'handle_vowel'."
2135,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""never odd or even""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2136,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","public class Main {
    static int execute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(execute_vowel(""python programming""));
    }
}","Vowel Count operation, function named 'execute_vowel'."
2137,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""python programming""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2138,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""deified""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2139,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","public class Main {
    static int apply_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(apply_vowel(""algorithms and data structures""));
    }
}","Vowel Count operation, function named 'apply_vowel'."
2140,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","public class Main {
    static int compute_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(compute_vowel(""algorithms and data structures""));
    }
}","Vowel Count operation, function named 'compute_vowel'."
2141,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","public class Main {
    static int run_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(run_vowel(""rotor""));
    }
}","Vowel Count operation, function named 'run_vowel'."
2142,Java,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","public class Main {
    static int perform_vowel(String s) {
        int count = 0;
        for (char c : s.toLowerCase().toCharArray()) {
            if (""aeiou"".indexOf(c) >= 0) count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(perform_vowel(""rotor""));
    }
}","Vowel Count operation, function named 'perform_vowel'."
2143,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""racecar""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2144,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int process_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_vowel(""racecar""));
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2145,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""hello world""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2146,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""hello world""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2147,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""A man a plan a canal Panama""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2148,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""A man a plan a canal Panama""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2149,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""Rust is fun""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2150,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int compute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_vowel(""Rust is fun""));
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2151,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""level""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2152,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""level""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2153,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""OpenAI Claude""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2154,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int apply_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_vowel(""OpenAI Claude""));
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2155,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int process_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_vowel(""was it a car or a cat i saw""));
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2156,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int apply_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_vowel(""was it a car or a cat i saw""));
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2157,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int compute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_vowel(""noon""));
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2158,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""noon""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2159,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int perform_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_vowel(""data science""));
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2160,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""data science""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2161,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""step on no pets""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2162,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""step on no pets""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2163,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""coding""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2164,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""coding""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2165,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""madam im adam""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2166,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""madam im adam""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2167,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int apply_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_vowel(""kayak""));
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2168,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int process_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_vowel(""kayak""));
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2169,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int process_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_vowel(""the quick brown fox""));
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2170,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""the quick brown fox""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2171,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""civic""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2172,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int process_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", process_vowel(""never odd or even""));
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2173,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int execute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", execute_vowel(""never odd or even""));
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2174,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int compute_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", compute_vowel(""python programming""));
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2175,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""python programming""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2176,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int apply_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_vowel(""deified""));
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2177,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int handle_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", handle_vowel(""deified""));
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2178,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int apply_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", apply_vowel(""algorithms and data structures""));
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2179,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int perform_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", perform_vowel(""rotor""));
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2180,C,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","#include <stdio.h>
#include <string.h>
#include <ctype.h>

int run_vowel(const char* s) {
    int count = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        char c = tolower(s[i]);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main(void) {
    printf(""%d\n"", run_vowel(""rotor""));
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2181,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","#include <iostream>
#include <string>
#include <cctype>

int execute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << execute_vowel(""racecar"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2182,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""racecar"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2183,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""hello world"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2184,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""hello world"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2185,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <string>
#include <cctype>

int handle_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << handle_vowel(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2186,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""A man a plan a canal Panama"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2187,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","#include <iostream>
#include <string>
#include <cctype>

int execute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << execute_vowel(""Rust is fun"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2188,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""Rust is fun"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2189,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""level"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2190,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""level"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2191,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""OpenAI Claude"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2192,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","#include <iostream>
#include <string>
#include <cctype>

int perform_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << perform_vowel(""OpenAI Claude"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2193,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <string>
#include <cctype>

int process_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << process_vowel(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2194,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","#include <iostream>
#include <string>
#include <cctype>

int perform_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << perform_vowel(""was it a car or a cat i saw"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2195,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","#include <iostream>
#include <string>
#include <cctype>

int perform_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << perform_vowel(""noon"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2196,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""data science"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2197,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","#include <iostream>
#include <string>
#include <cctype>

int perform_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << perform_vowel(""data science"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'perform_vowel'."
2198,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""step on no pets"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2199,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","#include <iostream>
#include <string>
#include <cctype>

int execute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << execute_vowel(""step on no pets"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2200,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","#include <iostream>
#include <string>
#include <cctype>

int execute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << execute_vowel(""coding"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2201,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""madam im adam"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2202,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","#include <iostream>
#include <string>
#include <cctype>

int handle_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << handle_vowel(""madam im adam"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2203,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""kayak"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2204,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""kayak"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2205,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""the quick brown fox"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2206,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""the quick brown fox"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2207,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""civic"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2208,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""civic"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2209,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""never odd or even"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2210,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""never odd or even"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2211,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","#include <iostream>
#include <string>
#include <cctype>

int handle_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << handle_vowel(""python programming"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2212,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""python programming"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2213,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","#include <iostream>
#include <string>
#include <cctype>

int handle_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << handle_vowel(""deified"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'handle_vowel'."
2214,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","#include <iostream>
#include <string>
#include <cctype>

int run_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << run_vowel(""deified"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'run_vowel'."
2215,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","#include <iostream>
#include <string>
#include <cctype>

int compute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << compute_vowel(""algorithms and data structures"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'compute_vowel'."
2216,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","#include <iostream>
#include <string>
#include <cctype>

int process_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << process_vowel(""algorithms and data structures"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'process_vowel'."
2217,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","#include <iostream>
#include <string>
#include <cctype>

int execute_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << execute_vowel(""rotor"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'execute_vowel'."
2218,C++,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","#include <iostream>
#include <string>
#include <cctype>

int apply_vowel(const std::string& s) {
    int count = 0;
    for (char c : s) {
        c = tolower(c);
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') count++;
    }
    return count;
}

int main() {
    std::cout << apply_vowel(""rotor"") << std::endl;
    return 0;
}","Vowel Count operation, function named 'apply_vowel'."
2219,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","fn compute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", compute_vowel(""racecar""));
}","Vowel Count operation, function named 'compute_vowel'."
2220,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""racecar"".","fn apply_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", apply_vowel(""racecar""));
}","Vowel Count operation, function named 'apply_vowel'."
2221,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""hello world""));
}","Vowel Count operation, function named 'run_vowel'."
2222,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""hello world"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""hello world""));
}","Vowel Count operation, function named 'perform_vowel'."
2223,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","fn handle_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", handle_vowel(""A man a plan a canal Panama""));
}","Vowel Count operation, function named 'handle_vowel'."
2224,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""A man a plan a canal Panama"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""A man a plan a canal Panama""));
}","Vowel Count operation, function named 'perform_vowel'."
2225,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""Rust is fun""));
}","Vowel Count operation, function named 'process_vowel'."
2226,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""Rust is fun"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""Rust is fun""));
}","Vowel Count operation, function named 'run_vowel'."
2227,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""level""));
}","Vowel Count operation, function named 'execute_vowel'."
2228,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""level"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""level""));
}","Vowel Count operation, function named 'perform_vowel'."
2229,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""OpenAI Claude"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""OpenAI Claude""));
}","Vowel Count operation, function named 'run_vowel'."
2230,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""was it a car or a cat i saw""));
}","Vowel Count operation, function named 'run_vowel'."
2231,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""was it a car or a cat i saw"".","fn handle_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", handle_vowel(""was it a car or a cat i saw""));
}","Vowel Count operation, function named 'handle_vowel'."
2232,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""noon""));
}","Vowel Count operation, function named 'perform_vowel'."
2233,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""noon"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""noon""));
}","Vowel Count operation, function named 'process_vowel'."
2234,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""data science""));
}","Vowel Count operation, function named 'execute_vowel'."
2235,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""data science"".","fn handle_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", handle_vowel(""data science""));
}","Vowel Count operation, function named 'handle_vowel'."
2236,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","fn handle_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", handle_vowel(""step on no pets""));
}","Vowel Count operation, function named 'handle_vowel'."
2237,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""step on no pets"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""step on no pets""));
}","Vowel Count operation, function named 'execute_vowel'."
2238,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""coding"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""coding""));
}","Vowel Count operation, function named 'execute_vowel'."
2239,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""madam im adam""));
}","Vowel Count operation, function named 'process_vowel'."
2240,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""madam im adam"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""madam im adam""));
}","Vowel Count operation, function named 'execute_vowel'."
2241,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""kayak""));
}","Vowel Count operation, function named 'execute_vowel'."
2242,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""kayak"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""kayak""));
}","Vowel Count operation, function named 'perform_vowel'."
2243,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""the quick brown fox""));
}","Vowel Count operation, function named 'run_vowel'."
2244,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""the quick brown fox"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""the quick brown fox""));
}","Vowel Count operation, function named 'process_vowel'."
2245,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","fn compute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", compute_vowel(""civic""));
}","Vowel Count operation, function named 'compute_vowel'."
2246,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""civic"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""civic""));
}","Vowel Count operation, function named 'execute_vowel'."
2247,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""never odd or even"".","fn handle_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", handle_vowel(""never odd or even""));
}","Vowel Count operation, function named 'handle_vowel'."
2248,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","fn execute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", execute_vowel(""python programming""));
}","Vowel Count operation, function named 'execute_vowel'."
2249,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""python programming"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""python programming""));
}","Vowel Count operation, function named 'perform_vowel'."
2250,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","fn run_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", run_vowel(""deified""));
}","Vowel Count operation, function named 'run_vowel'."
2251,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""deified"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""deified""));
}","Vowel Count operation, function named 'perform_vowel'."
2252,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""algorithms and data structures""));
}","Vowel Count operation, function named 'process_vowel'."
2253,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""algorithms and data structures"".","fn compute_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", compute_vowel(""algorithms and data structures""));
}","Vowel Count operation, function named 'compute_vowel'."
2254,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","fn process_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", process_vowel(""rotor""));
}","Vowel Count operation, function named 'process_vowel'."
2255,Rust,String Manipulation,intermediate,"Perform 'vowel count' on the string ""rotor"".","fn perform_vowel(s: &str) -> usize {
    s.to_lowercase().chars().filter(|c| ""aeiou"".contains(*c)).count()
}

fn main() {
    println!(""{}"", perform_vowel(""rotor""));
}","Vowel Count operation, function named 'perform_vowel'."