Please enable JavaScript.

Coggle requires JavaScript to display documents.

NUMBER SYSTEMS AND REGULAR EXPRESSIONS (Regular Expressions (Building…

- - - - Each place within a binary number represents a power of 2
        
        e.g. binary 101 =
        1 x 2^2 +
        0 x 2^1 +
        1 x 2^0
        
        Equals 5 in decimal
        
        Electrical representation: three wires
        
        | | | on off on 5V 0V 5V
      - Binary Addition
        Binary addition, subtraction, and multiplication can be treated exactly the same as with Decimals, except that only the digits 0 and 1 are used
        
        e.g.
        11 1010 +0111 ------ 10001
    - - Integer Data
        
        Humans use Decimal number. 10 digits, 0-9
        -Each place within a decimal number represents a power of 10
        
        e.g.
        
        236 =
        2 10^2 +
        3 10^1 +
        6 * 10^0 +
      - 10 is not a 'natural' base (it is an anatomical incident!)
        
        Computers work more naturally with base 2 because transistors have two states
        
        In base 2, only digits 0 and 1 are used
      - Humans perform decimal addition by
        
        Memorising all single-digit additions
        
        Writing the numbers to be added down right-aligned, one above the other
        
        Starting at the right and working towards the left
        
        Adding the digits, writing down the result and propagating any carry to the next column
        
        Subtraction works the same way, except you borrow from the next column
        
        Multiplication with a single-digit number works much the same way too
        
        Multiplicationwith a multi-digit number is treated as a series of separate single digit nultiplications, the results of which are added together
    - - Humans use Base 10
        
        Difficult to represent electronically
        
        Machine count in Base 2
        
        Two-state devices are easy to make (transistors)
        
        Only two digits used (0 and 1) called binary digits or bits
        
        Electronically represented by 0 volts and 5 volts
        
        Each bit occupies one memory cell
        
        Basic working unit consists usually of 8 bits, called a byte
        
        Basic memory unit is a multiple number of bytes e.g.
      - 2 bytes = 16 bits
        
        4 bytes = 32 bits
        
        8 bytes = 64 bits
      - Basic memory unit is called word length
        
        i.e. piece of data that can be transferred to and from the working memory in a single operation
      - All bytes in memory are numbered, or addressable
        
        first byte numbered 0, second 1 etc.
        
        Memory size usually expressed in mega/giga bytes
        
        All data held within the computer is represented by a number of bits or bytes
        
        All high level objects, such as Java or C++ class must be translated into bits
    - - General Idea
        
        Problem with binary arithmetic -- Long strings are fine for machines but awkward for humans
- - - - Normal Characters
        
        ABCDEFGHIJKLMNOPQRSTUVWXYZ
      - Non-printing
        
        \t = tab
        
        \n = newline
        
        \r = carriage return
        
        \f = formfeed
        
        \a = alarm, that is, the BEL character
        
        \ddd = octal code ddd, or backreference
        
        cx = "control-x" where x is any character
        
        \e = escape
        
        \xhh
        
        \p{xx} = a character with the xx property
      - Escaped Characters
        
        . means .
        
        * means *
        
        + means +
        
        [ means [
        
        \ means \
        
        etc.
      - Any Character
        
        c.t
        -- any character at the '.'
      - Character Ranges
        
        [0123456789] = [0-9]
        
        [^a-zA-Z0-9]
        
        [-a-z]
        
        []456]
    - - 0 or more
        a-*b-*c
        
        Will match:
        
        abc
        a----------bc
        a---b--------c
        etc.
      - 1 or more
        a-+b-+c
        
        Will match: a-b-c
        a--------b--c
        etc.
        Will NOT match:
        abc
      - Optional
        a,?b,?c
        
        Will match:
        abc
        a,bc
        a,b,c
        ab,c
      - "m" matches
        [0-9]{4}
        
        Match: 0000 up to 9999
        Partial match: 45678
        NO match: 123
      - "m" or more matches
        [0-9]{2,}
        
        Will match:
        00
        98702
        12345675344256246475
        
        Will NOT match:
        1
        5
      - "m" to "n" matches
        [0-9]{2,4}
        
        Match: 00 to 9999
        Partial match: 45678
        NO match: 1
      - Equivalents
        
        [0-9]+ == [0-9][0-9]*
        
        [0-9]{2} == [0-9][0-9]
        
        [0-9]{2,} == [0-9][0-9][0-9]*
        
        [0-9]{2,4} == [0-9][0-9][0-9]?[0-9]?
      - Greediness
        
        Greedy
        in the word "Mississippi"
        i.*s
        Matches "ississ"
        i.+s
        Matches "ississ"
        
        Non-greedy (indicated by ?)
        in the word "Mississippi"
        
        i.*?s
        Matches "is"
        i.+?s
        Matches "iss"
        
        When applied to:
        
        <a id="a1" href="fred.php">Fred</a><a href="mary.php">Mary</a>
        
        <a .*?href=".*?"
        Matches
        id="a1" and "fred.php"
        
        <a .*href=".*"
        Matches
        'id="a1" href="fred.php">Fred</a><a ' and 'mary.php'
    - - Simple Constraints
        A[0-9]{2,4}B
        
        Matches:
        A22B
        A456B
        A6789B
        But not:
        A12345B
      - Common Constraints
        
        ^ == start of line
        
        $ == end of line
        
        \b == word boundary
        
        \B == not a word boundary
      - Metacharacters
        
        \d == digit [0-9]
        
        \D == non-digit [^0-9]
        
        \s == whitespace
        
        \S == non-whitespace
        
        \w == word character [A-Za-z0-9_]
        
        \W == non-word character [^A-Za-z0-9_]
      - Branches and Groups
        
        (and|but)
        
        (a*B?dex)
      - Back Reference
        '.*?' | "[^"]*?"
        Can be written
        ([' "]).*?\1
        No back reference:
        (?:abcde)
    - - Common Classes
        
        "blank space" == \s or [[:space:]]
        
        "digits" == \d or [[:digit:]]
        
        "letters" == [[:alpha:]]
        
        "names" == \w or [[:alnum:]]
        
        "start of word" == [[:<:]]
        
        "end of word" == [[:>:]]
        
        etc.