## 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;
```