New theories of crime were being studied by psychologists. These theories began to develop in the early 1900s. Your task is to search Biological, Sociological and Psychological Theories of Crime and then you need to write your findings with your own thoughts and words. Your word limit is 750-1000. very long please explain

I need a different answer to avoid plagiarism

Question Two: (Word count 200 words) “A system” Name and explain any system that you deal with in real life, in your explanation use all what you have learned about the characteristics of a system, where all parts must be clear and applied.

1) Using IEEE 754 format, determine the number this represents:

(64 bits)     0 11000111010 1100110000000100000000000000100000000000000000000000

2) Using complement two:

a) Represent 127

b) 127 – 499

3) How many nibbles can fit in three Word?

4) Using complement one:

a) What number represents 10001111?

Modify this program so that it takes in input from a TEXT FILE and outputs the results in a seperate OUTPUT FILE. (C programming)!

Program works just need to modify it to take in input from a text file and output the results in an output file.

________________________________________________________________________________________________

#include <stdio.h>

#include <string.h>

// Maximum string size

#define MAX_SIZE 1000

int countOccurrences(char * str, char * toSearch);

int main()

{

char str[MAX_SIZE];

char toSearch[MAX_SIZE];

char ch;

int count,len,a[26]={0},p[MAX_SIZE]={0},temp;

int i,j;

//Take user's input

printf("Enter any string : ");

gets(str);

//store length of string

len=strlen(str);

//array "a" contains count of every character

for(i=0;i<len;i++)

{

if(str[i]>='a'&&str[i]<='z')

a[str[i]-'a']++;

}

//output the result

for(i=0;i<26;i++)

{

if(a[i]!=0)

{

ch=i +'a';

printf("%c occurs %d times\n",ch,a[i]);

}

}

//array "p" contains count of length of every word

for(i=0;i<len;i++)

{

temp=0;

while(i<len&&str[i]!=' ')

{

temp++;

i++;

}

p[temp]++;

}

//output the result

for(i=0;i<MAX_SIZE;i++)

{

if(p[i]!=0)

{

printf("Word length %d occurs %d times\n",i,p[i]);

}

}

for(i=0;i<len;i++)

{

memset ( toSearch, 0, MAX_SIZE );

temp=0;

while(i<len&&str[i]!=' ')

{

toSearch[temp]=str[i];

temp++;

i++;

}

count = countOccurrences(str, toSearch);

printf("Total occurrences of '%s' is %d\n", toSearch, count);

}

return 0;

}

int countOccurrences(char * str, char * toSearch)

{

int i, j, found, count;

int stringLen, searchLen;

stringLen = strlen(str); // length of string

searchLen = strlen(toSearch); // length of word to be searched

count = 0;

for(i=0; i <= stringLen-searchLen; i++)

{

/* Match word with string */

found = 1;

for(j=0; j<searchLen; j++)

{

if(str[i + j] != toSearch[j])

{

found = 0;

break;

}

}

if(found == 1)

{

count++;

}

}

return count;

}

Problem 2: Universal Product Codes(UPCs) Retail products are identified by their Universal Product Codes (UPCs). The most common form of a UPC has 12 decimal digits: The first digit identifies the product category, the next five digits identify the manufacturer, the following five identify the particular product, and the last digit is a check digit. The check digit is determined in the following way: • Beginning with the first digit multiply every second digit by 3. • Sum all the multiplied digits and the rest of the digits except the last digit. • If the (10 - sum % 10) is equal to the last digit, then the product code is valid. • Otherwise it is not a valid UPC. The expression is: sum = 3.x1 + x2 + 3.x3 + x4 + 3.x5 + x6 + 3.x7 + x8 + 3.x9 + x10 + 3.x11 where the x’s are the first 11 digits of the code. If you choose to add the last digit also in the second step and if the sum is a multiple of 10, then the UPC is valid. Either way, you still need to perform the modular division to check whether the given number is a valid code. In this problem, you need to use either a string or long long integer type for the product code because it is 12 digits long. If you use string, you can convert one character substring of the string in to a single digit integer from left to right using the function stoi(str.substr(i,1)). This way you do not need to get last digit of the number and then divide the number by 10. 1 Problem 3: Translate the following pseudocode for randomly permuting the characters in a string into a C++ program. Read a word. repeat word.length() times Pick a random position i in the word, but not the last position. Pick a random position j > i in the word. swap the letters at positions j and i. Print the word. Please work on this problem after we learn to generate random numbers in the class which is on Wednesday the latest. These problems only deal with simple loop while, for and do loops. You will get a second set of problems next week on nested loops. in loops and string and not fuction that all the info i have

IN JAVA

• A recursive method that takes a String as its argument and returns a list of Strings which includes all anagrams of the String. This method will contain a loop that generates each possible substring consisting of all but one character in the input String, ie the substring that omits the first letter, then the substring that omits the second letter, etc. Within the loop, the method calls itself recursively for each substring. For each String in the list returned by the recursive call, add the omitted character back to the end and add the String to the list to be returned. When the first instance of this method returns, the list will contain all anagrams of the original input String. It may help to work this out with a pencil and paper for a very short string (like "abc".) The most straightforward base case (termination condition for the recursion) is to return a list containing only a new empty String if the input String has length 0. If you want a challenge, try replacing this algorithm with one that uses the only recursion, with no loops.
• A nonrecursive method that starts the recursion for the filtering step. This method will take a list of Strings, consisting of the anagrams, as its argument. Use a loop that takes each String in the list, converts it to an array of Strings using String's split() method with a blank space as the argument, and then uses the array to provide values for a list of Strings. The result of this will be a list of Strings in which each String is a word from the anagram. Still, inside the loop, call the recursive filter method for each of these Strings. In each case when it receives a non-null String as the return value fo the recursive filter method, it will add the String to the list which it returns.
• A recursive filter method that takes a list of Strings and returns the following:
  • if all of the Strings in the list are contained in the list of valid words, return a single String made up of the Strings in the order in which they appear in the list
  • if any of the Strings in the list do not appear in the list of valid words, return null. This should be much more common than the first case.

If a list is received for which the last String is in the word list, this method should recursively call itself on a list consisting of all but the last word. If the recursive call returns a String (not null), add the last word back to the end of the String and return it. This method should not contain any loops.