Please enable JavaScript.

Coggle requires JavaScript to display documents.

OCR computing paper 2 : - Coggle Diagram

- - - - pseudocode
      - flow charts
  - - - set counter to 0
        
        examin value held in list at counter position
        
        check to see if it matches value searched for
        
        if matched end search, otherwise repeat
        
        it is very slow
  - - - compare the first value in list with the next one up, if the first value is bigger, then swap the two values
        
        continue doing this until the list is in order
        
        it is extremly slow
  - - - extremely quick
        
        e.g data set is 1,2,3,4,5,6,
        
        anf your looking for the number 6
        
        first find middle term, which is 4, as you round up
        
        is 4 larger than value, no so get rid of it, as well as all the other to the left of it as they will all be smaller
        
        repeat, so you only have 5 and 6 left, and you always round up, so 6, and its done.
  - - - uses divide and conquer
        
        e.g numbers were 4213
        
        first spit the data into two smaller sub stes
        
        so you would have 42 and 13
        
        next split them in half again so you would have 4, 2, 1, 3
        
        compare them putting the smallest one infont of the larger one
        
        1 more item...
  - - - decomposition is removing any unneeded details
- - - - more clear
    - - so you know what it does/ is supposed to do
    - - lets you (and other developers) know why you wrote the code how you did
- - - - computer cant understand it
      - easer to write
      - has to be translated to low level code
      - commonly used high level languages
        
        java, python, C++
    - - use abbreviated English E.G. int= input
      - computer can understand it
      - much harder to write
    - - turn high level language into low level language
        
        3 types, compilers, interpreters and assemblers
        
        compilers
        
        compilers take the source code as a whole and translates it into object code
        
        advantages
        
        optimise code (run quicker and take less storage)
        
        quick run time
        
        disadvantages
        
        don't stop errors
        
        as its translated in one go needs lots of memory space at the start
        
        assemblers
        
        interpriters
        
        translate source code to object code one line at a time
        
        advantages
        
        accurate
        
        finds errors
        
        disadvantages
        
        slow
  - - - very hard to write
- - - - example, 1= false, 0= true
      - swiches them around, if imput is false, the output is true
- - - - i can contain letters and numbers, but must start with a letter, has to contain at least 1 letter, cant contain special character (%*;:#)
  - - - https://www.bbc.co.uk/bitesize/guides/znh6pbk/revision/3
  - - - https://www.bbc.co.uk/bitesize/guides/znh6pbk/revision/4
  - - - infiinate continue running forever, the program never stops
      - conrolled loops loop a certain number of times, or until X happens