## Chapter 1: Introduction

The following subprograms are implementations of the Inventing an Algorithm examples.

### To Lower

The Ada example code does not append to the array as the algorithms. Instead we create an empty array of the desired length and then replace the characters inside.

```  .mw-parser-output .ada-kw{background:none;border:none;padding:0;margin:0;color:DodgerBlue;font-weight:bold}.mw-parser-output .ada-kw a,.mw-parser-output .ada-kw a:visited{color:inherit}`function` To_Lower (C : Character) `return` Character `renames`

--  tolower - translates all alphabetic, uppercase characters
--  in str to lowercase
`function` To_Lower (Str : String) `return` String `is`
Result : String (Str'Range);
`begin`
`for` C `in`  Str'Range `loop`
Result (C) := To_Lower (Str (C));
`end` `loop`;
`return` Result;
`end` To_Lower;
```

Would the append approach be impossible with Ada? No, but it would be significantly more complex and slower.

### Equal Ignore Case

```  --  equal-ignore-case -- returns true if s or t are equal,
--  ignoring case
`function` Equal_Ignore_Case
(S    : String;
T    : String)
`return` Boolean
`is`
O : `constant` Integer := S'First - T'First;
`begin`
`if` T'Length /= S'Length `then`
`return` False;  --  if they aren't the same length, they
--  aren't equal
`else`
`for` I `in`  S'Range `loop`
`if` To_Lower (S (I)) /=
To_Lower (T (I + O))
`then`
`return` False;
`end` `if`;
`end` `loop`;
`end` `if`;
`return` True;
`end` Equal_Ignore_Case;
```