Intermediate/Senior Oracle Plsql Developer prectical test

Comment

0

DECLARE
     l_condition   BOOLEAN := TRUE;
     l_index       PLS_INTEGER := 1;
  BEGIN
     WHILE l_index
     LOOP
        l_index := NULL;
     END LOOP;
  END;

Popularity 5/10 Helpfulness 1/10 Language sql

Source: devgym.oracle.com

Tags: oracle plsql sql

Share

Link to this answer
Share Copy Link

Contributed on Oct 22 2024

Homely Hummingbird

0 Answers Avg Quality 2/10

quick sort

Comment

1

function swap(arr, leftIndex, rightIndex){
  // swap 2 elements in the array
    var temp = arr[leftIndex];
    arr[leftIndex] = arr[rightIndex];
    arr[rightIndex] = temp;
}
function partition(arr, left, right) {
    var pivot   = arr[Math.floor((right + left) / 2)], //middle element
        i       = left, //left pointer
        j       = right; //right pointer
    while (i <= j) { // while left pointer is smaller than right pointer
        while (arr[i] < pivot) { // move the left pointer to the right
            i++;
        }
        while (arr[j] > pivot) { // move the right pointer to the left
            j--;
        }
        if (i <= j) { //left pointer smaller or equal to right pointer
            swap(arr, i, j); //sawpping two elements
            i++;
            j--;
        }
    }
    return i;
}
// run as quickSort(array, 0, array.length - 1);
function quickSort(arr, left, right) {
    var index;
    if (arr.length > 1) {
        index = partition(arr, left, right); //index returned from partition
        if (left < index - 1) { //more elements on the left side of the pivot
            quickSort(arr, left, index - 1);
        }
        if (index < right) { //more elements on the right side of the pivot
            quickSort(arr, index, right);
        }
    }
    return arr;
}

Popularity 10/10 Helpfulness 2/10 Language javascript

Source: sorting-algorithms.me

Tags: javascript j

Share

Link to this answer
Share Copy Link

Contributed on Sep 13 2022

katanton reckless

0 Answers Avg Quality 2/10

quick sort

Comment

0

#https://github.com/paulnegz/sorts-py/blob/main/sort.py
def quick_sort(array :list)->list:
    def _quick_sort(array :list)->list:
        if len(array)<=1: return array
        
        pivot, is_bigger = array.pop(), lambda x: x>pivot
        left_partition = _quick_sort([x for x in array if not is_bigger(x)])
        right_partition = _quick_sort([x for x in array if is_bigger(x)])
        return [*left_partition, pivot, *right_partition]
    return _quick_sort(array)
  
arr = [7, 2, 4, 0, 1, 5, 8, 3, 2, 0]
print(quick_sort(arr)) # [0, 0, 1, 2, 2, 3, 4, 5, 7, 8]

Popularity 10/10 Helpfulness 2/10 Language python

Source: github.com

Tags: whatever whateve

Share

Link to this answer
Share Copy Link

Contributed on Jun 25 2023

Paul Negedu

0 Answers Avg Quality 2/10

quick sort

Comment

0

  static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }  
  
  static int partition(int[] arr, int low, int high) { 
    
    int pivot = arr[high]; 
    // Index of smaller element and
    // indicates the right position
    // of pivot found so far
    int i = (low - 1); 
  
    for(int j = low; j <= high - 1; j++) {
      // If current element is smaller 
      // than the pivot
      if (arr[j] < pivot) {
        // Increment index of 
        // smaller element
        i++; 
        swap(arr, i, j);
      }
    }
    swap(arr, i + 1, high);
    return (i + 1);
  }
  
  static void quickSort(int[] arr, int low, int high) {
      if (low < high) {
          // pi is partitioning index, arr[p]
          // is now at right place 
          int pi = partition(arr, low, high);

          // Separately sort elements before
          // partition and after partition
          quickSort(arr, low, pi - 1);
          quickSort(arr, pi + 1, high);
      }
  }

Popularity 10/10 Helpfulness 2/10 Language java

Source: Grepper

Tags: function functio

Share

Link to this answer
Share Copy Link

Contributed on Sep 14 2022

Inexpensive Ibex

0 Answers Avg Quality 2/10

quick sort

Comment

0

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))
# Prints "[1, 1, 2, 3, 6, 8, 10]"

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: cs231n.github.io

Tags: whatever whateve

Share

Link to this answer
Share Copy Link

Contributed on Feb 04 2022

Purple Team

0 Answers Avg Quality 2/10

quick sort

Comment

0

def partition(start, end, array):
     
    # Initializing pivot's index to start
    pivot_index = start
    pivot = array[pivot_index]
     
    # This loop runs till start pointer crosses
    # end pointer, and when it does we swap the
    # pivot with element on end pointer
    while start < end:
         
        # Increment the start pointer till it finds an
        # element greater than  pivot
        while start < len(array) and array[start] <= pivot:
            start += 1
             
        # Decrement the end pointer till it finds an
        # element less than pivot
        while array[end] > pivot:
            end -= 1
         
        # If start and end have not crossed each other,
        # swap the numbers on start and end
        if(start < end):
            array[start], array[end] = array[end], array[start]
     
    # Swap pivot element with element on end pointer.
    # This puts pivot on its correct sorted place.
    array[end], array[pivot_index] = array[pivot_index], array[end]
    
    # Returning end pointer to divide the array into 2
    return end
     
# The main function that implements QuickSort
def quick_sort(start, end, array):
     
    if (start < end):
         
        # p is partitioning index, array[p]
        # is at right place
        p = partition(start, end, array)
         
        # Sort elements before partition
        # and after partition
        quick_sort(start, p - 1, array)
        quick_sort(p + 1, end, array)

Popularity 10/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: whatever whateve

Share

Link to this answer
Share Copy Link

Contributed on Feb 17 2022

Defiant Donkey

0 Answers Avg Quality 2/10

Quick sort

Comment

0

// Take Left (first) Index of the array and Right (last) Index of the array
void quickSort(int Data[], int l , int r)
{
	// If the first index less or equal than the last index
	if (l <= r)
	{
		// Create a Key/Pivot Element
		int key = Data[(l+r)/2];

		// Create temp Variables to loop through array
		int i = l;
		int j = r;

		while (i <= j)
		{
			while (Data[i] < key)
				i++;
			while (Data[j] > key)
				j--;

			if (i <= j)
			{
				swap(Data[i], Data[j]);
				i++;
				j--;
			}
		}

		// Recursion to the smaller partition in the array after sorted above

		if (l < j)
			quickSort(Data, l, j);
		if (r > i)
			quickSort(Data, i, r);
	}
}

Popularity 10/10 Helpfulness 1/10 Language cpp

Source: www.stdio.vn

Tags: c++

Share

Link to this answer
Share Copy Link

Contributed on Jun 24 2022

Tiien

0 Answers Avg Quality 2/10

quick sort

Comment

0

def quick_sort(array):
    if len(array) < 2:
        return array
    else:
        pivot = array[0]
        less = [i for i in array[1:] if i <= pivot]
        greater = [i for i in array[1:] if i > pivot]
        return quick_sort(less) + [pivot] + quick_sort(greater)
import random
import matplotlib.pyplot as plt
import time
timeList=[]
fornnumberList=[]
for i in range(6):
    no=random.choice(range(10))
    numList=random.sample(range(10,100,5),no)#for 'no' random numbers
    print("before sort",numList)
    #num=random.choice(numList) #used for pivot or something
    start_time=time.time()
    quick_sort(numList)#enter the function here
    print("after sort",quick_sort(numList))
    end_time=time.time()
    final_time= end_time- start_time
    timeList.append(final_time)
    fornnumberList.append(no)
print("time for each process",timeList)
print("length of the lists",fornnumberList)
x=timeList
y=fornnumberList
plt.xlabel("Time taken")
plt.ylabel("For 'x' random numbers")
plt.plot(x, y)
plt.scatter(x,y)

Popularity 9/10 Helpfulness 1/10 Language python

Source: Grepper

Tags: python py

Share

Link to this answer
Share Copy Link

Contributed on Nov 29 2022

Horrible Heron

0 Answers Avg Quality 2/10

Quick Sort

Comment

0

# Quick sort in Python

# function to find the partition position
def partition(array, low, high):

  # choose the rightmost element as pivot
  pivot = array[high]

  # pointer for greater element
  i = low - 1

  # traverse through all elements
  # compare each element with pivot
  for j in range(low, high):
    if array[j] <= pivot:
      # if element smaller than pivot is found
      # swap it with the greater element pointed by i
      i = i + 1

      # swapping element at i with element at j
      (array[i], array[j]) = (array[j], array[i])

  # swap the pivot element with the greater element specified by i
  (array[i + 1], array[high]) = (array[high], array[i + 1])

  # return the position from where partition is done
  return i + 1

# function to perform quicksort
def quickSort(array, low, high):
  if low < high:

    # find pivot element such that
    # element smaller than pivot are on the left
    # element greater than pivot are on the right
    pi = partition(array, low, high)

    # recursive call on the left of pivot
    quickSort(array, low, pi - 1)

    # recursive call on the right of pivot
    quickSort(array, pi + 1, high)


data = [8, 7, 2, 1, 0, 9, 6]
print("Unsorted Array")
print(data)

size = len(data)

quickSort(data, 0, size - 1)

print('Sorted Array in Ascending Order:')
print(data)

Popularity 9/10 Helpfulness 1/10 Language python

Source: www.programiz.com

Tags: python py

Share

Link to this answer
Share Copy Link

Contributed on Mar 15 2023

Muhammad Zubair

0 Answers Avg Quality 2/10

quick sort

Comment

0

// C++ code to implement quicksort
 
#include <bits/stdc++.h>
using namespace std;
 
// This function takes last element as pivot,
// places the pivot element at its correct position
// in sorted array, and places all smaller to left
// of pivot and all greater elements to right of pivot
int partition(int arr[], int low, int high)
{
    // Choosing the pivot
    int pivot = arr[high];
 
    // Index of smaller element and indicates
    // the right position of pivot found so far
    int i = (low - 1);
 
    for (int j = low; j <= high - 1; j++) {
 
        // If current element is smaller than the pivot
        if (arr[j] < pivot) {
 
            // Increment index of smaller element
            i++;
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[i + 1], arr[high]);
    return (i + 1);
}
 
// The main function that implements QuickSort
// arr[] --> Array to be sorted,
// low --> Starting index,
// high --> Ending index
void quickSort(int arr[], int low, int high)
{
    if (low < high) {
 
        // pi is partitioning index, arr[p]
        // is now at right place
        int pi = partition(arr, low, high);
 
        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 10, 7, 8, 9, 1, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call
    quickSort(arr, 0, N - 1);
    cout << "Sorted array: " << endl;
    for (int i = 0; i < N; i++)
        cout << arr[i] << " ";
    return 0;
}

Popularity 9/10 Helpfulness 1/10 Language whatever

Source: www.geeksforgeeks.org

Tags: whatever whateve

Share

Link to this answer
Share Copy Link

Contributed on May 24 2023

Yon Ko

0 Answers Avg Quality 2/10

quick sort

Comment

0

_# choose pivot_
swap a[1,rand(1,n)]

_# 2-way partition_
k = 1
for i = 2:n, if a[i] < a[1], swap a[++k,i]
swap a[1,k]
_→ invariant: a[1..k-1] < a[k] <= a[k+1..n]_

_# recursive sorts_
sort a[1..k-1]
sort a[k+1,n]

Popularity 6/10 Helpfulness 1/10 Language whatever

Source: www.toptal.com

Tags: whatever

Share

Link to this answer
Share Copy Link

Contributed on Oct 21 2024

Lorenzo Benedetti

0 Answers Avg Quality 2/10

Intermediate/Senior Oracle Plsql Developer prectical test

Contents

More Related Answers