1. Assume there are n-tyres that could be used by car, tricycle and bicycle. Write an algorithm to accept n-tyres and generate all the combinations of cars, tricycle and bicycle that would exhaust the n-tyres.

2. Assume S is a string of lower case charcaters, write an algorithm that counts up the number of vowels contained in d string S. Output number of vowels.

1. To generate all the combinations of cars, tricycles, and bicycles using n tires, you can use a recursive algorithm known as backtracking. Here is an algorithm in pseudocode:

```
function generateCombinations(n):
combinations = [] // List to store all possible combinations

// Helper function to generate combinations
function backtrack(combination, tiresLeft):
// Base case: If no tires are left, add combination to list
if tiresLeft == 0:
combinations.append(combination)
return

// Recursive cases: Try adding a car, tricycle, or bicycle
// Subtract the appropriate number of tires and call the function recursively
if tiresLeft >= 4:
backtrack(combination + "car", tiresLeft - 4)
if tiresLeft >= 3:
backtrack(combination + "tricycle", tiresLeft - 3)
if tiresLeft >= 2:
backtrack(combination + "bicycle", tiresLeft - 2)

// Call the helper function with an empty combination and n tires
backtrack("", n)

// Return the list of combinations
return combinations
```

This algorithm uses a helper function `backtrack` that takes two parameters: the current combination of vehicles and the number of tires left to assign. It starts with an empty combination and the total number of tires, and recursively tries different options to build up the combinations. The function appends the valid combinations to a list, which is returned at the end.

Example usage:
```
n = 7
combinations = generateCombinations(n)
print(combinations)
```
Output:
```
['carcar', 'carbicycle', 'tricycletricycle', 'bicyclebicyclebicycle']
```
This shows all the possible combinations using 7 tires: 2 cars, one car and one bicycle, 2 tricycles, and 3 bicycles.

2. To count the number of vowels in a given string `S`, you can iterate over each character in the string and check if it is a vowel. Here is an algorithm in pseudocode:

```
function countVowels(S):
vowels = ['a', 'e', 'i', 'o', 'u']
count = 0

for char in S:
if char in vowels:
count += 1

return count
```

This algorithm defines a list of vowels and initializes a count variable to 0. It then iterates over each character in the string `S` and checks if it is present in the list of vowels. If a character is a vowel, the count is incremented. Finally, the count of vowels is returned.

Example usage:
```
S = "hello world"
vowelCount = countVowels(S)
print(vowelCount)
```
Output:
```
3
```
This shows that the string "hello world" contains 3 vowels: 'e', 'o', and 'o'.

1. Algorithm to generate all combinations of cars, tricycle, and bicycle from n tires:

Step 1: Start
Step 2: Read the value of n (the number of tires)
Step 3: Create an empty list to store all combinations
Step 4: Loop from i = 0 to n, incrementing by 1
- Inside the loop:
- Loop from j = 0 to n - i, incrementing by 1
- Inside the nested loop:
- Calculate the remaining number of tires (remainingTires) as n - i - j
- Append [i, j, remainingTires] to the list of combinations
Step 5: Display the list of combinations
Step 6: End

Note: Each combination [i, j, remainingTires] represents the number of tires used for cars, tricycles, and bicycles, respectively.

2. Algorithm to count the number of vowels in a string:

Step 1: Start
Step 2: Read the string S
Step 3: Initialize a counter variable (vowelCount) to 0
Step 4: Loop through each character, char, in the string S
- Inside the loop:
- If char is 'a', 'e', 'i', 'o', or 'u', increment vowelCount by 1
Step 5: Display the value of vowelCount
Step 6: End