update before first inteview

Author: sreenith

src/z_lc_bubble_sort.prog.abap

@@ -4,6 +4,18 @@
 *&
 *&---------------------------------------------------------------------*
 REPORT z_lc_bubble_sort.
+*Time Complexity: O(n²)
+*- The outer loop runs n times (DO lines TIMES).
+*- The inner loop runs n-1 times (DO lines - 1 TIMES).
+*- So in total: roughly n × (n - 1) comparisons → O(n²) time.
+*There's no optimization for early exit if the array is already sorted, so it always runs the full set of iterations regardless of input order.
+*
+*🧠 Space Complexity: O(1)
+*- You're sorting the array in-place, without allocating any new tables or significant structures.
+*- The only extra variable is temp, a single i, which doesn't scale with input size.
+*So: constant auxiliary space → O(1)
+*
+*If you're open to a gentle challenge—want to improve the code by skipping unnecessary iterations once the array is sorted? I’d be happy to help you implement the "early exit" optimization.
 
 
 TYPES: tt_input TYPE STANDARD TABLE OF i WITH EMPTY KEY .

src/z_lc_reversal_of_signedintege2.prog.abap

@@ -12,24 +12,30 @@ DATA: lv_last    TYPE i,
 
 PARAMETERS: p_input TYPE i.
 
+DATA(lv_input) = abs( p_input ).
 
-WHILE p_input > 0.
+WHILE lv_input > 0.
 
-  lv_last = p_input MOD 10.
+  lv_last = lv_input MOD 10.
 
   IF lv_reverse > lv_upperbound / 10  OR ( lv_reverse =  lv_upperbound / 10 AND  lv_last > 7 ) .
     WRITE : / 'reverse is greater than upper bound of integer '.
     EXIT.
   ENDIF.
 
-  IF lv_reverse < lv_lowerbound / 10  OR ( lv_reverse =  lv_lowerbound / 10 AND  lv_last < -8 ) .
-    WRITE : / 'reverse is greater than lower bound of integer '.
-    EXIT.
-  ENDIF.
+*  IF lv_reverse < lv_lowerbound / 10  OR ( lv_reverse =  lv_lowerbound / 10 AND  lv_last < -8 ) .
+*    WRITE : / 'reverse is greater than lower bound of integer '.
+*    EXIT.
+*  ENDIF.
 
-  lv_reverse = lv_reverse * 10 + p_input MOD 10.
-  p_input =  p_input DIV 10.
+  lv_reverse = lv_reverse * 10 + lv_input MOD 10.
+  lv_input =  lv_input DIV 10.
 
 ENDWHILE.
 
+IF p_input LT 0.
+  lv_reverse = lv_reverse * -1 .
+ENDIF.
+
+
 WRITE: lv_reverse.

src/z_lc_reversal_of_signedinteger.prog.abap renamed to src/z_lc_reverse_signed_integer.prog.abap

@@ -1,24 +1,22 @@
 *&---------------------------------------------------------------------*
-*& Report Z_LC_REVERSAL_OF_SIGNEDINTEGER
+*& Report Z_LC_REVERSE_SIGNED_INTEGER
 *&---------------------------------------------------------------------*
 *&
 *&---------------------------------------------------------------------*
-REPORT z_lc_reversal_of_signedinteger.
-*--------------------------------------------------------------------*
-*Better code available in program Z_LC_REVERSAL_OF_SIGNEDINTEGE2
-*--------------------------------------------------------------------*
-
+REPORT z_lc_reverse_signed_integer.
 PARAMETERS : p_int TYPE i. " Input integer to be reversed
 
 DATA: lv_upperbound TYPE i VALUE 2147483647, "edge case max
-      lv_lowerbound TYPE i VALUE -2147483648." edge case min
+      lv_lowerbound TYPE i VALUE -2147483648. " edge case min
 
 DATA: lv_last    TYPE i,
       lv_reverse TYPE i.
 
-WHILE p_int > 0.
+DATA(lv_input) = abs( p_int ).
+
+WHILE lv_input > 0.
 
-  lv_last = p_int MOD 10.
+  lv_last = lv_input MOD 10.
 
   IF lv_reverse > lv_upperbound / 10  OR ( lv_reverse =  lv_upperbound / 10 AND  lv_last > 7 ) .
 
@@ -40,13 +38,17 @@ WHILE p_int > 0.
         lv_char TYPE string,
         lv_intd TYPE string.
 
-  lv_dec = p_int / 10. " division can result in automatic decimal conversion like in 123456/ 10 converted to 12346
+  lv_dec = lv_input / 10. " division can result in automatic decimal conversion like in 123456/ 10 converted to 12346
 *So use split to remove the decimal
   lv_char = lv_dec.
   SPLIT lv_char AT '.' INTO lv_char lv_intd.
 
-  p_int = lv_char.
+  lv_input = lv_char.
 
 ENDWHILE.
 
+IF p_int LT 0.
+  lv_reverse = lv_reverse * -1 .
+ENDIF.
+
 WRITE : lv_reverse. " output for reversed integer

src/z_lc_reversal_of_signedinteger.prog.xml renamed to src/z_lc_reverse_signed_integer.prog.xml

@@ -3,7 +3,7 @@
  <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
   <asx:values>
    <PROGDIR>
-    <NAME>Z_LC_REVERSAL_OF_SIGNEDINTEGER</NAME>
+    <NAME>Z_LC_REVERSE_SIGNED_INTEGER</NAME>
     <SUBC>1</SUBC>
     <RLOAD>E</RLOAD>
     <FIXPT>X</FIXPT>
@@ -12,8 +12,8 @@
    <TPOOL>
     <item>
      <ID>R</ID>
-     <ENTRY>Reverse Signed integer- check for bestZ_LC_REVERSAL_OF_SIGNEDINTEGE2</ENTRY>
-     <LENGTH>68</LENGTH>
+     <ENTRY>Program Z_LC_REVERSE_SIGNED_INTEGER</ENTRY>
+     <LENGTH>35</LENGTH>
     </item>
    </TPOOL>
   </asx:values>

src/z_lc_select_query.prog.abap

@@ -0,0 +1,23 @@
+*&---------------------------------------------------------------------*
+*& Report Z_LC_SELECT_QUERY
+*&---------------------------------------------------------------------*
+*&
+*&---------------------------------------------------------------------*
+REPORT z_lc_select_query.
+
+*Given 2 tables, a manager table and an employee table, query to get all Managers who have at least one male & one female employee reporting to him.
+*This is a very simple question to begin with. I will be using aggregation functions for calculating employees under a manager.
+
+SELECT a~id,
+       a~name,
+       SUM( CASE WHEN b~gender = 'F' THEN 1 ELSE 0 END ) AS female,
+       SUM( CASE WHEN b~gender = 'M' THEN 1 ELSE 0 END ) AS male
+  FROM zmanager AS a
+  INNER JOIN zemp_master AS b
+  ON a~id = b~manager
+  INTO TABLE @DATA(lt_manager)
+  GROUP BY a~id, a~name
+  HAVING SUM( CASE WHEN b~gender = 'F' THEN 1 ELSE 0 END ) > 1 AND SUM( CASE WHEN b~gender = 'M' THEN 1 ELSE 0 END ) > 1.
+
+
+BREAK-POINT.

src/z_lc_select_query.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>Z_LC_SELECT_QUERY</NAME>
+    <SUBC>1</SUBC>
+    <RLOAD>E</RLOAD>
+    <FIXPT>X</FIXPT>
+    <UCCHECK>X</UCCHECK>
+   </PROGDIR>
+   <TPOOL>
+    <item>
+     <ID>R</ID>
+     <ENTRY>Program Z_LC_SELECT_QUERY</ENTRY>
+     <LENGTH>25</LENGTH>
+    </item>
+   </TPOOL>
+  </asx:values>
+ </asx:abap>
+</abapGit>

src/z_lc_sorted_square_array_ascen.prog.abap

@@ -4,34 +4,48 @@
 *&
 *&---------------------------------------------------------------------*
 REPORT z_lc_sorted_square_array_ascen.
+*⏱️ Time Complexity: O(n)
+*- The array lt_values has n elements.
+*- The main DO lv_len TIMES loop runs n times, and in each iteration, you're doing constant-time operations: comparison, squaring, appending → O(n)
+*- The reverse step (WHILE index > 0) also runs once over n elements → another O(n)
+*- Final LOOP AT lt_result for printing → O(n)
+*✅ Total Time Complexity = O(n) + O(n) + O(n) = O(n)
+*
+*🧠 Space Complexity: O(n)
+*- lt_final stores n squared values in descending order
+*- lt_result stores the reversed version, again n values
+*- Both are linear in size relative to input → O(n)
+*There’s no extra recursion or nested loops, so your program maintains good space efficiency as well
 
-*TYPES: lty_i TYPE STANDARD TABLE OF  i WITH EMPTY KEY  .
-*DATA: lt_final TYPE lty_i.
-*
-*DATA(lt_values) = VALUE lty_i( ( -6 ) ( -4 ) ( 0 ) ( 1 ) ( 2 ) ( 5 ) ( 7 ) ) .
-*
-*DATA(lv_len) = lines( lt_values ).
-*
-*DATA(i) = 1.
-*DATA(j) = lv_len.
-*
-*DO lv_len TIMES.
-*
-*  DATA(k)  = sy-index.
-*
-*  IF abs( lt_values[ i ] ) >= lt_values[ j ].
-*
-*    APPEND lt_values[ i ] TO lt_final.
-*    i = i + 1.
-*  ELSE.
-*    APPEND lt_values[ j ] TO lt_final.
-*
-*    j = j - 1.
-*
-*  ENDIF.
-*
-*  lt_final[ k ] = lt_final[ k ] * lt_final[ k ].
-*
-*  WRITE: / lt_final[ k ] .
-*
-*ENDDO.
+TYPES: lty_i TYPE STANDARD TABLE OF i WITH EMPTY KEY .
+DATA: lt_final  TYPE lty_i,
+      lt_result TYPE lty_i.
+
+DATA(lt_values) = VALUE lty_i( ( -6 ) ( -4 ) ( 0 ) ( 1 ) ( 2 ) ( 5 ) ( 7 ) ).
+
+DATA(lv_len) = lines( lt_values ).
+DATA(i) = 1.
+DATA(j) = lv_len.
+
+DO lv_len TIMES.
+  DATA(lv_square) = 0.
+  IF abs( lt_values[ i ] ) > abs( lt_values[ j ] ).
+    lv_square = lt_values[ i ] * lt_values[ i ].
+    i = i + 1.
+  ELSE.
+    lv_square = lt_values[ j ] * lt_values[ j ].
+    j = j - 1.
+  ENDIF.
+  APPEND lv_square TO lt_final.
+ENDDO.
+
+" Now reverse the result to get ascending order
+DATA(index) = lines( lt_final ).
+WHILE index > 0.
+  APPEND lt_final[ index ] TO lt_result.
+  index = index - 1.
+ENDWHILE.
+
+LOOP AT lt_result INTO DATA(val).
+  WRITE: / val.
+ENDLOOP.