dhyuti-n/xlcost-variable-roles huggingface dataset:
Python program:
import sys
def checkIfSortRotated ( arr , n ) :
    minEle = sys . maxsize
    maxEle = - sys . maxsize - 1
    minIndex = - 1
    for i in range ( n ) :
        if arr [ i ] < minEle :
            minEle = arr [ i ]
            minIndex = i
    flag1 = 1
    for i in range ( 1 , minIndex ) :
        if arr [ i ] < arr [ i - 1 ] :
            flag1 = 0
            break
    flag2 = 2
    for i in range ( minIndex + 1 , n ) :
        if arr [ i ] < arr [ i - 1 ] :
            flag2 = 0
            break
    if ( flag1 and flag2 and arr [ n - 1 ] < arr [ 0 ] ) :
        print ( " YES " )
    else :
        print ( " NO " )
arr = [ 3 , 4 , 5 , 1 , 2 ]
n = len ( arr )
checkIfSortRotated ( arr , n )

Index/key variables: i
Iterator variables: i
Python program:
N = 4
def rotate90Clockwise ( arr ) :
    global N
    for j in range ( N ) :
        for i in range ( N - 1 , - 1 , - 1 ) :
            print ( arr [ i ] [ j ] , end = " ▁ " )
        print ( )
arr = [ [ 1 , 2 , 3 , 4 ] , [ 5 , 6 , 7 , 8 ] , [ 9 , 10 , 11 , 12 ] , [ 13 , 14 , 15 , 16 ] ]
rotate90Clockwise ( arr ) ;

Index/key variables: i, j
Iterator variables: i, j
Python program:
def occurredOnce ( arr , n ) :
    arr . sort ( )
    if arr [ 0 ] != arr [ 1 ] :
        print ( arr [ 0 ] , end = " ▁ " )
    for i in range ( 1 , n - 1 ) :
        if ( arr [ i ] != arr [ i + 1 ] and arr [ i ] != arr [ i - 1 ] ) :
            print ( arr [ i ] , end = " ▁ " )
    if arr [ n - 2 ] != arr [ n - 1 ] :
        print ( arr [ n - 1 ] , end = " ▁ " )
if __name__ == " _ _ main _ _ " :
    arr = [ 7 , 7 , 8 , 8 , 9 , 1 , 1 , 4 , 2 , 2 ]
    n = len ( arr )
    occurredOnce ( arr , n )

Index/key variables: i
Iterator variables: i
Python program:
import math as mt
def occurredOnce ( arr , n ) :
    mp = dict ( )
    for i in range ( n ) :
        if arr [ i ] in mp . keys ( ) :
            mp [ arr [ i ] ] += 1
        else :
            mp [ arr [ i ] ] = 1
    for it in mp :
        if mp [ it ] == 1 :
            print ( it , end = " ▁ " )
arr = [ 7 , 7 , 8 , 8 , 9 , 1 , 1 , 4 , 2 , 2 ]
n = len ( arr )
occurredOnce ( arr , n )

Index/key variables: i, it
Iterator variables: i, it
Python program:
def occurredOnce ( arr , n ) :
    i = 1
    len = n
    if arr [ 0 ] == arr [ len - 1 ] :
        i = 2
        len -= 1
    while i < n :
        if arr [ i ] == arr [ i - 1 ] :
            i += 1
        else :
            print ( arr [ i - 1 ] , end = " ▁ " )
        i += 1
    if ( arr [ n - 1 ] != arr [ 0 ] and arr [ n - 1 ] != arr [ n - 2 ] ) :
        print ( arr [ n - 1 ] )
if __name__ == " _ _ main _ _ " :
    arr = [ 7 , 7 , 8 , 8 , 9 , 1 , 1 , 4 , 2 , 2 ]
    n = len ( arr )
    occurredOnce ( arr , n )

Index/key variables: i
Python program:
def rvereseArray ( arr , start , end ) :
    while start < end :
        temp = arr [ start ]
        arr [ start ] = arr [ end ]
        arr [ end ] = temp
        start += 1
        end -= 1
def printArray ( arr , n ) :
    for i in range ( n ) :
        print ( arr [ i ] , end = " ▁ " )
def splitArr ( arr , k , n ) :
    rvereseArray ( arr , 0 , n - 1 )
    rvereseArray ( arr , 0 , n - k - 1 )
    rvereseArray ( arr , n - k , n - 1 )
arr = [ 12 , 10 , 5 , 6 , 52 , 36 ]
n = len ( arr )
k = 2
splitArr ( arr , k , n )
printArray ( arr , n )

Index/key variables: end, i, start
Iterator variables: i
Python program:
def isRotation ( a : str , b : str ) -> bool :
    n = len ( a )
    m = len ( b )
    if ( n != m ) :
        return False
    lps = [ 0 for _ in range ( n ) ]
    length = 0
    i = 1
    lps [ 0 ] = 0
    while ( i < n ) :
        if ( a [ i ] == b [ length ] ) :
            length += 1
            lps [ i ] = length
            i += 1
        else :
            if ( length == 0 ) :
                lps [ i ] = 0
                i += 1
            else :
                length = lps [ length - 1 ]
    i = 0
    for k in range ( lps [ n - 1 ] , m ) :
        if ( b [ k ] != a [ i ] ) :
            return False
        i += 1
    return True
if __name__ == " _ _ main _ _ " :
    s1 = " ABACD "
    s2 = " CDABA "
    print ( "1" if isRotation ( s1 , s2 ) else "0" )

Index/key variables: i, k, length
Iterator variables: k
Python program:
def countRotationsDivBy8 ( n ) :
    l = len ( n )
    count = 0
    if ( l == 1 ) :
        oneDigit = int ( n [ 0 ] )
        if ( oneDigit % 8 == 0 ) :
            return 1
        return 0
    if ( l == 2 ) :
        first = int ( n [ 0 ] ) * 10 + int ( n [ 1 ] )
        second = int ( n [ 1 ] ) * 10 + int ( n [ 0 ] )
        if ( first % 8 == 0 ) :
            count += 1
        if ( second % 8 == 0 ) :
            count += 1
        return count
    threeDigit = 0
    for i in range ( 0 , ( l - 2 ) ) :
        threeDigit = ( int ( n [ i ] ) * 100 + int ( n [ i + 1 ] ) * 10 + int ( n [ i + 2 ] ) )
        if ( threeDigit % 8 == 0 ) :
            count += 1
    threeDigit = ( int ( n [ l - 1 ] ) * 100 + int ( n [ 0 ] ) * 10 + int ( n [ 1 ] ) )
    if ( threeDigit % 8 == 0 ) :
        count += 1
    threeDigit = ( int ( n [ l - 2 ] ) * 100 + int ( n [ l - 1 ] ) * 10 + int ( n [ 0 ] ) )
    if ( threeDigit % 8 == 0 ) :
        count += 1
    return count
if __name__ == ' _ _ main _ _ ' :
    n = "43262488612"
    print ( " Rotations : " , countRotationsDivBy8 ( n ) )

Index/key variables: i
Accumulator variables: count
Iterator variables: i
Python program:
import sys
def minimunMoves ( arr , n ) :
    ans = sys . maxsize
    for i in range ( n ) :
        curr_count = 0
        for j in range ( n ) :
            tmp = arr [ j ] + arr [ j ]
            index = tmp . find ( arr [ i ] )
            if ( index == len ( arr [ i ] ) ) :
                return - 1
            curr_count += index
        ans = min ( curr_count , ans )
    return ans
if __name__ == " _ _ main _ _ " :
    arr = [ " xzzwo " , " zwoxz " , " zzwox " , " xzzwo " ]
    n = len ( arr )
    print ( minimunMoves ( arr , n ) )

Index/key variables: i, j
Accumulator variables: curr_count
Iterator variables: i, j
Python program:
class Node :
    def __init__ ( self , data ) :
        self . data = data
        self . next = None
def countRotation ( head ) :
    count = 0
    min = head . data
    while ( head != None ) :
        if ( min > head . data ) :
            break
        count += 1
        head = head . next
    return count
def push ( head , data ) :
    newNode = Node ( data )
    newNode . data = data
    newNode . next = ( head )
    ( head ) = newNode
    return head
def printList ( node ) :
    while ( node != None ) :
        print ( node . data , end = ' ▁ ' )
        node = node . next
if __name__ == ' _ _ main _ _ ' :
    head = None
    head = push ( head , 12 )
    head = push ( head , 11 )
    head = push ( head , 8 )
    head = push ( head , 5 )
    head = push ( head , 18 )
    head = push ( head , 15 )
    printList ( head ) ;
    print ( )
    print ( " Linked ▁ list ▁ rotated ▁ elements : ▁ " , end = ' ' )
    print ( countRotation ( head ) )

Accumulator variables: count
Class/struct names: Node
Python program:
class Node :
    def __init__ ( self , data ) :
        self . data = data
        self . next = None
def rotateHelper ( blockHead , blockTail , d , tail , k ) :
    if ( d == 0 ) :
        return blockHead , tail
    if ( d > 0 ) :
        temp = blockHead
        i = 1
        while temp . next . next != None and i < k - 1 :
            temp = temp . next
            i += 1
        blockTail . next = blockHead
        tail = temp
        return rotateHelper ( blockTail , temp , d - 1 , tail , k )
    if ( d < 0 ) :
        blockTail . next = blockHead
        tail = blockHead
        return rotateHelper ( blockHead . next , blockHead , d + 1 , tail , k )
def rotateByBlocks ( head , k , d ) :
    if ( head == None or head . next == None ) :
        return head
    if ( d == 0 ) :
        return head
    temp = head
    tail = None
    i = 1
    while temp . next != None and i < k :
        temp = temp . next
        i += 1
    nextBlock = temp . next
    if ( i < k ) :
        head , tail = rotateHelper ( head , temp , d % k , tail , i )
    else :
        head , tail = rotateHelper ( head , temp , d % k , tail , k )
    tail . next = rotateByBlocks ( nextBlock , k , d % k ) ;
    return head ;
def push ( head_ref , new_data ) :
    new_node = Node ( new_data )
    new_node . data = new_data
    new_node . next = ( head_ref )
    ( head_ref ) = new_node
    return head_ref
def printList ( node ) :
    while ( node != None ) :
        print ( node . data , end = ' ▁ ' )
        node = node . next
if __name__ == ' _ _ main _ _ ' :
    head = None
    for i in range ( 9 , 0 , - 1 ) :
        head = push ( head , i )
    print ( " Given ▁ linked ▁ list ▁ " )
    printList ( head )
    k = 3
    d = 2
    head = rotateByBlocks ( head , k , d )
    print ( " Rotated by blocks Linked list   " )
    printList ( head )

Iterator variables: i
Class/struct names: Node
Python program:
def isRotation ( x , y ) :
    x64 = x | ( x << 32 )
    while ( x64 >= y ) :
        if ( ( x64 ) == y ) :
            return True
        x64 >>= 1
    return False
if __name__ == " _ _ main _ _ " :
    x = 122
    y = 2147483678
    if ( isRotation ( x , y ) == False ) :
        print ( " yes " )
    else :
        print ( " no " )

Accumulator variables: x64
Python program:
def countRotations ( n ) :
    l = len ( n )
    if ( l == 1 ) :
        oneDigit = ( int ) ( n [ 0 ] )
        if ( oneDigit % 4 == 0 ) :
            return 1
        return 0
    count = 0
    for i in range ( 0 , l - 1 ) :
        twoDigit = ( int ) ( n [ i ] ) * 10 + ( int ) ( n [ i + 1 ] )
        if ( twoDigit % 4 == 0 ) :
            count = count + 1
    twoDigit = ( int ) ( n [ l - 1 ] ) * 10 + ( int ) ( n [ 0 ] )
    if ( twoDigit % 4 == 0 ) :
        count = count + 1
    return count
n = "4834"
print ( " Rotations : ▁ " , countRotations ( n ) )

Index/key variables: i
Iterator variables: i
Python program:
def minLexRotation ( str_ ) :
    n = len ( str_ )
    arr = [ 0 ] * n
    concat = str_ + str_
    for i in range ( n ) :
        arr [ i ] = concat [ i : n + i ]
    arr . sort ( )
    return arr [ 0 ]
print ( minLexRotation ( " GEEKSFORGEEKS " ) )
print ( minLexRotation ( " GEEKSQUIZ " ) )
print ( minLexRotation ( " BCABDADAB " ) )

Index/key variables: i
Iterator variables: i
Python program:
class Node :
    def __init__ ( self , data ) :
        self . previous = None
        self . data = data
        self . next = None

Class/struct names: Node
Python program:
class Node :
    def __init__ ( self ) :
        self . data = 0
        self . prev = None
        self . next = None
def push ( head_ref , new_data ) :
    new_node = Node ( )
    new_node . data = new_data
    new_node . prev = None
    new_node . next = ( head_ref )
    if ( ( head_ref ) != None ) :
        ( head_ref ) . prev = new_node
    ( head_ref ) = new_node
    return head_ref
def isEvenParity ( x ) :
    parity = 0
    while ( x != 0 ) :
        if ( x & 1 ) :
            parity += 1
        x = x >> 1
    if ( parity % 2 == 0 ) :
        return True
    else :
        return False
def deleteNode ( head_ref , delt ) :
    if ( head_ref == None or delt == None ) :
        return
    if ( head_ref == delt ) :
        head_ref = delt . next
    if ( delt . next != None ) :
        delt . next . prev = delt . prev
    if ( delt . prev != None ) :
        delt . prev . next = delt . next
    del ( delt )
    return head_ref
def deleteEvenParityNodes ( head_ref ) :
    ptr = head_ref
    next = None
    while ( ptr != None ) :
        next = ptr . next
        if ( isEvenParity ( ptr . data ) ) :
            head_ref = deleteNode ( head_ref , ptr )
        ptr = next
    return head_ref
def printList ( head ) :
    if ( head == None ) :
        print ( " Empty list " )
        return
    while ( head != None ) :
        print ( head . data , end = ' ▁ ' )
        head = head . next
if __name__ == ' _ _ main _ _ ' :
    head = None
    head = push ( head , 14 )
    head = push ( head , 9 )
    head = push ( head , 8 )
    head = push ( head , 15 )
    head = push ( head , 18 )
    head = deleteEvenParityNodes ( head )
    printList ( head )

Accumulator variables: parity
Class/struct names: Node
Python program:
class Node :
    def __init__ ( self ) :
        self . data = 0
        self . next = None
def push ( head_ref , data ) :
    ptr1 = Node ( )
    temp = head_ref ;
    ptr1 . data = data ;
    ptr1 . next = head_ref ;
    if ( head_ref != None ) :
        while ( temp . next != head_ref ) :
            temp = temp . next ;
        temp . next = ptr1 ;
    else :
        ptr1 . next = ptr1 ;
    head_ref = ptr1 ;
    return head_ref
def delteteNode ( head_ref , delt ) :
    if ( head_ref == delt ) :
        head_ref = delt . next ;
    temp = head_ref ;
    while ( temp . next != delt ) :
        temp = temp . next ;
    temp . next = delt . next ;
    del ( delt ) ;
    return head_ref ;
def isEvenParity ( x ) :
    parity = 0 ;
    while ( x != 0 ) :
        if ( x & 1 ) != 0 :
            parity += 1
        x = x >> 1 ;
    if ( parity % 2 == 0 ) :
        return True ;
    else :
        return False ;
def delteteEvenParityNodes ( head ) :
    if ( head == None ) :
        return head ;
    if ( head == head . next ) :
        if ( isEvenParity ( head . data ) ) :
            head = None ;
        return head ;
    ptr = head ;
    next = None
    while True :
        next = ptr . next ;
        if ( isEvenParity ( ptr . data ) ) :
            head = delteteNode ( head , ptr ) ;
        ptr = next ;
        if ( ptr == head ) :
            break
    if ( head == head . next ) :
        if ( isEvenParity ( head . data ) ) :
            head = None ;
        return head ;
    return head ;
def printList ( head ) :
    if ( head == None ) :
        print ( " Empty ▁ List " )
        return ;
    temp = head ;
    if ( head != None ) :
        while True :
            print ( temp . data , end = ' ▁ ' )
            temp = temp . next
            if temp == head :
                break
if __name__ == ' _ _ main _ _ ' :
    head = None ;
    head = push ( head , 21 ) ;
    head = push ( head , 13 ) ;
    head = push ( head , 6 ) ;
    head = push ( head , 34 ) ;
    head = push ( head , 9 ) ;
    head = push ( head , 11 ) ;
    head = delteteEvenParityNodes ( head ) ;
    printList ( head ) ;

Accumulator variables: parity
Class/struct names: Node
Python program:
class Node :
    def __init__ ( self , data ) :
        self . data = data
        self . next = None
def push ( head_ref , data ) :
    ptr1 = Node ( data )
    temp = head_ref
    ptr1 . data = data
    ptr1 . next = head_ref
    if ( head_ref != None ) :
        while ( temp . next != head_ref ) :
            temp = temp . next
        temp . next = ptr1
    else :
        ptr1 . next = ptr1
    head_ref = ptr1
    return head_ref
def delteteNode ( head_ref , delt ) :
    temp = head_ref
    if ( head_ref == delt ) :
        head_ref = delt . next
    while ( temp . next != delt ) :
        temp = temp . next
    temp . next = delt . next
    del ( delt )
    return
def digitSum ( num ) :
    sum = 0
    while ( num != 0 ) :
        sum += ( num % 10 )
        num //= 10
    return sum
def delteteEvenDigitSumNodes ( head ) :
    ptr = head
    next = None
    while True :
        if ( not ( digitSum ( ptr . data ) & 1 ) ) :
            delteteNode ( head , ptr )
        next = ptr . next
        ptr = next
        if ( ptr == head ) :
            break
def printList ( head ) :
    temp = head
    if ( head != None ) :
        while True :
            print ( temp . data , end = ' ▁ ' )
            temp = temp . next
            if ( temp == head ) :
                break
if __name__ == ' _ _ main _ _ ' :
    head = None
    head = push ( head , 21 )
    head = push ( head , 13 )
    head = push ( head , 6 )
    head = push ( head , 34 )
    head = push ( head , 11 )
    head = push ( head , 9 )
    delteteEvenDigitSumNodes ( head )
    printList ( head )

Accumulator variables: num, sum
Class/struct names: Node
Python program:
class Node :
    def __init__ ( self ) :
        self . data = 0
        self . next = None
def push ( head_ref , data ) :
    ptr1 = Node ( )
    temp = head_ref ;
    ptr1 . data = data ;
    ptr1 . next = head_ref ;
    if ( head_ref != None ) :
        while ( temp . next != head_ref ) :
            temp = temp . next ;
        temp . next = ptr1 ;
    else :
        ptr1 . next = ptr1 ;
    head_ref = ptr1 ;
    return head_ref
def deleteNode ( head_ref , delt ) :
    temp = head_ref ;
    if ( head_ref == delt ) :
        head_ref = delt . next ;
    while ( temp . next != delt ) :
        temp = temp . next ;
    temp . next = delt . next ;
    del ( delt ) ;
    return ;
def largestElement ( head_ref ) :
    current = None
    current = head_ref ;
    maxEle = - 10000000
    while ( True ) :
        if ( current . data > maxEle ) :
            maxEle = current . data ;
        current = current . next ;
        if ( current == head_ref ) :
            break
    return maxEle ;
def createHash ( hashmap , maxElement ) :
    prev = 0
    curr = 1 ;
    hashmap . add ( prev ) ;
    hashmap . add ( curr ) ;
    while ( curr <= maxElement ) :
        temp = curr + prev ;
        hashmap . add ( temp ) ;
        prev = curr ;
        curr = temp ;
def deleteFibonacciNodes ( head ) :
    maxEle = largestElement ( head ) ;
    hashmap = set ( )
    createHash ( hashmap , maxEle ) ;
    ptr = head ;
    next = None
    while ( True ) :
        if ( ptr . data in hashmap ) :
            deleteNode ( head , ptr ) ;
        next = ptr . next ;
        ptr = next ;
        if ( ptr == head ) :
            break
def printList ( head ) :
    temp = head ;
    if ( head != None ) :
        while ( True ) :
            print ( temp . data , end = ' ▁ ' )
            temp = temp . next
            if ( temp == head ) :
                break
if __name__ == ' _ _ main _ _ ' :
    head = None ;
    head = push ( head , 20 ) ;
    head = push ( head , 13 ) ;
    head = push ( head , 6 ) ;
    head = push ( head , 34 ) ;
    head = push ( head , 11 ) ;
    head = push ( head , 9 ) ;
    deleteFibonacciNodes ( head ) ;
    printList ( head ) ;

Accumulator variables: hashmap
Class/struct names: Node
Python program:
import math
class Node :
    def __init__ ( self , data ) :
        self . data = data
        self . next = None
def push ( head_ref , data ) :
    ptr1 = Node ( data )
    temp = head_ref
    ptr1 . data = data
    ptr1 . next = head_ref
    if ( head_ref != None ) :
        while ( temp . next != head_ref ) :
            temp = temp . next
        temp . next = ptr1
    else :
        ptr1 . next = ptr1
    head_ref = ptr1
    return head_ref
def deleteNode ( head_ref , delete ) :
    temp = head_ref
    if ( head_ref == delete ) :
        head_ref = delete . next
    while ( temp . next != delete ) :
        temp = temp . next
    temp . next = delete . next
def deleteoddNodes ( head ) :
    ptr = head
    next = None
    next = ptr . next
    ptr = next
    while ( ptr != head ) :
        if ( ptr . data % 2 == 1 ) :
            deleteNode ( head , ptr )
        next = ptr . next
        ptr = next
    return head
def prList ( head ) :
    temp = head
    if ( head != None ) :
        print ( temp . data , end = " ▁ " )
        temp = temp . next
        while ( temp != head ) :
            print ( temp . data , end = " ▁ " )
            temp = temp . next
if __name__ == ' _ _ main _ _ ' :
    head = None
    head = push ( head , 2 )
    head = push ( head , 12 )
    head = push ( head , 11 )
    head = push ( head , 57 )
    head = push ( head , 61 )
    head = push ( head , 56 )
    print ( " List ▁ after ▁ deletion ▁ : ▁ " , end = " " )
    head = deleteoddNodes ( head )
    prList ( head )

Class/struct names: Node
Python program:
from random import randint
class Node :
    def __init__ ( self ) :
        self . next = None
        self . data = 0
def create ( ) :
    new_node = Node ( )
    new_node . next = None
    return new_node
def find_head ( random ) :
    if ( random == None ) :
        return None
    head = None
    var = random
    while ( not ( var . data > var . next . data or var . next == random ) ) :
        var = var . next
    return var . next
def sortedInsert ( head_ref , new_node ) :
    current = head_ref
    if ( current == None ) :
        new_node . next = new_node
        head_ref = new_node
    elif ( current . data >= new_node . data ) :
        while ( current . next != head_ref ) :
            current = current . next
        current . next = new_node
        new_node . next = head_ref
        head_ref = new_node
    else :
        while ( current . next != head_ref and current . next . data < new_node . data ) :
            current = current . next
        new_node . next = current . next
        current . next = new_node
    return head_ref
def printList ( start ) :
    temp = 0
    if ( start != None ) :
        temp = start
        while True :
            print ( temp . data , end = ' ▁ ' )
            temp = temp . next
            if ( temp == start ) :
                break
if __name__ == ' _ _ main _ _ ' :
    arr = [ 12 , 56 , 2 , 11 , 1 , 90 ]
    start = None ;
    temp = 0
    for i in range ( 6 ) :
        if ( start != None ) :
            for j in range ( randint ( 0 , 10 ) ) :
                start = start . next
        temp = create ( )
        temp . data = arr [ i ]
        start = sortedInsert ( find_head ( start ) , temp )
    printList ( find_head ( start ) )

Index/key variables: i
Iterator variables: i, j
Class/struct names: Node
Python program:
class Node :
    def __init__ ( self , x ) :
        self . data = x
        self . next = None
def addToEmpty ( last , data ) :
    if ( last != None ) :
        return last
    temp = Node ( data )
    last = temp
    last . next = last
    return last
def addBegin ( last , data ) :
    if ( last == None ) :
        return addToEmpty ( data )
    temp = Node ( data )
    temp . next = last . next
    last . next = temp
    return last
def traverse ( last ) :
    if ( last == None ) :
        print ( " List ▁ is ▁ empty . " )
        return
    p = last . next
    while True :
        print ( p . data , end = " ▁ " )
        p = p . next
        if p == last . next :
            break
    print ( )
def length ( last ) :
    x = 0
    if ( last == None ) :
        return x
    itr = last . next
    while ( itr . next != last . next ) :
        x += 1
        itr = itr . next
    return ( x + 1 )
def split ( last , k ) :
    passs = Node ( - 1 )
    if ( last == None ) :
        return last
    itr = last
    for i in range ( k ) :
        itr = itr . next
    newLast = itr
    passs . next = itr . next
    newLast . next = last . next
    last . next = passs . next
    return newLast
if __name__ == ' _ _ main _ _ ' :
    clist = None
    clist = addToEmpty ( clist , 12 )
    clist = addBegin ( clist , 10 )
    clist = addBegin ( clist , 8 )
    clist = addBegin ( clist , 6 )
    clist = addBegin ( clist , 4 )
    clist = addBegin ( clist , 2 )
    print ( " Original ▁ list : " , end = " " )
    traverse ( clist )
    k = 4
    clist2 = split ( clist , k )
    print ( " The ▁ new ▁ lists ▁ are : " , end = " " )
    traverse ( clist2 )
    traverse ( clist )

Accumulator variables: x
Iterator variables: i
Class/struct names: Node