id stringlengths 22 24 | content stringlengths 46 1.22k |
|---|---|
g-transeval-cpp_data_301 | string GetClosestVowel ( string word ) { string vowels = "AEIOUaeiou" ; for ( int i = word . length ( ) - 2 ; i > 0 ; i -- ) { if ( vowels . find ( word [ i ] ) != string :: npos && vowels . find ( word [ i + 1 ] ) == string :: npos && vowels . find ( word [ i - 1 ] ) == string :: npos ) { return string ( 1 , word [ i ] ) ; } } return "" ; }
|
g-transeval-cpp_data_302 | string MatchParens ( vector < string > lst ) { vector < string > strings = { lst [ 0 ] + lst [ 1 ] , lst [ 1 ] + lst [ 0 ] } ; for ( auto & l : strings ) { int count = 0 ; for ( char c : l ) { if ( c == '(' ) { count += 1 ; } if ( c == ')' ) { count -= 1 ; } if ( count < 0 ) { break ; } } if ( count == 0 ) { return "Yes" ; } } return "No" ; }
|
g-transeval-cpp_data_303 | vector < int > Maximum ( vector < int > arr , int k ) { if ( k == 0 ) { return { } ; } sort ( arr . begin ( ) , arr . end ( ) ) ; return vector < int > ( arr . end ( ) - k , arr . end ( ) ) ; }
|
g-transeval-cpp_data_304 | bool ValidDate ( string date ) { if ( date . length ( ) != 10 ) { return false ; } for ( int i = 0 ; i < 10 ; i ++ ) { if ( i == 2 || i == 5 ) { if ( date [ i ] != '-' ) { return false ; } } else if ( ! isdigit ( date [ i ] ) ) { return false ; } } int month = stoi ( date . substr ( 0 , 2 ) ) ; int day = stoi ( date . substr ( 3 , 2 ) ) ; int year = stoi ( date . substr ( 6 , 4 ) ) ; if ( month < 1 || month > 12 ) { return false ; } if ( day < 1 || day > 31 ) { return false ; } if ( day == 31 && ( month == 4 || month == 6 || month == 9 || month == 11 || month == 2 ) ) { return false ; } if ( day == 30 && month == 2 ) { return false ; } return true ; }
|
g-transeval-cpp_data_305 | vector < string > SplitWords ( string txt ) { string current ; vector < string > result ; if ( txt . find ( ' ' ) != string :: npos ) { for ( int i = 0 ; i <= txt . length ( ) ; i ++ ) { if ( i == txt . length ( ) || txt [ i ] == ' ' ) { if ( current . length ( ) > 0 ) { result . push_back ( current ) ; } current . clear ( ) ; } else { current += txt [ i ] ; } } return result ; } if ( txt . find ( ',' ) != string :: npos ) { for ( int i = 0 ; i <= txt . length ( ) ; i ++ ) { if ( i == txt . length ( ) || txt [ i ] == ',' ) { if ( current . length ( ) > 0 ) { result . push_back ( current ) ; } current . clear ( ) ; } else { current += txt [ i ] ; } } return result ; } int num = 0 ; for ( char c : txt ) { if ( islower ( c ) && c % 2 == 0 ) { num += 1 ; } } return { to_string ( num ) } ; }
|
g-transeval-cpp_data_306 | vector < int > Tri ( int n ) { if ( n == 0 ) { return { 1 } ; } vector < int > tris = { 1 , 3 } ; for ( int i = 2 ; i <= n ; i ++ ) { if ( i % 2 == 0 ) { tris . push_back ( i / 2 + 1 ) ; } else { tris . push_back ( tris [ i - 1 ] + tris [ i - 2 ] + ( i + 3 ) / 2 ) ; } } return tris ; }
|
g-transeval-cpp_data_307 | bool CheckIfLastCharIsALetter ( string txt ) { if ( txt . empty ( ) ) { return false ; } return isalpha ( txt [ txt . length ( ) - 1 ] ) && ( txt . length ( ) == 1 || ! isalpha ( txt [ txt . length ( ) - 2 ] ) ) ; }
|
g-transeval-cpp_data_308 | vector < int > OrderByPoints ( vector < int > nums ) { vector < int > result ; for ( int num : nums ) { string w = to_string ( abs ( num ) ) ; int sum = 0 ; for ( char c : w ) { sum += c - '0' ; } if ( num < 0 ) { sum -= 2 * ( w [ 0 ] - '0' ) ; } result . push_back ( sum ) ; } for ( int i = 0 ; i < nums . size ( ) ; i ++ ) { for ( int j = 1 ; j < nums . size ( ) ; j ++ ) { if ( result [ j - 1 ] > result [ j ] ) { swap ( result [ j ] , result [ j - 1 ] ) ; swap ( nums [ j ] , nums [ j - 1 ] ) ; } } } return nums ; }
|
g-transeval-cpp_data_309 | vector < string > Bf ( string planet1 , string planet2 ) { vector < string > planets = { "Mercury" , "Venus" , "Earth" , "Mars" , "Jupiter" , "Saturn" , "Uranus" , "Neptune" } ; auto it1 = find ( planets . begin ( ) , planets. end ( ) , planet1 ) ; int idx1 = it1 == planets . end ( ) ? -1 : it1 - planets . begin ( ) ; auto it2 = find ( planets . begin ( ) , planets . end ( ) , planet2 ) ; int idx2 = it2 == planets . end ( ) ? -1 : it2 - planets . begin ( ) ; if ( idx1 == -1 || idx2 == -1 || idx1 == idx2 ) { return { } ; } return idx1 > idx2 ? vector < string > ( planets . begin ( ) + idx2 + 1 , planets . begin ( ) + idx1 ) : vector < string > ( planets . begin ( ) + idx1 + 1 , planets . begin ( ) + idx2 ) ; }
|
g-transeval-cpp_data_310 | vector < string > SortedListSum ( vector < string > lst ) { vector < string > result ; for ( auto & i : lst ) { if ( i . length ( ) % 2 == 0 ) { result . push_back ( i ) ; } } sort ( result . begin ( ) , result . end ( ) , [ ] ( string & l , string & r ) { if ( l . length ( ) == r . length ( ) ) { return l < r ; } return l . length ( ) < r . length ( ) ; } ) ; return result ; }
|
g-transeval-cpp_data_311 | bool CycpatternCheck ( string a , string b ) { for ( int i = 0 ; i < b . length ( ) ; i ++ ) { string rotate = b . substr ( i ) + b . substr ( 0 , i ) ; if ( a . find ( rotate ) != string :: npos ) { return true ; } } return false ; }
|
g-transeval-cpp_data_312 | vector < int > EvenOddCount ( int num ) { int even_count = 0 , odd_count = 0 ; for ( char i : to_string ( abs ( num ) ) ) { if ( i % 2 == 0 ) { even_count += 1 ; } else { odd_count += 1 ; } } return { even_count , odd_count } ; }
|
g-transeval-cpp_data_313 | string FindMax ( vector < string > words ) { string max ; int max_length = 0 ; for ( auto & word : words ) { vector < char > unique ; for ( char w : word ) { if ( find ( unique . begin ( ) , unique . end ( ) , w ) == unique . end ( ) ) { unique . push_back ( w ) ; } } if ( unique . size ( ) > max_length || ( unique . size ( ) == max_length && word < max ) ) { max = word ; max_length = unique . size ( ) ; } } return max ; }
|
g-transeval-cpp_data_314 | string Solve ( string s ) { bool no_letter = true ; string result ; for ( char ch : s ) { if ( isupper ( ch ) ) { ch = tolower ( ch ) ; no_letter = false ; } else if ( islower ( ch ) ) { ch = toupper ( ch ) ; no_letter = false ; } result += ch ; } if ( no_letter ) { return string ( s . rbegin ( ) , s . rend ( ) ) ; } else { return result ; } }
|
g-transeval-cpp_data_315 | int MostFrequent ( vector < int > arr , int n ) { unordered_map < int , int > hp ; for ( int i = 0 ; i < n ; i ++ ) { if ( hp . find ( arr [ i ] ) != hp . end ( ) ) { hp [ arr [ i ] ] ++ ; } else { hp [ arr [ i ] ] = 1 ; } } int max_count = 0 , res = -1 ; for ( auto & entry : hp ) { if ( max_count < entry . second ) { res = entry . first ; max_count = entry . second ; } } return res ; }
|
g-transeval-cpp_data_316 | int Find ( vector < int > a , vector < int > b , int k , int n1 , int n2 ) { unordered_set < int > s ; for ( int i = 0 ; i < n2 ; i ++ ) { s . insert ( b [ i ] ) ; } int missing = 0 ; for ( int i = 0 ; i < n1 ; i ++ ) { if ( s . find ( a [ i ] ) == s . end ( ) ) { missing ++ ; } if ( missing == k ) { return a [ i ] ; } } return -1 ; }
|
g-transeval-cpp_data_317 | int SolveQuery ( int start , int end , vector < int > arr ) { unordered_map < int , int > mp ; for ( int i = start ; i <= end ; i ++ ) { mp [ arr [ i ] ] ++ ; } int count = 0 ; for ( auto & [ key , value ] : mp ) { if ( key == value ) { count ++ ; } } return count ; }
|
g-transeval-cpp_data_318 | int Segregate ( vector < int > arr , int size ) { int j = 0 ; for ( int i = 0 ; i < size ; i ++ ) { if ( arr [ i ] <= 0 ) { swap ( arr [ i ] , arr [ j ] ) ; j ++ ; } } return j ; }
|
g-transeval-cpp_data_319 | int CountTriplets ( vector < int > a , int n ) { unordered_set < int > s ; for ( int i = 0 ; i < n ; i ++ ) { s . insert ( a [ i ] ) ; } int count = 0 ; for ( int i = 0 ; i < n - 1 ; i ++ ) { for ( int j = i + 1 ; j < n ; j ++ ) { int xr = a [ i ] ^ a [ j ] ; if ( s . find ( xr ) != s . end ( ) && xr != a [ i ] && xr != a [ j ] ) { count ++ ; } } } return count / 3 ; }
|
g-transeval-cpp_data_320 | int LeastFrequent ( vector < int > arr , int n ) { unordered_map < int , int > hp ; for ( int i = 0 ; i < n ; i ++ ) { if ( hp . find ( arr [ i ] ) != hp . end ( ) ) { hp [ arr [ i ] ] ++ ; } else { hp [ arr [ i ] ] = 1 ; } } int min_count = n + 1 , res = -1 ; for ( auto & entry : hp ) { if ( min_count >= entry . second ) { res = entry . first ; min_count = entry . second ; } } return res ; }
|
g-transeval-cpp_data_321 | int FindPermutations ( vector < int > arr ) { int cnt = 0 ; int max_ind = -1 , min_ind = 10000000 ; int n = arr . size ( ) ; unordered_map < int , int > index_of ; for ( int i = 0 ; i < n ; i ++ ) { index_of [ arr [ i ] ] = i + 1 ; } for ( int i = 1 ; i <= n ; i ++ ) { max_ind = max ( max_ind , index_of [ i ] ) ; min_ind = min ( min_ind , index_of [ i ] ) ; if ( max_ind - min_ind + 1 == i ) { cnt ++ ; } } return cnt ; }
|
g-transeval-cpp_data_322 | int FormQuadruplets ( vector < int > arr , int n ) { int ans = 0 , pairs = 0 ; pairs = n / 4 ; sort ( arr . begin ( ) , arr . end ( ) , greater < > ( ) ) ; for ( int i = 0 ; i < n - pairs ; i += 3 ) { ans += arr [ i + 2 ] ; } return ans ; }
|
g-transeval-cpp_data_323 | string LexicographicallyMaximum ( string s , int n ) { unordered_map < char , int > m ; for ( int i = 0 ; i < n ; ++ i ) { if ( m . find ( s [ i ] ) != m . end ( ) ) { m [ s [ i ] ] ++ ; } else { m [ s [ i ] ] = 1 ; } } vector < char > v ; for ( char i = 'a' ; i < 'a' + min ( n , 25 ) ; ++ i ) { if ( m . find ( i ) == m . end ( ) ) { v . push_back ( i ) ; } } int j = v . size ( ) - 1 ; for ( int i = 0 ; i < n ; ++ i ) { if ( s [ i ] >= 'a' + min ( n , 25 ) || ( m . find ( s [ i ] ) != m . end ( ) && m [ s [ i ] ] > 1 ) ) { if ( v [ j ] < s [ i ] ) { continue ; } m [ s [ i ] ] -- ; s = s . substr ( 0 , i ) + v [ j ] + s . substr ( i + 1 ) ; j -- ; } if ( j < 0 ) { break ; } } int l = 0 ; for ( int i = n - 1 ; i >= 0 ; i -- ) { if ( l > j ) { break ; } if ( s [ i ] >= 'a' + min ( n , 25 ) || ( m . find ( s [ i ] ) != m . end ( ) && m [ s [ i ] ] > 1 ) ) { m [ s [ i ] ] -- ; s = s . substr ( 0 , i ) + v [ l ] + s . substr ( i + 1 ) ; l ++ ; } } return s ; }
|
g-transeval-cpp_data_324 | int NoOfValidKbers ( int k , vector < int > arr ) { unordered_set < int > s ; while ( k != 0 ) { s . insert ( k % 10 ) ; k = k / 10 ; } int count = 0 ; for ( int i = 0 ; i < arr . size ( ) ; i ++ ) { int no = arr [ i ] ; bool flag = true ; while ( no != 0 ) { int digit = no % 10 ; if ( s . find ( digit ) == s . end ( ) ) { flag = false ; break ; } no = no / 10 ; } if ( flag ) { count ++ ; } } return count ; }
|
g-transeval-cpp_data_325 | int DelCost ( string s , vector < int > cost ) { int ans = 0 ; map < char , int > for_max ; map < char , int > for_tot ; for ( int i = 0 ; i < s . length ( ) ; i ++ ) { if ( for_max . find ( s [ i ] ) == for_max . end ( ) ) { for_max [ s [ i ] ] = cost [ i ] ; } else { for_max [ s [ i ] ] = max ( cost [ i ] , for_max [ s [ i ] ] ) ; } if ( for_tot . find ( s [ i ] ) == for_tot . end ( ) ) { for_tot [ s [ i ] ] = cost [ i ] ; } else { for_tot [ s [ i ] ] = for_tot [ s [ i ] ] + cost [ i ] ; } } for ( auto & i : for_max ) { ans += for_tot [ i . first ] - i . second ; } return ans ; }
|
g-transeval-cpp_data_326 | vector < string > ReplaceDuplicates ( vector < string > names ) { unordered_map < string , int > hash ; for ( int i = 0 ; i < names . size ( ) ; i ++ ) { if ( hash . find ( names [ i ] ) == hash . end ( ) ) { hash [ names [ i ] ] = 1 ; } else { int count = hash [ names [ i ] ] ; hash [ names [ i ] ] ++ ; names [ i ] += to_string ( count ) ; } } return names ; }
|
g-transeval-cpp_data_327 | vector < int > minmaxNumbers ( vector < vector < int > > matrix , vector < int > res ) { unordered_set < int > s ; for ( int i = 0 ; i < matrix . size ( ) ; i ++ ) { int min_r = INT_MAX ; for ( int j = 0 ; j < matrix [ i ] . size ( ) ; j ++ ) { min_r = min ( min_r , matrix [ i ] [ j ] ) ; } s . insert ( min_r ) ; } for ( int j = 0 ; j < matrix [ 0 ] . size ( ) ; j ++ ) { int max_c = INT_MIN ; for ( int i = 0 ; i < matrix . size ( ) ; i ++ ) { max_c = max ( max_c , matrix [ i ] [ j ] ) ; } if ( s . find ( max_c ) != s . end ( ) ) { res . push_back ( max_c ) ; } } return res ; }
|
g-transeval-cpp_data_328 | int LengthOfLongestAp ( vector < int > a , int n ) { unordered_map < int , unordered_map < int , int > > dp ; int res = 2 ; for ( int i = 0 ; i < n ; ++ i ) { for ( int j = i + 1 ; j < n ; ++ j ) { int d = a [ j ] - a [ i ] ; if ( dp . find ( d ) != dp . end ( ) ) { if ( dp [ d ] . find ( i ) != dp [ d ] . end ( ) ) { dp [ d ] [ j ] = dp [ d ] [ i ] + 1 ; } else { dp [ d ] [ j ] = 2 ; } } else { dp [ d ] = unordered_map < int , int > ( ) ; dp [ d ] [ j ] = 2 ; } res = max ( res , dp [ d ] [ j ] ) ; } } return res ; }
|
g-transeval-cpp_data_329 | char FindKthChar ( int n , int k ) { string prev = "A" ; string cur ; if ( n == 1 ) { return 'A' ; } for ( int j = 2 ; j <= n ; j ++ ) { cur = prev + "B" ; for ( int i = 0 ; i < prev . length ( ) ; i ++ ) { if ( prev [ i ] == 'A' ) { prev [ i ] = 'B' ; } else { prev [ i ] = 'A' ; } } reverse ( prev . begin ( ) , prev . end ( ) ) ; cur += prev ; prev = cur ; } return cur [ k - 1 ] ; }
|
g-transeval-cpp_data_330 | char FindKthLargest ( string s , int k ) { string tmp = s ; sort ( tmp . begin ( ) , tmp . end ( ) ) ; reverse ( tmp . begin ( ) , tmp . end ( ) ) ; return tmp [ k - 1 ] ; }
|
g-transeval-cpp_data_331 | int SubArraylen ( vector < int > arr , int n , int k ) { unordered_map < int , int > mp ; mp [ arr [ 0 ] ] = 0 ; for ( int i = 1 ; i < n ; i ++ ) { arr [ i ] = arr [ i ] + arr [ i - 1 ] ; mp [ arr [ i ] ] = i ; } int length = INT_MAX ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] < k ) { continue ; } else { int x = arr [ i ] - k ; if ( x == 0 ) { length = min ( length , i ) ; } if ( mp . find ( x ) == mp . end ( ) ) { continue ; } else { length = min ( length , i - mp [ x ] ) ; } } } return length ; }
|
g-transeval-cpp_data_332 | int FindMaxLen ( vector < int > a , int k ) { int n = a . size ( ) ; sort ( a . begin ( ) , a . end ( ) ) ; vector < bool > vis ( n , false ) ; map < int , int > mp ; for ( int i = 0 ; i < n ; i ++ ) { mp [ a [ i ] ] = i ; } int c = 0 ; for ( int i = 0 ; i < n ; ++ i ) { if ( ! vis [ i ] ) { int check = a [ i ] * k ; if ( mp . find ( check ) != mp . end ( ) ) { c ++ ; vis [ mp [ check ] ] = true ; } } } return n - c ; }
|
g-transeval-cpp_data_333 | vector < int > MinDistancePoints ( vector < int > a , int k , int n ) { map < int , int > m ; queue < int > q ; for ( int i = 0 ; i < n ; ++ i ) { m [ a [ i ] ] = 1 ; q . push ( a [ i ] ) ; } vector < int > ans ; while ( k > 0 ) { int x = q . front ( ) ; q . pop ( ) ; if ( m . find ( x - 1 ) == m . end ( ) && k > 0 ) { m [ x - 1 ] = 1 ; q . push ( x - 1 ) ; ans . push_back ( x - 1 ) ; k -- ; } if ( ! m [ x + 1 ] && k > 0 ) { m [ x + 1 ] = 1 ; q . push ( x + 1 ) ; ans . push_back ( x + 1 ) ; k -- ; } } return ans ; }
|
g-transeval-cpp_data_334 | bool IsValidLen ( string s , int length , int k ) { int n = s . size ( ) ; unordered_map < char , int > mp ; int right = 0 ; while ( right < length ) { if ( mp . find ( s [ right ] ) != mp . end ( ) ) { mp [ s [ right ] ] ++ ; } else { mp [ s [ right ] ] = 1 ; } right ++ ; } if ( mp . size ( ) <= k ) { return true ; } while ( right < n ) { if ( mp . find ( s [ right ] ) != mp . end ( ) ) { mp [ s [ right ] ] ++ ; } else { mp [ s [ right ] ] = 1 ; } if ( mp . find ( s [ right - length ] ) != mp . end ( ) ) { mp [ s [ right - length ] ] -- ; } if ( mp [ s [ right - length ] ] == 0 ) { mp . erase ( s [ right - length ] ) ; } if ( mp . size ( ) <= k ) { return true ; } right ++ ; } return mp . size ( ) <= k ; }
|
g-transeval-cpp_data_335 | int Partition ( vector < int > arr , int low , int high ) { int pivot = arr [ high ] ; int i = ( low - 1 ) ; for ( int j = low ; j <= high - 1 ; j ++ ) { if ( arr [ j ] <= pivot ) { i ++ ; swap ( arr [ i ] , arr [ j ] ) ; } } swap ( arr [ i + 1 ] , arr [ high ] ) ; return i + 1 ; }
|
g-transeval-cpp_data_336 | int StrScore ( vector < string > strs , string s , int n ) { unordered_map < string , int > m ; for ( int i = 0 ; i < n ; i ++ ) { m [ strs [ i ] ] = i + 1 ; } if ( m . find ( s ) == m . end ( ) ) { return 0 ; } int score = 0 ; for ( int i = 0 ; i < s . length ( ) ; i ++ ) { score += s [ i ] - 'a' + 1 ; } score = score * m [ s ] ; return score ; }
|
g-transeval-cpp_data_337 | vector < int > CountEle ( vector < int > s , vector < int > a , int n ) { unordered_map < int , bool > mp ; vector < int > ans ; for ( int i = 0 ; i < n ; ++ i ) { int num = a [ i ] ; if ( mp . find ( num ) != mp . end ( ) ) { ans . push_back ( 0 ) ; } else { int cnt = 0 ; while ( s [ 0 ] != num ) { mp [ s [ 0 ] ] = true ; s . erase ( s . begin ( ) ) ; cnt ++ ; } s . erase ( s . begin ( ) ) ; cnt ++ ; ans . push_back ( cnt ) ; } } return ans ; }
|
g-transeval-cpp_data_338 | int MaxDistinctChar ( string s , int n , int k ) { unordered_map < char , int > freq ; for ( int i = 0 ; i < n ; i ++ ) { freq [ s [ i ] ] ++ ; } vector < int > v ; for ( auto & it : freq ) { v . push_back ( it . second ) ; } sort ( v . begin ( ) , v . end ( ) ) ; for ( int i = 0 ; i < v . size ( ) ; i ++ ) { int mn = min ( v [ i ] - 1 , k ) ; v [ i ] -= mn ; k -= mn ; } if ( k > 0 ) { for ( int i = 0 ; i < v . size ( ) ; i ++ ) { int mn = min ( v [ i ] , k ) ; v [ i ] -= mn ; k -= mn ; } } int res = 0 ; for ( int i = 0 ; i < v . size ( ) ; i ++ ) { if ( v [ i ] == 1 ) { res ++ ; } } return res ; }
|
g-transeval-cpp_data_339 | int FindKth ( vector < int > arr , int n , int k ) { unordered_set < int > missing ; int count = 0 ; for ( int i = 0 ; i < n ; i ++ ) { missing . insert ( arr [ i ] ) ; } int max_m = * max_element ( arr . begin ( ) , arr . end ( ) ) ; int min_m = * min_element ( arr . begin ( ) , arr . end ( ) ) ; for ( int i = min_m + 1 ; i < max_m ; i ++ ) { if ( missing . find ( i ) == missing . end ( ) ) { count ++ ; } if ( count == k ) { return i ; } } return -1 ; }
|
g-transeval-cpp_data_340 | bool AlmostSort ( vector < int > a , int n ) { for ( int i = 0 ; i < n - 1 ; i ++ ) { if ( a [ i ] > a [ i + 1 ] ) { swap ( a [ i ] , a [ i + 1 ] ) ; i ++ ; } } for ( int i = 0 ; i < n - 1 ; i ++ ) { if ( a [ i ] > a [ i + 1 ] ) { return false ; } } return true ; }
|
g-transeval-cpp_data_341 | int MaximumSum ( string s , int n , int k ) { int sum = 0 ; vector < int > freq ( 256 ) ; for ( int i = 0 ; i < n ; i ++ ) { freq [ s [ i ] ] ++ ; } sort ( freq . begin ( ) , freq . end ( ) , greater < > ( ) ) ; for ( int i = 0 ; i < 256 ; i ++ ) { if ( k > freq [ i ] ) { sum += freq [ i ] * freq [ i ] ; k -= freq [ i ] ; } else { sum += freq [ i ] * k ; break ; } } return sum ; }
|
g-transeval-cpp_data_342 | int FindMinOperations ( vector < int > arr , int n , int k ) { int operations = 0 ; for ( int i = 0 ; i < k ; i ++ ) { unordered_map < int , int > freq ; for ( int j = i ; j < n ; j += k ) { freq [ arr [ j ] ] ++ ; } int max1 = 0 , num = 0 ; for ( auto & [ key , value ] : freq ) { if ( value > max1 ) { max1 = value ; num = key ; } } for ( auto & [ key , value ] : freq ) { if ( key != num ) { operations += value ; } } } return operations ; }
|
g-transeval-cpp_data_343 | vector < string > SubString ( string s , int n ) { vector < string > v ; for ( int i = 0 ; i < n ; i ++ ) { for ( int length = 1 ; length <= n - i ; length ++ ) { string find = s . substr ( i , length ) ; v . push_back ( find ) ; } } return v ; }
|
g-transeval-cpp_data_344 | bool CheckUniqueFrequency ( vector < int > arr , int n ) { unordered_map < int , int > freq ; for ( int i = 0 ; i < n ; i ++ ) { freq [ arr [ i ] ] ++ ; } unordered_set < int > unique_freq ; for ( auto & [ key , value ] : freq ) { if ( unique_freq . find ( value ) != unique_freq . end ( ) ) { return false ; } else { unique_freq . insert ( value ) ; } } return true ; }
|
g-transeval-cpp_data_345 | int MinCost ( string str1 , string str2 , int n ) { int cost = 0 ; string tmp = str1 ; for ( int i = 0 ; i < n ; i ++ ) { if ( tmp [ i ] != str2 [ i ] ) { if ( i < n - 1 && tmp [ i + 1 ] != str2 [ i + 1 ] ) { swap ( tmp [ i ] , tmp [ i + 1 ] ) ; cost ++ ; } else { cost ++ ; } } } return cost ; }
|
g-transeval-cpp_data_346 | bool IsValidNum ( string x ) { map < int , int > mp ; for ( int i = 0 ; i < x . length ( ) ; i ++ ) { if ( mp . find ( x [ i ] - '0' ) != mp . end ( ) ) { return false ; } else if ( x [ i ] - '0' > 5 ) { return false ; } else { mp [ x [ i ] - '0' ] = 1 ; } } return true ; }
|
g-transeval-cpp_data_347 | int MinimizeDiff ( vector < int > arr , int n , int k ) { int max = * max_element ( arr . begin ( ) , arr . end ( ) ) ; int min = * min_element ( arr . begin ( ) , arr . end ( ) ) ; if ( max - min <= k ) { return max - min ; } int avg = ( max + min ) / 2 ; for ( int i = 0 ; i < n ; i ++ ) { if ( arr [ i ] > avg ) { arr [ i ] -= k ; } else { arr [ i ] += k ; } } max = * max_element ( arr . begin ( ) , arr . end ( ) ) ; min = * min_element ( arr . begin ( ) , arr . end ( ) ) ; return max - min ; }
|
g-transeval-cpp_data_348 | int GetMinCost ( vector < int > arr , int n ) { int min_ele = * min_element ( arr . begin ( ) , arr . end ( ) ) ; return min_ele * ( n - 1 ) ; }
|
g-transeval-cpp_data_349 | bool Possibility ( unordered_map < int , int > m , int length , string s ) { int count_odd = 0 ; for ( int i = 0 ; i < length ; i ++ ) { if ( m [ s [ i ] - '0' ] & 1 ) { count_odd ++ ; } if ( count_odd > 1 ) { return false ; } } return true ; }
|
g-transeval-cpp_data_350 | int MinimumCostOfBreaking ( vector < int > x , vector < int > y , int m , int n ) { int res = 0 ; sort ( x . begin ( ) , x . end ( ) , greater < > ( ) ) ; sort ( y . begin ( ) , y . end ( ) , greater < > ( ) ) ; int hzntl = 1 , vert = 1 ; int i = 0 , j = 0 ; while ( i < m && j < n ) { if ( x [ i ] > y [ j ] ) { res += x [ i ] * vert ; hzntl ++ ; i ++ ; } else { res += y [ j ] * hzntl ; vert ++ ; j ++ ; } } int total = 0 ; while ( i < m ) { total += x [ i ++ ] ; } res += total * vert ; total = 0 ; while ( j < n ) { total += y [ j ++ ] ; } res += total * hzntl ; return res ; }
|
g-transeval-cpp_data_351 | int FindMaximumScore ( vector < int > a , int n ) { unordered_map < int , int > freq ; for ( int i = 0 ; i < n ; i ++ ) { if ( freq . find ( a [ i ] ) != freq . end ( ) ) { freq [ a [ i ] ] = freq [ a [ i ] ] + 1 ; } else { freq [ a [ i ] ] = 1 ; } } vector < int > dp ( * max_element ( a . begin ( ) , a . end ( ) ) + 1 , 0 ) ; dp [ 0 ] = 0 ; dp [ 1 ] = freq [ 1 ] ; for ( int i = 2 ; i < dp . size ( ) ; i ++ ) { dp [ i ] = max ( dp [ i - 1 ] , dp [ i - 2 ] + freq [ i ] * i ) ; } return dp [ dp . size ( ) - 1 ] ; }
|
g-transeval-cpp_data_352 | int CountWays ( string s , string t , int k , int mod ) { int n = s . size ( ) ; int a = 0 , b = 0 ; for ( int i = 0 ; i < n ; i ++ ) { string p = s . substr ( i , n - i ) + s . substr ( 0 , i ) ; if ( p == t ) { a ++ ; } else { b ++ ; } } vector < int > dp1 ( k + 1 ) , dp2 ( k + 1 ) ; if ( s == t ) { dp1 [ 0 ] = 1 ; dp2 [ 0 ] = 0 ; } else { dp1 [ 0 ] = 0 ; dp2 [ 0 ] = 1 ; } for ( int i = 1 ; i <= k ; i ++ ) { dp1 [ i ] = ( ( dp1 [ i - 1 ] * ( a - 1 ) ) % mod + ( dp2 [ i - 1 ] * a ) % mod ) % mod ; dp2 [ i ] = ( ( dp1 [ i - 1 ] * ( b ) ) % mod + ( dp2 [ i - 1 ] * ( b - 1 ) ) % mod ) % mod ; } return dp1 [ k ] ; }
|
g-transeval-cpp_data_353 | int FindSubarraySum ( vector < int > arr , int n , int k ) { unordered_map < int , int > prev_sum ; int res = 0 ; int curr_sum = 0 ; for ( int i = 0 ; i < n ; i ++ ) { curr_sum += arr [ i ] ; if ( curr_sum == k ) { res ++ ; } if ( prev_sum . find ( curr_sum - k ) != prev_sum . end ( ) ) { res += prev_sum [ curr_sum - k ] ; } prev_sum [ curr_sum ] ++ ; } return res ; }
|
g-transeval-cpp_data_354 | int MaximumOccurrence ( string s ) { int n = s . length ( ) ; map < string , int > freq ; for ( int i = 0 ; i < n ; i ++ ) { string temp ; temp += s [ i ] ; freq [ temp ] ++ ; } for ( int i = 0 ; i < n ; i ++ ) { for ( int j = i + 1 ; j < n ; j ++ ) { string temp ; temp += s [ i ] ; temp += s [ j ] ; freq [ temp ] ++ ; } } int answer = INT_MIN ; for ( auto entry : freq ) { answer = max ( answer , entry . second ) ; } return answer ; }
|
g-transeval-cpp_data_355 | int CountCharacters ( vector < string > strings , string chars ) { int res = 0 ; unordered_map < char , int > freq ; for ( int i = 0 ; i < chars . length ( ) ; i ++ ) { freq [ chars [ i ] ] += 1 ; } for ( string & st : strings ) { bool flag = true ; for ( char c : st ) { if ( freq . find ( c ) == freq . end ( ) ) { flag = false ; break ; } } if ( flag ) { res += st . length ( ) ; } } return res ; }
|
g-transeval-cpp_data_356 | int DistinctSubstring ( string p , string q , int k , int n ) { unordered_set < string > ss ; for ( int i = 0 ; i < n ; ++ i ) { int sum = 0 ; string s ; for ( int j = i ; j < n ; ++ j ) { int pos = p [ j ] - 'a' ; sum += q [ pos ] - '0' ; s += p [ j ] ; if ( sum <= k ) { ss . insert ( s ) ; } else { break ; } } } return ss . size ( ) ; }
|
g-transeval-cpp_data_357 | int UniqueMorseRep ( vector < string > arr ) { vector < string > morseCode = { ".-" , "-..." , "-.-." , "-.." , "." , "..-." , "--." , "...." , ".." , ".---" , "-.-" , ".-.." , "--" , "-." , "---" , ".--." , "--.-" , ".-." , "..." , "-" , "..-" , "...-" , ".--" , "-..-" , "-.--" , "--.." } ; unordered_set < string > st ; int n = arr . size ( ) ; for ( int i = 0 ; i < n ; i ++ ) { string temp ; int m = arr [ i ] . length ( ) ; for ( int j = 0 ; j < m ; j ++ ) { temp += morseCode [ arr [ i ] [ j ] - 'a' ] ; } st . insert ( temp ) ; } return st . size ( ) ; }
|
g-transeval-cpp_data_358 | int CountSubstrings ( string st , int k ) { int n = st . size ( ) ; int answer = 0 ; unordered_map < char , int > map ; for ( int i = 0 ; i < k ; i ++ ) { if ( map . find ( st [ i ] ) == map . end ( ) ) { map [ st [ i ] ] = 1 ; } else { map [ st [ i ] ] ++ ; } } if ( map . size ( ) == k ) { answer ++ ; } for ( int i = k ; i < n ; i ++ ) { if ( map . find ( st [ i ] ) == map . end ( ) ) { map [ st [ i ] ] = 1 ; } else { map [ st [ i ] ] ++ ; } map [ st [ i - k ] ] -- ; if ( map [ st [ i - k ] ] == 0 ) { map . erase ( st [ i - k ] ) ; } if ( map . size ( ) == k ) { answer ++ ; } } return answer ; }
|
g-transeval-cpp_data_359 | bool CanConstruct ( string s , int k ) { map < int , int > m ; int i = 0 , j = 0 , p = 0 ; if ( s . length ( ) == k ) { return true ; } for ( i = 0 ; i < s . length ( ) ; i ++ ) { m [ s [ i ] ] = m [ s [ i ] ] + 1 ; } if ( k > s . length ( ) ) { return false ; } else { for ( auto & h : m ) { if ( h . second % 2 != 0 ) { p = p + 1 ; } } } if ( k < p ) { return false ; } return true ; }
|
g-transeval-cpp_data_360 | bool EqualIgnoreCase ( string str1 , string str2 ) { transform ( str1 . begin ( ) , str1 . end ( ) , str1 . begin ( ) , :: toupper ) ; transform ( str2 . begin ( ) , str2 . end ( ) , str2 . begin ( ) , :: toupper ) ; return str1 == str2 ; }
|
g-transeval-cpp_data_361 | int FindLongestSub ( string bin ) { int n = bin . length ( ) , i ; int sum = 0 ; unordered_map < int , int > prev_sum ; int max_len = 0 ; for ( i = 0 ; i < n ; i ++ ) { if ( bin [ i ] == '1' ) { sum ++ ; } else { sum -- ; } if ( sum > 0 ) { max_len = i + 1 ; } else if ( sum <= 0 ) { if ( prev_sum . find ( sum - 1 ) != prev_sum . end ( ) ) { int curr_len = i - prev_sum [ sum - 1 ] ; max_len = max ( max_len , curr_len ) ; } } if ( prev_sum . find ( sum ) == prev_sum . end ( ) ) { prev_sum [ sum ] = i ; } } return max_len ; }
|
g-transeval-cpp_data_362 | bool HasAllCodes ( string s , int k ) { unordered_set < string > us ; for ( int i = 0 ; i + k <= s . size ( ) ; i ++ ) { us . insert ( s . substr ( i , k ) ) ; } return us . size ( ) == 1 << k ; }
|
g-transeval-cpp_data_363 | bool CheckPalin ( string word ) { int n = word . length ( ) ; transform ( word . begin ( ) , word . end ( ) , word . begin ( ) , :: tolower ) ; for ( int i = 0 ; i < n ; i ++ , n -- ) { if ( word [ i ] != word [ n - 1 ] ) { return false ; } } return true ; }
|
g-transeval-cpp_data_364 | string Convert ( string st ) { string w , z ; transform ( st . begin ( ) , st . end ( ) , st . begin ( ) , :: toupper ) ; st += " " ; for ( int i = 0 ; i < st . length ( ) ; i ++ ) { char ch = st [ i ] ; if ( ch != ' ' ) { w += ch ; } else { z += char ( tolower ( w [ 0 ] ) ) + w . substr ( 1 ) + " " ; w = "" ; } } return z ; }
|
g-transeval-cpp_data_365 | int MaxLines ( int n , vector < int > x1 , vector < int > y1 , vector < int > x2 , vector < int > y2 ) { unordered_set < double > s ; double slope ; for ( int i = 0 ; i < n ; ++ i ) { if ( x1 [ i ] == x2 [ i ] ) { slope = INT_MAX ; } else { slope = ( y2 [ i ] - y1 [ i ] ) * 1.0 / ( x2 [ i ] - x1 [ i ] ) ; } s . insert ( slope ) ; } return s . size ( ) ; }
|
g-transeval-cpp_data_366 | unordered_map < int , int > PrimeFactor ( int n ) { unordered_map < int , int > primef ; while ( n % 2 == 0 ) { if ( primef . find ( 2 ) != primef . end ( ) ) { primef [ 2 ] += 1 ; } else { primef [ 2 ] = 1 ; } n /= 2 ; } for ( int i = 3 ; i <= sqrt ( n ) ; i ++ ) { while ( n % i == 0 ) { if ( primef . find ( i ) != primef . end ( ) ) { primef [ i ] += 1 ; } else { primef [ i ] = 1 ; } n /= i ; } } if ( n > 2 ) { primef [ n ] = 1 ; } return primef ; }
|
g-transeval-cpp_data_367 | string IsDivisibleByDivisor ( int s , int d ) { s %= d ; unordered_set < int > hash_map ; hash_map . insert ( s ) ; for ( int i = 0 ; i <= d ; i ++ ) { s += s % d ; s %= d ; if ( hash_map . find ( s ) != hash_map . end ( ) ) { if ( s == 0 ) { return "Yes" ; } return "No" ; } else { hash_map . insert ( s ) ; } } return "Yes" ; }
|
g-transeval-cpp_data_368 | bool OddSum ( vector < int > a , int n , int k ) { set < int > odd ; set < int > even ; for ( int i = 0 ; i < n ; i ++ ) { if ( a [ i ] % 2 == 0 ) { even . insert ( a [ i ] ) ; } else { odd . insert ( a [ i ] ) ; } } if ( odd . size ( ) >= k ) { return true ; } bool flag = false ; for ( int i = 1 ; i < k ; i += 2 ) { int needed = k - i ; if ( needed <= even . size ( ) ) { return true ; } } return flag ; }
|
g-transeval-cpp_data_369 | int DayOfYear ( string date ) { vector < int > days { 31 , 28 , 31 , 30 , 31 , 30 , 31 , 31 , 30 , 31 , 30 , 31 } ; int year = stoi ( date . substr ( 0 , 4 ) ) ; int month = stoi ( date . substr ( 5 , 2 ) ) ; int day = stoi ( date . substr ( 8 ) ) ; if ( month > 2 && year % 4 == 0 && ( year % 100 != 0 || year % 400 == 0 ) ) { ++ day ; } while ( month > 1 ) { day = day + days [ month - 2 ] ; -- month ; } return day ; }
|
g-transeval-cpp_data_370 | bool IsPerfectSquare ( vector < int > arr , int n ) { unordered_map < int , int > umap ; for ( int i = 0 ; i < n ; i ++ ) { umap [ arr [ i ] ] ++ ; } for ( auto & itr : umap ) { if ( itr . second % 2 == 1 ) { return false ; } } return true ; }
|
g-transeval-cpp_data_371 | int MinMoves ( int n ) { string s = to_string ( n ) ; int ans = INT_MAX ; int length = s . size ( ) ; for ( int i = 0 ; i < length ; ++ i ) { for ( int j = 0 ; j < length ; ++ j ) { if ( i == j ) { continue ; } string t = s ; int cur = 0 ; for ( int k = i ; k < length - 1 ; ++ k ) { swap ( t [ k ] , t [ k + 1 ] ) ; ++ cur ; } for ( int k = j - ( j > i ) ; k < length - 2 ; ++ k ) { swap ( t [ k ] , t [ k + 1 ] ) ; ++ cur ; } int pos = -1 ; for ( int k = 0 ; k < length ; ++ k ) { if ( t [ k ] != '0' ) { pos = k ; break ; } } for ( int k = pos ; k > 0 ; -- k ) { swap ( t [ k ] , t [ k - 1 ] ) ; ++ cur ; } int nn = stoi ( t ) ; if ( nn % 25 == 0 ) { ans = min ( ans , cur ) ; } } } if ( ans == INT_MAX ) { return -1 ; } return ans ; }
|
g-transeval-cpp_data_372 | int MinimumOperations ( vector < int > a , int n ) { unordered_map < int , int > mp ; for ( int i = 0 ; i < n ; i ++ ) { mp [ a [ i ] ] += 1 ; } int count = 0 ; for ( auto & entry : mp ) { if ( entry . second > 1 ) { count += entry . second - 1 ; } } return count ; }
|
g-transeval-cpp_data_373 | int KaprekarRec ( int n , int prev ) { if ( n == 0 ) { return 0 ; } prev = n ; int digits [ 4 ] ; for ( int i = 0 ; i < 4 ; i ++ ) { digits [ i ] = n % 10 ; n = n / 10 ; } sort ( digits , digits + 4 ) ; int asc = 0 ; for ( int i = 0 ; i < 4 ; i ++ ) { asc = asc * 10 + digits [ i ] ; } sort ( digits , digits + 4 ) ; int desc = 0 ; for ( int i = 3 ; i >= 0 ; i -- ) { desc = desc * 10 + digits [ i ] ; } int diff = abs ( asc - desc ) ; if ( diff == prev ) { return diff ; } return KaprekarRec ( diff , prev ) ; }
|
g-transeval-cpp_data_374 | string FractionToDecimal ( int numr , int denr ) { string res ; map < int , int > mp ; int rem = numr % denr ; while ( rem != 0 && mp . find ( rem ) == mp . end ( ) ) { mp [ rem ] = res . length ( ) ; rem = rem * 10 ; int res_part = rem / denr ; res += to_string ( res_part ) ; rem = rem % denr ; } if ( rem == 0 ) { return "" ; } if ( mp . find ( rem ) != mp . end ( ) ) { return res . substr ( mp [ rem ] ) ; } return "" ; }
|
g-transeval-cpp_data_375 | bool IsFancy ( string num ) { map < char , char > fp ; fp [ '0' ] = '0' ; fp [ '1' ] = '1' ; fp [ '6' ] = '9' ; fp [ '8' ] = '8' ; fp [ '9' ] = '6' ; int n = num . length ( ) ; int l = 0 , r = n - 1 ; while ( l <= r ) { if ( fp . find ( num [ l ] ) == fp . end ( ) || fp [ num [ l ] ] != num [ r ] ) { return false ; } l ++ ; r -- ; } return true ; }
|
g-transeval-cpp_data_376 | double DistinctOddRatio ( vector < int > numbers ) { unordered_set < int > distinct_numbers ( numbers . begin ( ) , numbers . end ( ) ) ; int distinct_count = ranges :: distance ( distinct_numbers ) ; int distinct_odd_count = ranges :: distance ( distinct_numbers | views :: filter ( [ ] ( int n ) { return n % 2 == 1 ; } ) ) ; return ( double ) distinct_odd_count / distinct_count ; }
|
g-transeval-cpp_data_377 | int CompareSum ( vector < int > numbers , vector < string > words ) { int int_sum = reduce ( numbers . begin ( ) , numbers . end ( ) ) ; auto tmp = words | views :: transform ( [ ] ( string & w ) { return w . size ( ) ; } ) ; int word_length_sum = reduce ( tmp . begin ( ) , tmp . end ( ) ) ; if ( int_sum < word_length_sum ) { return -1 ; } if ( int_sum > word_length_sum ) { return 1 ; } return 0 ; }
|
g-transeval-cpp_data_378 | bool AllLongerThan ( vector < string > short_words , vector < string > long_words ) { int max_of_short = ranges :: max ( short_words | views :: transform ( [ ] ( string & w ) { return w . size ( ) ; } ) ) ; int min_of_long = ranges :: min ( long_words | views :: transform ( [ ] ( string & w ) { return w . size ( ) ; } ) ) ; return min_of_long > max_of_short ; }
|
g-transeval-cpp_data_379 | int CompareOddEvenRange ( vector < int > numbers ) { int range_odd = ranges :: max ( numbers | views :: filter ( [ ] ( int n ) { return n % 2 == 1 ; } ) ) - ranges :: min ( numbers | views :: filter ( [ ] ( int n ) { return n % 2 == 1 ; } ) ) ; int range_even = ranges :: max ( numbers | views :: filter ( [ ] ( int n ) { return n % 2 == 0 ; } ) ) - ranges :: min ( numbers | views :: filter ( [ ] ( int n ) { return n % 2 == 0 ; } ) ) ; if ( range_odd < range_even ) { return -1 ; } if ( range_odd > range_even ) { return 1 ; } return 0 ; }
|
g-transeval-cpp_data_380 | double AverageDistinctLength ( vector < string > words ) { unordered_set < string > s ( words . begin ( ) , words . end ( ) ) ; vector < string > distinct_words ( s . begin ( ) , s . end ( ) ) ; auto distinct_size = distinct_words | views :: transform ( [ ] ( string & w ) { return w . size ( ) ; } ) ; double average_len = ! distinct_size . empty ( ) ? ( double ) reduce ( distinct_size . begin ( ) , distinct_size . end ( ) ) / ranges :: distance ( distinct_size ) : 0 ; return average_len ; }
|
g-transeval-cpp_data_381 | int WithDrawBalance ( int start , vector < int > withdrawals ) { int end = accumulate ( withdrawals . begin ( ) , withdrawals . end ( ) , start , [ ] ( int balance , int next_withdrawal ) { return next_withdrawal <= balance ? balance - next_withdrawal : balance ; } ) ; return end ; }
|
g-transeval-cpp_data_382 | string FirstShortAndStartsWithO ( vector < string > words ) { auto matched_view = words | views :: filter ( [ ] ( const string & w ) { return w . size ( ) < 5 ; } ) | views :: filter ( [ ] ( const string & w ) { return w [ 0 ] == 'o' ; } ) | views :: take ( 1 ) ; string matched_element = matched_view . empty ( ) ? "" : matched_view . front ( ) ; return matched_element ; }
|
g-transeval-cpp_data_383 | int BigNumberAtIndex ( vector < int > numbers , int index ) { auto matched_view = numbers | views :: filter ( [ ] ( int n ) { return n > 5 ; } ) | views :: drop ( index ) ; int target_num = matched_view . front ( ) ; return target_num ; }
|
g-transeval-cpp_data_384 | bool ContainsSquareInRange ( int range_start , int range_length ) { bool contains_square = ranges :: any_of ( views :: iota ( range_start , range_start + range_length ) , [ ] ( int n ) { return pow ( ( int ) sqrt ( n ) , 2 ) == n ; } ) ; return contains_square ; }
|
g-transeval-cpp_data_385 | unordered_map < int , vector < int > > GroupNumbersByMod ( vector < int > numbers , int mod ) { unordered_map < int , vector < int > > number_groups ; for ( int n : numbers ) { int key = n % mod ; number_groups [ key ] . push_back ( n ) ; } return number_groups ; }
|
g-transeval-cpp_data_386 | unordered_map < char , vector < string > > GroupWordsByFirstChar ( vector < string > words ) { unordered_map < char , vector < string > > word_groups ; for ( string & word : words ) { word_groups [ word [ 0 ] ] . push_back ( word ) ; } return word_groups ; }
|
g-transeval-cpp_data_387 | vector < string > OrderByLengthAndDescending ( vector < string > words ) { vector < string > sorted_words = words ; sort ( sorted_words . begin ( ) , sorted_words . end ( ) , [ ] ( string & a , string & b ) { if ( a . length ( ) == b . length ( ) ) { return a > b ; } return a . length ( ) < b . length ( ) ; } ) ; return sorted_words ; }
|
g-transeval-cpp_data_388 | vector < string > OrderFirstCharDescendingReverse ( vector < string > words ) { vector < string > sorted_words = words ; sort ( sorted_words . begin ( ) , sorted_words . end ( ) , [ ] ( string & a , string & b ) { if ( a [ 0 ] == b [ 0 ] ) { return a < b ; } return a [ 0 ] > b [ 0 ] ; } ) ; reverse ( sorted_words . begin ( ) , sorted_words . end ( ) ) ; return sorted_words ; }
|
g-transeval-cpp_data_389 | vector < int > GetSubListOfNegative ( vector < int > numbers , int start , int length ) { auto matched_view = numbers | views :: drop ( start ) | views :: filter ( [ ] ( int n ) { return n < 0 ; } ) | views :: take ( length ) ; vector < int > sub_list ; ranges :: copy ( matched_view , back_inserter ( sub_list ) ) ; return sub_list ; }
|
g-transeval-cpp_data_390 | vector < int > GetPositiveSequence ( vector < int > numbers ) { auto matched_view = numbers | views :: drop_while ( [ ] ( int n ) { return n <= 0 ; } ) | views :: take_while ( [ ] ( int n ) { return n >= 0 ; } ) ; vector < int > sub_sequence ; ranges :: copy ( matched_view , back_inserter ( sub_sequence ) ) ; return sub_sequence ; }
|
g-transeval-cpp_data_391 | vector < int > GetLargerThanIndexSequence ( vector < int > numbers ) { auto matched_view = views :: iota ( 0 , ( int ) numbers . size ( ) ) | views :: drop_while ( [ & numbers ] ( int n ) { return numbers [ n ] < n ; } ) | views :: take_while ( [ & numbers ] ( int n ) { return numbers [ n ] > n ; } ) | views :: transform ( [ & numbers ] ( int n ) { return numbers [ n ] ; } ) ; vector < int > sub_sequence ; ranges :: copy ( matched_view , back_inserter ( sub_sequence ) ) ; return sub_sequence ; }
|
g-transeval-cpp_data_392 | vector < string > RearrangeWordByIndexes ( vector < string > words , vector < int > indexes ) { auto new_indexes = indexes | views :: filter ( [ & words ] ( int n ) { return n >= words . size ( ) ; } ) | views :: transform ( [ & words ] ( int n ) { return n % words . size ( ) ; } ) ; auto matched_view = new_indexes | views :: transform ( [ & words ] ( int n ) { return words [ n ] ; } ) ; vector < string > new_words ; ranges :: copy ( matched_view , back_inserter ( new_words ) ) ; return new_words ; }
|
g-transeval-cpp_data_393 | vector < vector < string > > GetWordsUpperLower ( vector < string > words ) { auto matched_view = words | views :: transform ( [ ] ( string & w ) { string upper = w ; string lower = w ; ranges :: transform ( upper . begin ( ) , upper . end ( ) , upper . begin ( ) , :: toupper ) ; ranges :: transform ( lower . begin ( ) , lower . end ( ) , lower . begin ( ) , :: tolower ) ; return vector < string > { upper , lower } ; } ) ; vector < vector < string > > upper_lower_words ; ranges :: copy ( matched_view , back_inserter ( upper_lower_words ) ) ; return upper_lower_words ; }
|
g-transeval-cpp_data_394 | vector < bool > SelectIfInPlace ( vector < int > numbers ) { auto matched_view = views :: iota ( 0 , ( int ) numbers . size ( ) ) | views :: transform ( [ & numbers ] ( int n ) { return numbers [ n ] == n ; } ) ; vector < bool > nums_in_place ; ranges :: copy ( matched_view , back_inserter ( nums_in_place ) ) ; return nums_in_place ; }
|
g-transeval-cpp_data_395 | vector < vector < int > > SelectPairs ( vector < int > numbers_a , vector < int > numbers_b ) { auto matched_view = numbers_a | views :: transform ( [ & numbers_b ] ( int a ) { return numbers_b | views :: filter ( [ a ] ( auto b ) { return a < b ; } ) | views :: transform ( [ a ] ( auto b ) { return vector < int > { a , b } ; } ) ; } ) | views :: join ; vector < vector < int > > pairs ; ranges :: copy ( matched_view , back_inserter ( pairs ) ) ; return pairs ; }
|
g-transeval-cpp_data_396 | vector < string > StringCrossJoin ( vector < string > end_words , vector < string > begin_words ) { auto matched_view = begin_words | views :: transform ( [ & end_words ] ( string & b ) { return end_words | views :: filter ( [ b ] ( string & e ) { return b [ 0 ] == e [ e . length ( ) - 1 ] ; } ) | views :: transform ( [ b ] ( auto e ) { return e + " " + b ; } ) ; } ) | views :: join ; vector < string > cross_strings ; ranges :: copy ( matched_view , back_inserter ( cross_strings ) ) ; return cross_strings ; }
|
g-transeval-cpp_data_397 | int ElementsContainSubword ( vector < string > words , string subword ) { if ( ranges :: all_of ( words | views :: take ( 5 ) , [ & subword ] ( string & w ) { return w . find ( subword ) != string :: npos ; } ) ) return 1 ; if ( ranges :: any_of ( words | views :: take ( 5 ) , [ & subword ] ( string & w ) { return w . find ( subword ) != string :: npos ; } ) ) return 0 ; return -1 ; }
|
g-transeval-cpp_data_398 | vector < int > ConcatLargeNumbers ( vector < int > numbers_a , vector < int > numbers_b , int flag ) { auto large_numbers_a = numbers_a | views :: filter ( [ flag ] ( int n ) { return n > flag ; } ) ; auto large_numbers_b = numbers_b | views :: filter ( [ flag ] ( int n ) { return n > flag ; } ) ; std :: vector < int > all_numbers ; ranges :: copy ( large_numbers_a , back_inserter ( all_numbers ) ) ; ranges :: copy ( large_numbers_b , back_inserter ( all_numbers ) ) ; return all_numbers ; }
|
g-transeval-cpp_data_399 | int DotProduct ( vector < int > vector_a , vector < int > vector_b ) { int dot_product = inner_product ( vector_a . begin ( ) , vector_a . end ( ) , vector_b . begin ( ) , 0 ) ; return dot_product ; }
|
g-transeval-cpp_data_400 | vector < int > SetDifference ( vector < int > set_a , vector < int > set_b ) { vector < int > difference ; ranges :: sort ( set_a ) ; ranges :: sort ( set_b ) ; set_symmetric_difference ( set_a . begin ( ) , set_a . end ( ) , set_b . begin ( ) , set_b . end ( ) , back_inserter ( difference ) ) ; return difference ; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.