GeeksforGeeks App
Open App
Browser
Continue

# Python – Test for Incrementing Dictionary

Given a dictionary, test if it is incrementing, i.e. its key and values are increasing by 1.

Input : test_dict = {1:2, 3:4, 5:6, 7:8}
Output : True
Explanation : All keys and values in order differ by 1.

Input : test_dict = {1:2, 3:10, 5:6, 7:8}
Output : False
Explanation : Irregular items.

Method 1: Using items() + loop + extend() + list comprehension

In this, 1st step is to get the dictionary to list conversion using items() + list comprehension and extend(), next loop is used to test if the converted list is incremental.

## Python3

 `# Python3 code to demonstrate working of``# Test for Incrementing Dictionary``# Using extend() + list comprehension` `# initializing dictionary``test_dict ``=` `{``1``: ``2``, ``3``: ``4``, ``5``: ``6``, ``7``: ``8``}` `# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))` `temp ``=` `[]` `# forming list from dictionary``[temp.extend([key, val]) ``for` `key, val ``in` `test_dict.items()]` `# checking for incrementing elements``res ``=` `True``for` `idx ``in` `range``(``0``, ``len``(temp) ``-` `1``):` `    ``# test for increasing list``    ``if` `temp[idx ``+` `1``] ``-` `1` `!``=` `temp[idx]:``        ``res ``=` `False` `# printing result``print``(``"Is dictionary incrementing : "` `+` `str``(res))`

Output

```The original dictionary is : {1: 2, 3: 4, 5: 6, 7: 8}
Is dictionary incrementing : True```

Time complexity: O(n), where n is the number of items in the dictionary. The time complexity is determined by the for loop that iterates through the list formed from the dictionary.
Auxiliary space: O(n), where n is the number of items in the dictionary. The auxiliary space is determined by the use of a list “temp” that stores the key-value pairs from the dictionary.

Method 2: Using keys(),values() and sort() method

## Python3

 `# Python3 code to demonstrate working of``# Test for Incrementing Dictionary` `# initializing dictionary``test_dict ``=` `{``1``: ``2``, ``3``: ``10``, ``5``: ``6``, ``7``: ``8``}` `# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))` `res ``=` `False` `x ``=` `list``(test_dict.keys())``y ``=` `list``(test_dict.values())` `a ``=` `[]` `for` `i ``in` `range``(``0``, ``len``(x)):``    ``a.append(x[i])``    ``a.append(y[i])``    ` `b ``=` `[]` `b.extend(a)``b.sort()` `if``(a ``=``=` `b):``    ``res ``=` `True` `# printing result``print``(``"Is dictionary incrementing : "` `+` `str``(res))`

Output

```The original dictionary is : {1: 2, 3: 10, 5: 6, 7: 8}
Is dictionary incrementing : False```

Time Complexity: O(n log n)
Auxiliary Space: O(n)

Method 3: Using replace(),list(),map(),extend(),sort() methods

## Python3

 `# Python3 code to demonstrate working of``# Test for Incrementing Dictionary` `# initializing dictionary``test_dict ``=` `{``1``: ``2``, ``3``: ``10``, ``5``: ``6``, ``7``: ``8``}` `# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))``res ``=` `False``x ``=` `str``(test_dict)``x ``=` `x.replace(``"{"``, "")``x ``=` `x.replace(``"}"``, "")``x ``=` `x.replace(``":"``, "")``x ``=` `x.replace(``","``, "")``y ``=` `x.split()``y ``=` `list``(``map``(``int``, y))``a ``=` `[]``a.extend(y)``y.sort()``if``(a ``=``=` `y):``    ``res ``=` `True``# printing result``print``(``"Is dictionary incrementing : "` `+` `str``(res))`

Output

```The original dictionary is : {1: 2, 3: 10, 5: 6, 7: 8}
Is dictionary incrementing : False```

Time complexity: O(n log n), where n is the number of key-value pairs in the dictionary.
Auxiliary space: O(n), where n is the number of key-value pairs in the dictionary.

Method 4: Using all() and zip()

## Python3

 `def` `is_incrementing(dictionary):``  ` `    ``# Use the built-in `all` function to check if all elements in the generator expression are `True```    ``# The generator expression `(val - 1 == prev for prev, val in zip(dictionary.keys(), dictionary.values()))```    ``# generates a sequence of booleans that represent whether the difference between each key and value is 1``    ``# If all elements in the sequence are `True`, `all` returns `True`; otherwise, it returns `False```    ``return` `all``(val ``-` `1` `=``=` `prev ``for` `prev, val ``in` `zip``(dictionary.keys(), dictionary.values()))`  `# Define the test dictionary``test_dict ``=` `{``1``: ``2``, ``3``: ``9``, ``5``: ``6``, ``7``: ``8``}``# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))``# Call the function and pass in the test dictionary as an argument``print``(``"Is dictionary incrementing:"``, is_incrementing(test_dict))``# This code is contributed by Jyothi pinjala`

Output

```The original dictionary is : {1: 2, 3: 9, 5: 6, 7: 8}
Is dictionary incrementing: False```

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 5: Using recursion:

1. Convert the dictionary keys and values to lists.
2. If the length of the keys list is 1, return True (a single key-value pair is always considered incrementing).
3. Otherwise, check if the difference between the first value and the first key is 1. If so, recursively call the function with a new dictionary created by zipping the remaining keys and values lists together.
4. If the difference is not 1 or if the recursion reaches a single key-value pair that is not incrementing, return False.

## Python3

 `def` `is_incrementing(dictionary):``  ``keys ``=` `list``(dictionary.keys())``  ``values ``=` `list``(dictionary.values())``  ``if` `len``(keys) ``=``=` `1``:``      ``return` `True``  ``elif` `values[``0``] ``-` `keys[``0``] ``=``=` `1``:``      ``return` `is_incrementing(``dict``(``zip``(keys[``1``:], values[``1``:])))``  ``else``:``      ``return` `False` `# Example usage:` `test_dict ``=` `{``1``: ``2``, ``2``: ``3``, ``3``: ``4``, ``4``: ``5``}``# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))``print``(is_incrementing(test_dict))``#This code is contributed by Rayudu.`

Output

```The original dictionary is : {1: 2, 2: 3, 3: 4, 4: 5}
True```

Time complexity: O(n) where n is the number of key-value pairs in the dictionary. This is because the function must iterate over each key-value pair in the dictionary once.
Auxiliary space: O(n) because the function creates two lists of length n (the keys and values lists). However, the recursion depth is at most n-1, so the maximum amount of space used by the call stack is also O(n).

Method 6: Using iteration and a flag variable

1. Initialize a flag variable “is_incremental” to True.
2. Iterate over the dictionary using a for loop and Check if the current key is equal to the previous key + 1, if not set the flag variable “is_incremental” to False and break the loop.
3. Return the flag variable “is_incremental”

## Python3

 `def` `is_incrementing(dictionary):``    ``keys ``=` `list``(dictionary.keys())``    ``is_incremental ``=` `True``    ``for` `i ``in` `range``(``1``, ``len``(keys)):``        ``if` `keys[i] !``=` `keys[i``-``1``] ``+` `1` `or` `dictionary[keys[i]] !``=` `dictionary[keys[i``-``1``]] ``+` `1``:``            ``is_incremental ``=` `False``            ``break``    ``return` `is_incremental` `# Example usage:`  `test_dict ``=` `{``1``: ``2``, ``2``: ``3``, ``3``: ``4``, ``4``: ``5``}` `# printing original dictionary``print``(``"The original dictionary is : "` `+` `str``(test_dict))``print``(is_incrementing(test_dict))`

Output

```The original dictionary is : {1: 2, 2: 3, 3: 4, 4: 5}
True```

Time Complexity: O(n), where n is the number of key-value pairs in the dictionary
Auxiliary Space: O(1), as we are not using any additional data structure

My Personal Notes arrow_drop_up