# Aug 27, 2018

## Python

### dictionary `get()` Method

The method `get()` returns a value for the given key. If key is not available then returns default value `None`.

```python
dict.get(key, default = None)
```

* **key** − This is the `Key` to be searched in the dictionary.
* **default** − This is the `Value` to be returned in case key does not exist.

```python
dict = {'Name': 'Zabra', 'Age': 7}
print "Value : %s" %  dict.get('Age')
print "Value : %s" %  dict.get('Education', "Never")
```

```
Output:

Value : 7
Value : Never
```

## C++

### `abs()`

Returns the absolute value of parameter `n` .

```cpp
/* abs example */
#include <stdio.h>      /* printf */
#include <stdlib.h>     /* abs */

int main ()
{
  int n,m;
  n=abs(23);
  m=abs(-11);
  printf ("n=%d\n",n);
  printf ("m=%d\n",m);
  return 0;
}
```

```
Output

n=23
m=11
```

### `std::tolower(charT c, const locale& loc)`

Converts parameter `c` to its lowercase equivalent if `c` is an uppercase letter and has a lowercase equivalent, as determined by the [ctype](http://www.cplusplus.com/ctype) facet of locale `loc`. If no such conversion is possible, the value returned is `c` unchanged.

```cpp
// tolower example (C++)
#include <iostream>       // std::cout
#include <string>         // std::string
#include <locale>         // std::locale, std::tolower

int main ()
{
  std::locale loc;
  std::string str="Test String.\n";
  for (std::string::size_type i=0; i<str.length(); ++i)
    std::cout << std::tolower(str[i],loc);
  return 0;
}
```

### `std::string::erase()`

```
sequence (1)	string& erase (size_t pos = 0, size_t len = npos);
character (2)	iterator erase (const_iterator p);
range (3)	    iterator erase (const_iterator first, const_iterator last);
```

Erases part of the [string](http://www.cplusplus.com/string), reducing its [length](http://www.cplusplus.com/string::length)

1. sequence: Erases the portion of the string value that begins at the character position `pos` and spans `len` characters (or until the end of the string, if either the content is too short or if `len` is [string::npos](http://www.cplusplus.com/string::npos).\
   **Notice that the default argument erases all characters in the string (like member function** [**clear**](http://www.cplusplus.com/string::clear)**).**
2. character: Erases the character pointed by `p`.
3. range: Erases the sequence of characters in the range `[first,last)`.

```cpp
string remove_rubbish(string s) {
    auto is_rubbish = [](char c) { 
        return ispunct(c) || isspace(c); 
    };
    
    // remove spaces and puctuations
    s.erase(std::remove_if(s.begin(), 
                           s.end(), 
                           is_rubbish), 
            s.end());
    return s;
}
```

### `std::string::substr()`

```cpp
string substr (size_t pos = 0, size_t len = npos) const;
```

Returns a newly constructed [string](http://www.cplusplus.com/string) object with its value initialized to a copy of a substring of this object.\
\
The substring is the portion of the object that starts at character position `pos` and spans `len` characters (or until the end of the string, whichever comes first).

* pos
  * Position of the first character to be copied as a substring.\
    If this is equal to the [string length](http://www.cplusplus.com/string::length), the function returns an empty string.\
    If this is greater than the [string length](http://www.cplusplus.com/string::length), it throws [out\_of\_range](http://www.cplusplus.com/out_of_range).\
    Note: The first character is denoted by a value of `0` (not 1).
* len
  * Number of characters to include in the substring (if the string is shorter, as many characters as possible are used).\
    A value of [string::npos](http://www.cplusplus.com/string::npos) indicates **all characters until the end of the string**.

```cpp
#include <iostream>
#include <string>

int main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

  std::string str2 = str.substr(3,5);     // "think"

  std::size_t pos = str.find("live");      // position of "live" in str

  std::string str3 = str.substr(pos);     // get from "live" to the end

  std::cout << str2 << ' ' << str3 << '\n';

  return 0;
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://lintcode-solutions.gitbook.io/project/oj-review/aug-27-2018.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.