Laborator 7
Problema 1
interface calcul{
public int suma(int a, int b);
public int produs(int a, int b);
public int diferenta(int a, int b);
}
abstract class Rezultat implements calcul{
public int suma(int a, int b){
return a+b;
}
public int produs(int a, int b){
return a*b;
}
}
class Numere extends Rezultat{
public int diferenta(int a, int b){
return a-b;
}
}
public class Main {
public static void main(String[] args) {
Rezultat a=new Numere();
System.out.println(a.suma(1,2));
}
}
Se poate ca o clasa sa nu implementeze toate metodele interfetei, dar aceasta trebuie sa fie abstracta.
Problema 2
class Person{
private String name;
private Transmitter transmitter;
public Person(String name){
this.name=name;
}
public void setTransmitter(Transmitter t){
this.transmitter=t;
}
public Transmitter getTransmitter(){
return transmitter;
}
public void send(Person p1, String message){
this.transmitter.store(new Message(this, p1, message));
}
public void notifyPerson(Transmitter t){
Message m = t.retrieve(this);
if(m==null)
System.out.println("Something wrong happend");
else
System.out.println(m);
}
public String toString(){
return this.name;
}
}
class Message{
private Person sender,recevier;
private String message;
public Message(Person sender, Person recevier, String message){
this.sender=sender;
this.recevier=recevier;
this.message=message;
}
public String toString(){
String result="";
result=result+this.sender+" said to "+this.recevier+" ("+this.sender.getTransmitter()+"):"+this.message;
return result;
}
public Person getRecevier() {
return recevier;
}
}
interface Transmitter {
void store(Message message);
Message retrieve(Person receiver);
String toString();
}
class EmailTransmitter implements Transmitter{
private Message message;
public EmailTransmitter(){
}
public void store(Message message){
this.message=message;
message.getRecevier().notifyPerson(this);
}
public Message retrieve(Person receiver){
return message;
}
public String toString(){
return "EMAIL";
}
}
class MailTransmitter implements Transmitter{
private int numberMessages=0;
private int maxMessages;
private Message[] messages;
public MailTransmitter(int maxMessages){
this.maxMessages=maxMessages;
this.messages=new Message[maxMessages];
}
public void store(Message message){
if(numberMessages<maxMessages){
this.messages[numberMessages]=message;
numberMessages++;
}
if(numberMessages==maxMessages) {
for(int i=0;i<numberMessages;i++) {
messages[i].getRecevier().notifyPerson(this);
}
this.numberMessages=0;
this.messages=new Message[maxMessages];
}
}
public Message retrieve(Person receiver){
for(int i=0;i<numberMessages;i++) {
if (receiver == messages[i].getRecevier()) {
return messages[i];
}
}
return null;
}
public String toString(){
return "MAIL";
}
}
public class Main {
public static void main(String[] args) {
Person p1=new Person("Paul");
Person p2=new Person("Andreea");
Person p3=new Person("Ioana");
Person p4=new Person("Gabriel");
Transmitter email=new EmailTransmitter(); //cream sistemul de transmitere prin e-mail-uri
Transmitter mail=new MailTransmitter(2); //cream sistemul de transmitere prin scrisori, cu un buffer de 2 scrisori
p1.setTransmitter(email); //p1 doreste sa trimita un e-mail catre p2
p1.send(p2,"Scrie-i Ioanei sa-mi dea adresa ei de e-mail!"); /*p2 trimite o scrisoare catre p3. Scrisoarea nu va ajunge imediat,
deoarece deocamdata este singura in "cutia postala"*/
p2.setTransmitter(mail);
p2.send(p3,"Paul zice sa-i trimiti adresa ta de e-mail");
p4.setTransmitter(mail); //p4 trimite o scrisoare catre p1. Fiind a doua scrisoare,
p4.send(p1,"Ce mai faci?"); //buffer-ul de scrisori se va umple si ambele scrisori vor fi trimise
//p3 a primit in acest moment scrisoarea de la p2 si poate raspunde
//prin e-mail lui p1
p3.setTransmitter(email);
p3.send(p1,"Adresa mea de e-mail este: ioana@yahoo.com");
}
}
Problema 3
interface SumaTotala{
float getSumaTotala();
}
abstract class ContBancar implements SumaTotala{
protected String numarCont;
protected float suma;
public ContBancar(String numarCont, float suma){
this.numarCont=numarCont;
this.suma=suma;
}
public abstract float getSumaTotala();
public void setNumarCont(String numarCont){
this.numarCont=numarCont;
}
public void setSuma(float suma){
this.suma=suma;
}
public float getSuma() {
return suma;
}
public String getNumarCont() {
return numarCont;
}
}
class ContLei extends ContBancar{
public ContLei(String numarCont, float suma){
super(numarCont,suma);
}
public void transfer(ContBancar contDestinatie, float suma){
if(contDestinatie instanceof ContLei) {
contDestinatie.suma = contDestinatie.suma + suma;
super.suma = super.suma - suma;
}
else{
System.out.println("Transferurile se pot face numai intre conturile in lei.");
}
}
public float getSumaTotala(){
return super.suma;
}
}
class ContEuro extends ContBancar{
private static final int PragMinimDobanda = 500;
private static final float DobandaFixa= (float) 0.3;
public ContEuro(String numarCont, float suma){
super(numarCont,suma);
}
public float getDobanda(){
if(super.suma>PragMinimDobanda)
return DobandaFixa;
else
return 0;
}
public float getSumaTotala(){
return 36000*super.suma;
}
}
class Client{
private static final int maxConturi=5;
private String nume,adresa;
private ContBancar[] contbancar;
private int numarConturi=0;
public Client(String nume, String adresa, ContBancar[] conturi){
this.nume=nume;
this.adresa=adresa;
if(conturi.length<maxConturi){
this.contbancar=new ContBancar[conturi.length];
this.contbancar=conturi;
this.numarConturi=conturi.length;
}
else {
System.out.println("Nu se pot crea mai mult de " + maxConturi + " conturi");
}
}
public void adaugareContBancar(ContBancar b1){
if(numarConturi<maxConturi){
ContBancar[] tmp=new ContBancar[numarConturi+1];
for(int i=0;i<numarConturi;i++)
tmp[i]=contbancar[i];
tmp[numarConturi]=b1;
contbancar=tmp;
numarConturi++;
}
else{
System.out.println("Nu se pot crea mai mult de " + maxConturi + " conturi");
}
}
public void setNume(String nume) {
this.nume = nume;
}
public void setAdresa(String adresa){
this.adresa=adresa;
}
public String getNume(){
return this.nume;
}
public String getAdresa() {
return adresa;
}
public String toString(){
String result="";
String result2="";
result=result+"Client: "+this.nume+"\nAdresa: "+this.adresa+"\n";
for(int i=0;i<contbancar.length;i++){
String result3="Cont bancar ";
result2=result2+result3+(i+1)+": "+contbancar[i].numarCont+"\n Suma totala: "+contbancar[i].getSumaTotala()+"\n";
}
result=result+result2;
return result;
}
}
class Banca {
private int numarClienti = 0;
private Client[] clienti = new Client[100];
private String codBanca;
public String getCodBanca() {
return codBanca;
}
public void setCodBanca(String codBanca) {
this.codBanca = codBanca;
}
public void adaugareClient(Client c) {
if (numarClienti < clienti.length) {
clienti[numarClienti] = c;
numarClienti++;
} else {
Client[] tmp = new Client[clienti.length + 100];
for (int i = 0; i < clienti.length; i++)
tmp[i] = clienti[i];
clienti = tmp;
clienti[numarClienti] = c;
numarClienti++;
}
}
public void afisareClient(String nume) {
int gasit=0;
for (int i = 0; i < numarClienti; i++) {
if (clienti[i].getNume().equals(nume)) {
System.out.println(clienti[i]);
gasit=1;
}
}
if(gasit==0) {
System.out.println("Clientul " + nume + " nu a fost gasit");
}
}
}
public class Main {
public static void main(String[] args) {
Banca b1=new Banca();
b1.setCodBanca("Banca X");
ContBancar cl1=new ContLei("123",1000);
ContBancar cl2=new ContLei("124",1500);
ContBancar ce1=new ContEuro("125",2000);
ContBancar ce2=new ContEuro("126",2500);
ContBancar[] leiEuro={cl1,ce1};
ContBancar[] euroLei={ce2,cl2};
Client c1=new Client("Popescu Ion","Timisoara",leiEuro);
Client c2=new Client("Popovici Viorel","Bucuresti",euroLei);
c1.adaugareContBancar(ce2);
b1.adaugareClient(c1);
b1.adaugareClient(c2);
//System.out.println(c1);
//System.out.println(c2);
b1.afisareClient("Popovici Viorel");
b1.afisareClient("Popescus Ion");
((ContLei)cl1).transfer(cl2,250);
System.out.println("\nTransfer intre conturi:\n");
b1.afisareClient("Popovici Viorel");
b1.afisareClient("Popescu Ion");
}
}
Problema 4
interface Risky{
public double getRisk();
}
abstract class Project implements Risky{
private String title, objective;
private long funds;
private Manager manager;
private Member[] members=new Member[100];
private int numberOfMembers=0;
private long maxMembers;
private static final int infinity=-1;
public Project(String title, String objective,long funds, Manager manager,int maxMembers){
this.title=title;
this.objective=objective;
this.funds=funds;
this.manager=manager;
this.maxMembers=maxMembers;
}
public void addMember(Member m){
if(maxMembers==infinity) {
if (numberOfMembers < members.length) {
members[numberOfMembers] = m;
numberOfMembers++;
}
else {
Member[] tmp = new Member[members.length + 100];
for (int i = 0; i < numberOfMembers; i++)
tmp[i] = members[i];
members = tmp;
members[numberOfMembers] = m;
numberOfMembers++;
}
}
else{
if(numberOfMembers<maxMembers){
members[numberOfMembers]=m;
numberOfMembers++;
}
else{
System.out.println("Numarul maxim de membrii ai proiectului a fost atins\n");
}
}
}
public long getFunds(){
return this.funds;
}
public String getTitle() {
return title;
}
public String getObjective() {
return objective;
}
public Manager getManager() {
return manager;
}
public Member[] getMembers() {
return members;
}
public int getNumberOfMembers() {
return numberOfMembers;
}
public long getMaxMembers(){
return maxMembers;
}
public String toString(){
return "Proiectul:"+this.title+"\nObiectivul: "+this.objective+"\nManagerul: "+this.manager.getName()+"\nNumar membrii:"+this.numberOfMembers;
}
}
abstract class MilitaryComercialProject extends Project{
private String deadLine;
private static final int maxMembers=15;
public MilitaryComercialProject(String title, String objective, long funds, Manager manager, int maxMembers,String deadLine) {
super(title, objective, funds, manager, MilitaryComercialProject.maxMembers);
this.deadLine=deadLine;
}
}
class MilitaryProject extends MilitaryComercialProject{
private String password;
public MilitaryProject(String title, String objective, long funds, Manager manager, int maxMembers, String deadLine,String password) {
super(title, objective, funds, manager, maxMembers, deadLine);
this.password=password;
}
public double getRisk(){
return (double)(getNumberOfMembers()/this.password.length())/getFunds();
}
}
class ComercialProject extends MilitaryComercialProject{
private long marketingFunds;
private int numberOfTeams;
public ComercialProject(String title, String objective, long funds, Manager manager, int maxMembers, String deadLine,int numberOfTeams) {
super(title, objective,funds ,manager, maxMembers, deadLine);
this.numberOfTeams=numberOfTeams;
marketingFunds=getFunds()/2;
}
public long getMarketingFunds() {
return marketingFunds;
}
public int getNumberOfTeams() {
return numberOfTeams;
}
public double getRisk(){
return (double)((3*this.numberOfTeams)/super.getNumberOfMembers())/this.marketingFunds;
}
}
class OpenSourceProject extends Project{
private static final int unlimitedMembers=-1;
private String mailList;
public OpenSourceProject(String title, String objective, long funds, Manager manager, int maxMembers,String mailList) {
super(title, objective, funds, manager,unlimitedMembers);
this.mailList=mailList;
}
public String getMailList() {
return mailList;
}
public double getRisk(){
return (double)getNumberOfMembers()/getFunds();
}
}
abstract class Programmer{
private int age;
private String name;
public Programmer(int age, String name){
this.age=age;
this.name=name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
}
class Manager extends Programmer{
public Manager(int age, String name){
super(age,name);
}
}
class Member extends Programmer{
public Member(int age, String name){
super(age,name);
}
}
public class InvestmentCompany {
private Project[] projects=new Project[100];
private int numberOfProjects=0;
public void addProject(Project p){
if(numberOfProjects<projects.length){
projects[numberOfProjects]=p;
numberOfProjects++;
}
else{
Project[] tmp=new Project[projects.length+100];
for(int i=0;i<numberOfProjects;i++) {
tmp[i] = projects[i];
}
projects=tmp;
projects[numberOfProjects]=p;
numberOfProjects++;
}
}
public Project getBestInvestment(){
double lowestRisk=projects[0].getRisk();
int found=0;
for(int i=0;i<numberOfProjects;i++) {
if (lowestRisk < projects[i].getRisk()) {
lowestRisk = projects[i].getRisk();
found = i;
}
}
return projects[found];
}
public static void main(String[] args) {
InvestmentCompany ic1=new InvestmentCompany();
Project p1=new MilitaryProject("Military Project-y28","Defense",1000000,new Manager(40,"John A."),
14,"31.12.2017","Military-Defense");
p1.addMember(new Member(25,"Mike"));
Project p2=new ComercialProject("Comercial Project-December","Christmas",100000,new Manager(42,"Andrew"),
12,"25.01.2017",3);
p2.addMember(new Member(24,"Johnson"));
p2.addMember(new Member(31,"Adams"));
Project p3=new OpenSourceProject("Open-Source Projec_Frostivus","Game-Design",1000,new Manager(38,"Chris"),
25,"Mail-1 Mail-2 Mail-3");
p3.addMember(new Member(28,"Smith"));
p3.addMember(new Member(29,"Clark"));
p3.addMember(new Member(27,"Lewis"));
ic1.addProject(p1);
ic1.addProject(p2);
ic1.addProject(p3);
System.out.println(ic1.getBestInvestment());
}
}
Varianta 2 (fara infinity)
package com.company;
interface Risky{
public double getRisk();
}
abstract class Project implements Risky{
private String title, objective;
private long funds;
private Manager manager;
protected Member[] members=new Member[100];
protected int numberOfMembers=0;
protected long maxMembers;
public Project(String title, String objective,long funds, Manager manager,int maxMembers){
this.title=title;
this.objective=objective;
this.funds=funds;
this.manager=manager;
this.maxMembers=maxMembers;
}
abstract public void addMember(Member m);
public long getFunds(){
return this.funds;
}
public String getTitle() {
return title;
}
public String getObjective() {
return objective;
}
public Manager getManager() {
return manager;
}
public Member[] getMembers() {
return members;
}
public int getNumberOfMembers() {
return numberOfMembers;
}
public long getMaxMembers(){
return maxMembers;
}
public String toString(){
return "Proiectul:"+this.title+"\nObiectivul: "+this.objective+"\nManagerul: "+this.manager.getName()+"\nNumar membrii:"+this.numberOfMembers;
}
}
abstract class MilitaryComercialProject extends Project{
private String deadLine;
private static final int maxMembers=15;
public MilitaryComercialProject(String title, String objective, long funds, Manager manager, int maxMembers,String deadLine) {
super(title, objective, funds, manager, MilitaryComercialProject.maxMembers);
this.deadLine=deadLine;
}
public void addMember(Member m){
if(super.numberOfMembers<maxMembers){
members[numberOfMembers]=m;
numberOfMembers++;
}
else{
System.out.println("Numarul maxim de membrii ai proiectului a fost atins\n");
}
}
}
class MilitaryProject extends MilitaryComercialProject{
private String password;
public MilitaryProject(String title, String objective, long funds, Manager manager, int maxMembers, String deadLine,String password) {
super(title, objective, funds, manager, maxMembers, deadLine);
this.password=password;
}
public double getRisk(){
return (double)(getNumberOfMembers()/this.password.length())/super.getFunds();
}
}
class ComercialProject extends MilitaryComercialProject{
private long marketingFunds;
private int numberOfTeams;
public ComercialProject(String title, String objective, long funds, Manager manager, int maxMembers, String deadLine,int numberOfTeams) {
super(title, objective,funds ,manager, maxMembers, deadLine);
this.numberOfTeams=numberOfTeams;
marketingFunds=super.getFunds()/2;
}
public long getMarketingFunds() {
return marketingFunds;
}
public int getNumberOfTeams() {
return numberOfTeams;
}
public double getRisk(){
return (double)((3*this.numberOfTeams)/super.getNumberOfMembers())/this.marketingFunds;
}
}
class OpenSourceProject extends Project{
private String mailList;
public OpenSourceProject(String title, String objective, long funds, Manager manager, int maxMembers,String mailList) {
super(title, objective, funds, manager,maxMembers);
this.mailList=mailList;
}
public String getMailList() {
return mailList;
}
public void addMember(Member m) {
if (numberOfMembers < members.length) {
members[numberOfMembers] = m;
numberOfMembers++;
} else {
Member[] tmp = new Member[members.length + 100];
for (int i = 0; i < numberOfMembers; i++)
tmp[i] = members[i];
members = tmp;
members[numberOfMembers] = m;
numberOfMembers++;
super.maxMembers=members.length;
}
}
public double getRisk(){
return (double)getNumberOfMembers()/getFunds();
}
}
abstract class Programmer{
private int age;
private String name;
public Programmer(int age, String name){
this.age=age;
this.name=name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
}
class Manager extends Programmer{
public Manager(int age, String name){
super(age,name);
}
}
class Member extends Programmer{
public Member(int age, String name){
super(age,name);
}
}
public class InvestmentCompany {
private Project[] projects=new Project[100];
private int numberOfProjects=0;
public void addProject(Project p){
if(numberOfProjects<projects.length){
projects[numberOfProjects]=p;
numberOfProjects++;
}
else{
Project[] tmp=new Project[projects.length+100];
for(int i=0;i<numberOfProjects;i++) {
tmp[i] = projects[i];
}
projects=tmp;
projects[numberOfProjects]=p;
numberOfProjects++;
}
}
public Project getBestInvestment(){
double lowestRisk=projects[0].getRisk();
int found=0;
for(int i=0;i<numberOfProjects;i++) {
if (lowestRisk < projects[i].getRisk()) {
lowestRisk = projects[i].getRisk();
found = i;
}
}
return projects[found];
}
public static void main(String[] args) {
InvestmentCompany ic1=new InvestmentCompany();
Project p1=new MilitaryProject("Military Project-y28","Defense",1000000,new Manager(40,"John A."),
14,"31.12.2017","Military-Defense");
p1.addMember(new Member(25,"Mike"));
Project p2=new ComercialProject("Comercial Project-December","Christmas",100000,new Manager(42,"Andrew"),
12,"25.01.2017",3);
p2.addMember(new Member(24,"Johnson"));
p2.addMember(new Member(31,"Adams"));
Project p3=new OpenSourceProject("Open-Source Project_Frostivus","Game-Design",1000,new Manager(38,"Chris"),
25,"Mail-1 Mail-2 Mail-3");
p3.addMember(new Member(28,"Smith"));
p3.addMember(new Member(29,"Clark"));
p3.addMember(new Member(27,"Lewis"));
ic1.addProject(p1);
ic1.addProject(p2);
ic1.addProject(p3);
System.out.println(ic1.getBestInvestment());
}
}
Varianta cu liste:
package com.company;
import java.util.LinkedList;
import java.util.List;
interface Risky {
double getRisk();
}
abstract class Member {
private String name;
private int age;
public Member(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Member{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
class Manager extends Member {
public Manager(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Manager{" + super.toString() + '}';
}
}
class Programmer extends Member {
public Programmer(String name, int age) {
super(name, age);
}
@Override
public String toString() {
return "Programmer{" + super.toString() + '}';
}
}
abstract class Project implements Risky {
private Manager manager;
private List<Programmer> programmers;
private final String name;
private final String objective;
private long funds;
public Project(Manager manager, String name, String objective, long funds) {
this.manager = manager;
this.programmers = new LinkedList<>();
this.name = name;
this.objective = objective;
this.funds = funds;
}
public void addProgrammer(Programmer programmer) {
this.programmers.add(programmer);
}
public void removeProgrammer(Programmer programmer) {
this.programmers.remove(programmer);
}
public Manager getManager() {
return manager;
}
public void setManager(Manager manager) {
this.manager = manager;
}
private int getNumberOfProgrammers() {
return programmers.size();
}
public int getNumberOfMembers() {
return getNumberOfProgrammers() + 1;
}
public long getFunds() {
return funds;
}
@Override
public String toString() {
final StringBuffer sb = new StringBuffer("Project{");
sb.append("manager=").append(manager);
sb.append(", name='").append(name).append('\'');
sb.append(", objective='").append(objective).append('\'');
sb.append(", funds=").append(funds);
sb.append('}');
return sb.toString();
}
}
abstract class CommercialMilitaryProject extends Project {
private final String deadline;
private int maxMembers;
public CommercialMilitaryProject(Manager manager, String name, String objective, long funds, String deadline, int maxMembers) {
super(manager, name, objective, funds);
this.deadline = deadline;
this.maxMembers = maxMembers;
}
@Override
public void addProgrammer(Programmer programmer) {
if (maxMembers > getNumberOfMembers()) {
super.addProgrammer(programmer);
} else {
System.out.println("The number of maximum members has been reached");
}
}
}
class MilitaryProject extends CommercialMilitaryProject {
private String password;
public MilitaryProject(Manager manager, String name, String objective, long funds, String deadline, int maxMembers, String password) {
super(manager, name, objective, funds, deadline, maxMembers);
this.password = password;
}
@Override
public double getRisk() {
return (double) super.getNumberOfMembers() / this.password.length() / super.getFunds();
}
}
class CommercialProject extends CommercialMilitaryProject {
private int numberOfTeams;
private double marketingFunds;
public CommercialProject(Manager manager, String name, String objective, long funds, String deadline, int maxMembers, int numberOfTeams) {
super(manager, name, objective, funds, deadline, maxMembers);
this.numberOfTeams = numberOfTeams;
this.marketingFunds = (double) super.getFunds() / 2;
}
@Override
public double getRisk() {
return (double) this.numberOfTeams * 3 / super.getNumberOfMembers() / this.marketingFunds;
}
}
class OpenSourceProject extends Project {
private String mailingList;
public OpenSourceProject(Manager manager, String name, String objective, long funds, String mailingList) {
super(manager, name, objective, funds);
this.mailingList = mailingList;
}
@Override
public double getRisk() {
return (double) super.getNumberOfMembers() / super.getFunds();
}
}
class InvestmentCompany {
private List<Project> projects = new LinkedList<>();
public void addProject(Project p) {
this.projects.add(p);
}
public void removeProject(Project p) {
this.projects.remove(p);
}
public Project getBestInvestment() {
Project lowestRiskProject = projects.get(0);
for (var project : projects) {
if (project.getRisk() < lowestRiskProject.getRisk()) {
lowestRiskProject = project;
}
}
return lowestRiskProject;
}
}
public class Main {
public static void main(String[] args) {
InvestmentCompany ic1 = new InvestmentCompany();
Project p1 = new MilitaryProject(new Manager("John A.", 40), "Military Project-y28", "Defense", 1000000,
"31.12.2017", 15, "Military-Defense");
p1.addProgrammer(new Programmer("Mike", 25));
Project p2 = new CommercialProject(new Manager("Andrew", 42), "Comercial Project-December", "Christmas", 100000,
"25.01.2017", 15, 3);
p2.addProgrammer(new Programmer("Johnson", 24));
p2.addProgrammer(new Programmer("Adams", 31));
Project p3 = new OpenSourceProject(new Manager("Chris", 38), "Open-Source Project_Frostivus", "Game-Design", 1000,
"Mail-1 Mail-2 Mail-3");
p3.addProgrammer(new Programmer("Smith", 28));
p3.addProgrammer(new Programmer("Clark", 29));
p3.addProgrammer(new Programmer("Lewis", 27));
ic1.addProject(p1);
ic1.addProject(p2);
ic1.addProject(p3);
System.out.println(ic1.getBestInvestment());
}
}
VARIANTA C
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define resizeCapacity(STRUCTURE_TYPE) \
STRUCTURE_TYPE **resize##STRUCTURE_TYPE##s(STRUCTURE_TYPE **STRUCTURE_TYPE##s, unsigned int currentCapacity)\
{ unsigned int newCapacity = 2 * currentCapacity;\
STRUCTURE_TYPE **tmp = (STRUCTURE_TYPE**)realloc(STRUCTURE_TYPE##s, newCapacity*sizeof(STRUCTURE_TYPE));\
if(NULL == tmp){\
printf("Not enough memory for reallocation");\
return NULL;\
}\
STRUCTURE_TYPE##s = tmp;\
return STRUCTURE_TYPE##s;\
}
void *allocMemory(size_t memory) {
void *p = malloc(memory);
if (!p) {
printf("Not enough memory");
exit(EXIT_FAILURE);
}
return p;
}
typedef struct Project Project;
typedef struct Risk {
double (*getRisk)(Project *p);
} Risk;
typedef struct Programmer {
short unsigned int age;
char *name;
} Programmer;
typedef struct BaseProject {
char *title;
char *objective;
long funds;
Programmer *manager;
Programmer **programmers;
unsigned int numberOfProgrammers;
unsigned int maxProgrammers;
} BaseProject;
struct Project {
Risk *riskOperations;
BaseProject *baseProject;
};
typedef struct InvestmentCompany {
Project **projects;
unsigned int numberOfProjects;
unsigned int maxNumberOfProjects;
} InvestmentCompany;
typedef struct CommercialProject {
Project project;
unsigned int numberOfTeams;
long marketingFunds;
} CommercialProject;
typedef struct MilitaryProject {
Project project;
char *deadline;
char *password;
} MilitaryProject;
typedef struct OpenSourceProject {
Project project;
char *mailingList;
} OpenSourceProject;
double getCommercialProjectRisk(Project *project) {
CommercialProject *c = (CommercialProject *) project;
return (double) c->numberOfTeams * 3 / c->project.baseProject->numberOfProgrammers / (double) c->marketingFunds;
}
double getMilitaryProjectRisk(Project *project) {
MilitaryProject *m = (MilitaryProject *) project;
return (double) m->project.baseProject->numberOfProgrammers / (double) strlen(m->password) / (double) m->project.baseProject->funds;
}
double getOpenSourceProjectRisk(Project *project) {
OpenSourceProject *os = (OpenSourceProject *) project;
return (double) os->project.baseProject->numberOfProgrammers / (double) os->project.baseProject->funds;
}
Risk commercialRisk = {getCommercialProjectRisk};
Risk militaryRisk = {getMilitaryProjectRisk};
Risk openSourceRisk = {getOpenSourceProjectRisk};
InvestmentCompany *newInvestmentCompany() {
InvestmentCompany *investmentCompany = (InvestmentCompany *) allocMemory(sizeof(InvestmentCompany));
investmentCompany->numberOfProjects = 0;
investmentCompany->maxNumberOfProjects = 10;
investmentCompany->projects = (Project **) allocMemory(investmentCompany->maxNumberOfProjects * sizeof(Project));
investmentCompany->projects[0] = NULL;
return investmentCompany;
}
resizeCapacity(Project)
InvestmentCompany *addProjectToInvestmentCompany(InvestmentCompany *investmentCompany, Project *project) {
Project **tmp = NULL;
if (investmentCompany->maxNumberOfProjects == investmentCompany->numberOfProjects) {
tmp = resizeProjects(investmentCompany->projects, investmentCompany->numberOfProjects);
if (NULL == tmp) {
return NULL;
}
}
if(NULL != tmp) {
investmentCompany->projects = tmp;
investmentCompany->maxNumberOfProjects *= 2;
}
investmentCompany->projects[investmentCompany->numberOfProjects] = project;
++investmentCompany->numberOfProjects;
return investmentCompany;
}
Programmer *newProgrammer(int age, char *name) {
Programmer *programmer = (Programmer *) allocMemory(sizeof(Programmer));
programmer->age = age;
programmer->name = name;
return programmer;
}
BaseProject *newBaseProject(char *title, char *objective, long funds, Programmer *manager) {
BaseProject *base = allocMemory(sizeof(BaseProject));
base->title = title;
base->objective = objective;
base->funds = funds;
base->numberOfProgrammers = 0;
base->maxProgrammers = 14;
base->manager = manager;
base->programmers = (Programmer **) allocMemory(base->maxProgrammers * sizeof(Programmer));
base->programmers[0] = NULL;
return base;
}
resizeCapacity(Programmer)
BaseProject *addProgrammer(BaseProject *baseProject, Programmer *programmer) {
Programmer **tmp = NULL;
if (baseProject->maxProgrammers == baseProject->numberOfProgrammers) {
tmp = resizeProgrammers(baseProject->programmers, baseProject->numberOfProgrammers);
if (NULL == tmp) {
return NULL;
}
}
if(NULL != tmp) {
baseProject->programmers = tmp;
baseProject->maxProgrammers *= 2;
}
baseProject->programmers[baseProject->numberOfProgrammers] = programmer;
++baseProject->numberOfProgrammers;
return baseProject;
}
Project *newProject(BaseProject *baseProject, Risk *risk) {
Project *project = (Project *) allocMemory(sizeof(Project));
project->baseProject = baseProject;
project->riskOperations = risk;
return project;
}
CommercialProject *newCommercialProject(BaseProject *baseProject, unsigned int numberOfTeams) {
Project *project = newProject(baseProject, &commercialRisk);
CommercialProject *commercialProject = (CommercialProject *) allocMemory(sizeof(CommercialProject));
commercialProject->project = *project;
commercialProject->marketingFunds = project->baseProject->funds / 2;
commercialProject->numberOfTeams = numberOfTeams;
return commercialProject;
}
MilitaryProject *newMilitaryProject(BaseProject *baseProject, char *deadline, char *password) {
Project *project = newProject(baseProject, &militaryRisk);
MilitaryProject *militaryProject = (MilitaryProject *) allocMemory(sizeof(MilitaryProject));
militaryProject->project = *project;
militaryProject->password = password;
militaryProject->deadline = deadline;
return militaryProject;
}
OpenSourceProject *newOpenSourceProject(BaseProject *baseProject, char *mailingList) {
Project *project = newProject(baseProject, &openSourceRisk);
OpenSourceProject *openSourceProject = (OpenSourceProject *) allocMemory(sizeof(OpenSourceProject));
openSourceProject->project = *project;
openSourceProject->mailingList = mailingList;
return openSourceProject;
}
MilitaryProject *addProgrammerToMilitaryProject(MilitaryProject *militaryProject, Programmer *programmer) {
if (militaryProject->project.baseProject->numberOfProgrammers < militaryProject->project.baseProject->maxProgrammers) {
BaseProject *tmp = addProgrammer(militaryProject->project.baseProject, programmer);
if (NULL == tmp) {
printf("Adding programmer to military project failed");
return NULL;
}
militaryProject->project.baseProject = tmp;
}
return militaryProject;
}
CommercialProject *addProgrammerToCommercialProject(CommercialProject *commercialProject, Programmer *programmer) {
if (commercialProject->project.baseProject->numberOfProgrammers < commercialProject->project.baseProject->maxProgrammers) {
BaseProject *tmp = addProgrammer(commercialProject->project.baseProject, programmer);
if (NULL == tmp) {
printf("Adding programmer to commercial project failed");
return NULL;
}
commercialProject->project.baseProject = tmp;
}
return commercialProject;
}
OpenSourceProject *addProgrammerToOpenSourceProject(OpenSourceProject *openSourceProject, Programmer *programmer) {
BaseProject *tmp = addProgrammer(openSourceProject->project.baseProject, programmer);
if (NULL == tmp) {
printf("Adding programmer to open-source project failed");
return NULL;
}
openSourceProject->project.baseProject = tmp;
return openSourceProject;
}
Project *getBestInvestment(InvestmentCompany *investmentCompany) {
Project *bestProject = investmentCompany->projects[0];
double lowestRisk = bestProject->riskOperations->getRisk(bestProject);
unsigned int numberOfProjects = investmentCompany->numberOfProjects;
for (unsigned int i = 1; i < numberOfProjects; ++i) {
Project *currentProject = investmentCompany->projects[i];
double currentRisk = currentProject->riskOperations->getRisk(currentProject);
if (currentRisk < lowestRisk) {
bestProject = currentProject;
lowestRisk = currentRisk;
}
}
return bestProject;
}
void testing() {
Programmer *programmer1 = newProgrammer(20, "name1");
Programmer *programmer2 = newProgrammer(25, "name2");
Programmer *programmer3 = newProgrammer(30, "name2");
Programmer *manager1 = newProgrammer(35, "Manager1");
Programmer *manager2 = newProgrammer(45, "Manager2");
Programmer *manager3 = newProgrammer(55, "Manager3");
BaseProject *baseProject1 = newBaseProject("Project1", "Objective1", 10000, manager1);
BaseProject *baseProject2 = newBaseProject("Project2", "Objective2", 20000, manager2);
BaseProject *baseProject3 = newBaseProject("Project3", "Objective3", 30000, manager3);
CommercialProject *commercialProject = newCommercialProject(baseProject1, 3);
MilitaryProject *militaryProject = newMilitaryProject(baseProject2, "31.12.2021", "password");
OpenSourceProject *openSourceProject = newOpenSourceProject(baseProject3, "mail1, mail2");
commercialProject = addProgrammerToCommercialProject(commercialProject, programmer1);
commercialProject = addProgrammerToCommercialProject(commercialProject, programmer2);
commercialProject = addProgrammerToCommercialProject(commercialProject, programmer3);
militaryProject = addProgrammerToMilitaryProject(militaryProject, programmer1);
militaryProject = addProgrammerToMilitaryProject(militaryProject, programmer2);
militaryProject = addProgrammerToMilitaryProject(militaryProject, programmer3);
openSourceProject = addProgrammerToOpenSourceProject(openSourceProject, programmer1);
openSourceProject = addProgrammerToOpenSourceProject(openSourceProject, programmer2);
openSourceProject = addProgrammerToOpenSourceProject(openSourceProject, programmer3);
InvestmentCompany *investmentCompany = newInvestmentCompany();
investmentCompany = addProjectToInvestmentCompany(investmentCompany, (Project *) commercialProject);
investmentCompany = addProjectToInvestmentCompany(investmentCompany, (Project *) militaryProject);
investmentCompany = addProjectToInvestmentCompany(investmentCompany, (Project *) openSourceProject);
printf("Best project %s", getBestInvestment(investmentCompany)->baseProject->title);
}
int main(int argc, char *argv[]) {
testing();
return 0;
}