dhyuti-n/xlcost-variable-roles huggingface dataset:
C# program:
using System ; using System . Collections . Generic ; class GFG { static int countOfSubStrings ( String s ) { int n = s . Length ; int x = ( int ) Math . Sqrt ( n ) ; List < int > ones = new List < int > ( ) ; for ( int i = 0 ; i < n ; i ++ ) { if ( s [ i ] == '1' ) ones . Add ( i ) ; } if ( ones . Count == 0 ) return 0 ; ones . Add ( n ) ; int [ ] totCount = new int [ n * x + n ] ; int sum = 0 ; for ( int k = 0 ; k <= x ; k ++ ) { int now = 0 ; totCount [ k * n ] ++ ; for ( int j = 1 ; j <= n ; j ++ ) { if ( s [ j - 1 ] == '1' ) now ++ ; int index = j - k * now ; sum += totCount [ index + k * n ] ; totCount [ index + k * n ] ++ ; } now = 0 ; totCount [ k * n ] -- ; for ( int j = 1 ; j <= n ; j ++ ) { if ( s [ j - 1 ] == '1' ) now ++ ; int index = j - k * now ; totCount [ index + k * n ] -- ; } } int [ ] prefix_sum = new int [ n ] ; for ( int i = 0 ; i < n ; i ++ ) prefix_sum [ i ] = - 1 ; int cnt = 0 ; for ( int i = 0 ; i < n ; i ++ ) { prefix_sum [ i ] = cnt ; if ( s [ i ] == '1' ) cnt ++ ; } for ( int k = 0 ; k < n ; k ++ ) { for ( int j = 1 ; j <= ( n / x ) && prefix_sum [ k ] + j <= cnt ; j ++ ) { int l = ones [ prefix_sum [ k ] + j - 1 ] - k + 1 ; int r = ones [ prefix_sum [ k ] + j ] - k ; l = Math . Max ( l , j * ( x + 1 ) ) ; if ( l <= r ) { sum += r / j - ( l - 1 ) / j ; } } } return sum ; } public static void Main ( String [ ] args ) { String S = "1111100000" ; Console . Write ( countOfSubStrings ( S ) ) ; } }

Index/key variables: i, k, n
Accumulator variables: cnt, i, j, k, now, sum
Iterator variables: i, j, k
Class/struct names: GFG
C# program:
using System ; class GFG { static int countSetBits ( int n ) { int count = 0 ; while ( n > 0 ) { count += n & 1 ; n >>= 1 ; } return count ; } static int largestNum ( int n ) { int num = 0 ; int max_setBits = 0 ; for ( int i = 0 ; i <= n ; i ++ ) { int setBits = countSetBits ( i ) ; if ( setBits >= max_setBits ) { num = i ; max_setBits = setBits ; } } return num ; } public static void Main ( String [ ] args ) { int N = 345 ; Console . Write ( largestNum ( N ) ) ; } }

Accumulator variables: count, i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; using System . Collections . Generic ; class GFG { public class Node { public int data ; public Node left , right ; } static int getLeafCount ( Node node ) { if ( node == null ) { return 0 ; } Queue < Node > q = new Queue < Node > ( ) ; int count = 0 ; q . Enqueue ( node ) ; while ( q . Count != 0 ) { Node temp = q . Peek ( ) ; q . Dequeue ( ) ; if ( temp . left != null ) { q . Enqueue ( temp . left ) ; } if ( temp . right != null ) { q . Enqueue ( temp . right ) ; } if ( temp . left == null && temp . right == null ) { count ++ ; } } return count ; } static Node newNode ( int data ) { Node node = new Node ( ) ; node . data = data ; node . left = node . right = null ; return ( node ) ; } public static void Main ( String [ ] args ) { { Node root = newNode ( 1 ) ; root . left = newNode ( 2 ) ; root . right = newNode ( 3 ) ; root . left . left = newNode ( 4 ) ; root . left . right = newNode ( 5 ) ; Console . WriteLine ( getLeafCount ( root ) ) ; } } }

Accumulator variables: count
Class/struct names: GFG, Node
C# program:
using System ; using System . Collections . Generic ; class GFG { public class Pair { public int first ; public int second ; public Pair ( int first , int second ) { this . first = first ; this . second = second ; } public int getFirst ( ) { return first ; } public int getSecond ( ) { return second ; } } static int solve ( int [ ] Array , int N , int K ) { int [ ] count_Arr = new int [ N + 2 ] ; int factor = 1 ; int size = N ; while ( size > 0 ) { int end = size ; count_Arr [ 1 ] += factor * N ; count_Arr [ end + 1 ] -= factor * N ; factor ++ ; size /= 2 ; } for ( int i = 2 ; i <= N ; i ++ ) count_Arr [ i ] += count_Arr [ i - 1 ] ; List < Pair > element = new List < Pair > ( ) ; for ( int i = 0 ; i < N ; i ++ ) { Pair x = new Pair ( Array [ i ] , count_Arr [ i + 1 ] ) ; element . Add ( x ) ; } int start = 1 ; for ( int i = 0 ; i < N ; i ++ ) { int end = start + element [ 0 ] . getSecond ( ) - 1 ; if ( K >= start && K <= end ) return element [ i ] . getFirst ( ) ; start += element [ i ] . getSecond ( ) ; } return - 1 ; } public static void Main ( String [ ] args ) { int [ ] arr = { 2 , 4 , 5 , 1 } ; int N = arr . Length ; int K = 13 ; Console . WriteLine ( solve ( arr , N , K ) ) ; } }

Index/key variables: i
Accumulator variables: factor, i, size, start
Iterator variables: i
Class/struct names: GFG, Pair
C# program:
using System ; class GFG { static String strings ( int c , char d ) { String s = " " ; for ( int i = 0 ; i < c ; i ++ ) s += d ; return s ; } static String next_balanced_sequence ( String s ) { String next = " - 1" ; int length = s . Length ; int depth = 0 ; for ( int i = length - 1 ; i >= 0 ; -- i ) { if ( s [ i ] == ' ( ' ) depth -- ; else depth ++ ; if ( s [ i ] == ' ( ' && depth > 0 ) { depth -- ; int open = ( length - i - 1 - depth ) / 2 ; int close = length - i - 1 - open ; next = s . Substring ( 0 , i ) + ' ) ' + strings ( open , ' ( ' ) + strings ( close , ' ) ' ) ; break ; } } return next ; } public static void Main ( String [ ] args ) { String s = " ( ( ( ) ) ) " ; Console . WriteLine ( next_balanced_sequence ( s ) ) ; } }

Index/key variables: i
Accumulator variables: depth, i, s
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { public static void printMaxNumber ( int n ) { if ( n % 2 != 0 ) { Console . Write ( "7" ) ; for ( int i = 0 ; i < ( n - 3 ) / 2 ; i ++ ) Console . Write ( "1" ) ; } else { for ( int i = 0 ; i < n / 2 ; i ++ ) Console . Write ( "1" ) ; } } public static void Main ( String [ ] args ) { int n = 5 ; printMaxNumber ( n ) ; } }

Accumulator variables: i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { static void getSum ( int n ) { int sumOdd = 0 ; int sumEven = 0 ; String num = n . ToString ( ) ; for ( int i = 0 ; i < num . Length ; i ++ ) if ( i % 2 == 0 ) sumOdd = sumOdd + ( num [ i ] - '0' ) ; else sumEven = sumEven + ( num [ i ] - '0' ) ; Console . WriteLine ( " Sum ▁ odd ▁ = ▁ " + sumOdd ) ; Console . WriteLine ( " Sum ▁ even ▁ = ▁ " + sumEven ) ; } public static void Main ( ) { int n = 457892 ; getSum ( n ) ; } }

Index/key variables: i
Accumulator variables: i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; public class Node { public int data ; public Node left , right ; public Node ( int d ) { data = d ; left = right = null ; } } public class BinaryTree { public static Node root ; static int countLeaves ( Node node ) { if ( node == null ) { return 0 ; } if ( node . left == null && node . right == null ) { return 1 ; } return countLeaves ( node . left ) + countLeaves ( node . right ) ; } static public void Main ( ) { BinaryTree . root = new Node ( 1 ) ; BinaryTree . root . left = new Node ( 2 ) ; BinaryTree . root . right = new Node ( 3 ) ; BinaryTree . root . left . left = new Node ( 4 ) ; BinaryTree . root . left . right = new Node ( 5 ) ; Console . WriteLine ( countLeaves ( root ) ) ; } }

Class/struct names: BinaryTree, Node
C# program:
using System ; class GFG { static int sorted_partitions ( int [ ] arr ) { int n = arr . Length ; int [ ] right_min = new int [ n + 1 ] ; right_min [ n ] = int . MaxValue ; for ( int i = n - 1 ; i >= 0 ; i -- ) { right_min [ i ] = Math . Min ( right_min [ i + 1 ] , arr [ i ] ) ; } int partitions = 0 ; for ( int current_max = arr [ 0 ] , i = 0 ; i < n ; i ++ ) { current_max = Math . Max ( current_max , arr [ i ] ) ; if ( current_max <= right_min [ i + 1 ] ) partitions ++ ; } return partitions ; } public static void Main ( ) { int [ ] arr = { 3 , 1 , 2 , 4 , 100 , 7 , 9 } ; int ans = sorted_partitions ( arr ) ; Console . WriteLine ( ans ) ; } }

Index/key variables: i, n
Accumulator variables: i, partitions
Iterator variables: current_max, i
Class/struct names: GFG
C# program:
using System ; using System . Linq ; class GfG { public static int getMinCost ( int [ ] arr , int n ) { int min_ele = arr . Min ( ) ; return min_ele * ( n - 1 ) ; } public static void Main ( String [ ] args ) { int [ ] arr = { 4 , 2 , 5 } ; int n = arr . Length ; Console . WriteLine ( getMinCost ( arr , n ) ) ; } }

Class/struct names: GfG
C# program:
using System ; class GFG { static int countMinSwaps ( string s ) { int N = s . Length ; int one = 0 ; int zero = 0 ; for ( int i = 0 ; i < N ; i ++ ) { if ( s [ i ] == '1' ) one ++ ; else zero ++ ; } if ( one > zero + 1 zero > one + 1 ) return - 1 ; if ( N % 2 == 1 ) { int num = ( N + 1 ) / 2 ; int one_even = 0 , zero_even = 0 ; for ( int i = 0 ; i < N ; i ++ ) { if ( i % 2 == 0 ) { if ( s [ i ] == '1' ) one_even ++ ; else zero_even ++ ; } } if ( one > zero ) return num - one_even ; else return num - zero_even ; } else { int one_odd = 0 , one_even = 0 ; for ( int i = 0 ; i < N ; i ++ ) { if ( s [ i ] == '1' ) { if ( i % 2 == 1 ) one_odd ++ ; else one_even ++ ; } } return Math . Min ( N / 2 - one_odd , N / 2 - one_even ) ; } } public static void Main ( String [ ] args ) { string s = "111000" ; Console . Write ( countMinSwaps ( s ) ) ; } }

Index/key variables: i
Accumulator variables: i, one, one_even, one_odd, zero, zero_even
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { public static void Main ( ) { string st = " NNNWEWESSS " ; int len = st . Length ; for ( int i = 0 ; i < len ; i ++ ) { if ( st [ i ] == ' N ' ) n += 1 ; if ( st [ i ] == ' S ' ) s += 1 ; if ( st [ i ] == ' W ' ) w += 1 ; if ( st [ i ] == ' E ' ) e += 1 ; } if ( n == s && w == e ) Console . WriteLine ( " YES " ) ; else Console . WriteLine ( " NO " ) ; } }

Index/key variables: i
Accumulator variables: e, i, n, s, w
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; using System . Linq ; public class GFG { static int cost ( int [ ] a , int n ) { return ( n - 1 ) * a . Min ( ) ; } static public void Main ( ) { int [ ] a = { 4 , 3 , 2 } ; int n = a . Length ; Console . WriteLine ( cost ( a , n ) ) ; } }

Class/struct names: GFG
C# program:
using System ; class GFG { static int minCost ( int [ ] coin , int n , int k ) { Array . Sort ( coin ) ; int coins_needed = ( int ) Math . Ceiling ( 1.0 * n / ( k + 1 ) ) ; int ans = 0 ; for ( int i = 0 ; i <= coins_needed - 1 ; i ++ ) ans += coin [ i ] ; return ans ; } public static void Main ( ) { int [ ] coin = { 8 , 5 , 3 , 10 , 2 , 1 , 15 , 25 } ; int n = coin . Length ; int k = 3 ; Console . Write ( minCost ( coin , n , k ) ) ; } }

Index/key variables: i
Accumulator variables: ans, i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { static void firstFit ( int [ ] blockSize , int m , int [ ] processSize , int n ) { int [ ] allocation = new int [ n ] ; for ( int i = 0 ; i < allocation . Length ; i ++ ) allocation [ i ] = - 1 ; for ( int i = 0 ; i < n ; i ++ ) { for ( int j = 0 ; j < m ; j ++ ) { if ( blockSize [ j ] >= processSize [ i ] ) { allocation [ i ] = j ; blockSize [ j ] -= processSize [ i ] ; break ; } } } Console . WriteLine ( " STRNEWLINE Process ▁ No . TABSYMBOL Process ▁ Size TABSYMBOL Block ▁ no . " ) ; for ( int i = 0 ; i < n ; i ++ ) { Console . Write ( " ▁ " + ( i + 1 ) + " TABSYMBOL TABSYMBOL " + processSize [ i ] + " TABSYMBOL TABSYMBOL " ) ; if ( allocation [ i ] != - 1 ) Console . Write ( allocation [ i ] + 1 ) ; else Console . Write ( " Not ▁ Allocated " ) ; Console . WriteLine ( ) ; } } public static void Main ( ) { int [ ] blockSize = { 100 , 500 , 200 , 300 , 600 } ; int [ ] processSize = { 212 , 417 , 112 , 426 } ; int m = blockSize . Length ; int n = processSize . Length ; firstFit ( blockSize , m , processSize , n ) ; } }

Index/key variables: i, j, n
Accumulator variables: i, j
Iterator variables: i, j
Class/struct names: GFG
C# program:
using System ; using System . Collections . Generic ; class GFG { static int [ ] deno = { 1 , 2 , 5 , 10 , 20 , 50 , 100 , 500 , 1000 } ; static int n = deno . Length ; static void findMin ( int V ) { List < int > ans = new List < int > ( ) ; for ( int i = n - 1 ; i >= 0 ; i -- ) { while ( V >= deno [ i ] ) { V -= deno [ i ] ; ans . Add ( deno [ i ] ) ; } } for ( int i = 0 ; i < ans . Count ; i ++ ) { Console . Write ( " ▁ " + ans [ i ] ) ; } } public static void Main ( String [ ] args ) { int n = 93 ; Console . Write ( " Following ▁ is ▁ minimal ▁ number ▁ " + " of ▁ change ▁ for ▁ " + n + " : ▁ " ) ; findMin ( n ) ; } }

Index/key variables: i
Accumulator variables: V, i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; public class GFG { static int MinimumRemovals ( int [ ] a , int N , int K ) { int [ ] b = new int [ N + 1 ] ; for ( int i = 0 ; i < N ; i ++ ) { b [ i + 1 ] = a [ i ] ; } int [ , ] dp = new int [ N + 1 , N + 1 ] ; for ( int i = 0 ; i < N ; i ++ ) { for ( int j = 0 ; j <= i ; j ++ ) { dp [ i + 1 , j ] = Math . Max ( dp [ i + 1 , j ] , dp [ i , j ] ) ; dp [ i + 1 , j + 1 ] = Math . Max ( dp [ i + 1 , j + 1 ] , dp [ i , j ] + ( ( b [ i + 1 ] == j + 1 ) ? 1 : 0 ) ) ; } } for ( int j = N ; j >= 0 ; j -- ) { if ( dp [ N , j ] >= K ) { return ( N - j ) ; } } return - 1 ; } static public void Main ( ) { int [ ] arr = { 5 , 1 , 3 , 2 , 3 } ; int K = 2 ; int N = arr . Length ; Console . Write ( MinimumRemovals ( arr , N , K ) ) ; } }

Index/key variables: i
Accumulator variables: i, j
Iterator variables: i, j
Class/struct names: GFG
C# program:
using System ; public class GFG { public static int countArray ( int [ ] arr , int N , int M ) { int [ , ] dp = new int [ N , M + 2 ] ; for ( int i = 0 ; i < N ; i ++ ) { for ( int j = 0 ; j < M + 2 ; j ++ ) { dp [ i , j ] = 0 ; } } if ( arr [ 0 ] == - 1 ) { for ( int j = 1 ; j <= M ; j ++ ) { dp [ 0 , j ] = 1 ; } } else { dp [ 0 , arr [ 0 ] ] = 1 ; } for ( int i = 1 ; i < N ; i ++ ) { if ( arr [ i ] != - 1 ) { int j = arr [ i ] ; dp [ i , j ] += dp [ i - 1 , j - 1 ] + dp [ i - 1 , j ] + dp [ i - 1 , j + 1 ] ; } if ( arr [ i ] == - 1 ) { for ( int j = 1 ; j <= M ; j ++ ) { dp [ i , j ] += dp [ i - 1 , j - 1 ] + dp [ i - 1 , j ] + dp [ i - 1 , j + 1 ] ; } } } int arrCount = 0 ; for ( int j = 1 ; j <= M ; j ++ ) { arrCount += dp [ N - 1 , j ] ; } return arrCount ; } public static void Main ( String [ ] args ) { int [ ] arr = { 4 , - 1 , 2 , 1 , - 1 , - 1 } ; int N = arr . Length ; int M = 10 ; Console . WriteLine ( countArray ( arr , N , M ) ) ; } }

Index/key variables: i
Accumulator variables: arrCount, i, j
Iterator variables: i, j
Class/struct names: GFG
C# program:
using System ; public class GFG { static int maxMergingScore ( int [ ] A , int N ) { int [ , ] dp = new int [ 101 , 101 ] ; for ( int i = 0 ; i < 101 ; i ++ ) { { for ( int j = 0 ; j < 101 ; j ++ ) dp [ i , j ] = 0 ; } } for ( int len = 1 ; len < N ; ++ len ) { for ( int i = 0 ; i + len < N ; ++ i ) { int j = i + len ; dp [ i , j ] = 0 ; for ( int k = i + 1 ; k < j ; ++ k ) { dp [ i , j ] = Math . Max ( dp [ i , j ] , dp [ i , k ] + dp [ k , j ] + A [ i ] * A [ j ] ) ; } } } return dp [ 0 , N - 1 ] ; } static public void Main ( ) { int N = 4 ; int [ ] A = { 1 , 2 , 3 , 4 } ; Console . WriteLine ( maxMergingScore ( A , N ) ) ; N = 2 ; int [ ] B = { 1 , 55 } ; Console . WriteLine ( maxMergingScore ( B , N ) ) ; } }

Index/key variables: i, j
Accumulator variables: i, j
Iterator variables: i, j, k, len
Class/struct names: GFG
C# program:
using System ; public class GFG { static int longestOddEvenSubarray ( int [ ] A , int N ) { int dp ; dp = 1 ; int ans = 1 ; for ( int i = 1 ; i < N ; i ++ ) { if ( ( A [ i ] % 2 == 0 && A [ i - 1 ] % 2 == 0 ) || ( A [ i ] % 2 != 0 && A [ i - 1 ] % 2 != 0 ) ) { dp = dp + 1 ; ans = Math . Max ( ans , dp ) ; } else dp = 1 ; } return ans ; } public static void Main ( String [ ] args ) { int [ ] A = { 2 , 5 , 7 , 2 , 4 , 6 , 8 , 3 } ; int N = A . Length ; Console . Write ( longestOddEvenSubarray ( A , N ) ) ; } }

Index/key variables: i
Accumulator variables: i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { static int [ , , ] dp = new int [ 100 , 10 , 10 ] ; static int countOfNumbers ( int digit , int prev1 , int prev2 , int n ) { if ( digit == n + 1 ) { return 1 ; } int val = dp [ digit , prev1 , prev2 ] ; if ( val != - 1 ) { return val ; } val = 0 ; if ( digit == 1 ) { for ( int i = ( n == 1 ? 0 : 1 ) ; i <= 9 ; ++ i ) { val += countOfNumbers ( digit + 1 , i , prev1 , n ) ; } } else if ( digit == 2 ) { for ( int i = 0 ; i <= 9 ; ++ i ) { val += countOfNumbers ( digit + 1 , i , prev1 , n ) ; } } else { int mean = prev1 ; int current = ( 2 * mean ) - prev2 ; if ( current >= 0 && current <= 9 ) val += countOfNumbers ( digit + 1 , current , prev1 , n ) ; if ( ( current + 1 ) >= 0 && ( current + 1 ) <= 9 ) val += countOfNumbers ( digit + 1 , current + 1 , prev1 , n ) ; } return val ; } static public void Main ( ) { for ( int i = 0 ; i < 100 ; i ++ ) { for ( int j = 0 ; j < 10 ; j ++ ) { for ( int k = 0 ; k < 10 ; k ++ ) { dp [ i , j , k ] = - 1 ; } } } int n = 2 ; Console . Write ( countOfNumbers ( 1 , 0 , 0 , n ) ) ; } }

Accumulator variables: i, j, k, val
Iterator variables: i, j, k
Class/struct names: GFG
C# program:
using System ; using System . Collections . Generic ; public class Node { public int data ; public Node left , right ; public Node ( int item ) { data = item ; left = null ; right = null ; } } public class BinaryTree { Node root ; int gethalfCount ( ) { if ( root == null ) return 0 ; Queue < Node > queue = new Queue < Node > ( ) ; queue . Enqueue ( root ) ; int count = 0 ; while ( queue . Count != 0 ) { Node temp = queue . Dequeue ( ) ; if ( temp . left != null && temp . right == null temp . left == null && temp . right != null ) count ++ ; if ( temp . left != null ) queue . Enqueue ( temp . left ) ; if ( temp . right != null ) queue . Enqueue ( temp . right ) ; } return count ; } public static void Main ( ) { BinaryTree tree_level = new BinaryTree ( ) ; tree_level . root = new Node ( 2 ) ; tree_level . root . left = new Node ( 7 ) ; tree_level . root . right = new Node ( 5 ) ; tree_level . root . left . right = new Node ( 6 ) ; tree_level . root . left . right . left = new Node ( 1 ) ; tree_level . root . left . right . right = new Node ( 11 ) ; tree_level . root . right . right = new Node ( 9 ) ; tree_level . root . right . right . left = new Node ( 4 ) ; Console . WriteLine ( tree_level . gethalfCount ( ) ) ; } }

Accumulator variables: count
Class/struct names: BinaryTree, Node
C# program:
using System ; using System . Collections . Generic ; class GFG { static int [ , , ] dp = new int [ 50 , 10 , 10 ] ; static void initialize ( ) { for ( int i = 0 ; i < 50 ; i ++ ) { for ( int j = 0 ; j < 10 ; j ++ ) { for ( int k = 0 ; k < 10 ; k ++ ) { dp [ i , j , k ] = - 1 ; } } } } static int countOfNumbers ( int digit , int prev1 , int prev2 , int N ) { if ( digit == N + 1 ) return 1 ; if ( dp [ digit , prev1 , prev2 ] != - 1 ) return dp [ digit , prev1 , prev2 ] ; dp [ digit , prev1 , prev2 ] = 0 ; if ( digit == 1 ) { for ( int j = ( N == 1 ? 0 : 1 ) ; j <= 9 ; ++ j ) { dp [ digit , prev1 , prev2 ] += countOfNumbers ( digit + 1 , j , prev1 , N ) ; } } else if ( digit == 2 ) { for ( int j = 0 ; j <= 9 ; ++ j ) { dp [ digit , prev1 , prev2 ] += countOfNumbers ( digit + 1 , j , prev1 , N ) ; } } else { for ( int j = 0 ; j <= Math . Abs ( prev1 - prev2 ) ; ++ j ) { dp [ digit , prev1 , prev2 ] += countOfNumbers ( digit + 1 , j , prev1 , N ) ; } } return dp [ digit , prev1 , prev2 ] ; } public static void Main ( ) { initialize ( ) ; int N = 3 ; Console . Write ( countOfNumbers ( 1 , 0 , 0 , N ) ) ; } }

Accumulator variables: i, j, k
Iterator variables: i, j, k
Class/struct names: GFG
C# program:
using System ; public class GFG { static int count0 ( string s ) { int count = 0 ; for ( int i = 0 ; i < s . Length ; i ++ ) { if ( s [ i ] == '0' ) { count ++ ; } } return count ; } static int solve ( string [ ] vec , int A , int B , int idx , int [ , , ] dp ) { if ( idx == vec . Length A + B == 0 ) { return 0 ; } if ( dp [ A , B , idx ] > 0 ) { return dp [ A , B , idx ] ; } int zero = count0 ( vec [ idx ] ) ; int one = vec [ idx ] . Length - zero ; int inc = 0 ; if ( zero <= A && one <= B ) { inc = 1 + solve ( vec , A - zero , B - one , idx + 1 , dp ) ; } int exc = solve ( vec , A , B , idx + 1 , dp ) ; dp [ A , B , idx ] = Math . Max ( inc , exc ) ; return dp [ A , B , idx ] ; } static int MaxSubsetlength ( string [ ] arr , int A , int B ) { int [ , , ] dp = new int [ A + 1 , B + 1 , arr . Length + 1 ] ; return solve ( arr , A , B , 0 , dp ) ; } static public void Main ( ) { string [ ] arr = { "1" , "0" , "10" } ; int A = 1 , B = 1 ; Console . WriteLine ( MaxSubsetlength ( arr , A , B ) ) ; } }

Index/key variables: i, idx
Accumulator variables: count, i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; class GFG { static bool isMatch ( string text , string pattern ) { if ( text == null pattern == null ) { return false ; } int N = text . Length ; int M = pattern . Length ; bool [ , ] dp = new bool [ N + 1 , M + 1 ] ; dp [ 0 , 0 ] = true ; for ( int i = 0 ; i < M ; i ++ ) { if ( pattern [ i ] == ' * ' && dp [ 0 , i - 1 ] ) { dp [ 0 , i + 1 ] = true ; } } for ( int i = 0 ; i < N ; i ++ ) { for ( int j = 0 ; j < M ; j ++ ) { if ( pattern [ j ] == ' . ' ) { dp [ i + 1 , j + 1 ] = dp [ i , j ] ; } if ( pattern [ j ] == text [ i ] ) { dp [ i + 1 , j + 1 ] = dp [ i , j ] ; } if ( pattern [ j ] == ' * ' ) { if ( pattern [ j - 1 ] != text [ i ] && pattern [ j - 1 ] != ' . ' ) { dp [ i + 1 , j + 1 ] = dp [ i + 1 , j - 1 ] ; } else { dp [ i + 1 , j + 1 ] = ( dp [ i + 1 , j ] dp [ i , j + 1 ] dp [ i + 1 , j - 1 ] ) ; } } } } return dp [ N , M ] ; } public static void Main ( ) { string text = " geeksforgeeks " ; string pattern = " ge * ksforgeeks " ; if ( isMatch ( text , pattern ) ) { Console . WriteLine ( " Yes " ) ; } else { Console . WriteLine ( " No " ) ; } } }

Index/key variables: i, j
Accumulator variables: i, j
Iterator variables: i, j
Class/struct names: GFG
C# program:
using System ; class GFG { static void waysToPaint ( int n ) { long same = 6 ; long diff = 6 ; for ( int i = 0 ; i < n - 1 ; i ++ ) { long sameTmp = 3 * same + 2 * diff ; long diffTmp = 2 * same + 2 * diff ; same = sameTmp ; diff = diffTmp ; } Console . WriteLine ( same + diff ) ; } static public void Main ( ) { int N = 2 ; waysToPaint ( N ) ; } }

Accumulator variables: i
Iterator variables: i
Class/struct names: GFG
C# program:
using System ; using System . Collections ; using System . Collections . Generic ; using System . Linq ; class Solution { int k ; int n ; int goal ; int [ , ] dp ; List < int > bits = new List < int > ( ) ; public int minimumIncompatibility ( int [ ] A , int k ) { this . n = A . Length ; this . k = k ; goal = n / k ; Dictionary < int , int > map = new Dictionary < int , int > ( ) ; foreach ( int i in A ) { if ( ! map . ContainsKey ( i ) ) map [ i ] = 0 ; map [ i ] ++ ; if ( map [ i ] > k ) return - 1 ; } int state = ( 1 << n ) - 1 ; for ( int i = 0 ; i <= state ; i ++ ) { if ( Convert . ToString ( i , 2 ) . Count ( c => c == '1' ) == goal ) bits . Add ( i ) ; } dp = new int [ 1 << n , k ] ; for ( int i = 0 ; i < dp . GetLength ( 0 ) ; i ++ ) { for ( int j = 0 ; j < dp . GetLength ( 1 ) ; j ++ ) { dp [ i , j ] = - 1 ; } } return dfs ( A , state , 0 ) ; } public int dfs ( int [ ] A , int state , int index ) { if ( index >= k ) { return 0 ; } int res = 1000 ; if ( dp [ state , index ] != - 1 ) { return dp [ state , index ] ; } foreach ( int bit in bits ) { if ( Convert . ToString ( bit , 2 ) . Count ( c => c == '1' ) == goal ) { int newstate = state ; int mn = 100 , mx = - 1 ; bool [ ] visit = new bool [ n + 1 ] ; bool good = true ; for ( int j = 0 ; j < n ; j ++ ) { if ( ( bit & ( 1 << j ) ) != 0 ) { if ( visit [ A [ j ] ] == true || ( state & ( 1 << j ) ) == 0 ) { good = false ; break ; } visit [ A [ j ] ] = true ; newstate = newstate ^ ( 1 << j ) ; mx = Math . Max ( mx , A [ j ] ) ; mn = Math . Min ( mn , A [ j ] ) ; } } if ( good ) { res = Math . Min ( res , mx - mn + dfs ( A , newstate , index + 1 ) ) ; } } } dp [ state , index ] = res ; return res ; } } class GFG { public static void Main ( ) { Solution st = new Solution ( ) ; int [ ] arr = { 1 , 2 , 1 , 4 } ; int K = 2 ; Console . Write ( st . minimumIncompatibility ( arr , K ) ) ; } }

Index/key variables: i, j
Accumulator variables: i, j
Iterator variables: bit, i, j
Boolean variables: good
Class/struct names: GFG, Solution