5 2 133

January 7, 2023 at 3:12 pm

This is the code from the screenshot above, so that ABAP developers can check by themselves:

CLASS solution DEFINITION.
  PUBLIC SECTION.
    METHODS: group_anagrams IMPORTING strs TYPE string_table
                       RETURNING VALUE(rv_anagrams) TYPE t_t_string_table.
ENDCLASS.

CLASS solution IMPLEMENTATION.
  METHOD group_anagrams.
    DATA: ans TYPE t_t_string_table,
          ca TYPE string,
          key TYPE string.
    IF lines( strs ) = 0.
      rv_anagrams = VALUE #( ).
      RETURN.
    ENDIF.
    CREATE DATA ans TYPE HASHED TABLE OF t_string_table
                      WITH UNIQUE KEY string.
    LOOP AT strs INTO ca.
      SORT ca BY character.
      key = ca.
      IF NOT ans IS INITIAL.
        INSERT VALUE #( ca ) INTO TABLE ans-values INDEX key.
      ELSE.
        INSERT VALUE #( ( ca ) ) INTO TABLE ans INDEX key.
      ENDIF.
    ENDLOOP.
    rv_anagrams = ans-values.
  ENDMETHOD.
ENDCLASS.

That's the test class:

CLASS ltc_main DEFINITION FOR TESTING DURATION SHORT RISK LEVEL HARMLESS.
  PRIVATE SECTION.
    METHODS test FOR TESTING.
ENDCLASS.
CLASS ltc_main IMPLEMENTATION.
  METHOD test.
    DATA(words) = VALUE string_table( 
        ( `are` ) ( `bat` ) ( `ear` ) ( `code` ) ( `tab` ) ( `era` ) ).
    DATA(answer) = NEW solution( )->group_anagrams( words ).
    cl_abap_unit_assert=>assert_equals( act = answer exp = VALUE solution=>t_t_string_table(
        ( VALUE #( ( `are` ) ( `ear` ) ( `era` ) ) )
        ( VALUE #( ( `bat` ) ( `tab` ) ) )
        ( VALUE #( ( `code` ) ) ) ) ).
  ENDMETHOD.
ENDCLASS.

• Like 1
• Share

January 7, 2023 at 4:21 pm

Below what I would expect from a developer who would convert the java algorithm line by line. That's a code which works, each line is more or less equivalent to the java code:

CLASS solution DEFINITION.
  PUBLIC SECTION.
    TYPES: t_t_string_table TYPE STANDARD TABLE OF string_table WITH DEFAULT KEY.
    METHODS: group_anagrams IMPORTING strs               TYPE string_table
                            RETURNING VALUE(rv_anagrams) TYPE t_t_string_table.
ENDCLASS.

CLASS solution IMPLEMENTATION.
  METHOD group_anagrams.
    TYPES: ty_count TYPE STANDARD TABLE OF i WITH EMPTY KEY,
           BEGIN OF ty_ans_line,
             mapkey   TYPE string,
             mapvalue TYPE string_table,
           END OF ty_ans_line,
           ty_ans TYPE HASHED TABLE OF ty_ans_line WITH UNIQUE KEY mapkey.
    IF lines( strs ) = 0. rv_anagrams = VALUE #( ). RETURN. ENDIF.
    DATA(ans) = VALUE ty_ans( ).
    DATA(count) = VALUE ty_count( FOR x = 0 WHILE x < 26 ( ) ).
    LOOP AT strs INTO DATA(s).
      DO lines( count ) TIMES. count[ sy-index ] = 0. ENDDO.
      LOOP AT VALUE string_table( FOR off = 0 WHILE off < strlen( s ) ( substring( val = s off = off len = 1 ) ) ) INTO DATA(c).
        DATA(index) = cl_abap_conv_out_ce=>uccpi( c ) - cl_abap_conv_out_ce=>uccpi( 'a' ) + 1.
        count[ index ] = count[ index ] + 1.
      ENDLOOP.
      DATA(sb) = VALUE string_table( ).
      DO 26 TIMES.
        APPEND `#` TO sb.
        APPEND |{ count[ sy-index ] }| TO sb.
      ENDDO.
      DATA(key) = concat_lines_of( table = sb ).
      IF NOT line_exists( ans[ mapkey = key ] ). INSERT VALUE #( mapkey = key ) INTO TABLE ans. ENDIF.
      ASSIGN ans[ mapkey = key ]-mapvalue TO FIELD-SYMBOL(<mapvalue>).
      INSERT s INTO TABLE <mapvalue>.
    ENDLOOP.
    rv_anagrams = VALUE #( FOR <ans_line> IN ans ( <ans_line>-mapvalue ) ).
  ENDMETHOD.
ENDCLASS.

• Like 1
• Share

January 7, 2023 at 4:53 pm

Thanks a lot Prasanth Padmanabhan Menon for the encouragement and Discussion.

• Like 1
• Share

January 7, 2023 at 4:57 pm

I think you're a little too bit optimistic when you say "the generated output is not that far from being accurate with some minor syntax errors which can be fixed by a skilled developer."

Here is the version of ChatGPT corrected by me with the fewest changes possible:

CLASS solution DEFINITION.
  PUBLIC SECTION.
    TYPES: t_t_string_table TYPE STANDARD TABLE OF string_table WITH DEFAULT KEY.
    METHODS: group_anagrams IMPORTING strs               TYPE string_table
                       RETURNING VALUE(rv_anagrams) TYPE t_t_string_table.
ENDCLASS.

CLASS solution IMPLEMENTATION.
  METHOD group_anagrams.
    TYPES: BEGIN OF t_string_table,
             string   TYPE string,
             mapvalue TYPE string_table,
           END OF t_string_table,
           t_string_table_2 TYPE HASHED TABLE OF t_string_table WITH UNIQUE KEY string.
    DATA: ans TYPE REF TO t_string_table_2,
          key TYPE string.
    IF lines( strs ) = 0.
      rv_anagrams = VALUE #( ).
      RETURN.
    ENDIF.
    CREATE DATA ans TYPE HASHED TABLE OF t_string_table
                      WITH UNIQUE KEY string.
    LOOP AT strs INTO DATA(s).
      DATA(ca) = VALUE string_table( FOR off = 0 WHILE off < strlen( s ) ( substring( val = s off = off len = 1 ) ) ).
      SORT ca BY table_line.
      key = concat_lines_of( table = ca ).
      IF NOT line_exists( ans->*[ string = key ] ).
        INSERT VALUE #( string = key ) INTO TABLE ans->*.
      ENDIF.
      ASSIGN ans->*[ string = key ]-mapvalue TO FIELD-SYMBOL(<mapvalue>).
      INSERT s INTO TABLE <mapvalue>.
    ENDLOOP.
    rv_anagrams = VALUE #( FOR <ans_line> IN ans->* ( <ans_line>-mapvalue ) ).
  ENDMETHOD.
ENDCLASS.

What the differences are:

To do these fixes, I had to understand the algorithm (from the java code for instance). It was impossible for me to FIRST understand the crazy code generated by ChatGPT.

After that, I had to understand which parts of ChatGPT code correspond to which part of the algorithm, and I could find the minimal changes.

Conclusion: it took me 3x more time to find how to fix the program with minimal changes rather than writing the algorithm from scratch.

But I guess ChatGPT could be trained with ABAP code equivalent to java code and maybe that would result in more reusable code in the future...

• Like 1
• Share