// Copyright Amruth N. Kumar, amruth@computer.org

// This is the master plan for the for loops
// [Single Loop]
//    Skip - Zero Iteration 
// 
//    PassThrough - One Iteration
// 
//    Infinite
// 
//    [Many Iterations] - Normal case, not mentioned
//       Initialization
//          No
//          Assignment
//             [Single]
//             [Multiple]
//          Declaration
//             [Single]
//             [Multiple]
//                Same variable declared both before and in header,
//                     and printed both in and after loop
// 
//       Condition
//          No
//          [Exists]
//             Arithmetic
//                [True]
//                [False]
//             Logical
//                [Short Circuit + Side Effect]
//                [No Short Circuit]
//             Assignment
//                [True]
//                [False]
//             Relational
// 	          Boundary does not change
// 	          Boundary changes
//	       Declaration
//	          [Single]
//		  [Multiple]
//                Same variable declared both before and in header,
//                     and printed both in and after loop
//
// 
//       Action
//          Empty [statement]
//          Simple [statement]
//          Compound [statement]
//             Revises [LoopVar]
//	          Before [Action]
//		  After [Action]
//             [Does not revise LoopVar]
// 
//       Update
//          None
//          Up [Counting]
//             One
//             Many
//          Down [Counting]
//             One
//             Many
//
//       PostLoop [Resume after loop]
// 
// 
// Multiple [Back to back]
//    Dependent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
//    Independent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
// Nested
//    Dependent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
//    Independent
//       [2 loop problems] - degrees of hardness
//       [3 loop problems] - degrees of hardness
//       [All loops of same type] - degrees of hardness
//       [Loops of different types] - degrees of hardness
//          Up [Counting]
//          Down [Counting]
// 
// -------------------------------------------------------------------
// Other factors that affect template hardness:
// Loop body:
// Just a print statement
//     a constant
//     the loop counter
//     a simple expression involving the loopvar
//     the loopvar, boundary value (when boundary is a variable or expression)
//     an expression involving the loopvar and boundary value (when
//         it is a variable) - No, too complicated
//     an if-else statement with different variables in the two clauses 
//
// Note that the type of operator, and its subtypes determine hardness,
// not learning objectives.
// Number of iterations:
//   Zero iterations
//    <  >  
//      far off value
//       boundary value
//    <=  >=
//      far off value
//    ==
//      far off value
//    !=
//      same value
//      Only One iteration
// Multiple iterations
//    <  >
//      far off value
//    <=   >=
//      far off value
//      boundary value
//    ==
//      same value
//    !=
//      n-removed value
// ----------------------------------------------------
// 100
// Iteration.Counter.Skip
// Iteration.Counter.PassThrough
// 150
// Iteration.Counter.Initialization.No
// Iteration.Counter.Initialization.Assignment
// Iteration.Counter.Initialization.Declaration
// 225
// Iteration.Counter.Condition.No
// Iteration.Counter.Condition.Arithmetic
// Iteration.Counter.Condition.Logical
// Iteration.Counter.Condition.Assignment
// Iteration.Counter.Condition.Relational
// Iteration.Counter.Condition.Declaration
// Iteration.Counter.Condition.Changing
// 400
// Iteration.Counter.Action.Empty
// Iteration.Counter.Action.Simple
// Iteration.Counter.Action.Compound
// Iteration.Counter.Action.Changing.Before
// Iteration.Counter.Action.Changing.After
// 525
// Iteration.Counter.Update.No
// Iteration.Counter.Update.Up.One
// Iteration.Counter.Update.Up.Many
// Iteration.Counter.Update.Down.One
// Iteration.Counter.Update.Down.Many
// 650
// Iteration.Counter.PostLoop
// 675
// Iteration.Counter.Multiple.Dependent
//          [Up Counting]
//          [Down Counting]
// Iteration.Counter.Multiple.Independent
//          [Up Counting]
//          [Down Counting]
// 
// Iteration.Counter.Nested.Dependent
//          [Up Counting]
//          [Down Counting]
// Iteration.Counter.Nested.Independent
//          [Up Counting]
//          [Down Counting]
// break 800
// continue 825
// Iteration.Counter.Infinite 900
// 
// Up.One, Up.Many, Down.One, Down.Many are intertwined with the templates of most other learning objectives.
// Could either 
//  1) elilminate all but Up.One for all other learning objectives and introduce them as templates for 
//     Up.Many, Down.One, Down.Many
//  2) Add a few token learning objectives for Up.One, Up.Many, Down.One, Down.Many, and
//     either designate the other learning objectives as meeting these objectives, are 
//     provide credit for these learning objectives alongside the other learning objectives.
// In Fall 2004, not creating any templates for or giving credit for these learning objectives.
//
//
// Visual Basic works only with templates such that
//   condition is of the type var <= value or var >= value
//   update is of the type var = var op value
// 
//************** FOR LOOPS ************************************************
// ------------------------------------------------------------------------
// Counter.Skip ************************************ 100

//Empty Loops *************************** 100
# 100
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> > <R2#integer;6<=R2<=10;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 101
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> == <R2#integer;6<=R2<=10;#>;<V1> = <V1> + 1){<<<V1>;<<<R1>;}}}
>
Type: output
Hardness: 50

# 102
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=10;#>;<V1> < <R2#integer;1<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;<<<R2>;}}}
>
Type: output
Hardness: 50

# 103
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <R2#integer;6<=R2<=10;#>;<V1> = <V1> - 1){<<<R1>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 104
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R1>;<V1> = <V1> + 1){<<<V1>;<<<R1>;}}}
>
Type: output
Hardness: 50

# 105
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <R2#integer;1<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;<<<R2>;}}}
>
Type: output
Hardness: 50


# 106
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 107
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> == <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 108
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 109
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V2>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 110
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=5;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 111
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 112
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> > <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 113
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> < <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 114
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> != <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60


// Introduced for the sake of Visual Basic
# 115
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;1<=R3<=3;#>){<<<V2>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 116
Counter.Skip
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=10;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;1<=R3<=3;#>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50
// ------------------------------------------------------------------------
// Counter.PassThrough ************************************ 125

# 125
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=9;#>;for(<V1> = <V1> - 1;<V1> < <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 126
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#3<=R1<=9;#>;for(<V1> = <V1> + 1;<V1> > <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 127
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> == <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 128
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> <= <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 129
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> >= <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 130
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <R2>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 131
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=10;#>;<V1> = <R2>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 132
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=9;#>;<V1> > 0;<V1> = <V1> - <R1>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 133
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=9;#>;<T1><V2>;for(<V2> = <R1>;<V1> == <V2>;<V2> = <V2> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 134
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=10;#>;<V1> = <R2> * 2){<<<V1>;}}}
>
Type: output
Hardness: 50

# 135
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;3<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2>;<V1> = <V2> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 136
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;<V2> = <V2> + 1;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 137
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;<V2> = <V2> + 1;for(<V1> = <R1>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 138
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#3<=R1<=9;#>;<V2> = <V2> - 1;for(<V1> = <R1>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 139
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R1>;<V1> == <V2>;<V2> = <R2#integer;6<=R2<=9;#>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50

# 140
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V2> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 141
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V2> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 142
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> != <V2>;<V2> = <V1>){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 50




# 143
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;for(<V1> = <R1>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 144
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R1#1<=R1<=9;#>;for(<V1> = <R1>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50


# 145
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R2>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 146
Counter.PassThrough
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - <R1>){<<<V1>;}}}
>
Type: output
Hardness: 50

// ------------------------------------------------------------------------
// Counter.Initialization.No ************************************ 150

// ------------------------------------------------------------------------
// Counter.Initialization.Assignment ************************************ 175
// ------------------------------------------------------------------------
// Counter.Initialization.Declaration ************************************ 200

// ------------------------------------------------------------------------
// Counter.Condition.No ************************************ 225
// ------------------------------------------------------------------------
// Counter.Condition.Arithmetic ************************************ 250
// ------------------------------------------------------------------------
// Counter.Condition.Logical ************************************ 275
// ------------------------------------------------------------------------
// Counter.Condition.Assignment ************************************ 300
// ------------------------------------------------------------------------
// Counter.Condition.Relational ************************************ 325

// Using a constant as boundary value, update by one
# 325
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 20

# 326
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 327
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 20

# 328
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 329
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by one
# 330
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 331
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> > <V2>;<V2> = <V2> + 1){<<<V2>;}}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 50

# 332
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> <= <V2>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 60

# 333
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 60

# 334
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}} // Simplified for S08
>
Type: output
Hardness: 50

# 335
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;<<<V1>;}}} // Simplified for S08
>
Type: output
Hardness: 50

// Using a constant to hold boundary value, update by more than one
# 336
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 20

# 337
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 338
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 20

# 339
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by more than one
# 340
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 341
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 50

# 342
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;15<=R2<=20;#>;<V1> <= <V2>;<V2> = <V2> - <R3#integer;2<=R3<=5;#>){<<<V2>;}}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
>
Type: output
Hardness: 60

# 343
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> >= <V2>;<V2> = <V2> + <R3#integer;2<=R3<=5;#>){<<<V2>;}}}
>
Type: output
Hardness: 60

# 344
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}}}
>
Type: output
Hardness: 70

# 345
Counter.Condition.Relational
?
Counter.Update.After
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R4>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}}}
>
Type: output
Hardness: 70

# 346
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<<<V1>;}}}
>
Type: output
Hardness: 70

# 347
Counter.Condition.Relational
?
Counter.Update.After
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<<<V1>;}}}
>
Type: output
Hardness: 70

// ------------------------------------------------------------------------
// Counter.Condition.Declaration ************************************ 350
// ------------------------------------------------------------------------
// Counter.Condition.Changing ************************************ 375
// NOT simplified for S08 since multiple outputs in the loop help student correctly understand behavior of loop

// Loop variable and Boundary variable changing in the opposite directions by 1
# 375
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 60

# 376
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#10<=R1<=15;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 60

# 377
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 70

# 378
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#10<=R1<=15;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 70

# 379
Counter.Condition.Changing
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;for(<V2> = <V2> + 6 * <R2#integer;1<=R2<=5;#>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V1>;<<<V2>;<V1> = <V1> + <R2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#><R3#R3 = R1 + 6 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R1>;for(<V2> = <R3>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V1>;<<<V2>;<V1> = <V1> + <R2>;}}}
>
Type: output
Hardness: 60

// Loop variable and Boundary variable changing in the opposite directions by the same amount, not 1
# 380
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;16<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - <R3>;}}}
>
Type: output
Hardness: 70

# 381
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#16<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> + <R3>;}}}
>
Type: output
Hardness: 70

# 382
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - <R3>;}}}
>
Type: output
Hardness: 70

# 383
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> + <R3>;}}}
>
Type: output
Hardness: 70

# 384
Counter.Condition.Changing
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>=<R1>;for(<V1> = <V1> + 4 * <R2#integer;1<=R2<=5;#>;<V1> != <V2>;<V1> = <V1> - <R2>){<<<V1>;<<<V2>;<V2> = <V2> + <R2>;}}}
[<R1#1<=R1<=5;#>,<R2#integer;1<=R2<=5;#>,<R3#R3 = R1 + 4 * R2;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>=<R1>;for(<V1> = <R3>;<V1> != <V2>;<V1> = <V1> - <R2>){<<<V1>;<<<V2>;<V2> = <V2> + <R2>;}}}
>
Type: output
Hardness: 70

// Loop variable and Boundary variable changing in the same direction, but by different amounts
# 385
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;12<=R2<=15;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

# 386
Counter.Condition.Changing
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;10<=R2<=15;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;<<<V2>;<V2> = <V2> + 1;}}}
>
Type: output
Hardness: 80

# 387
Counter.Condition.Changing
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#15<=R1<=18;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80

# 388
Counter.Condition.Changing
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#15<=R1<=18;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;3<=R3<=5;#>){<<<V1>;<<<V2>;<V2> = <V2> - 1;}}}
>
Type: output
Hardness: 80


// ------------------------------------------------------------------------
// Counter.Action.Empty ************************************ 400
// ------------------------------------------------------------------------
// Counter.Action.Simple ************************************ 425

// Using a constant as boundary value, update by one
# 425
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 426
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=4;#>;<V1> = <V1> - 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 427
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 428
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1)<<<V1>;}}
>
Type: output
Hardness: 60

# 429
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=4;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1)<<<V1>;}}
>
Type: output
Hardness: 60

// Using a variable to hold boundary value, update by one
# 430
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> < <V2>;<V1> = <V1> + 1)<<<V1>;<V2> = <V2> - 1;}}
>
Type: output
Hardness: 70

# 431
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=4;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1)<<<V1>;<V2> = <V2> + 1;}}
>
Type: output
Hardness: 70

# 432
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1)<<<V1>;<V2> = <V2> - 1;}}
>
Type: output
Hardness: 80

# 433
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1)<<<V1>;<V2> = <V2> + 1;}}
>
Type: output
Hardness: 80

# 434
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=4;#>;<V1> != <V2>;<V1> = <V1> + 1)<<<V1>;<<<V2>;}} 
>
Type: output
Hardness: 70

# 435
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=4;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1)<<<V2>;<<<V1>;}} 
>
Type: output
Hardness: 70

// Using a constant to hold boundary value, update by more than one
# 436
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 50

# 437
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 60

# 438
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 50

# 439
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;}}
>
Type: output
Hardness: 60

// Using a variable to hold boundary value, update by more than one
# 440
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> - <R3>;}}
>
Type: output
Hardness: 70

# 441
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> + <R3>;}}
>
Type: output
Hardness: 70

# 442
Counter.Action.Simple
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> - <R3>;}}
>
Type: output
Hardness: 80

# 443
Counter.Action.Simple
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>)<<<V1>;<V2> = <V2> + <R3>;}}
>
Type: output
Hardness: 80

# 444
Counter.Action.Simple
?
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>)<<<V1>;<<<V2>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R4>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

# 445
Counter.Action.Simple
?
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <V1> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;<V2> != <V1>;<V2> = <V2> - <R2>)<<<V2>;<<<V1>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R4>;<V2> != <V1>;<V2> = <V2> - <R2>)<<<V2>;<<<V1>;}}
>
Type: output
Hardness: 80

# 446
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

# 447
Counter.Action.Simple
?
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>)<<<V1>;<<<V2>;}}
>
Type: output
Hardness: 80

// ------------------------------------------------------------------------
// Counter.Action.Compound ************************************ 450
// ------------------------------------------------------------------------
// Counter.Action.Changing.Before ************************************ 475
// Counter loop being changed in the body, before the body

// Using a constant as boundary value, update by one
# 475
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <R2#integer;7<=R2<=9;#>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 20

# 476
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=3;#>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 477
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=3;#>;<V1> <= <R2#integer;7<=R2<=9;#>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 20

# 478
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=3;#>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 479
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=3;#> + <R2#integer;2<=R2<=5;#> * 2;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by one
# 480
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;7<=R2<=9;#>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 481
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=3;#>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 482
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;7<=R2<=9;#>;for(<V1> = <R1#1<=R1<=3;#>;<V1> <= <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 60

# 483
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=3;#>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<V1> = <V1> - 1;<<<V1>;}}}
>
Type: output
Hardness: 60

# 484
Counter.Action.Changing.Before
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=3;#> + 2 * <R2#integer;2<=R2<=5;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;<<<V2>;}}} // Simplified for S08
// {<T0><F0>(){<T1#integer#><V1> = <R1#1<=R1<=3;#>;<T1><V2> = <R2#integer;2<=R2<=5;#>;<V2> = 2 * <V2> + <R1>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
[<R1#1<=R1<=3;#>,<R2#integer;2<=R2<=5;#>,<R3#R3 = 2 * R2 + R1;#>]{<T0><F0>(){<T1#integer#><V1> = <R1>;<T1><V2> = <R3>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + 1){<V1> = <V1> + 1;<<<V1>;}}}
>
Type: output
Hardness: 50

# 485
Counter.Action.Changing.Before
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2>;for(<V2> = <R1> + 2 * <R2#integer;3<=R2<=6;#>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;<<<V1>;}}} // Simplified for S08
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=3;#>;<T1><V2> = <R2#integer;3<=R2<=6;#>;for(<V2> = 2 * <V2> + <R1>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;}}}
[<R1#1<=R1<=3;#>,<R2#integer;3<=R2<=6;#>,<R3#R3 = 2 * R2 + R1;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2>;for(<V2> = <R3>;<V2> != <V1>;<V2> = <V2> - 1){<V2> = <V2> - 1;<<<V2>;}}}
>
Type: output
Hardness: 50

// Using a constant to hold boundary value, update by more than one
# 486
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 20

# 487
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 488
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 20

# 489
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

// Using a variable to hold boundary value, update by more than one
# 490
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 491
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 50

# 492
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<V1> = <V1> + <R3>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 493
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<V1> = <V1> - <R3>;<<<V1>;}}}
>
Type: output
Hardness: 60

# 494
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 70

# 495
Counter.Action.Changing.Before
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<V1> = <V1> + <V1>;<<<V1>;}}}
>
Type: output
Hardness: 70

// ------------------------------------------------------------------------
// Counter.Action.Changing.After ************************************ 500

// ------------------------------------------------------------------------
// Counter.Update.No ************************************ 525

// ------------------------------------------------------------------------
// Counter.Update.Before ************************************ 550

// ------------------------------------------------------------------------
// Do we need this? This is general case
// Counter.Update.Up.One ************************************ 550

// ------------------------------------------------------------------------
// Counter.PostLoop ************************************ 650


// Using a constant as boundary value, update by one
# 650
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 651
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 652
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 653
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 654
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <R2#integer;6<=R2<=9;#>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

// Using a variable to hold boundary value, update by one
# 655
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 656
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#6<=R1<=9;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> > <V2>;<V2> = <V2> + 1){<<<V2>;}<<<V2>;}}
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> > <V2>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 657
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V1> <= <V2>;<V2> = <V2> - 1){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 658
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#6<=R1<=9;#>;<V1> >= <V2>;<V1> = <V1> - 1){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 659
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;6<=R2<=9;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> != <V2>;<V1> = <V1> + 1){<<<V1>;<<<V2>;}<<<V1>;}} // Simplified for S08
>
Type: output
Hardness: 30

# 660
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;}<<<V2>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;6<=R2<=9;#>;<V2> != <V1>;<V2> = <V2> - 1){<<<V2>;<<<V1>;}<<<V2>;}} // Simplified for S08
>
Type: output
Hardness: 40

// Using a constant to hold boundary value, update by more than one
# 661
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 662
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 663
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <R2#integer;15<=R2<=20;#>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 664
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <R2#integer;1<=R2<=5;#>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

// Using a variable to hold boundary value, update by more than one
# 665
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 666
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> > <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 40

# 667
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;15<=R2<=20;#>;for(<V1> = <R1#1<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2>;for(<V2> = <R2#integer;15<=R2<=20;#>;<V1> <= <V2>;<V2> = <V2> - <R3#integer;2<=R3<=5;#>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 668
Counter.PostLoop
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>=<R2#integer;1<=R2<=5;#>;for(<V1> = <R1#15<=R1<=20;#>;<V1> >= <V2>;<V1> = <V1> - <R3#integer;2<=R3<=5;#>){<<<V1>;}<<<V1>;}}
// {<T0><F0>(){<T1#integer#><V1>=<R1#15<=R1<=20;#>;<T1><V2>;for(<V2> = <R2#integer;1<=R2<=5;#>;<V1> >= <V2>;<V2> = <V2> + <R3#integer;2<=R3<=5;#>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 30

# 669
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R1#1<=R1<=5;#> + <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}<<<V1>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R1 + R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>;<T1><V2> = <R4>;for(<V1> = <R1>;<V1> != <V2>;<V1> = <V1> + <R2>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 670
Counter.PostLoop
>
// {<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<T1><V2> = <R2#integer;2<=R2<=5;#> * <R3#integer;2<=R3<=4;#>;for(<V2> = <V2> + <V1>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}<<<V2>;}}
[<R1#1<=R1<=5;#>,<R2#integer;2<=R2<=5;#>,<R3#integer;2<=R3<=4;#>,<R4#R4 = R2 * R3;#>]{<T0><F0>(){<T1#integer#><V1>=<R1>;<T1><V2> = <R4>;for(<V2> = <V2> + <V1>;<V2> != <V1>;<V2> = <V2> - <R2>){<<<V2>;}<<<V2>;}}
>
Type: output
Hardness: 40

# 671
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;50<=R2<=60;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> < <V2>;<V1> = <V1> + <V1>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

# 672
Counter.PostLoop
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>=<R2#integer;40<=R2<=50;#>;for(<V1> = <R1#2<=R1<=5;#>;<V1> <= <V2>;<V1> = <V1> + <V1>){<<<V1>;}<<<V1>;}}
>
Type: output
Hardness: 30

// ------------------------------------------------------------------------
// Counter.Multiple.Dependent ************************************ 675
//          [Up Counting]
//          [Down Counting]


// 2 loops
// UpUp - Update by 1 vs many - use first loop variable's value as second loop's start value/end value
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// ********************** Up X Up X update by 1 ********************** 
# 675
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> <= <R3#integer;7<=R3<=9;#>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 676
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;0<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;1<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Up X Update by many ********************** 
# 677
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> <= <R4#integer;20<=R4<=22;#>;<V1> = <V1> + <R5#integer;2<=R5<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 678
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;0<=R4<=2;#>;<V2> <= <V1>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Down X update by 1 ********************** 
# 679
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> >= <R1>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 680
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;4<=R2<=6;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;7<=R3<=9;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;4<=R2<=6;#>;<V1> = <V1> + 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;7<=R3<=9;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Up X Down X Update by many ********************** 
# 681
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> >= <R1>;<V1> = <V1> - <R4#integer;2<=R4<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 682
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;20<=R4<=25;#>;<V2> >= <V1>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Up X Update by 1 ********************** 
# 683
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}for(;<V1> <= <R1>;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 684
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;4<=R2<=6;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;0<=R3<=2;#>;<V2> < <V1>;<V2> = <V2> + 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> >= <R2#integer;4<=R2<=6;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;1<=R3<=2;#>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Up X Update by many ********************** 
# 685
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> <= <R1>;<V1> = <V1> + <R4#integer;2<=R4<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 686
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> >= <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;0<=R4<=2;#>;<V2> < <V1>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Down X Update by 1 ********************** 
# 687
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#7<=R1<=9;#>;<V1> > <R2#integer;3<=R2<=5;#>;<V1> = <V1> - 1){<<<V1>;}for(;<V1> >= <R3#integer;0<=R3<=2;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 80

# 688
Counter.Multiple.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;4<=R3<=6;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#3<=R1<=5;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;}<T1><V2>;for(<V2> = <R3#integer;3<=R3<=5;#>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}
>
Type: output
Hardness: 80

// ********************** Down X Down X Update by many ********************** 
# 689
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> > <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}for(;<V1> >= <R4#integer;0<=R4<=2;#>;<V1> = <V1> - <R5#integer;2<=R5<=4;#>){<<<V1>;}}}
>
Type: output
Hardness: 80

# 690
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <R4#integer;10<=R4<=12;#>;<V2> >= <V1>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80


// ********************** 3-levels ********************** 
# 691
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=5;#>;<V1> = <V1> + 1){<<<V1>;}for(;<V1> < <R3#integer;10<=R3<=12;#>;<V1> = <V1> + 2){<<<V1>;}for(;<V1> < <R4#integer;20<=R4<=25;#>;<V1> = <V1> + 3){<<<V1>;}}}
>
Type: output
Hardness: 90

# 692
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> > <R2#integer;10<=R2<=12;#>;<V1> = <V1> - 3){<<<V1>;}for(;<V1> > <R3#integer;3<=R3<=5;#>;<V1> = <V1> - 2){<<<V1>;}for(;<V1> > <R4#integer;0<=R4<=2;#>;<V1> = <V1> - 1){<<<V1>;}}}
>
Type: output
Hardness: 90

// ***************** Introduced for the benefit of Visual Basic ********************
// Trivial modification of 677
# 693
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> <= <R4#integer;20<=R4<=22;#>;<V2> = <V2> + <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 681
# 694
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - <R4#integer;2<=R4<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 685
# 695
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;1<=R2<=4;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + <R4#integer;2<=R4<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80

// Trivial modification of 689
# 696
Counter.Multiple.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;for(<V1> = <R1#20<=R1<=25;#>;<V1> >= <R2#integer;10<=R2<=12;#>;<V1> = <V1> - <R3#integer;2<=R3<=4;#>){<<<V1>;}<T1><V2>;for(<V2> = <V1>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;2<=R5<=4;#>){<<<V2>;}}}
>
Type: output
Hardness: 80


// ------------------------------------------------------------------------
// Counter.Multiple.Independent ************************************ 700
//          [Up Counting]
//          [Down Counting]


// ------------------------------------------------------------------------
// Counter.Nested.Dependent ************************************ 725
//          [Up Counting]
//          [Down Counting]


// 2 loops nested
// UpUp - Update by 1 vs many - use outside loop variable's value as inside loop's start value/end value/update value
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// Up X Up X update by 1
# 725
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 726
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Up X Update by many
# 727
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> <= <R2>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 728
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 729
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=3;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;2<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> <= <R2>;<V2> = <V2> + <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Up X Down X update by 1
# 730
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 731
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X Update by many
# 732
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 733
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <V1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 734
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#2<=R1<=4;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <V1>){<<<V2>;}}}}
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#2<=R1<=4;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Down X Up X Update by 1
# 735
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 736
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by many
# 737
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> <= <R1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 738
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <V1>;<V2> = <V2> + <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 739
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <R1>;<V2> = <V2> + <V1>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> <= <R1>;<V2> = <V2> + <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

// Down X Down X Update by 1
# 740
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> >= <R2>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 741
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by many
# 742
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <V1>;<V2> >= <R2>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 743
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <V1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 744
Counter.Nested.Dependent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <R2>;<V2> = <V2> - <V1>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R1>;<V2> >= <R2>;<V2> = <V2> - <V1>){<<<V2>;}}}}
>
Type: output
Hardness: 90

//3-levels
# 745
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R2#integer;2<=R2<=3;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V1>;<V2> < <R2>;<V2> = <V2> + 1){<<<V2>;for(<V3> = <V2>;<V3> < <R2>;<V3> = <V3> + 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R2#integer;2<=R2<=3;#>;<V1> = <V1> + 1){for(<V2> = <V1>;<V2> < <R2>;<V2> = <V2> + 1){for(<V3> = <V2>;<V3> < <R2>;<V3> = <V3> + 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

# 746
Counter.Nested.Dependent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R2#integer;0<=R2<=1;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V1>;<V2> > <R2>;<V2> = <V2> - 1){<<<V2>;for(<V3> = <V2>;<V3> > <R2>;<V3> = <V3> - 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R2#integer;0<=R2<=1;#>;<V1> = <V1> - 1){for(<V2> = <V1>;<V2> > <R2>;<V2> = <V2> - 1){for(<V3> = <V2>;<V3> > <R2>;<V3> = <V3> - 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

// ------------------------------------------------------------------------
// Counter.Nested.Independent ************************************ 750
//          [Up Counting]
//          [Down Counting]

// 2 loops nested
// UpUp - Update by 1 vs many - 2 constants for bounds, same constant for bounds, 2 variables for bounds both same
// UpDown - Update by 1 vs many
// DownUp - Update by 1 vs many
// DownDown - Update by 1 vs many

// Up X Up X update by 1
# 750
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#1<=R1<=2;#>;<V1> <= <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#1<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 751
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 752
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R2#integer;3<=R2<=4;#>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <V3>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> < <V3>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Up X Update by many
# 753
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;10<=R4<=12;#>;<V2> = <V2> + <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 754
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R2>;<V2> = <V2> + <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 755
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R2#integer;10<=R2<=12;#>;<T1><V4>=<R3#integer;3<=R3<=4;#>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <V3>;<V1> = <V1> + <V4>){<<<V1>;for(<V2> = <R4#0<=R4<=2;#>;<V2> <= <V3>;<V2> = <V2> + <V4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X update by 1
# 756
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 757
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;3<=R2<=4;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 758
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V3>;<V1> < <V4>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;1<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V3>;<V1> <= <V4>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Up X Down X Update by many
# 759
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 760
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> < <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#0<=R1<=2;#>;<V1> <= <R2#integer;10<=R2<=12;#>;<V1> = <V1> + <R3#integer;3<=R3<=4;#>){<<<V1>;for(<V2> = <R2>;<V2> >= <R1>;<V2> = <V2> - <R3>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 761
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R1>;<V4> < <V2>;<V4> = <V4> + <V3>){<<<V4>;for(<V5> = <V2>;<V5> >= <V1>;<V5> = <V5> - <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by 1
# 762
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> >= <R2#integer;1<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#1<=R3<=2;#>;<V2> <= <R4#integer;3<=R4<=5;#>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 763
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 764
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> > <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V3>;<V2> <= <V4>;<V2> = <V2> + 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Up X Update by many
# 765
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#10<=R1<=12;#>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R4#integer;10<=R4<=12;#>;<V2> = <V2> + <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 766
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#0<=R3<=2;#>;<V2> <= <R1>;<V2> = <V2> + <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 767
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R2>;<V4> > <V1>;<V4> = <V4> - <V3>){<<<V4>;for(<V5> = <V1>;<V5> <= <V2>;<V5> = <V5> + <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by 1
# 768
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 769
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#3<=R1<=4;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R3#3<=R3<=4;#>;<V2> >= <R2>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 770
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> > <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>=<R1#integer;0<=R1<=2;#>;<T1><V4>=<R2#3<=R2<=4;#>;for(<V1> = <V4>;<V1> >= <V3>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <V4>;<V2> >= <V3>;<V2> = <V2> - 1){<<<V2>;}}}}
>
Type: output
Hardness: 80

// Down X Down X Update by many
# 771
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R6#integer;3<=R6<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R4#integer;0<=R4<=2;#>;<V2> = <V2> - <R5#integer;3<=R5<=4;#>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 772
Counter.Nested.Independent
>
// {<T0><F0>(){<T1#integer#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> > <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R2>;<V2> = <V2> - <R4>){<<<V2>;}}}} - Till Fall 2007
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;for(<V1> = <R1#10<=R1<=12;#>;<V1> >= <R2#integer;0<=R2<=2;#>;<V1> = <V1> - <R4#integer;3<=R4<=4;#>){<<<V1>;for(<V2> = <R3#10<=R3<=12;#>;<V2> >= <R2>;<V2> = <V2> - <R4>){<<<V2>;}}}}
>
Type: output
Hardness: 80

# 773
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>=<R1#0<=R1<=2;#>;<T1><V2>=<R2#integer;10<=R2<=12;#>;<T1><V3>=<R3#integer;3<=R3<=4;#>;<T1><V4>;<T1><V5>;for(<V4> = <R2>;<V4> > <V1>;<V4> = <V4> - <V3>){<<<V4>;for(<V5> = <V2>;<V5> >= <V1>;<V5> = <V5> - <V3>){<<<V5>;}}}}
>
Type: output
Hardness: 80

//3-levels
# 774
Counter.Nested.Independent
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R4#integer;2<=R4<=3;#>;<V1> = <V1> + 1){<<<V1>;for(<V2> = <R2#0<=R2<=1;#>;<V2> < <R4>;<V2> = <V2> + 1){<<<V2>;for(<V3> = <R3#0<=R3<=1;#>;<V3> < <R4>;<V3> = <V3> + 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#integer#><V1>;<T1><V3>;for(<V1> = <R1#0<=R1<=1;#>;<V1> < <R4#integer;2<=R4<=3;#>;<V1> = <V1> + 1){<T1><V2>;for(<V2> = <R2#0<=R2<=1;#>;<V2> < <R4>;<V2> = <V2> + 1){for(<V3> = <R3#0<=R3<=1;#>;<V3> < <R4>;<V3> = <V3> + 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90

//3-levels
# 775
Counter.Nested.Independent
>
{<T0><F0>(){<T1#signed#><V1>;<T1><V2>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R4#integer;0<=R4<=1;#>;<V1> = <V1> - 1){<<<V1>;for(<V2> = <R2#2<=R2<=3;#>;<V2> > <R4>;<V2> = <V2> - 1){<<<V2>;for(<V3> = <R3#2<=R3<=3;#>;<V3> > <R4>;<V3> = <V3> - 1){<<<V3>;}}}}}
// {<T0><F0>(){<T1#signed#><V1>;<T1><V3>;for(<V1> = <R1#2<=R1<=3;#>;<V1> > <R4#integer;0<=R4<=1;#>;<V1> = <V1> - 1){<T1><V2>;for(<V2> = <R2#2<=R2<=3;#>;<V2> > <R4>;<V2> = <V2> - 1){for(<V3> = <R3#2<=R3<=3;#>;<V3> > <R4>;<V3> = <V3> - 1){<<<V1>;<<<V2>;<<<V3>;}}}}} // Simplified for S08
>
Type: output
Hardness: 90



// ------------------ Parsons Puzzles --------------------------------------------------------
// DESIGN PRINCIPLES:
//   Simple counting exercises

// Learning objectives:
// Counter.Parsons.Single - 2000                 
// Counter.Parsons.Multiple.Independent - 2025   
// Counter.Parsons.Multiple.Dependent - 2050     (TO DO)
// Counter.Parsons.Nested.Independent - 2075
// Counter.Parsons.Nested.Dependent - 2100       (TO DO)


// ------------------------------------------------------------------------
// Counter.Parsons.Single - 2000                 

// Instructions, Comments, Code OK - Test Distracters
# 2000
Counter.Parsons.Single
>
"It reads a number, and prints all the numbers from 1 up to that number, e.g., if it reads 5, it prints 1,2,3,4,5."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count,counter,numCounter#>;
/* Read <V1> and print from 1 up to <V1> */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 10

// Instructions, Comments, Code OK - Test Distracters
# 2001
Counter.Parsons.Single
>
"It reads a number, and prints all the numbers from that number down to 1, e.g., if it reads 5, it prints 5,4,3,2,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numStart,startNum#>;
/* Declare <V2> */
<T1><V2#count,counter,numCounter#>;
/* Read <V1> and print from <V1> down to 1 */
<< "Enter the number from which to count down";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2>-- )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 10

// Instructions, Comments, Code OK - Test Distracters
# 2002
Counter.Parsons.Single
>
"It reads a number, and prints all the odd numbers from 1 up to that number, e.g., if it reads 8, it prints 1,3,5,7."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numLimit,limitNum#>;
/* Declare <V2> */
<T1><V2#oddNum,oddCounter,counterOdd#>;
/* Read <V1> and print odd numbers from 1 up to <V1> */
<< "Enter the number up to which to print odd numbers";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2> += 2 )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 20

// Instructions, Comments, Code OK - Test Distracters
# 2003
Counter.Parsons.Single
>
"It reads a number, and prints every third number from that number down to 1, e.g., if it reads 10, it prints 10,7,3,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#signed#><V1#number,numInitial,initNum#>;
/* Declare <V2> */
<T1><V2#thirdNum,thirdCounter,counterThird#>;
/* Read <V1> and print every third number from <V1> down to 1 */
<< "Enter the number down from which to print every third number";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2> -= 3 )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 20

// // THIS IS INCORRECT! FIX IT!!
// # 2004
// Counter.Parsons.Single
// >
// "It reads a number, repeatedly divides it by 2 and prints it, e.g., if it reads 13, it prints 6,3,1,0."
// {<T0><F0>(){
// /* Declare <V1> */
// <T1#integer#><V1#number,numFirst,firstNum#>;
// /* Declare <V2> */
// <T1><V2#halfNum,halfCounter,counterHalf#>;
// /* Read <V1> and print <V1> after repeatedly dividing it by 2 */
// << "Enter the number that should be printed repeatedly divided by 2";
// >> <V1>;
// for( <V2> = <V1>; <V2> >= 0; <V2> /= 2 )
// {
// << <V2>;
// }
// }}
// >
// Type: parsons
// Hardness: 30







// Instrn, Comments, Code - OK;  Test Distracters
// DemoParsons
// Reads a number, calculates it factorial and prints it
# 2010
Counter.Parsons.Single
>
"It reads a number, calculates its factorial and prints it, e.g., if it reads 4, it prints 24, which is the product of 4,3,2 and 1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#count,counter,numCounter#>;
/* Declare <V3> */
<T1><V3#factorial,numFactorial,factorialNum#>;
/* Read <V1> */
<< "Enter the number whose factorial is desired";
>> <V1>;
/* Compute factorial of <V1> in <V3> and print it*/
<V3> = 1;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
<V3> = <V3> * <V2>;
}
<< "Factorial of " << <V1> << " is " << <V3>;
}}
>
Type: parsons
Hardness: 20

// Instrn, Comments, Code - OK;  Test Distracters
// pretest
// Read TWO numbers, calculates the sum of all the numbers between them and print it
# 2011
Counter.Parsons.Single
>
"It reads two numbers, calculates the sum of all the numbers between the two and prints it, e.g., if it reads 4 and 7, it prints 22, which is the sum of 4,5,6 and 7."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#start,startNum,numStart#>;
/* Declare <V2> */
<T1#integer#><V2#end,endNum,numEnd#>;
/* Declare <V3> */
<T1><V3#count,counter,numCounter#>;
/* Declare <V4> */
<T1><V4#sum,numSum,sumNum#>;
/* Read <V1> */
<< "Enter the strating number";
>> <V1>;
/* Read <V2> */
<< "Enter the ending number";
>> <V2>;
/* Compute the sum of <V1> through <V2> in <V4> and print it*/
<V4> = 0;
for( <V3> = <V1>; <V3> <= <V2>; <V3>++ )
{
<V4> = <V4> + <V3>;
}
<< "The sum of " << <V1> << " through " << <V2> << " is " << <V4>;
}}
>
Type: parsons
Hardness: 30

// Instrn, Comments, Code - OK;  Test Distracters
// posttest
# 2012
Counter.Parsons.Single
>
"It reads a base number and a power, calculates the base raised to the power and prints it, e.g., if it reads 3 as base number and 2 as power, it prints 9, which is 3 squared."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#base,baseNum,numBase#>;
/* Declare <V2> */
<T1><V2#power,powerNum,numPower#>;
/* Declare <V3> */
<T1><V3#count,counter,numCounter#>;
/* Declare <V4> */
<T1><V4#result,numResult,resultNum#>;
/* Read <V1> */
<< "Enter the base number";
>> <V1>;
/* Read <V2> */
<< "Enter the power";
>> <V2>;
/* Compute <V1> raised to <V2> in <V4> and print it */
<V4> = 1;
for( <V3> = 1; <V3> <= <V2>; <V3>++ )
{
<V4> = <V4> * <V1>;
}
<< <V1> << " raised to " << <V2> << " is " << <V4>;
}}
>
Type: parsons
Hardness: 30

// Instrn, Comments, Code - OK;  Test Distracters
# 2013
Counter.Parsons.Single
>
"It reads a number n, computes nth Fibonacci number and prints it. The first two Fibonacci numbers are 1 and 1. Each subsequent Fibonacci number is the sum of the previous two Fibonacci numbers, e.g., 3rd number is 2 (1+1), 4th number is 3 (1+2) and 5th number is 5 (2+3)."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numInput,inputNum#>;
/* Declare <V2> */
<T1><V2#previous,previousNum,numPrevious#>;
/* Declare <V3> */
<T1><V3#current,currentNum,numCurrent#>;
/* Declare <V4> */
<T1><V4#count,counter,numCounter#>;
/* Declare <V5> */
<T1><V5#sum,sumNum,numSum#>;
/* Read <V1> */
<< "Enter the Fibonacci number desired";
>> <V1>;
/* Compute <V1>-th Fibonacci number in <V3> and print it */
<V2> = 1;
<V3> = 1;
for( <V4> = 3; <V4> <= <V1>; <V4>++ )
{
<V5> = <V2> + <V3>;
<V2> = <V3>;
<V3> = <V5>;
}
<< "Fibonacci number " << <V1> << " is " << <V3>;
}}
>
Type: parsons
Hardness: 30

// Instrn, Comments, Code - OK;  Test Distracters
// Read a week's temperatures, calculate average and print it
# 2014
Counter.Parsons.Single
>
"It reads the number of days, reads daily temperatures for those many days, calculates the average temperature and prints it."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#days,numDays,daysNum#>;
/* Declare <V2> */
<T2#real#><V2#temperature,inputTemp,tempInput#>;
/* Declare <V3> */
<T2><V3#sum,tempSum,sumTemp#>;
/* Declare <V4> */
<T1><V4#count,counter,countNum#>;
/* Read <V1> */
<< "Enter the number of days";
>> <V1>;
/* Read temperatures for all days, calculate average temperature and print it */
<V3> = 0;
for( <V4> = 1; <V4> <= <V1>; <V4>++ )
{
<< "Enter the temperature for day " << <V4>;
>> <V2>;
<V3> = <V3> + <V2>;
}
<< "Average temperature of " << <V1> << " days is " << <V3> / <V1>;
}}
>
Type: parsons
Hardness: 20

// Instrn, Comments, Code - OK;  Test Distracters
// Conversion from a different  base to base 10
# 2015
Counter.Parsons.Single
>
"It converts a number from a given base to decimal, e.g., 110 in base 2 is 6 in decimal. It first reads the base (e.g., 2) and the number of digits in the number (110 has 3). Then, it reads the number (110) one digit at a time, converts it to decimal (6) and prints it."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#baseVal,numBase,baseNum#>;
/* Declare <V2> */
<T1><V2#totalDigits,numDigits,digitNum#>;
/* Declare <V3> */
<T1><V3#oneDigit,nextDigit,digitNext#>;
/* Declare <V4> */
<T1><V4#decimal,decimalNum,numDecimal#>;
/* Declare <V5> */
<T1><V5#count,counter,countNum#>;
/* Read <V1> */
<< "Enter the base";
>> <V1>;
/* Read <V2> */
<< "Enter the number of digits in the number";
>> <V2>;
/* Read the number one digit at a time, convert it to decimal and print it */
<V4> = 0;
for( <V5> = 1; <V5> <= <V2>; <V5>++ )
{
<< "Enter the next digit in the number";
>> <V3>;
<V4> = <V4> * <V1> + <V3>;
}
<< "The number you entered in base " << <V1> << " is " << <V4>;
}}
>
Type: parsons
Hardness: 20

// Could do conversion from decimal to another base, but the digits would be in reverse order.

// Weighted sum?
// weighted average : sigma wx / sigma x

// calculation of pi = 4/1 - 4/3 + 4/5 - 4/7 + 4/9 - ...

// calculation of e = 1/1 + 1/1 + 1/2 + 1/6 + 1/24 + 1/120 + ...
//   SImilarly, e^x





// ------------------------------------------------------------------------
// Counter.Parsons.Multiple.Independent - 2025


// ------------------------------------------------------------------------
// Counter.Parsons.Multiple.Dependent - 2050     (TO DO)
// DESIGN: Use accumulator of inputs as counter?

// Reads a number, prints that many odd numbers from 1 up, followed by even numbers back down to 0.

// TO DO All odds followed by all evens

// TO DO 10th power followed by 12th power?


// Instrn, Comments, Code - OK;  Test Distracters
# 2050
Counter.Parsons.Multiple.Dependent
>
"It reads a number, and prints all the numbers from 1 up to that number, followed by all the numbers back down to 1, e.g., if it reads 4, it prints 1,2,3,4,3,2,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count,counter,numCounter#>;
/* Read <V1> and print from 1 up to <V1> and back down to 1 */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> < <V1>; <V2>++ )
{
<< <V2>;
}
<< <V2>;
for( <V2> = <V2> - 1; <V2> >= 1; <V2>-- )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
# 2051
Counter.Parsons.Multiple.Dependent
>
"It reads a number, and prints all the numbers from that number down to 1, followed by all the numbers back up to that number, e.g., if it reads 4, it prints 4,3,2,1,2,3,4."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count,counter,numCounter#>;
/* Read <V1> and print from <V1> down to 1 and back up to <V1> */
<< "Enter the number from which to count";
>> <V1>;
for( <V2> = <V1>; <V2> > 1; <V2>-- )
{
<< <V2>;
}
<< <V2>;
for( <V2> = <V2> + 1; <V2> <= <V1>; <V2>++ )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 10



// Instrn, Comments, Code - OK;  Test Distracters
// Calculate m^n / n^m for 2 whole real numbers m and n
# 2055
Counter.Parsons.Multiple.Dependent
>
"It reads two real numbers m and n, calculates and prints m^n / n^m, where m^n means m raised to the power n, e.g., 5 raised to the power 2 is 25.  So, if it reads 2 and 5, it calculates 2^5 / 5^2, i.e., 32 / 25 and prints it."
{<T0><F0>(){
/* Declare <V1> */
<T1#real#><V1#number1,numFirst,firstNum#>;
/* Declare <V2> */
<T1><V2#number2,numSecond,secondNum#>;
/* Declare <V3> */
<T1><V3#result,numResult,resultNum#>;
/* Declare <V4> */
<T1><V4#counter,numCounter,counterNum#>;
/* Read <V1> */
<< "Enter the first number";
>> <V1>;
/* Read <V2> */
<< "Enter the second number";
>> <V2>;
/* Compute and print <V1> raised to <V2> / <V2> raised to <V1> */
<V3> = 1;
for( <V4> = 1; <V4> <= <V2>; <V4>++ )
{
<V3> = <V3> * <V1>;
}
for( <V4> = 1; <V4> <= <V1>; <V4>++ )
{
<V3> = <V3> / <V2>;
}
<< <V3>;
}}
>
Type: parsons
Hardness: 20

// DemoParsons
// Instrn, Comments, Code - OK;  Test Distracters
// n choose k = (n * n-1 * ... * n - k + 1)/ k!
# 2056
Counter.Parsons.Multiple.Dependent
>
"It reads two integers n and k, and computes and prints the number of ways k items can be chosen from among n items, given by n * (n - 1) * ... * (n - k + 1 ) / k!, where k! = k * (k - 1) * ... * 1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#total,numTotal,totalNum#>;
/* Declare <V2> */
<T1><V2#select,numSelect,selectNum#>;
/* Declare <V3> */
<T1><V3#result,numResult,resultNum#>;
/* Declare <V4> */
<T1><V4#counter,numCounter,counterNum#>;
/* Read <V1> */
<< "Enter the total number of items available";
>> <V1>;
/* Read <V2> */
<< "Enter the number of items to be selected";
>> <V2>;
/* Compute ways to choose <V2> items out of <V1> in <V3> and print it */
<V3> = 1;
for( <V4> = <V1>; <V4> >= <V1> - <V2> + 1; <V4>-- )
{
<V3> = <V3> * <V4>;
}
for( <V4> = 2; <V4> <= <V2>; <V4>++ )
{
<V3> = <V3> / <V4>;
}
<< <V3>;
}}
>
Type: parsons
Hardness: 20

// Instrn, Comments, Code - OK;  Test Distracters
// e^x is Sigma 0->Inf x^n / n!  We calculate one term
# 2057
Counter.Parsons.Multiple.Dependent
>
"It reads a real number x and an integer n, and computes and prints x^n / n!, where x^n is x raised to the power n and n! is n factorial, i.e., n * (n - 1) *...*  1. x^n / n! is one term used in the calculation of e^x."
{<T0><F0>(){
/* Declare <V1> */
<T1#real#><V1#real,numReal,realNum#>;
/* Declare <V2> */
<T2#integer#><V2#integer,numInteger,integerNum#>;
/* Declare <V3> */
<T1><V3#result,numResult,resultNum#>;
/* Declare <V4> */
<T2><V4#counter,numCounter,counterNum#>;
/* Read <V1> */
<< "Enter the real number";
>> <V1>;
/* Read <V2> */
<< "Enter the integer number";
>> <V2>;
/* Compute <V1> raised to <V2> / <V2> ! in <V3> and print it */
<V3> = 1;
for( <V4> = 1; <V4> <= <V2>; <V4>++ )
{
<V3> = <V3> * <V1>;
}
for( <V4> = 2; <V4> <= <V2>; <V4>++ )
{
<V3> = <V3> / <V4>;
}
<< <V3>;
}}
>
Type: parsons
Hardness: 20

// Pretest
// Instrn, Comments, Code - OK;  Test Distracters
// read income for 12 months followed by expenses
# 2060
Counter.Parsons.Multiple.Dependent
>
"It reads the monthly income for a year, prints their sum, reads the monthly expenses for the year, and prints money left over after expenses."
{<T0><F0>(){
/* Declare <V1> */
<T1#real#><V1#amount,numAmount,amountNum#>;
/* Declare <V2> */
<T1><V2#balance,numBalance,balanceNum#>;
/* Declare <V3> */
<T2#integer#><V3#counter,numCounter,counterNum#>;
/* Read monthly income into <V1>, print sum in <V2> */
<V2> = 0;
for( <V3> = 1; <V3> <= 12; <V3>++ )
{
<< "Please enter the income for month " << <V3>;
>> <V1>;
<V2> = <V2> + <V1>;
}
<< "Sum of monthly income is $ " << <V2>;
/* Read monthly expenses into <V1>, print balance in <V2> after expenses */
for( <V3> = 1; <V3> <= 12; <V3>++ )
{
<< "Please enter the expenses for month " << <V3>;
>> <V1>;
<V2> = <V2> - <V1>;
}
<< "Balance after expenses is $ " << <V2>;
}}
>
Type: parsons
Hardness: 15

// Posttest
// Instrn, Comments, Code - OK;  Test Distracters
// read for a week for a basket of 30 stocks - appreciation percentage.. sum followed by appreciation
# 2061
Counter.Parsons.Multiple.Dependent
>
"It reads the price of 30 stocks in Dow Jones index and calculates their average. It then reads the percentage change in the average each day for a week and prints the value of the average at the end of the week."
{<T0><F0>(){
/* Declare <V1> */
<T1#real#><V1#price,numPrice,priceNum#>;
/* Declare <V2> */
<T1><V2#sum,numSum,sumNum#>;
/* Declare <V3> */
<T1><V3#average,numAverage,averageNum#>;
/* Declare <V4> */
<T1><V4#percent,numPercent,percentNum#>;
/* Declare <V5> */
<T2#integer#><V5#counter,numCounter,counterNum#>;
/* Read price of 30 stocks into <V1>, calculate their average in <V3> */
<V2> = 0;
for( <V5> = 1; <V5> <= 30; <V5>++ )
{
<< "Please enter the price of the next stock";
>> <V1>;
<V2> = <V2> + <V1>;
}
<V3> = <V2> / 30;
/* Read daily percentage change in <V4>. Print <V3> at the end of the week. */
for( <V5> = 1; <V5> <= 7; <V5>++ )
{
<< "Please enter the percentage change for day " << <V5>;
>> <V4>;
<V3> = <V3> + <V3> * <V4>;
}
<< "Value of 30 stocks at the end of the week is $ " << <V3>;
}}
>
Type: parsons
Hardness: 15

// Instrn, Comments, Code - OK;  Test Distracters
// Calculate the average of the monthly temperatures of the first year, and then
//  calculate the variance of the monthly temperatures of the next year
# 2062
Counter.Parsons.Multiple.Dependent
>
"It reads the daily temperature for a week, calculates the average temperature of the week. It reads the daily temperature of the next week and calculates and prints its variance from the average of the first week."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#temperature,numTemp,tempNum#>;
/* Declare <V2> */
<T1><V2#sum,numSum,sumNum#>;
/* Declare <V3> */
<T2#real#><V3#average,numAverage,averageNum#>;
/* Declare <V4> */
<T2><V4#variance,numVariance,varianceNum#>;
/* Declare <V5> */
<T1><V5#counter,numCounter,counterNum#>;
/* Read daily temperature into <V1>, calculate its average in <V3> */
<V2> = 0;
for( <V5> = 1; <V5> <= 7; <V5>++ )
{
<< "Please enter the temperature on week 1, day " << <V5>;
>> <V1>;
<V2> = <V2> + <V1>;
}
<V3> = <V2> / 7.0;
/* Read next week's daily temperature into <V1>, calculate its variance in <V4> and print it */
<V4> = 0;
for( <V5> = 1; <V5> <= 7; <V5>++ )
{
<< "Please enter the temperature on week 2, day " << <V5>;
>> <V1>;
<V4> = <V4> + ( <V1> - <V3> ) * ( <V1> - <V3> ) ;
}
<V4> = <V4> / 6;
<< "Variance of second week temperatures is " << <V4>;
}}
>
Type: parsons
Hardness: 15



// Used to test single character variable name effectiveness, same as 2060
// read income for 12 months followed by expenses
# 2073
Counter.Parsons.Multiple.Dependent
>
"It reads the monthly income for a year, prints their sum, reads the monthly expenses for the year, and prints money left over after expenses."
{<T0><F0>(){
/* Declare <V1> */
<T1#real#><V1#x,y,z#>;
/* Declare <V2> */
<T1><V2#p,q,r#>;
/* Declare <V3> */
<T2#integer#><V3#a,b,c#>;
/* Read monthly income into <V1>, print sum in <V2> */
<V2> = 0;
for( <V3> = 1; <V3> <= 12; <V3>++ )
{
<< "Please enter the income for month " << <V3>;
>> <V1>;
<V2> = <V2> + <V1>;
}
<< "Sum of monthly income is $ " << <V2>;
/* Read monthly expenses into <V1>, print balance in <V2> after expenses */
for( <V3> = 1; <V3> <= 12; <V3>++ )
{
<< "Please enter the expenses for month " << <V3>;
>> <V1>;
<V2> = <V2> - <V1>;
}
<< "Balance after expenses is $ " << <V2>;
}}
>
Type: parsons
Hardness: 15

// Used to test single character variable name effectiveness, same as 2050
# 2074
Counter.Parsons.Multiple.Dependent
>
"It reads a number, and prints all the numbers from 1 up to that number, followed by all the numbers back down to 1, e.g., if it reads 4, it prints 1,2,3,4,3,2,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#x,y,z#>;
/* Declare <V2> */
<T1><V2#p,q,r#>;
/* Read <V1> and print from 1 up to <V1> and back down to 1 */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> < <V1>; <V2>++ )
{
<< <V2>;
}
<< <V2>;
for( <V2> = <V2> - 1; <V2> >= 1; <V2>-- )
{
<< <V2>;
}
}}
>
Type: parsons
Hardness: 10


// ------------------------------------------------------------------------
// Counter.Parsons.Nested.Independent - 2075


// print multiplication table

// draw a rectangle

// ------------------------------------------------------------------------
// Counter.Parsons.Nested.Dependent - 2100       

// For m < n, m > n

// TO DO for m..n, count up from 1

// TO DO for m..n, count up from m-n

// TO DO for m..n, count down from m to 1

// TO DO for m..n, count down from n to m

// TO DO for m..n, print m m times, m+1 m+1 times, and so on.

// draw triangle - upside down - need endl
// draw triangle - right side up - need endl

// Instrn, Comments, Code - OK;  Test Distracters
// DemoParsons
// up-up
# 2100
Counter.Parsons.Nested.Dependent
>
"It reads a number, and prints all the numbers from 1 up to that number in the following fashion: 1 once, 2 twice, 3 three times and so on, e.g., if it reads 3, it prints 1,2,2,3,3,3."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, print 1 once, up to <V1> <V1> times */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
  for( <V3> = 1; <V3> <= <V2>; <V3>++ )
  {
    << <V2>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// down-up
# 2101
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and prints all the numbers from 1 up to n, n-1, n-2 and so on till 1, e.g., if it reads 4, it prints 1,2,3,4,1,2,3,1,2,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, Count up to <V1>, <V1> - 1 and so on */
<< "Enter the starting number up to which to count";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2>-- )
{
  for( <V3> = 1; <V3> <= <V2>; <V3>++ )
  {
    << <V3>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// pretest
// down-up
# 2102
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and for each number from n down to 1, it prints all its multiples up to its square, e.g., if it reads 4, it prints 4,8,12,16,3,6,9,2,4,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, Print all multiples up to its square for <V1> down to 1 */
<< "Enter the starting number whose multiples must be printed";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2>-- )
{
  for( <V3> = 1; <V3> <= <V2>; <V3>++ )
  {
    << <V2> * <V3>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// down-up
# 2103
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and prints all the numbers from n down to 1, following each number with as many zeroes, e.g., if it reads 3, it prints 3,0,0,0,2,0,0,1,0."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, Print <V1> down to 1, each followed by as many zeroes */
<< "Enter the number from which to count down";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2>-- )
{
  << <V2>;
  for( <V3> = 1; <V3> <= <V2>; <V3>++ )
  {
    << 0;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// up-down
# 2104
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and prints all the numbers from 1 up to n in the following fashion: 1 n-times, 2 n-1 times, 3 n-2 times, and so on till it prints n once, e.g., if it reads 3, it prints 1,1,1,2,2,3."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, print 1 <V1> times down to <V1> once */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
  for( <V3> = <V1>; <V3> >= <V2>; <V3>-- )
  {
    << <V2>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// down-down
# 2105
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and prints all the numbers down to 1 from n, n-1, n-2 and so on, e.g., if it reads 4, it prints 4,3,2,1,3,2,1,2,1,1."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, Count down from <V1>, <V1> - 1 and so on */
<< "Enter the starting number from which to count down";
>> <V1>;
for( <V2> = <V1>; <V2> >= 1; <V2>-- )
{
  for( <V3> = <V2>; <V3> >= 1; <V3>-- )
  {
    << <V3>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Instrn, Comments, Code - OK;  Test Distracters
// posttest
// up-up
# 2106
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and for each number from 1 up to n, it prints all its multiples up to its square, e.g., if it reads 4, it prints 1,2,4,3,6,9,4,8,12,16."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#number,numFinal,finalNum#>;
/* Declare <V2> */
<T1><V2#count1,counter1,loopCounter1#>;
/* Declare <V3> */
<T1><V3#count2,counter2,loopCounter2#>;
/* Read <V1>, Print all multiples up to its square for 1 up to <V1> */
<< "Enter the last number whose multiples must be printed";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
  for( <V3> = 1; <V3> <= <V2>; <V3>++ )
  {
    << <V2> * <V3>;
  }
}
}}
>
Type: parsons
Hardness: 10

// Used to test effectiveness of single character variables, same as 2104
# 2124
Counter.Parsons.Nested.Dependent
>
"It reads a number, say n, and prints all the numbers from 1 up to n in the following fashion: 1 n-times, 2 n-1 times, 3 n-2 times, and so on till it prints n once, e.g., if it reads 3, it prints 1,1,1,2,2,3."
{<T0><F0>(){
/* Declare <V1> */
<T1#integer#><V1#x,y,z#>;
/* Declare <V2> */
<T1><V2#p,q,r#>;
/* Declare <V3> */
<T1><V3#a,b,c#>;
/* Read <V1>, print 1 <V1> times down to <V1> once */
<< "Enter the number up to which to count";
>> <V1>;
for( <V2> = 1; <V2> <= <V1>; <V2>++ )
{
  for( <V3> = <V1>; <V3> >= <V2>; <V3>-- )
  {
    << <V2>;
  }
}
}}
>
Type: parsons
Hardness: 10

// --------------------------------------------------------------------------
// Templates here are for demonstration purposes
// Included at the end so that regular practice does not pick up these templates

// How to enter 2 outputs
# 90
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>=<R1#1<=R1<=5;#>;<<<V1>;<T1><V2>=<R2#integer;6<=R2<=10;#>;<<<V2>;<< <V2> - <V1>;}}
>
Type: output
Hardness: 10

// How to enter multiple outputs from the same line
# 91
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;for(<V1> = 1;<V1> <= 2;<V1> = <V1> + 1){<<<V1>;}}}
>
Type: output
Hardness: 10

// How to enter multiple outputs from alternate lines
# 92
Demonstration
>
{<T0><F0>(){<T1#integer#><V1>;<T1><V2>;<V2> = 5;for(<V1> = 1;<V1> <= 2;<V1> = <V1> + 1){<<<V1>;<<<V2>;}}}
>
Type: output
Hardness: 10
// --------------------------------------------------------------------------