TASTY: A Transformer based Approach to Space and Time complexity
Paper • 2305.05379 • Published
code stringlengths 195 7.9k | space_complexity stringclasses 6
values | time_complexity stringclasses 7
values |
|---|---|---|
// LCM of given range queries using Segment Tree
#include <bits/stdc++.h>
using namespace std;
#define MAX 1000
// allocate space for tree
int tree[4 * MAX];
// declaring the array globally
int arr[MAX];
// Function to return gcd of a and b
int gcd(int a, int b)
{
if (a == 0)
return b;
return gc... | constant | linear |
// C++ program to find minimum and maximum using segment
// tree
#include <bits/stdc++.h>
using namespace std;
// Node for storing minimum and maximum value of given range
struct node {
int minimum;
int maximum;
};
// A utility function to get the middle index from corner
// indexes.
int getMid(int s, int e... | linear | logn |
/* C++ Program to find LCA of u and v by reducing the problem to RMQ */
#include<bits/stdc++.h>
#define V 9 // number of nodes in input tree
int euler[2*V - 1]; // For Euler tour sequence
int level[2*V - 1]; // Level of nodes in tour sequence
int firstOccurrence[V+1]; // First occurrences of... | linear | linear |
// A Divide and Conquer Program to find maximum rectangular area in a histogram
#include <bits/stdc++.h>
using namespace std;
// A utility function to find minimum of three integers
int max(int x, int y, int z)
{ return max(max(x, y), z); }
// A utility function to get minimum of two numbers in hist[]
int minVal... | linear | nlogn |
// C++ program to print all words in the CamelCase
// dictionary that matches with a given pattern
#include <bits/stdc++.h>
using namespace std;
// Alphabet size (# of upper-Case characters)
#define ALPHABET_SIZE 26
// A Trie node
struct TrieNode
{
TrieNode* children[ALPHABET_SIZE];
// isLeaf is true if t... | linear | quadratic |
// C++ program to construct an n x n
// matrix such that every row and every
// column has distinct values.
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
int mat[MAX][MAX];
// Fills non-one entries in column j
// Given that there is a "1" at
// position mat[i][j], this fun... | constant | quadratic |
// Given a binary matrix of M X N of integers,
// you need to return only unique rows of binary array
#include <bits/stdc++.h>
using namespace std;
#define ROW 4
#define COL 5
// The main function that prints
// all unique rows in a given matrix.
void findUniqueRows(int M[ROW][COL])
{
//Traverse through the matri... | constant | cubic |
// Given a binary matrix of M X N of integers,
// you need to return only unique rows of binary array
#include <bits/stdc++.h>
using namespace std;
#define ROW 4
#define COL 5
class BST
{
int data;
BST *left, *right;
public:
// Default constructor.
BST();
// Parameterized constru... | linear | quadratic |
// Given a binary matrix of M X N of integers,
// you need to return only unique rows of binary array
#include <bits/stdc++.h>
using namespace std;
#define ROW 4
#define COL 5
// A Trie node
class Node
{
public:
bool isEndOfCol;
Node *child[2]; // Only two children needed for 0 and 1
} ;
// A utility ... | quadratic | quadratic |
// C++ code to print unique row in a
// given binary matrix
#include<bits/stdc++.h>
using namespace std;
void printArray(int arr[][5], int row,
int col)
{
unordered_set<string> uset;
for(int i = 0; i < row; i++)
{
string s = "";
for(int j = 0; ... | linear | quadratic |
// A C++ program to find the count of distinct substring
// of a string using trie data structure
#include <bits/stdc++.h>
#define MAX_CHAR 26
using namespace std;
// A Suffix Trie (A Trie of all suffixes) Node
class SuffixTrieNode
{
public:
SuffixTrieNode *children[MAX_CHAR];
SuffixTrieNode() // Constructor
... | constant | linear |
#include <bits/stdc++.h>
using namespace std;
// Function to find minimum XOR pair
int minXOR(int arr[], int n)
{
// Sort given array
sort(arr, arr + n);
int minXor = INT_MAX;
int val = 0;
// calculate min xor of consecutive pairs
for (int i = 0; i < n - 1; i++) {
val = arr[i] ^ ar... | constant | nlogn |
// A simple C++ program to find max subarray XOR
#include<bits/stdc++.h>
using namespace std;
int maxSubarrayXOR(int arr[], int n)
{
int ans = INT_MIN; // Initialize result
// Pick starting points of subarrays
for (int i=0; i<n; i++)
{
int curr_xor = 0; // to store xor of current subarra... | constant | quadratic |
// C++ program for a Trie based O(n) solution to find max
// subarray XOR
#include<bits/stdc++.h>
using namespace std;
// Assumed int size
#define INT_SIZE 32
// A Trie Node
struct TrieNode
{
int value; // Only used in leaf nodes
TrieNode *arr[2];
};
// Utility function to create a Trie node
TrieNode *ne... | linear | linear |
// C++ code to demonstrate operations of Binary Index Tree
#include <iostream>
using namespace std;
/* n --> No. of elements present in input array.
BITree[0..n] --> Array that represents Binary Indexed Tree.
arr[0..n-1] --> Input array for which prefix sum is evaluated. */
// Returns sum of arr[0... | linear | nlogn |
/* C++ program to implement 2D Binary Indexed Tree
2D BIT is basically a BIT where each element is another BIT.
Updating by adding v on (x, y) means it's effect will be found
throughout the rectangle [(x, y), (max_x, max_y)],
and query for (x, y) gives you the result of the rectangle
[(0, 0), (x, y)], assuming the to... | quadratic | nlogn |
// A Simple C++ O(n^3) program to count inversions of size 3
#include<bits/stdc++.h>
using namespace std;
// Returns counts of inversions of size three
int getInvCount(int arr[],int n)
{
int invcount = 0; // Initialize result
for (int i=0; i<n-2; i++)
{
for (int j=i+1; j<n-1; j++)
{
... | constant | cubic |
// A O(n^2) C++ program to count inversions of size 3
#include<bits/stdc++.h>
using namespace std;
// Returns count of inversions of size 3
int getInvCount(int arr[], int n)
{
int invcount = 0; // Initialize result
for (int i=1; i<n-1; i++)
{
// Count all smaller elements on right of arr[i]
... | constant | quadratic |
// C++ program to count the number of inversion
// pairs in a 2D matrix
#include <bits/stdc++.h>
using namespace std;
// for simplicity, we are taking N as 4
#define N 4
// Function to update a 2D BIT. It updates the
// value of bit[l][r] by adding val to bit[l][r]
void update(int l, int r, int val, int bit[][N + 1... | quadratic | logn |
// Naive algorithm for building suffix array of a given text
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
// Structure to store information of a suffix
struct suffix
{
int index;
char *suff;
};
// A comparison function used by sort() to compare two suffixes
int cmp(stru... | linear | nlogn |
// C++ program to insert a node in AVL tree
#include<bits/stdc++.h>
using namespace std;
// An AVL tree node
class Node
{
public:
int key;
Node *left;
Node *right;
int height;
};
// A utility function to get the
// height of the tree
int height(Node *N)
{
if (N == NULL)
return 0;
... | constant | nlogn |
// C++ program to find N'th element in a set formed
// by sum of two arrays
#include<bits/stdc++.h>
using namespace std;
//Function to calculate the set of sums
int calculateSetOfSum(int arr1[], int size1, int arr2[],
int size2, int N)
{
// Insert each pair sum into set. Note that a set
... | linear | quadratic |
#include <iostream>
using namespace std;
void constructLowerArray(int arr[], int* countSmaller,
int n)
{
int i, j;
// Initialize all the counts in
// countSmaller array as 0
for (i = 0; i < n; i++)
countSmaller[i] = 0;
for (i = 0; i < n; i++) {
for (j =... | constant | quadratic |
#include <bits/stdc++.h>
using namespace std;
void merge(vector<pair<int, int> >& v, vector<int>& ans,
int l, int mid, int h)
{
vector<pair<int, int> >
t; // temporary array for merging both halves
int i = l;
int j = mid + 1;
while (i < mid + 1 && j <= h) {
// v[i].fir... | linear | nlogn |
#include <iostream>
using namespace std;
#include <stdio.h>
#include <stdlib.h>
// An AVL tree node
struct node {
int key;
struct node* left;
struct node* right;
int height;
// size of the tree rooted
// with this node
int size;
};
// A utility function to get
// maximum of two integ... | linear | nlogn |
#include <bits/stdc++.h>
using namespace std;
// BST node structure
class Node {
public:
int val;
int count;
Node* left;
Node* right;
// Constructor
Node(int num1, int num2)
{
this->val = num1;
this->count = num2;
this->left = this->right = NULL;
}
};
// F... | linear | quadratic |
// C++ program to sort an array according absolute
// difference with x.
#include <bits/stdc++.h>
using namespace std;
// Function to sort an array according absolute
// difference with x.
void rearrange(int arr[], int n, int x)
{
multimap<int, int> m;
multimap<int, int>::iterator it;
// Store values in... | linear | nlogn |
// CPP program for the above approach
#include <bits/stdc++.h>
using namespace std;
void rearrange(int arr[], int n, int x)
{
/*
We can send the value x into
lambda expression as
follows: [capture]()
{
//statements
//capture value can be used inside
... | constant | nlogn |
// C++ program to find maximum product of an increasing
// subsequence of size 3
#include <bits/stdc++.h>
using namespace std;
// Returns maximum product of an increasing subsequence of
// size 3 in arr[0..n-1]. If no such subsequence exists,
// then it returns INT_MIN
long long int maxProduct(int arr[], int n)
{
... | constant | cubic |
// C++ program to find maximum product of an increasing
// subsequence of size 3
#include <bits/stdc++.h>
using namespace std;
// Returns maximum product of an increasing subsequence of
// size 3 in arr[0..n-1]. If no such subsequence exists,
// then it returns INT_MIN
long long int maxProduct(int arr[], int n)
{
... | linear | nlogn |
// C++ Code for the above approach
#include <bits/stdc++.h>
using namespace std;
/* A binary tree node has data,
a pointer to left child
and a pointer to right child */
class Node {
public:
int data;
Node* left;
Node* right;
};
// Function to return a new Node
Node* newNode(int data)
{
Node* node ... | constant | linear |
/* CPP program to check if
a tree is height-balanced or not */
#include <bits/stdc++.h>
using namespace std;
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
class Node {
public:
int data;
Node* left;
Node* right;
Node(int d)
{
int data = d;
l... | linear | quadratic |
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
// Structure of a tree node
struct Node {
int key;
struct Node* left;
struct Node* right;
Node(int k)
{
key = k;
left = right = NULL;
}
};
// Function to check if tree is height balanced
int... | linear | linear |
// C++ program to find number of islands
// using Disjoint Set data structure.
#include <bits/stdc++.h>
using namespace std;
// Class to represent
// Disjoint Set Data structure
class DisjointUnionSets
{
vector<int> rank, parent;
int n;
public:
DisjointUnionSets(int n)
{
ra... | quadratic | quadratic |
// C++ program to find the height of the generic
// tree(n-ary tree) if parent array is given
#include <bits/stdc++.h>
using namespace std;
// function to fill the height vector
int rec(int i, int parent[], vector<int> height)
{
// if we have reached root node the
// return 1 as height of root node
if (pa... | linear | linear |
// C++ program to find number
// of children of given node
#include <bits/stdc++.h>
using namespace std;
// Represents a node of an n-ary tree
class Node {
public:
int key;
vector<Node*> child;
Node(int data)
{
key = data;
}
};
// Function to calculate number
// of children of given ... | linear | linear |
// C++ program to find sum of all
// elements in generic tree
#include <bits/stdc++.h>
using namespace std;
// Represents a node of an n-ary tree
struct Node {
int key;
vector<Node*> child;
};
// Utility function to create a new tree node
Node* newNode(int key)
{
Node* temp = new Node;
temp->key = k... | linear | linear |
// C++ program to create a tree with left child
// right sibling representation.
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
struct Node* child;
};
// Creating new Node
Node* newNode(int data)
{
Node* newNode = new Node;
newNode->next = newNode->child... | linear | linear |
// C++ program to count number of nodes
// which has more children than its parent
#include<bits/stdc++.h>
using namespace std;
// function to count number of nodes
// which has more children than its parent
int countNodes(vector<int> adj[], int root)
{
int count = 0;
// queue for applying BFS
queu... | linear | linear |
// C++ program to generate short url from integer id and
// integer id back from short url.
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
// Function to generate a short url from integer ID
string idToShortURL(long int n)
{
// Map to store 62 possible characters
char map[] = "ab... | constant | linear |
// A C++ program to implement Cartesian Tree sort
// Note that in this program we will build a min-heap
// Cartesian Tree and not max-heap.
#include<bits/stdc++.h>
using namespace std;
/* A binary tree node has data, pointer to left child
and a pointer to right child */
struct Node
{
int data;
Node *le... | linear | nlogn |
// C++ Program to search an element
// in a sorted and pivoted array
#include <bits/stdc++.h>
using namespace std;
// Standard Binary Search function
int binarySearch(int arr[], int low, int high, int key)
{
if (high < low)
return -1;
int mid = (low + high) / 2;
if (key == arr[mid])
re... | constant | logn |
// Search an element in sorted and rotated
// array using single pass of Binary Search
#include <bits/stdc++.h>
using namespace std;
// Returns index of key in arr[l..h] if
// key is present, otherwise returns -1
int search(int arr[], int l, int h, int key)
{
if (l > h)
return -1;
int mid = (l + h) ... | constant | logn |
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
// This function returns true if arr[0..n-1]
// has a pair with sum equals to x.
bool pairInSortedRotated(int arr[], int n, int x)
{
// Find the pivot element
int i;
for (i = 0; i < n - 1; i++)
if (arr[i] > arr... | constant | linear |
// C++ program to find max value of i*arr[i]
#include <iostream>
using namespace std;
// Returns max possible value of i*arr[i]
int maxSum(int arr[], int n)
{
// Find array sum and i*arr[i] with no rotation
int arrSum = 0; // Stores sum of arr[i]
int currVal = 0; // Stores sum of i*arr[i]
for (int i =... | constant | linear |
// A Naive C++ program to find maximum sum rotation
#include<bits/stdc++.h>
using namespace std;
// Returns maximum value of i*arr[i]
int maxSum(int arr[], int n)
{
// Initialize result
int res = INT_MIN;
// Consider rotation beginning with i
// for all possible values of i.
for (int i=0; i<n; i++)... | constant | quadratic |
// An efficient C++ program to compute
// maximum sum of i*arr[i]
#include<bits/stdc++.h>
using namespace std;
int maxSum(int arr[], int n)
{
// Compute sum of all array elements
int cum_sum = 0;
for (int i=0; i<n; i++)
cum_sum += arr[i];
// Compute sum of i*arr[i] for initial
// confi... | constant | linear |
// C++ program to find maximum sum of all
// rotation of i*arr[i] using pivot.
#include <iostream>
using namespace std;
// fun declaration
int maxSum(int arr[], int n);
int findPivot(int arr[], int n);
// function definition
int maxSum(int arr[], int n)
{
int sum = 0;
int i;
int pivot = findPivot(arr, n... | constant | linear |
// C++ program for the above approach
#include <iostream>
using namespace std;
int* rotateArray(int A[], int start, int end)
{
while (start < end) {
int temp = A[start];
A[start] = A[end];
A[end] = temp;
start++;
end--;
}
return A;
}
void leftRotate(int A[], int a, in... | linear | linear |
// CPP implementation of left rotation of
// an array K number of times
#include <bits/stdc++.h>
using namespace std;
// Fills temp[] with two copies of arr[]
void preprocess(int arr[], int n, int temp[])
{
// Store arr[] elements at i and i + n
for (int i = 0; i < n; i++)
temp[i] = temp[i + n] = arr[... | linear | linear |
// CPP implementation of left rotation of
// an array K number of times
#include <bits/stdc++.h>
using namespace std;
// Function to left rotate an array k times
void leftRotate(int arr[], int n, int k)
{
// Print array after k rotations
for (int i = k; i < k + n; i++)
cout << arr[i % n] << " ";
}
/... | constant | linear |
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the minimum value
int findMin(int arr[], int n)
{
int min_ele = arr[0];
// Traversing over array to
// find minimum element
for (int i = 0; i < n; i++) {
if (arr[i] < min_ele) {
... | constant | linear |
// C++ program to find minimum
// element in a sorted and rotated array
#include <bits/stdc++.h>
using namespace std;
int findMin(int arr[], int low, int high)
{
// This condition is needed to
// handle the case when array is not
// rotated at all
if (high < low)
return arr[0];
// If t... | constant | logn |
// C++ program for right rotation of
// an array (Reversal Algorithm)
#include <bits/stdc++.h>
/*Function to reverse arr[]
from index start to end*/
void reverseArray(int arr[], int start,
int end)
{
while (start < end)
{
std::swap(arr[start], arr[end]);
start++;
... | constant | linear |
// C++ Program to solve queries on Left and Right
// Circular shift on array
#include <bits/stdc++.h>
using namespace std;
// Function to solve query of type 1 x.
void querytype1(int* toRotate, int times, int n)
{
// Decreasing the absolute rotation
(*toRotate) = ((*toRotate) - times) % n;
}
// Function to ... | linear | linear |
// C++ implementation of left rotation of
// an array K number of times
#include <bits/stdc++.h>
using namespace std;
// Function to leftRotate array multiple times
void leftRotate(int arr[], int n, int k)
{
/* To get the starting point of rotated array */
int mod = k % n;
// Prints the rotated array fr... | constant | linear |
#include <bits/stdc++.h>
using namespace std;
int findElement(vector<int> arr, int ranges[][2],
int rotations, int index)
{
// Track of the rotation number
int n1 = 1;
// Track of the row index for the ranges[][] array
int i = 0;
// Initialize the left side of the ranges[][] array
int ... | constant | quadratic |
// CPP code to rotate an array
// and answer the index query
#include <bits/stdc++.h>
using namespace std;
// Function to compute the element at
// given index
int findElement(int arr[], int ranges[][2], int rotations,
int index)
{
for (int i = rotations - 1; i >= 0; i--) {
// Range[left... | constant | constant |
// CPP program to split array and move first
// part to end.
#include <iostream>
using namespace std;
void splitArr(int arr[], int n, int k)
{
for (int i = 0; i < k; i++) {
// Rotate array by 1.
int x = arr[0];
for (int j = 0; j < n - 1; ++j)
arr[j] = arr[j + 1];
arr[... | constant | quadratic |
// CPP program to split array and move first
// part to end.
#include <bits/stdc++.h>
using namespace std;
// Function to split array and
// move first part to end
void splitArr(int arr[], int length, int rotation)
{
int tmp[length * 2] = {0};
for(int i = 0; i < length; i++)
{
tmp[i] = arr[i];
... | linear | linear |
// C++ program for above approach
#include <iostream>
using namespace std;
// Function to transform the array
void fixArray(int ar[], int n)
{
int i, j, temp;
// Iterate over the array
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
// Check is any ar[j]
/... | constant | quadratic |
// C++ program for rearrange an
// array such that arr[i] = i.
#include <bits/stdc++.h>
using namespace std;
// Function to rearrange an array
// such that arr[i] = i.
void fixArray(int A[], int len)
{
for (int i = 0; i < len; i++)
{
if (A[i] != -1 && A[i] != i)
{
int x = A[i];
... | constant | linear |
#include <iostream>
#include <unordered_set>
using namespace std;
void fixArray(int arr[], int n)
{
// a set
unordered_set<int> s;
// Enter each element which is not -1 in set
for(int i=0; i<n; i++)
{
if(arr[i] != -1)
s.insert(arr[i]);
}
// Navigate through array,
// and put A[i] =... | linear | linear |
// C++ program for rearrange an
// array such that arr[i] = i.
#include <iostream>
using namespace std;
void fixArray(int arr[], int n)
{
int i = 0;
while (i < n) {
int correct = arr[i];
if (arr[i] != -1 && arr[i] != arr[correct]) {
// if array element should be lesser than
... | constant | linear |
// C++ program to rearrange the array as per the given
// condition
#include <bits/stdc++.h>
using namespace std;
// function to rearrange the array
void rearrangeArr(int arr[], int n)
{
// total even positions
int evenPos = n / 2;
// total odd positions
int oddPos = n - evenPos;
int tempArr[n];... | linear | nlogn |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,i,p,q;
int a[]= {1, 2, 1, 4, 5, 6, 8, 8};
n=sizeof(a)/sizeof(a[0]);
int b[n];
for(i=0;i<n;i++)
b[i]=a[i];
sort(b,b+n);
p=0;q=n-1;
for(i=n-1;i>=0;i--){
if(i%2!=0){
a[i]=b[q];
q-... | linear | nlogn |
/* C++ program to rearrange
positive and negative integers
in alternate fashion while keeping
the order of positive and negative numbers. */
#include <assert.h>
#include <iostream>
using namespace std;
// Utility function to right rotate all elements between
// [outofplace, cur]
void rightrotate(int arr[], ... | constant | quadratic |
// C++ Program to move all zeros to the end
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A[] = { 5, 6, 0, 4, 6, 0, 9, 0, 8 };
int n = sizeof(A) / sizeof(A[0]);
int j = 0;
for (int i = 0; i < n; i++) {
if (A[i] != 0) {
swap(A[j], A[i]); // Partitioning the array
... | constant | linear |
# C++ program to shift all zeros
# to right most side of array
# without affecting order of non-zero
# elements
# Given list
arr = [5, 6, 0, 4, 6, 0, 9, 0, 8]
# Storing all non zero values
nonZeroValues = [x for x in arr if x != 0]
# Storing all zeroes
zeroes = [j for j in arr if j == 0]
# Updating the answer
a... | constant | linear |
// C++ implementation to move all zeroes at the end of array
#include <iostream>
using namespace std;
// function to move all zeroes at the end of array
void moveZerosToEnd(int arr[], int n)
{
// Count of non-zero elements
int count = 0;
// Traverse the array. If arr[i] is non-zero, then
// update t... | constant | linear |
// C++ program to find minimum swaps required
// to club all elements less than or equals
// to k together
#include <iostream>
using namespace std;
// Utility function to find minimum swaps
// required to club all elements less than
// or equals to k together
int minSwap(int *arr, int n, int k) {
// Find co... | constant | linear |
#include <bits/stdc++.h>
using namespace std;
// Function for finding the minimum number of swaps
// required to bring all the numbers less
// than or equal to k together.
int minSwap(int arr[], int n, int k)
{
// Initially snowBallsize is 0
int snowBallSize = 0;
for (int i = 0; i < n; i++) {
... | constant | linear |
// C++ implementation of
// the above approach
#include <iostream>
void printArray(int array[], int length)
{
std::cout << "[";
for(int i = 0; i < length; i++)
{
std::cout << array[i];
if(i < (length - 1))
std::cout << ", ";
else
std::cout <<... | quadratic | quadratic |
// C++ program to print the array in given order
#include <bits/stdc++.h>
using namespace std;
// Function which arrange the array.
void rearrangeArray(int arr[], int n)
{
// Sorting the array elements
sort(arr, arr + n);
int tempArr[n]; // To store modified array
// Adding numbers from sorted arr... | linear | nlogn |
// C++ implementation to rearrange the array elements after
// modification
#include <bits/stdc++.h>
using namespace std;
// function which pushes all zeros to end of an array.
void pushZerosToEnd(int arr[], int n)
{
// Count of non-zero elements
int count = 0;
// Traverse the array. If element encounte... | constant | linear |
// C++ program to Rearrange positive and negative
// numbers in a array
#include <bits/stdc++.h>
using namespace std;
// A utility function to print an array of size n
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
cout<<arr[i]<<" ";
}
void rotateSubArray(int arr[], int l, int r) {
int ... | constant | quadratic |
// C++ program to Rearrange positive and negative
// numbers in a array
#include <stdio.h>
// A utility function to print an array of size n
void printArray(int arr[], int n)
{
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
printf("\n");
}
// Function to Rearrange positive and negative
// number... | constant | quadratic |
// C++ program to Rearrange positive and negative
// numbers in a array
#include <iostream>
using namespace std;
/* Function to print an array */
void printArray(int A[], int size)
{
for (int i = 0; i < size; i++)
cout << A[i] << " ";
cout << endl;
}
// Merges two subarrays of arr[].
// First subarr... | linear | nlogn |
// C++ program to Rearrange positive and negative
// numbers in a array
#include <bits/stdc++.h>
using namespace std;
/* Function to print an array */
void printArray(int A[], int size)
{
for (int i = 0; i < size; i++)
cout << A[i] << " ";
cout << endl;
}
/* Function to reverse an array. An array ca... | logn | nlogn |
#include <bits/stdc++.h>
using namespace std;
void Rearrange(int arr[], int n)
{
stable_partition(arr,arr+n,[](int x){return x<0;});
}
int main()
{
int n=4;
int arr[n]={-3, 3, -2, 2};
Rearrange( arr, n);
for (int i = 0; i < n; i++)
cout << arr[i] << " ";
... | linear | quadratic |
#include <iostream>
using namespace std;
void rearrangePosNegWithOrder(int *arr, int size)
{
int i = 0, j = 0;
while (j < size) {
if (arr[j] >= 0) {
j++;
}
else {
for (int k = j; k > i; k--) {
int temp = arr[k];
arr[k] = arr[k - 1];
... | constant | linear |
// C++ program to rearrange an array in minimum
// maximum form
#include <bits/stdc++.h>
using namespace std;
// Prints max at first position, min at second position
// second max at third position, second min at fourth
// position and so on.
void rearrange(int arr[], int n)
{
// Auxiliary array to hold modified ... | linear | linear |
#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
void move(vector<int>& arr){
sort(arr.begin(),arr.end());
}
int main() {
vector<int> arr = { -1, 2, -3, 4, 5, 6, -7, 8, 9 };
move(arr);
for (int e : arr)
cout<<e << " ";
return 0;
}
// This code is contributed b... | linear | nlogn |
// A C++ program to put all negative
// numbers before positive numbers
#include <bits/stdc++.h>
using namespace std;
void rearrange(int arr[], int n)
{
int j = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < 0) {
if (i != j)
swap(arr[i], arr[j]);
j++;
}
... | constant | linear |
// C++ program of the above
// approach
#include <iostream>
using namespace std;
// Function to shift all the
// negative elements on left side
void shiftall(int arr[], int left,
int right)
{
// Loop to iterate over the
// array from left to the right
while (left<=right)
{
// Condition... | constant | linear |
#include <iostream>
using namespace std;
// Swap Function.
void swap(int &a,int &b){
int temp =a;
a=b;
b=temp;
}
// Using Dutch National Flag Algorithm.
void reArrange(int arr[],int n){
int low =0,high = n-1;
while(low<high){
if(arr[low]<0){
low++;
}else if(arr[high]>0){
... | constant | linear |
// C++ program to Move All -ve Element At End
// Without changing order Of Array Element
#include<bits/stdc++.h>
using namespace std;
// Moves all -ve element to end of array in
// same order.
void segregateElements(int arr[], int n)
{
// Create an empty array to store result
int temp[n];
// Traversal a... | linear | linear |
// CPP code to rearrange an array such that
// even index elements are smaller and odd
// index elements are greater than their
// next.
#include <iostream>
using namespace std;
void rearrange(int* arr, int n)
{
for (int i = 0; i < n - 1; i++) {
if (i % 2 == 0 && arr[i] > arr[i + 1])
swap(arr[... | constant | linear |
// C++ program to rearrange positive and negative
// numbers
#include <bits/stdc++.h>
using namespace std;
void rearrange(int a[], int size)
{
int positive = 0, negative = 1;
while (true) {
/* Move forward the positive pointer till
negative number number not encountered */
whi... | constant | quadratic |
// C++ program to rearrange positive
// and negative numbers
#include<iostream>
using namespace std;
// Swap function
void swap(int* a, int i , int j)
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
return ;
}
// Print array function
void printArray(int* a, int n)
{
for(int i = 0; i < n; i++)
... | constant | quadratic |
// C++ program to update every array element with
// multiplication of previous and next numbers in array
#include<iostream>
using namespace std;
void modify(int arr[], int n)
{
// Nothing to do when array size is 1
if (n <= 1)
return;
// store current value of arr[0] and update it
int prev = ... | constant | linear |
// C++ Program to shuffle a given array
#include<bits/stdc++.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
// A utility function to swap to integers
void swap (int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// A utility function to print an array
void printArray (int arr[], int n... | constant | linear |
// C++ Implementation of the above approach
#include <iostream>
using namespace std;
void arrayEvenAndOdd(int arr[], int n)
{
int a[n], index = 0;
for (int i = 0; i < n; i++)
{
if (arr[i] % 2 == 0)
{
a[index] = arr[i];
index++;
}
}
for (int i = 0; i < ... | linear | linear |
// CPP code to segregate even odd
// numbers in an array
#include <bits/stdc++.h>
using namespace std;
// Function to segregate even odd numbers
void arrayEvenAndOdd(int arr[], int n)
{
int i = -1, j = 0;
int t;
while (j != n) {
if (arr[j] % 2 == 0) {
i++;
// Swapping e... | constant | linear |
// C++ program of above implementation
#include <bits/stdc++.h>
using namespace std;
// Standard partition process of QuickSort().
// It considers the last element as pivot and
// oves all smaller element to left of it
// and greater elements to right
int partition(int* arr, int l, int r)
{
int x = arr[r], i = ... | constant | nlogn |
// STL based C++ program to find k-th smallest
// element.
#include <bits/stdc++.h>
using namespace std;
int kthSmallest(int arr[], int n, int k)
{
// Insert all elements into the set
set<int> s;
for (int i = 0; i < n; i++)
s.insert(arr[i]);
// Traverse set and print k-th element
auto it = s.begin();
for (i... | linear | nlogn |
#include <iostream>
using namespace std;
// Swap function to interchange
// the value of variables x and y
int swap(int& x, int& y)
{
int temp = x;
x = y;
y = temp;
}
// Min Heap Class
// arr holds reference to an integer
// array size indicate the number of
// elements in Min Heap
class MinHeap {
... | linear | nlogn |
#include <bits/stdc++.h>
using namespace std;
// picks up last element between start and end
int findPivot(int a[], int start, int end)
{
// Selecting the pivot element
int pivot = a[end];
// Initially partition-index will be at starting
int pIndex = start;
for (int i = start; i < end; i++) {
... | constant | nlogn |
// C++ code for k largest/ smallest elements in an array
#include <bits/stdc++.h>
using namespace std;
// Function to find k largest array element
void kLargest(vector<int>& v, int N, int K)
{
// Implementation using
// a Priority Queue
priority_queue<int, vector<int>, greater<int> >pq;
for (int i ... | linear | nlogn |
#include <bits/stdc++.h>
using namespace std;
struct Node{
int data;
struct Node *left;
struct Node *right;
};
class Tree{
public:
Node *root = NULL;
void addNode(int data){
Node *newNode = new Node();
newNode->data = data;
if (!root){
... | linear | nlogn |
End of preview. Expand in Data Studio
Dataset Card for TASTY C++ and Python Codes with Complexities
This is a dataset of code snippets with their complexities, both space and time.
As part of this initial release, we cover C++ and Python.
This data was collected as part of our work on the paper called TASTY, published at the ICLR DL4Code workshop, a few years back.
We scraped the data from the popular coding website called GeeksForGeeks (GFG). It is under the CCBY license.
We published this paper before the advent of ChatGPT, so this is not recent by any means and things on the GFG website might have changed since we scraped the data. There was also a lot of manual work that went into correcting the scraped data and putting it into the format that we needed it to be, so some of the complexities might not be exactly what you see on the GFG website. For instance, what is given as "O(n)" on the GFG website is instead written as "linear" in our dataset. In the same way, linear equivalents, "O(n+m)" are also cast to "linear". The same applies to all the classes in our dataset.
There is work being undertaken on the next version of the paper, where we plan to expand to dataset to several more languages and a lot more examples. Probably 10x more samples for 4-5 more languages. There will be a fundamental change in the tone of the work as well since TASTY was published before the ChatGPT, LLMs were not as popular then.
Dataset Details
There are more than 1000 but less than 2000 codes and their space + time complexity.
Dataset Sources
- Repository: Private, will be made public after the next version of the paper is published,.
- Paper: TASTY: A Transformer based Approach to Space and Time complexity
Uses
- Classification of space and time complexity
- Eventual Auto Regressive prediciton of the same
- Cross Language Transfer
Direct Use
Read the paper above for direct uses.
BibTeX:
@misc{moudgalya2023tastytransformerbasedapproach,
title={TASTY: A Transformer based Approach to Space and Time complexity},
author={Kaushik Moudgalya and Ankit Ramakrishnan and Vamsikrishna Chemudupati and Xing Han Lu},
year={2023},
eprint={2305.05379},
archivePrefix={arXiv},
primaryClass={cs.SE},
url={https://arxiv.org/abs/2305.05379},
}
- Downloads last month
- 32
Curated by:
Banana-Leopard
Funded by [Banana-Leopard]:
Funded by [Banana-Leopard]:
Shared by [Banana-Leopard]:
Shared by [Banana-Leopard]:
Language(s) (NLP):
C++ and Python
License:
CCBY
Size of downloaded dataset files:
4.12 MB
Size of the auto-converted Parquet files:
1.47 MB
Number of rows:
2,783