SELECT  VAL
  FROM  DUAL
  MODEL
    DIMENSION BY(0 ID)
    MEASURES(
             0 TEMP_VAL,
             0 VAL
             )
    RULES ITERATE(&1)
      (
       TEMP_VAL[FOR ID FROM 0 TO ITERATION_NUMBER + 1 INCREMENT 1] = CASE
                                                                       WHEN VAL[ITERATION_NUMBER] - (ITERATION_NUMBER + 1) < 0
                                                                         THEN VAL[ITERATION_NUMBER] + ITERATION_NUMBER + 1
                                                                       ELSE VAL[ITERATION_NUMBER] - (ITERATION_NUMBER + 1)
                                                                     END,
       VAL[ITERATION_NUMBER + 1] = CASE
                                     WHEN VAL[ITERATION_NUMBER] - (ITERATION_NUMBER + 1) < 0
                                       THEN TEMP_VAL[0]
                                     WHEN COUNT(
                                                CASE TEMP_VAL
                                                  WHEN VAL THEN 1
                                                END
                                               )[ANY] = 1
                                       THEN VAL[ITERATION_NUMBER] + ITERATION_NUMBER + 1
                                       ELSE TEMP_VAL[0]
                                   END
      )
/
Enter value for 1: 20
old   9:     RULES ITERATE(&1)
new   9:     RULES ITERATE(20)

       VAL
----------
         0
         1
         3
         6
         2
         7
        13
        20
        12
        21
        11

       VAL
----------
        22
        10
        23
         9
        24
         8
        25
        43
        62
        42

21 rows selected.

SQL> 

SELECT  ID,
        VAL
  FROM  DUAL
  MODEL
    DIMENSION BY(0 VAL)
    MEASURES(
             0 ID,
             0 PREV_VAL
             )
    RULES ITERATE(&1)
      (
       PREV_VAL[0] = CASE
                       WHEN PREV_VAL[0] - (ITERATION_NUMBER + 1) < 0
                         THEN PREV_VAL[0] + ITERATION_NUMBER + 1
                       WHEN ID[PREV_VAL[0] - (ITERATION_NUMBER + 1)] IS NOT NULL
                         THEN PREV_VAL[0] + ITERATION_NUMBER + 1
                       ELSE PREV_VAL[0] - (ITERATION_NUMBER + 1)
                     END,
       ID[PREV_VAL[0]] = ITERATION_NUMBER + 1
      )
/
Enter value for 1: 10
old  10:     RULES ITERATE(&1)
new  10:     RULES ITERATE(10)

        ID        VAL
---------- ----------
         0          0
         1          1
         2          3
         3          6
         4          2
         5          7
         6         13
         7         20
         8         12
         9         21
        10         11

11 rows selected.

SQL> 

SQL> with t1 as (
  2  select i, Ai
  3  from ( select * from dual
  4          model ignore nav
  5          dimension by (0 i)
  6          measures (0 Ai, 0 t)
  7          rules iterate (100000)
  8          ( Ai[iteration_number] = Ai[iteration_number-1]
  9                                 + iteration_number
 10                                 * case when t[Ai[iteration_number-1]-iteration_number] >0
 11                                          or Ai[iteration_number-1]-iteration_number <= 0
 12                                      then 1
 13                                    else -1
 14                                    end
 15          , t[Ai[iteration_number]] = 1
 16          )
 17  ) where Ai is not null
 18  )
 19  select count(*), sum(Ai) from t1
 20  ;

  COUNT(*)    SUM(AI)
---------- ----------
    100000 8643985072

Elapsed: 00:00:04.39
SQL> WITH T AS (
  2             SELECT  ID,
  3                     VAL
  4               FROM  DUAL
  5               MODEL
  6                 DIMENSION BY(0 VAL)
  7                 MEASURES(
  8                          0 ID,
  9                          0 PREV_VAL
 10                          )
 11                 RULES ITERATE(&1)
 12                   (
 13                    PREV_VAL[0] = CASE
 14                                    WHEN PREV_VAL[0] - (ITERATION_NUMBER + 1) < 0
 15                                      THEN PREV_VAL[0] + ITERATION_NUMBER + 1
 16                                    WHEN ID[PREV_VAL[0] - (ITERATION_NUMBER + 1)] IS NOT NULL
 17                                      THEN PREV_VAL[0] + ITERATION_NUMBER + 1
 18                                    ELSE PREV_VAL[0] - (ITERATION_NUMBER + 1)
 19                                  END,
 20                    ID[PREV_VAL[0]] = ITERATION_NUMBER + 1
 21                   )
 22            )
 23  SELECT  COUNT(*),
 24          SUM(VAL)
 25    FROM  T
 26  /
Enter value for 1: 100000
old  11:                RULES ITERATE(&1)
new  11:                RULES ITERATE(100000)

  COUNT(*)   SUM(VAL)
---------- ----------
     74253 6575992441

Elapsed: 00:00:02.58
SQL> 

with t1 as (
select i, Ai
from ( select * from dual
        model ignore nav
        dimension by (0 i)
        measures (0 Ai, 0 t)
        rules iterate (100000)
        ( Ai[iteration_number] = Ai[iteration_number-1]
                               + iteration_number
                               * case when t[Ai[iteration_number-1]-iteration_number] >0
                                        or Ai[iteration_number-1]-iteration_number <= 0
                                    then 1
                                  else -1
                                  end
        , t[Ai[iteration_number]] = 1
        )
) where Ai is not null
)
select count(*),count(distinct Ai) from t1
/

  COUNT(*) COUNT(DISTINCTAI)
---------- -----------------
    100000             74253

SQL> 

SET TIMING ON
DECLARE
    TYPE NUM_LIST_TYPE
      IS
        TABLE OF PLS_INTEGER
          INDEX BY PLS_INTEGER;
    V_SEQ  NUM_LIST_TYPE;
    V_FLAG NUM_LIST_TYPE;
    V_CNT  NUMBER := &1;
    V_SUM  NUMBER;
BEGIN
    V_SEQ(0)  := 0;
    V_FLAG(0) := 0;
    V_SUM     := 0;
--    DBMS_OUTPUT.PUT_LINE('     0      0');
    FOR V_I IN 1..V_CNT - 1 LOOP
      IF V_SEQ(V_I - 1) <= V_I
        THEN
          V_SEQ(V_I) := V_SEQ(V_I - 1) + V_I;
      ELSIF  V_FLAG.EXISTS(V_SEQ(V_I - 1) - V_I)
        THEN 
          V_SEQ(V_I) := V_SEQ(V_I - 1) + V_I;
        ELSE
          V_SEQ(V_I) := V_SEQ(V_I - 1) - V_I;
      END IF;
      V_FLAG(V_SEQ(V_I)) := 0;
--      DBMS_OUTPUT.PUT_LINE(LPAD(V_I,6) || LPAD(V_SEQ(V_I),7));
      V_SUM := V_SUM + V_SEQ(V_I);
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('SUM = ' || V_SUM);
END;
/
Enter value for 1: 100000
old   8:     V_CNT  NUMBER := &1;
new   8:     V_CNT  NUMBER := 100000;
SUM = 8643985072

PL/SQL procedure successfully completed.

Elapsed: 00:00:00.09
SQL> 

CREATE OR REPLACE
  TYPE NUM_LIST_TYPE
    IS
      TABLE OF NUMBER
/
CREATE OR REPLACE
  FUNCTION RECAMAN(
                   P_CNT NUMBER
                  )
    RETURN NUM_LIST_TYPE
    IS
        TYPE PLS_INT_LIST_TYPE
          IS
            TABLE OF PLS_INTEGER
              INDEX BY PLS_INTEGER;
        V_SEQ  NUM_LIST_TYPE := NUM_LIST_TYPE();
        V_FLAG PLS_INT_LIST_TYPE;
        V_N    NUMBER;
    BEGIN
        V_SEQ.EXTEND(P_CNT);
        V_SEQ(1)  := 0;
        V_FLAG(1) := 0;
        FOR V_I IN 2..P_CNT LOOP
          V_N := V_I - 1;
          IF V_SEQ(V_I - 1) <= V_N
            THEN
              V_SEQ(V_I) := V_SEQ(V_I - 1) + V_N;
          ELSIF  V_FLAG.EXISTS(V_SEQ(V_I - 1) - V_N)
            THEN 
              V_SEQ(V_I) := V_SEQ(V_I - 1) + V_N;
            ELSE
              V_SEQ(V_I) := V_SEQ(V_I - 1) - V_N;
          END IF;
          V_FLAG(V_SEQ(V_I)) := 0;
        END LOOP;
        RETURN V_SEQ;
END;
/
SELECT  COUNT(*),
        SUM(COLUMN_VALUE)
  FROM  TABLE(RECAMAN(100000))
/

  COUNT(*) SUM(COLUMN_VALUE)
---------- -----------------
    100000        8643985072

Elapsed: 00:00:00.15
SQL> 

  COUNT(*) SUM(COLUMN_VALUE)
---------- -----------------
    100000        8643985072

Elapsed: 00:00:00.15
SQL>