changes

Author: sreenith

src/z_lc_anagram.prog.abap

@@ -4,6 +4,24 @@
 *&
 *&---------------------------------------------------------------------*
 REPORT z_lc_anagram.
+*⏱ Time Complexity:
+*Let n be the length of the input strings (since both are equal if they proceed past the length check).
+*- Main DO loop:
+*- Runs n times
+*- Each loop:
+*- Two READ TABLE operations into a HASHED TABLE → average O(1) each
+*- At most one INSERT per character if not already present → also O(1)
+*- So, per iteration = constant work → O(1)
+*✅ Total for loop: O(n)
+*- Final DELETE and IS INITIAL check:
+*- DELETE lt_dict WHERE val = 0 traverses the hash table → at most O(k)
+*- k = number of unique characters, and since we're working with single characters, k ≤ 128 (ASCII) → treated as O(1)
+*✅ Total Time Complexity: O(n)
+*🧠 Space Complexity:
+*- lt_dict holds up to k entries for each unique character across both strings
+*→ Maximum k = 128 (if extended ASCII, 256; Unicode could be higher, but normally bounded)
+*- Regardless of input size, this stays constant for small alphabet sizes
+*✅ Total Space Complexity: O(k) → effectively O(1) for ASCI
 
 TYPES : BEGIN OF ty_dict,
           let TYPE c,

src/z_lc_binary_tree.prog.abap

@@ -4,6 +4,18 @@
 *&
 *&---------------------------------------------------------------------*
 REPORT z_lc_binary_tree.
+*⏱️ Time Complexity
+*Insertion (add_value):
+*- In a perfectly balanced BST, each insertion takes O(log n).
+*- But in the worst case—if input is sorted or skewed—it can degrade to a linked list, resulting in O(n) per insertion.
+*- With n insertions from the loop, total complexity becomes:
+*- Best/Average case: O(n log n)
+*- Worst case: O(n²)
+*Traversal (print_value):
+*- This performs an in-order traversal, visiting each node once → O(n)
+*✅ Overall Time Complexity:
+*- Best/Average case: O(n log n)
+*- Worst case (unbalanced tree): O(n²)
 
 
 TYPES: BEGIN OF ty_binarybtree,
@@ -51,7 +63,7 @@ FORM add_value  USING   btree TYPE ty_binarybtree
                          val TYPE i.
 
   FIELD-SYMBOLS: <lbtree> TYPE ty_binarybtree.
-  DATA: work TYPE ty_binarybtree.
+*  DATA: work TYPE ty_binarybtree.
 
   IF btree IS INITIAL.
 

src/z_lc_compress_string.prog.abap

@@ -4,6 +4,16 @@
 *&
 *&---------------------------------------------------------*
 REPORT z_lc_compress_string.
+*⏱ Time Complexity: O(n)
+*- The loop runs once for each character of the input string → DO strlen( p_string ) TIMES → O(n)
+*- Each iteration performs only constant-time operations: character access, comparison, and string appending
+*- Appending to lv_cstr is handled by ABAP’s string concatenation, which has amortized linear performance, but since we only perform at most n such appends, the overall work remains linear
+*✅ Final time complexity: O(n), where n is the length of the input string
+*
+*🧠 Space Complexity: O(n)
+*- lv_cstr stores the compressed result. In the worst case (no repeated characters, like abcdef), the compressed string grows nearly double: 2n
+*- Apart from a few scalar variables (lv_curr, lv_next, etc.), there’s no additional memory overhead
+*✅ Final space complexity: O(n)
 
 *aaaabbbcccccdee
 DATA:lv_cstr  TYPE string,

src/z_lc_find_words_from_char.prog.abap

@@ -5,6 +5,35 @@
 *&---------------------------------------------------------------------*
 REPORT z_lc_find_words_from_char.
 
+*⏱ Time Complexity
+*Let:
+*- n = number of words (lt_words)
+*- k = average word length
+*- m = number of input characters in lt_chars
+*Step-by-step:
+*- Initialize lt_char_val with 26 alphabet entries:
+*- DO 26 TIMES → O(1)
+*- Build frequency table from lt_chars:
+*- Loop over m elements → each READ is O(1) in a hashed table
+*✅ Total: O(m)
+*- Main word loop (LOOP AT lt_words):
+*- Runs n times
+*- Each iteration:
+*- Copies the character frequency table → O(1) (fixed 26 entries)
+*- Inner WHILE over each character in the word → O(k)
+*- Each READ into lt_char_temp → O(1) ✅ Total: O(n × k)
+*Overall:
+*Total Time Complexity: O(m + n × k)
+*(Most often dominated by n × k if m is small)
+
+*🧠 Space Complexity
+*- lt_char_val: Fixed 26-letter hash → O(1)
+*- lt_char_temp: Copy of lt_char_val → still O(1)
+*- lt_words: Input of n words with k characters each → O(n × k)
+*- lt_chars: Input of m characters → O(m)
+*Total Space Complexity: O(n × k + m)
+*(Driven by input, not auxiliary structures)
+
 
 
 TYPES: tty_words TYPE STANDARD TABLE OF string WITH EMPTY KEY,
@@ -79,3 +108,64 @@ LOOP AT lt_words ASSIGNING FIELD-SYMBOL(<lfs_words>).
     WRITE : <lfs_words>.
   ENDIF.
 ENDLOOP.
+*--------------------------------------------------------------------*
+
+*TYPES: BEGIN OF ty_freq,
+*         char TYPE c,
+*         val  TYPE i,
+*       END OF ty_freq.
+*
+*TYPES: tty_words TYPE STANDARD TABLE OF string WITH EMPTY KEY,
+*       tty_chars TYPE STANDARD TABLE OF c WITH EMPTY KEY.
+*
+*DATA(lt_words) = VALUE tty_words( ( `coding` ) ( `apple`) ( `google`) ( `sreenith`) ( `pop`) ).
+*DATA(lt_chars) = VALUE tty_chars( ( 'a' ) ( 'e') ( 'g') ( 'o') ( 'p') ( 'o') ( 'l') ( 'p') ( 'e') ( 'g') ).
+*
+*DATA: lt_freq TYPE HASHED TABLE OF ty_freq WITH UNIQUE KEY char,
+*      ls_freq TYPE ty_freq.
+*
+*" Initialize frequency table
+*LOOP AT lt_chars INTO DATA(ch).
+*  READ TABLE lt_freq ASSIGNING FIELD-SYMBOL(<fs_freq>) WITH KEY char = ch.
+*  IF sy-subrc = 0.
+*    <fs_freq>-val += 1.
+*  ELSE.
+*    ls_freq-char = ch.
+*    ls_freq-val = 1.
+*    INSERT ls_freq INTO TABLE lt_freq.
+*  ENDIF.
+*ENDLOOP.
+*
+*" Process each word
+*LOOP AT lt_words INTO DATA(word).
+*  DATA word_freq TYPE HASHED TABLE OF ty_freq WITH UNIQUE KEY char.
+*  CLEAR word_freq.
+*
+*  DATA is_valid TYPE abap_bool VALUE abap_true.
+*
+*  DO strlen( word ) TIMES.
+*    DATA(lv_i) = sy-index - 1.
+*    DATA(lv_char) = word+lv_i(1).
+*
+*    " Count character for this word
+*    READ TABLE word_freq ASSIGNING FIELD-SYMBOL(<fs_w>) WITH KEY char = lv_char.
+*    IF sy-subrc = 0.
+*      <fs_w>-val += 1.
+*    ELSE.
+*      ls_freq-char = lv_char.
+*      ls_freq-val = 1.
+*      INSERT ls_freq INTO TABLE word_freq.
+*    ENDIF.
+*
+*    " Compare with available character frequency
+*    READ TABLE lt_freq INTO DATA(ls_avail) WITH KEY char = lv_char.
+*    IF sy-subrc <> 0 OR ls_avail-val < word_freq[ KEY char = lv_char ]-val.
+*      is_valid = abap_false.
+*      EXIT.
+*    ENDIF.
+*  ENDDO.
+*
+*  IF is_valid = abap_true.
+*    WRITE: / word.
+*  ENDIF.
+*ENDLOOP.

src/zlc_paliandrome_permutations.prog.abap

@@ -4,6 +4,20 @@
 *&
 *&---------------------------------------------------------------------*
 REPORT zlc_paliandrome_permutations.
+*⏱ Time Complexity
+*- Character frequency counting (DO strlen( p_input )):
+*- Each iteration: READ and potentially INSERT into a hashed table → O(1) per operation
+*- For input string of length n → O(n) total
+*- Odd frequency check (LOOP AT lt_freq):
+*- At most k iterations, where k is the number of unique characters (bounded, ≤ 128 for ASCII)
+*✅ Total Time Complexity: O(n)
+
+*🧠 Space Complexity
+*- lt_freq: Stores each unique character and its count → at most O(k) space
+*- Scalar variables and field symbols don’t scale with input → negligible
+*✅ Total Space Complexity: O(k)
+*➡️ With English letters or ASCII input, this is effectively O(1)
+
 *Given a string as an input parameter to a program, write code to identify if any permutations of the string is Palindrome or not.
 *For exmaple:
 *Given Input: aab
@@ -22,7 +36,7 @@ TYPES: BEGIN OF ty_freq,
          count TYPE i,
        END OF ty_freq.
 
-DATA: lt_freq TYPE SORTED TABLE OF ty_freq
+DATA: lt_freq TYPE HASHED TABLE OF ty_freq
                 WITH UNIQUE KEY char,
       ls_freq TYPE ty_freq.
 
@@ -34,10 +48,10 @@ DO strlen( p_input ) TIMES.
   lv_index = sy-index - 1 .
   lv_char = p_input+lv_index(1).
 
-  READ TABLE lt_freq INTO ls_freq WITH KEY char = lv_char BINARY SEARCH.
+  READ TABLE lt_freq ASSIGNING FIELD-SYMBOL(<lfs_freq>) WITH KEY char = lv_char. "BINARY SEARCH.
   IF sy-subrc = 0.
-    ls_freq-count = ls_freq-count + 1.
-    MODIFY lt_freq FROM ls_freq INDEX sy-tabix.
+    <lfs_freq>-count = <lfs_freq>-count + 1.
+
   ELSE.
     CLEAR ls_freq.
     ls_freq-char = lv_char.

src/zlc_recursive_tree_walking.prog.abap

@@ -0,0 +1,7 @@
+*&---------------------------------------------------------------------*
+*& Report ZLC_RECURSIVE_TREE_WALKING
+*&---------------------------------------------------------------------*
+*&
+*&---------------------------------------------------------------------*
+REPORT ZLC_RECURSIVE_TREE_WALKING.
+

src/zlc_recursive_tree_walking.prog.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_PROG" serializer_version="v1.0.0">
+ <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+   <PROGDIR>
+    <NAME>ZLC_RECURSIVE_TREE_WALKING</NAME>
+    <SUBC>1</SUBC>
+    <RLOAD>E</RLOAD>
+    <FIXPT>X</FIXPT>
+    <UCCHECK>X</UCCHECK>
+   </PROGDIR>
+  </asx:values>
+ </asx:abap>
+</abapGit>

src/zlc_sliding_window.prog.abap

@@ -0,0 +1,78 @@
+*&---------------------------------------------------------------------*
+*& Report ZLC_SLIDING_WINDOW
+*&---------------------------------------------------------------------*
+*&
+*&---------------------------------------------------------------------*
+REPORT zlc_sliding_window.
+*we have a 3 characters a,b, c and we have a text abcdbcacdbac
+*find the number of  combinations a b c in text
+*like here index 1 - abc, index 5 bca, index 10 bac , write a abap program for this
+
+
+PARAMETERS: p_text TYPE string DEFAULT 'abcdbcacdbac'.
+
+DATA: lv_count  TYPE i VALUE 0,
+      lv_substr TYPE string,
+      lv_len    TYPE i.
+
+lv_len = strlen( p_text ).
+
+DO lv_len - 2 TIMES.
+  DATA(lv_idx) = sy-index - 1.
+  lv_substr = p_text+lv_idx(3). " Take 3-character substring
+
+  IF lv_substr CS 'a' AND lv_substr CS 'b' AND lv_substr CS 'c'.
+    lv_count = lv_count + 1.
+    WRITE: / 'Match at index', sy-index, ':', lv_substr.
+  ENDIF.
+ENDDO.
+
+WRITE: / 'Total combinations of a, b, c:', lv_count.
+
+
+
+
+*
+*PARAMETERS: p_text TYPE string DEFAULT 'abcdbcacdbac'.
+*
+*DATA: lv_len TYPE i,
+*      lv_pos TYPE i,
+*      lv_count TYPE i VALUE 0,
+*      lv_char1 TYPE c LENGTH 1,
+*      lv_char2 TYPE c LENGTH 1,
+*      lv_char3 TYPE c LENGTH 1,
+*      lv_triplet TYPE string.
+*
+*lv_len = strlen( p_text ).
+*
+*DO lv_len - 2 TIMES.
+*  lv_pos = sy-index - 1.
+*
+*  " Access each character by index
+*  lv_char1 = p_text+lv_pos(1).
+*  lv_char2 = p_text+lv_pos+1(1).
+*  lv_char3 = p_text+lv_pos+2(1).
+*
+*  " Count presence of a, b, c manually
+*  DATA(na) = 0.
+*  DATA(nb) = 0.
+*  DATA(nc) = 0.
+*
+*  LOOP AT VALUE #( lv_char1 lv_char2 lv_char3 ) INTO DATA(ch).
+*    IF ch = 'a'.
+*      na = na + 1.
+*    ELSEIF ch = 'b'.
+*      nb = nb + 1.
+*    ELSEIF ch = 'c'.
+*      nc = nc + 1.
+*    ENDIF.
+*  ENDLOOP.
+*
+*  IF na = 1 AND nb = 1 AND nc = 1.
+*    lv_count += 1.
+*    WRITE: / 'Match at index', sy-index, '→', lv_char1, lv_char2, lv_char3.
+*  ENDIF.
+*
+*ENDDO.
+*
+*WRITE: / 'Total combinations of a, b, c:', lv_count.

src/zlc_sliding_window.prog.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_PROG" serializer_version="v1.0.0">
+ <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+   <PROGDIR>
+    <NAME>ZLC_SLIDING_WINDOW</NAME>
+    <SUBC>1</SUBC>
+    <RLOAD>E</RLOAD>
+    <FIXPT>X</FIXPT>
+    <UCCHECK>X</UCCHECK>
+   </PROGDIR>
+   <TPOOL>
+    <item>
+     <ID>R</ID>
+     <ENTRY>Program ZLC_SLIDING_WINDOW</ENTRY>
+     <LENGTH>26</LENGTH>
+    </item>
+   </TPOOL>
+  </asx:values>
+ </asx:abap>
+</abapGit>