24 game/ABAP

This is essentially a modified port of the C version.

Firstly we need to make a Reverse Polish Notation parser. To make it easier, I simply put this in the report used in the game itself. The following data declarations should be common to both for ease of use.

Global Data

report z24_with_rpn
constants: c_eval_to   type i value 24,
           c_tolerance type f value '0.0001'.
data: gt_val type table of f,
      gv_val type f,
      gv_pac type p,
      gv_chk type c.

RPN Code

" Log a message from the RPN Calculator.
form rpn_log using lv_msg type string.
  write : / 'RPN Message: ', lv_msg.
endform.

" Performs add in Reverse Polish Notation.
form rpn_add.
  data: lv_val1 type f,
        lv_val2 type f.
  " Get the last two values from the stack to add together.
  perform rpn_pop changing: lv_val1, lv_val2.
  add lv_val2 to lv_val1.
  " Add them and then add them back to the "top".
  perform rpn_push using lv_val1.
endform.

" Perform subtraction in RPN.
form rpn_sub.
  data: lv_val1 type f,
        lv_val2 type f.
  " Get the last two values, subtract them, and push them back on.
  perform rpn_pop changing: lv_val1, lv_val2.
  subtract lv_val1 from lv_val2.
  perform rpn_push using lv_val2.
endform.

" Perform multiplication in RPN.
form rpn_mul.
  data: lv_val1 type f,
        lv_val2 type f.
  " Get the last two values, multiply, and push them back.
  perform rpn_pop changing: lv_val1, lv_val2.
  multiply lv_val1 by lv_val2.
  perform rpn_push using lv_val1.
endform.

" Perform division in RPN.
form rpn_div.
  data: lv_val1 type f,
        lv_val2 type f.
  " Get the last two values, divide the first by the second
  " and then add it back to the stack.
  perform rpn_pop changing: lv_val1, lv_val2.
  divide lv_val1 by lv_val2.
  perform rpn_push using lv_val1.
endform.

" Negate a number in RPN.
form rpn_neg.
  data: lv_val type f.
  " Simply get the last number and negate it before pushing it back.
  perform rpn_pop changing lv_val.
  multiply lv_val by -1.
  perform rpn_push using lv_val.
endform.

" Swap the top two values on the RPN Stack.
form rpn_swap.
  data: lv_val1 type f,
        lv_val2 type f.
  " Get the top two values and then add them back in reverse order.
  perform rpn_pop changing: lv_val1, lv_val2.
  perform rpn_push using: lv_val2, lv_val1.
endform.

" Call the relevant RPN operation.
form rpn_call_op using iv_op type string.
  case iv_op.
    when '+'.
      perform rpn_add.
    when '-'.
      perform rpn_sub.
    when '*'.
      perform rpn_mul.
    when '/'.
      perform rpn_div.
    when 'n'.
      perform rpn_neg.
    when 's'.
      perform rpn_swap.
    when others. " Bad op-code found!
      perform rpn_log using 'Operation not found!'.
    endcase.
endform.

" Reverse_Polish_Notation Parser.
form rpn_pop changing ev_out type f.
  " Attempt to get the entry from the 'top' of the table.
  " If it's empty --> log an error and bail.
  data: lv_lines type i.

  describe table gt_val lines lv_lines.
  if lv_lines > 0.
    " After we have retrieved the value, we must remove it from the table.
    read table gt_val index lv_lines into ev_out.
    delete gt_val index lv_lines.
  else.
    perform rpn_log using 'RPN Stack is empty! Underflow!'.
    ev_out = 0.
  endif.
endform.

" Pushes the supplied value onto the RPN table / stack.
form rpn_push using iv_val type f.
  " Simple append - other languages this involves a stack of a certain size.
  append iv_val to gt_val.
endform.

" Refreshes the RPN stack / table.
form rpn_reset.
  " Clear the stack to start anew.
  refresh gt_val.
endform.

" Checks if the supplied string is numeric.
" Lazy evaluation - only checkcs for numbers without formatting.
form rpn_numeric using    iv_in  type string
                 changing ev_out type c.
  data: lv_moff type i,
        lv_len  type i.
  " Match digits with optional decimal places.
  find regex '\d+(\.\d+)*' in iv_in
    match offset lv_moff
    match length lv_len.
  " Get the offset and length of the first occurence, and work
  " out the length of the match.
  subtract lv_moff from lv_len.
  " If the length is different to the length of the whole string,
  " then it's NOT a match, else it is.
  if lv_len ne strlen( iv_in ).
    ev_out = ' '.
  else.
    ev_out = 'X'.
  endif.
endform.

" Convert input to a number. Added safety net of is_numeric.
form rpn_get_num using iv_in type string changing ev_num type f.
  data: lv_check type c.
  " Check if it's numeric - built in redundancy.
  perform rpn_numeric using iv_in changing lv_check.
  if lv_check = 'X'.
    ev_num = iv_in.
  else.
    perform rpn_log using 'Wrong call!'.
  endif.
endform.

" Evaluate the RPN expression and return true if success in eval.
form rpn_eval using in_expr type string changing ev_out type c.
  data: lv_len  type i,
        lv_off  type i value 0,
        lv_num  type c,
        lv_val  type f,
        lv_tok  type string.

  lv_len = strlen( in_expr ).
  do lv_len times.
    lv_tok = in_expr+lv_off(1).
    perform rpn_numeric using lv_tok changing lv_num.
    if lv_num = 'X'.
      perform: rpn_get_num using lv_tok changing lv_val,
               rpn_push    using lv_val.
    else.

      perform rpn_call_op using lv_tok.
    endif.
    add 1 to lv_off.
  enddo.

  ev_out = 'X'.
endform.

24 Game

We can now play the game since we have a parser. The interface is a hacked up screen, and is a bit more clunky than even a CLI (No such option for ABAP, at least not which I'm aware of).

The supplied Random Number Generator seems to highly favour a five as the first digit as well (It does occasionally take on other values). It doesn't appear to be a seeding issue, as the other numbers appear sufficiently random.

selection-screen begin of block main with frame title lv_title.
  parameters:
    p_first  type i,
    p_second type i,
    p_third  type i,
    p_fourth type i,
    p_expr   type string.
selection-screen end of block main.

initialization.
  perform ranged_rand using 1 9 changing p_first.
  perform ranged_rand using 1 9 changing p_second.
  perform ranged_rand using 1 9 changing p_third.
  perform ranged_rand using 1 9 changing p_fourth.

at selection-screen output.
  " Set-up paramter texts.
  lv_title = 'Reverse Polish Notation Tester - Enter expression that evaluates to 24.'.
  %_p_first_%_app_%-text  = 'First Number: '.
  %_p_second_%_app_%-text = 'Second Number: '.
  %_p_third_%_app_%-text  = 'Third Number: '.
  %_p_fourth_%_app_%-text = 'Fourth Number: '.
  %_p_expr_%_app_%-text   = 'Expression: '.
  " Disallow modification of supplied numbers.
  loop at screen.
    if screen-name = 'P_FIRST' or  screen-name = 'P_SECOND' or
       screen-name = 'P_THIRD' or  screen-name = 'P_FOURTH'.
      screen-input = '0'.
      modify screen.
    endif.
  endloop.

start-of-selection.
  " Check the expression is valid.
  perform check_expr using p_expr changing gv_chk.
  if gv_chk <> 'X'.
    write : / 'Invalid input!'.
    stop.
  endif.
  " Check if the expression actually evalutes.
  perform rpn_eval using p_expr changing gv_chk.
  " If it doesn't, warning!.
  if gv_chk <> 'X'.
    write : / 'Invalid expression!'.
    stop.
  endif.
  " Get the evaluated value. Transform it to something that displays a bit better.
  " Then check if it's a valid answer, with a certain tolerance.
  " If they're wrong, give them instructions to on how to go back.
  perform rpn_pop changing gv_val.
  gv_pac = gv_val.
  gv_val = abs( gv_val - c_eval_to ).
  if gv_val < c_tolerance.
    write : / 'Answer correct'.
  else.
    write : / 'Your expression evalutes to ', gv_pac.
    write : / 'Press "F3" to go back and try again!'.
  endif.
  write : / 'Re-run the program to generate a new set.'.

 " Check that the input expression is valid - i.e. all supplied numbers
 " appears exactly once. This does not validate the expression itself.
form check_expr using iv_exp type string changing ev_ok type c.
  data: lv_chk  type c,
        lv_tok  type string,
        lv_val  type i value 0,
        lv_len  type i,
        lv_off  type i,
        lv_num  type i,
        lt_nums type standard table of i.
  ev_ok = 'X'.
  " Update the number count table - indexes 1-9 correspond to numbers.
  " The value stored corresponds to the number of occurences.
  do 9 times.
    if p_first = sy-index.
      add 1 to lv_val.
    endif.
    if p_second = sy-index.
      add 1 to lv_val.
    endif.
    if p_third = sy-index.
      add 1 to lv_val.
    endif.
    if p_fourth = sy-index.
      add 1 to lv_val.
    endif.

    append lv_val to lt_nums.
    lv_val = 0.
  enddo.
  " Loop through the expression parsing the numbers.
  lv_len = strlen( p_expr ).
  do lv_len times.
    lv_tok = p_expr+lv_off(1). " Check if the current token is a number.
    perform rpn_numeric using lv_tok changing lv_chk.
    if lv_chk = 'X'.
      lv_num = lv_tok. " If it's a number, it must be from 1 - 9.
      if lv_num < 1 or lv_num > 9.
        ev_ok = ' '.
        write : / 'Numbers must be between 1 and 9!'.
        return.
      else.
        " Check how many times the number was supplied. If it wasn't supplied
        " or if we have used it up, we should give an error.
        read table lt_nums index lv_num into lv_val.
        if lv_val <= 0.
          ev_ok = ' '.
          write : / 'You can not use numbers more than once'.
          return.
        endif.
        " If we have values left for this number, we decrement the remaining amount.
        subtract 1 from lv_val.
        modify lt_nums index lv_num from lv_val.
      endif.
    endif.
    add 1 to lv_off.
  enddo.
  " Loop through the table and check we have no numbers left for use.
  do 9 times.
    read table lt_nums index  sy-index into lv_val.
    if lv_val > 0.
      write : / 'You must use all numbers'.
      ev_ok = ' '.
      return.
     endif.
  enddo.
endform.

" Generate a random number within the given range.
form ranged_rand using iv_min type i iv_max type i
                 changing ev_val type i.
  call function 'QF05_RANDOM_INTEGER'
    exporting
      ran_int_max = iv_max
      ran_int_min = iv_min
    importing
      ran_int     = ev_val.
endform.