W1 Flashcards

Question

How can you represent the integer 13 in bytes?

Answer 1

1101^2 = 1 × 2^3 + 1 × 2^2 + 0 × 2^1 + 1 × 2^0 = 13 *Therefore w can represent the integer 13 by 00000000 00000000 00000000 00001101

Answer 2

If the leftmost bit is 0, it represents a non-negative integer; When the leftmost bit is 1, it represents a negative integer. * We can represent integers from to (i.e. from−2^(n−1) through 2^(n−1) − 1 )

Answer 3

The number is greater than the maximum integer that 32 bits can represent (2152382740 > 2147483647 - The binary representation of 2152382740 is 10000000 01001010 11000001 00010100, which represents a negative integer

Answer 4

In a computer, real numbers are represented by floating-point numbers * Notice that: - The number of real numbers is infinite (i.e. imagine the real numbers between a small range like [0,0.01] - The number of patterns that can be represented by n-bits is finite (i.e. with 64 bits, we can represent 2^64 = 18446744073709551616 distinct numbers - It is not possible to represent all real numbers by finite bits

Answer 5

A floating-point number is represented approximately with a fixed number of significant digits (the significand) and scaled using an exponent in some fixed base in a form: significand× base^(exponent) * EXAMPLE: 0.0125 = 1.25 × 10^(-2) 1250 = 1.25 × 10^3 0.0125 = 125 × 10(-4) * The term floating point refers to the fact that a number's "point" can "float" - The point can "move" by changing the exponent. * In base 10 with finite digits, we are not able to represent some numbers exactly * By increasing the number of digits we can have a better approximation * Floating point numbers in a computer are represented using finite bits. Therefore, some numbers are not represented exactly

Answer 6

With base = 2: 0.001(base 2) = 1 × 2^(−3) = 0.125(base 10) * In base 2 with finite digits, we are not able to represent some numbers exactly * Some numbers that can be represented exactly in base 10 cannot be expressed precisely in base 2 with finite digits

Answer 7

* Real numbers are approximated in a computer * We need to be cautious when we compare floats * EXAMPLE: 3.14 + 3 Out: 6.140000000000001 3.14 + 3 == 6.14 Out: False

Answer 8

Text can be represented by a sequence of characters. * A character is a unit of information that roughly corresponds to a symbol, such as: - Letter - Digit - Punctuation mark (such as '.', '-') - space ' '

Answer 9

Control characters do not correspond to visible symbols but rather to instructions to format or process the text Example: Newline character '\n' which moves the print head down one line: print('Hello\nworld') OUT: Hello world

Answer 10

Escape Character '\\' is used to distinguish the newline character from the character 'n' EXAMPLE: print('n\nn') # n newline n OUT: n n

Answer 11

Whitespace is any character or series of characters that represent horizontal or vertical space. EXAMPLE: - space: ' ' - tab: '\t' - newline: '\n' print('Hello\tworld') print('st\t115') OUT: Hello world st 115

Answer 12

Characters are represented using a character encoding that assigns each character to something (e.g. integer). * Common examples of character encoding systems include: - ASCII (American Standard Code for Information Interchange) - UTF-8 or UTF-16 encoding for Unicode

Answer 13

ASCII (American Standard Code for Information Interchange) * ASCII defines 128 characters, which map to the integers 0–127 (i.e. requires only 7 bits): 52 English alphabets (uppercase and lowercase) e.g 'A' maps to 65, 'a' maps to 97 * Many more letters and symbols are desirable or required to directly represent other characters, such as: - Letters of alphabets other than English (e.g. é) - More kinds of punctuation and symbols (e.g. ¡ and £) - More mathematical operators (e.g. ÷) * As characters are often stored in 8 bits, and 8 bits can represent 256 distinct characters, additional 128-character definitions can be added!

Answer 14

The Unicode (or formally Unicode Standard) provides a unique mapping for every character, no matter what platform, device, application or language. * Every character: - It currently defines more than 150000 characters covering ~160 modern and historic scripts, as well as symbols, emojis, and non-visual control and formatting codes - It can at most represent around a million characters * Unique mapping: each character has their unique Unicode code point * It is a superset of ASCII, and the numbers 0–127 have the same meaning in ASCII as they have in Unicode (i.e. the number 65 is mapped to 'A') *Unicode characters do not generally fit into 8 bits * The Unicode standard defines Unicode Transformation Formats (UTF): - UTF-8 - UTF-16 - UTF-32

Answer 15

* The name is derived from Unicode Transformation Format – 8-bit * UTF-8 encodes all Unicode characters using one to four 8 bit (i.e. 1 byte) code units - Variable-width character encoding! *EXAMPLE: - ASCII characters require 1 byte Greek letters require 2 bytes (e.g. 𝛼) - Most Chinese, Japanese and Korean characters require 3 bytes (e.g. 食) - Emojis require four bytes (e.g. 😀)

Answer 16

* Variable-width character encoding * Encode all Unicode characters using one to two 16-bit (i.e. 2 bytes) code units

Answer 17

* Fixed-length character encoding *Encode all Unicode characters using 32 bits

Answer 18

'😀'.encode('utf-8') smile_utf_8.decode('utf-8') * Characters are represented differently internally when we use different encoding methods: EXAMPLE (UTF-8) smile_utf_8 = '😀'.encode('utf-8') Out: b'\xf0\x9f\x98\x80' EXAMPLE (UTF-16) smile_utf_16 = '😀'.encode('utf-16') Out: b'\xff\xfe=\xd8\x00\xde' * When we decode, we need to know how the data was encoded. EXAMPLE (Correct UTF-8) smile_utf_8.decode('utf-8') Out: '😀' EXAMPLE (WRONG UTF-16) smile_utf_8.decode('utf-16') Out: '鿰肘'

Answer 19

# H1 Headings: # H1 ## H2 ### H3

Answer 20

Bold: **bold**

Answer 21

Italic: *italic*

Answer 22

> blockquote NOTE: You can also nest blockquote via >> EXAMPLE: > Dorothy followed her through many of the beautiful rooms in her castle. > >> The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.

Answer 23

Link: [title](https://www.example.com)

Answer 24

Image: ![alt text](image.jpg)

Answer 25

You can create a table using the pipe (|) and hyphen (-) syntax | Header 1 | Header 2 | Header 3 | |------------|:----------:|-----------:| | Row 1, Col 1 | Row 1, Col 2 | Row 1, Col 3 | | Row 2, Col 1 | Row 2, Col 2 | Row 2, Col 3 | NOTE: * Header Row: The first row defines the headers of your table. * Separator Row: The second row uses hyphens (with optional colons for alignment) to separate the header from the rest of the table. |------------| creates a left-aligned column. |:----------:| creates a centered column. |-----------:| creates a right-aligned column. *Data Rows: Each subsequent row adds data cells, separated by pipes.

Answer 26

1101(2) = 1 x 2^3 + 1 x 2^2 + 0 x 2^1 + 1 x 2^0 = 13(10) MARKDOWN CODE: $$1101_2 = 1\times 2^3 + 1 \times 2^2 + 0 \times 2^1 + 1 \times 2^0 = 13_{10}$$

Answer 27

for i in range(0,len(appl_prices)): appl_prices[i]=round(appl_prices[i]) appl_prices

Answer 28

price_diff = [] for i in range(0,len(appl_prices)-1): price_diff.append(appl_prices[i+1]-appl_prices[i]) price_diff

Answer 29

* To convert to lowercase, you use .lower() * To convert to uppercase, you use .upper() * The capitalize() method converts the first character of the string to uppercase and the rest to lowercase. * The title() method converts the first character of each word in the string to uppercase and the rest to lowercase.

Answer 30

.count('t') adds up the number of times the character 't' appears in a string. You can also do words. It is case sensitive, so you may need to make the string lowercase

Answer 31

.replace( , ) s = "I intend to live forever, or die trying." s.replace("to", "three") OUT: 'I intend three live forever, or die trying.'

Answer 32

def absolute(x): if x > 0: return x else: return -x

Answer 33

def number_of_combinations(num_bits): return 2**num_bits

Answer 34

POSSIBLE SOLUTION 1: def uint_to_32_bit_binary(x): binary_str = bin(x)[2:] binary_str = (32 - len(binary_str)) * '0' + binary_str return binary_str[-32:] POSSIBLE SOLUTION 2: def uint_to_32_bit_binary(x): binx = bin(x)[2:] if len(binx) <= 32: return ('0'*(32 - len(binx))) + binx elif len(binx) > 32: return x + " can not be represented 32-bit binary representation"

Answer 35

def int_to_32_bit_binary(x): if x >= 0: return uint_to_32_bit_binary(x) else: return uint_to_32_bit_binary(2**32+x)

Answer 36

If you add 0.1 for 10 times in Python: x = 0 for i in range(10): x += 0.1 x OUT: 0.9999999999999999 NOTE: The total sum is not exactly 1, but some number that is close to 1. This happens as float is only an approximation of the given real number. x == 1 FALSE You should use an integer as a counter to control the loop as an integer is exact (i.e. use 1 not 0.1): x = 0 while x != 10: x += 1

Answer 37

The ord() function returns the number representing the unicode code of a specified character.

Answer 38

Greek letters need 2 bytes to represent, Chinese/Japanese/Korean characters often need 3 bytes and emoji often requires 4 bytes.

Answer 39

.split() score = 'harry \t 85\t79\n' print(score) name = score.split()[0]

Answer 40

.strip() EXAMPLE: 'abc '.strip() returns 'abc'

Answer 41

scores = [int(score) for score in tokens[1:]] for i in range(len(scores)): scores[i] = int(scores[i])

Answer 42

For loops often, don't forget range(len()) !!!!!!!

Answer 43

* How you categorise the data type depends on how you are going to use the data. * More important is that you work with the data appropriately, and having some idea of how the data is categorised can guide you.