Merge pull request Dijkstra-Edu#5 from SJ-Cipher/PlusOne

Solution Dijkstra-Edu#66 - SJ-Cipher/Edited - 02/02/2025 - @SJ-Cipher

Author: JRS296

Arrays & Strings/#66 - Plus One - Easy/Explanation.md

@@ -0,0 +1,5 @@
+Explanation:
+
+The array/list 'digits' given to us is the digits of a number. Our objective is to be able to return the array with the value of the next highest integer i.e number+1. Now there are many methods which we can use here eg: We can convert the array to an integer and converting back it back to an array after incementing by 1. But that would require going through the array/list multiple times, once for conversion and again for incrementation. So let us try to perform operations on the list/array itself.
+
+Now we have to be careful when we are operating on lists since it is easy to commit IndexErrors. So first let us start with a loop accessing the last element of the list. Now if this integer is less than 9 we can just simply increment it and return it. But if it is 9 we can simply change it to zero and continue the loop. Now it will check for the second last character and so on until it finds a digit less than 9 and return it. Now if all the integers are 9, the whole list will become 0 and loop will end. If that happens, we just insert a 1 at the beginning of the list and return the list. 

Arrays & Strings/#66 - Plus One - Easy/Plus One - Solution.c

@@ -0,0 +1,45 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+//SOLUTION FUCTION
+int* plusOne(int* digits, int digitsSize, int* returnSize) {
+    int i=0;
+    for(i=digitsSize-1;i>=0;i--){
+        if(digits[i]<9){
+            digits[i]+=1;
+            break;
+        }
+        digits[i]=0;
+    }
+    if(i==-1){
+        int *ret_arr=malloc(sizeof(int)*(digitsSize+1));
+        *returnSize = digitsSize+1;
+        ret_arr[0]=1;
+        for(int i=1;i<*returnSize;i++){
+            ret_arr[i]=digits[i-1];
+        }
+        return ret_arr;
+    }
+    else{
+        int *ret_arr = malloc(sizeof(int)*digitsSize);
+        *returnSize=digitsSize;
+        for(int i=0;i<digitsSize;i++){
+            ret_arr[i]=digits[i];
+        }
+        return ret_arr;
+    }
+
+}
+
+int main(){
+    int arr[]={9,9,9};
+    int size=sizeof(arr)/sizeof(arr[0]);
+    int returnSize;
+    int *ret_arr=plusOne(arr,size,&returnSize); 
+    printf("[");
+    for(int i=0;i<returnSize-1;i++){
+        printf("%d,",ret_arr[i]);
+    }
+    printf("%d]",ret_arr[returnSize-1]);
+    free(ret_arr);
+}

Arrays & Strings/L - Plus One.java renamed to Arrays & Strings/#66 - Plus One - Easy/Plus One - Solution.java

@@ -23,4 +23,4 @@ public int[] plusOne(int[] digits) {
 Memory Usage: 42.6 MB
 
 Simple and really efficient problem - O(n)
- */
+ */

Arrays & Strings/#66 - Plus One - Easy/Plus One - Solution.py

@@ -0,0 +1,17 @@
+from typing import List
+
+#SOLUTION
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]: 
+        for i in range(len(digits)-1,-1,-1): #iterating the list from the end to beginning
+            if digits[i] < 9: 
+                digits[i]+=1
+                return digits # if digit is less than 9 we add one and return
+            else:
+                digits[i]=0 #else make it zero and continue iterating
+        return [1] + digits # if all are 0 (i.e all 9's), we add one at the start and return
+    
+if __name__ == "__main__":
+    print(Solution().plusOne([9,9,9,9,9])) # Example input
+
+#Time Complexity : O(n)