answer:Here is a Python class titled SurfaceArea to calculate the surface area of three types of 3D polyhedra: cubes, spheres, and cylinders.```pythonimport mathclass SurfaceArea: def __init__(self): self.area = 0 def cube(self, side): self.area = 6 * side 2 return self.area def sphere(self, radius): self.area = 4 * math.pi * radius 2 return self.area def cylinder(self, radius, height): self.area = 2 * math.pi * radius * (radius + height) return self.area```In this class, there are three methods to calculate the surface area of each type of 3D polyhedra. After initializing an object of this class, you can call said methods with appropriate arguments to calculate surface areas. Here is a usage example:```pythonsa = SurfaceArea()print(sa.cube(3)) # prints 54print(sa.sphere(2)) # prints approximately 50.27print(sa.cylinder(2, 3)) # prints approximately 62.83```This class could be extended to include more 3D figures if needed. Just add an appropriate method following the given pattern for each new figure.

answer:On many Linux distributions, the temporary directory is usually /tmp or /var/tmp. However, for a more platform-agnostic solution, it is generally preferred to use an environment variable TMPDIR, as this can be set by the user, and various distributions might have different preferred locations for the temporary directory.Here's a way to access the temporary directory in a way that would be reasonable consistent across Unix-like systems including Linux, using C++:```cpp#include <cstdlib>std::string temp_dir(){ const char* dir = getenv("TMPDIR"); if (dir) return std::string(dir); return "/tmp";}```This will query the environment variable "TMPDIR", and if it's not set, will default to "/tmp". This way you will allow users to override the location of the temporary directory, while still providing a reasonable default. Note that this function returns `/tmp` if `TMPDIR` is not set, which is usually the default on many Unix-like systems, but if you want to make your application more portable across different types of Unix-like systems, you might want to make sure that `/tmp` exists and is writable.

answer:Here is a Python solution:```pythondef even_numbers(N, M): count = 0 sum_digits = 0 for i in range(1, N+1): if i % 10 <= M: count+= 1 sum_digits += sum(int(x) for x in str(i)[:-1]) return (count, sum_digits)#Exampleprint(even_numbers(30, 7)) # (18, 24)```This program works by iterating through every number from 1 to N (inclusive) and checking if the last digit of each number (obtained by calculating the remainder when the number is divided by 10) is less than or equal to M. If it is, we increase the count of matching numbers and add the sum of digits excluding the last digit to our running total. This is done by converting the number to a string, taking a slice to exclude the last digit, converting each digit back to an integer, and summing them. The results are returned as a tuple.

answer:To solve the problem, we can use C++ OOP (Object Oriented Programming) to create a class called Tetrahedron. Since the surface area of a tetrahedron is sqrt(3) * side ^2, we'd need the side length as an instance variable.However, n-dimensional tetrahedrons (specifically, 4-dimensional ones, also known as Simplexes) have a bit more complex calculation, so we can separate that into a different class for inheritence. The volume of n-dimensional tetrahedron requires factorial calculation, so we can also implement a factorial function.Please note that any n-dimensional tetrahedron (n>3) does not make geometrical sense in our universe. Here is code skeleton.```cpp#include<iostream>#include<cmath>using namespace std;class Tetrahedron {protected: double side;public: Tetrahedron(double side = 1){ if(side <= 0){ cout << "Invalid Input. Side length must be positive." << endl; exit(0); } this->side = side; } double surfaceArea(){ return sqrt(3)*pow(side,2); }};class nDimensionalTetrahedron : public Tetrahedron{public: nDimensionalTetrahedron(double side = 1) : Tetrahedron(side) {} double factorial(int num){ if(num == 0 || num == 1) return 1; return num*factorial(num-1); } double volumeNdimension(int n){ if(n <= 0){ cout << "Dimension must be a positive integer" << endl; exit(0); } return pow(side,n) / (factorial(n) * pow(n,n/2)); }};int main(){ Tetrahedron t(5); cout << "Surface Area of Tetrahedron: " << t.surfaceArea() << endl; nDimensionalTetrahedron nt(5); cout << "Volume of 4-Dimensional Tetrahedron: " << nt.volumeNdimension(4) << endl; return 0;}```The above code would calculate the volume of 4-dimensional tetrahedron. Note that there is no surface area for a 4-dimensional tetrahedron in our 3-dimensional space. But you can calculate its "hyper-volume" using the method `volumeNdimension`.Please ensure to provide a valid positive number as side length. A zero or negative number as side length or dimension is invalid as per the error handling in the code.

answer:Here's a Python code using collection's `Counter` to solve your problem:```Pythonfrom collections import Counterimport redef find_most_frequent_special_char(input_string): char_counts = Counter(re.sub(r'w|s', '', input_string)) max_count = max(char_counts.values()) most_frequent_chars = {c: counts for c, counts in char_counts.items() if counts == max_count} return most_frequent_charsinput_string = "I love apples! I love oranges??"frequent_chars = find_most_frequent_special_char(input_string)print(f"The most frequent non-whitespace and non-alphanumeric characters are:")for char, count in frequent_chars.items(): print(f"Character: {char}, Frequency: {count}")```Here's what the code does:1. It removes alphanumeric characters and whitespaces from the string using a regular expression, leaving only the special characters.2. It then counts the occurrence of each special character using the `Counter` class from the `collections` library.3. It finds the frequency of the most common special character.4. Lastly, it creates and returns a dictionary containing all the special characters with the highest frequency. In the case of your provided string, it will return two special characters "?" and "!" both with a frequency of 2.

answer:Here is a Python program to do that.```Pythonmydict = {'apple': ['banana', 'cherry', 'apple'], 'orange': ['kiwi', 'orange', 'lemon'], 'grape': ['grape', 'mango']}count = 0common_keys_values = []for key, values in mydict.items(): count += 1 for value in values: count += 1 if key == value: common_keys_values.append(key)print('Total keys and values:', count)print('Common keys and values:', common_keys_values)```This program iterates over the dictionary items. For each item, it increments a count for the key and then iterates over the values in the list, incrementing the count for each value. It also checks if the key is the same as the value and if so, adds it to a list of common keys and values. At the end, it prints the total count and the list of common keys and values.