class A
{
    A Show()
    {
        System.out.println("first");
        return this;
    }
}
class B extends A
{
    B Show()
    {
        super.Show();
        System.out.println("second");
        return this;
    }
}
class C
{
    public static void main(String[] args)
    {
        B r = new B();
        r.Show();
    }
    
}

class A
{
    A show()
    {
        System.out.println("super");
        return this; // return as it is 
    }
}
class B extends A
{
    @Override
    B show()
    {
        System.out.println("supreme");
        return this; // return as it is
    }
}
class F
{
    public static void main(String[] args){
        B r= new B();
        r.show();
    }
}

using System.Collections;
using Sestem.Collections.Generic;
using UnityEngine;
 
public class Balloon : MonoBehaviour
{
  	public int scoreToGive = 1;
  	public int clicksToPop = 5; 
  	public float scaleIncreasePerClick = 0.1f;
  
	void OnMouseDown()
  	{
      clicksToPop -= 1;
      transform.localScale += Vector3.one * scaleIncreasePerClick; 

    }
  
}

DATABASES = {
        'default': {
            'ENGINE': 'djongo',
            'NAME': 'DjongoTutorial',
            'ENFORCE_SCHEMA': True,
            'CLIENT': {
                'host': 'mongodb://localhost:27017/'
            }
        }
}

using System.Collections;
using Sestem.Collections.Generic;
using UnityEngine;

public class Balloon : MonoBehaviour
{
  //Start is called before the first frame update
  void Start()
  {
    
  }
  
  //Update is called once per frame
  void Update()
  {
    
  }
  
}

const percentageMatch = (y / x) * 100;
console.log(`Percentage Match: ${percentageMatch}%`);

async function qdb(sanitizedText) {
    try {
        const query = `
            SELECT answer
            FROM openai_model
            WHERE text='${sanitizedText}'
        `;

        const queryResult = await MindsDB.SQL.runQuery(query);
        console.log(queryResult);
    } catch (error) {
        console.log(error);
    }
}

CREATE MODEL openai_model
PREDICT answer
USING
    engine = 'openai_engine',
    prompt_template = 'Generate five multiple-choice questions with correct answers to assess a candidate's knowledge in deep tech areas. Ensure questions cover a range of topics and difficulty levels based on their resume. Examples may include specific programming languages, tools, frameworks, and best practices.',
    text:{{text}},
    max_tokens = 500,
    temperature = 0.3,
    api_key = 'your-api-key';

CREATE ML_ENGINE openai_engine
FROM openai
USING
	api_key = 'your-openai-api-key';

async function connectToMindsDB() {
    try {
        await MindsDB.connect({
            host: 'http://127.0.0.1:47334'
        });
        console.log('Connected to MindsDB');
    } catch (error) {
        console.error('Error connecting to MindsDB:', error);
    }
}

async function processPDF() {
    try {
        let dataBuffer = fs.readFileSync('/home/phineas/Documents/21113032_Default Resume_2023-10-31_19_03_01.pdf');
        const data = await pdf(dataBuffer);
        
        data.text = data.text.replace(/[\u2018\u2019']/g, '');
        const sanitizedText = data.text.replace(/'/g, "''");

        console.log(sanitizedText);

        await connectToMindsDB();
        await qdb(sanitizedText);
    } catch (error) {
        console.error('Error processing PDF:', error);
    }
}

processPDF();

export default function JobDescriptionCard({ details, j_id }) {
    const [expanded, setExpanded] = React.useState(false);

    const handleExpandClick = () => {
        setExpanded(!expanded);
    };

    return (
        <Card sx={{ width: "auto" }}>
            <CardHeader title={details?.job_title} subheader="July, 2023" />
            <CardContent>
                <Typography variant="body2" color="text.secondary">
                    {details?.jd}
                </Typography>
            </CardContent>
            <CardActions disableSpacing>
                <IconButton aria-label="share">
                    <ShareIcon />
                    <p
                        onClick={() => {
                            navigator.clipboard.writeText(`http://localhost:3000/job/${j_id}`);
                            alert("Link Copied ");
                        }}
                        style={{ marginLeft: '10px', fontSize: '15px' }}
                    >
                        http://localhost:3000/job/{j_id}
                    </p>
                </IconButton>
            </CardActions>
        </Card>
    );
}

<Modal open={isOpen} onClose={() => setIsOpen(false)}>
        <div className="add-job-modal">
          {flag ? (
            <>
              <h1 className="gradient__text" style={{ padding: "20px" }}>
                Job has been successfully posted. Share the following link with
                the candidates for hiring!!!
              </h1>
              <div className="modal-link">
                <a
                  className="modal-a"
                  style={{ paddingLeft: "30px", color: "blue" }}
                  href={http://localhost:3000/job/${jobId}}
                >
                  http://localhost:3000/job/{jobId}
                </a>
                <button
                  className="copy-button"
                  onClick={() =>
                    handlecopy(http://localhost:3000/job/${jobId})
                  }
                >
                  {buttontxt}
                </button>
              </div>

# Fetch changes from the remote without merging
git fetch origin main

# Rebase your local changes on top of the changes fetched from the remote
git rebase origin/main

# Now you can push your changes
git push origin main

import mongoose from 'mongoose';
const { Schema } = mongoose;

const BlogSchema = new Schema({
  title: String, // String is shorthand for {type: String}
  author: String,
  body: String,
  isDone:Boolean
});
export const Blog = mongoose.model('Todo', BlogSchema)

class A
{
    void show()
    {
        System.out.print("super");
    }
}
class B extends A
{
    @Override
    void show()
    {
        System.out.print("supt");
    }
}
class F
{
    public static void main(String[] args){
        B r= new B();
        r.show();
    }
}

Static Server boolean validateURL(URL    _url)
{
    Boolean   xppBool;
    System.Boolean netBool;
    Str matchURLPattern = "^(https?://)"
        + "?(([0-9a-z_!~*'().&=+$%-]+: )?[0-9a-z_!~*'().&=+$%-]+@)?" //user@
        + @"(([0-9]{1,3}\.){3}[0-9]{1,3}" // IP- 199.194.52.184
        + "|" // allows either IP or domain
        + @"([0-9a-z_!~*'()-]+\.)*" // tertiary domain(s)- www.
        + @"([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\." // second level domain
        + "[a-z]{2,6})" // first level domain- .com or .museum
        + "(:[0-9]{1,4})?" // port number- :80
        + "((/?)|" // a slash isn't required if there is no file name
        + "(/[0-9a-z_!~*'().;?:@&=+$,%#-]+)+/?)$";
    System.Text.RegularExpressions.Match myMatch;
    new InteropPermission(InteropKind::ClrInterop).assert();
    myMatch = System.Text.RegularExpressions.Regex::Match(_url,matchURLPattern);
    netBool = myMatch.get_Success();
    xppBool = netBool;
    CodeAccessPermission::revertAssert();
    Return xppBool;

}

Static Server boolean validateEMail(EMail    _eMail)
{
    Boolean   xppBool;
    System.Boolean netBool;
    Str MatchEmailPattern =
       @"^(([\w-]+\.)+[\w-]+|([a-zA-Z]{1}|[\w-]{2,}))@"
     + @"((([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?
       [0-9]{1,2}|25[0-5]|2[0-4][0-9])\."
     + @"([0-1]?[0-9]{1,2}|25[0-5]|2[0-4][0-9])\.([0-1]?
       [0-9]{1,2}|25[0-5]|2[0-4][0-9])){1}|"     
     + @"([\w-]+\.)+[a-zA-Z]{2,4})$";
    System.Text.RegularExpressions.Match myMatch;
    ;

    new InteropPermission(InteropKind::ClrInterop).assert();
    myMatch = System.Text.RegularExpressions.Regex::Match(_eMail,MatchEmailPattern);
    netBool = myMatch.get_Success();
    xppBool = netBool;
    CodeAccessPermission::revertAssert();
    Return xppBool;
} 

// Notify user when role is changed

function notify_user_on_role_change( $user_id, $new_role ) {

    $user_info = get_userdata( $user_id );

    $to = $user_info->user_email;

    $subject = 'Your role has been changed';

    $message = 'Hello ' . $user_info->display_name . ', your role has been changed to ' . $new_role . '.';

    wp_mail( $to, $subject, $message );

}

add_action( 'set_user_role', 'notify_user_on_role_change', 10, 2 );

// Hide update notifications for non-admin users

function hide_update_notifications() {

    if ( ! current_user_can( 'manage_options' ) ) {

        remove_action( 'admin_notices', 'update_nag', 3 );

    }

}

add_action( 'admin_head', 'hide_update_notifications' );

​

Query query = new Query();
QueryBuildDataSource qbds , qbdsCheck;
SysTableLookup _sysTableLookup = SysTableLookup::newParameters(tableNum(PurchReqTable),This);

qbds= query.addDataSource(tableNum(PurchReqTable));

qbds.addRange(fieldNum(PurchReqTable , RequisitionStatus)).value(enum2Str(PurchReqRequisitionStatus::Approved));
qbds.addRange(fieldNum(PurchReqTable , NW_RequestCategory)).value(enum2Str(NW_RequestCategory::RFP_RFQ));

qbdsCheck = qbds.addDataSource(tableNum(PurchRFQCaseTable));
qbdsCheck.addLink(fieldNum(PurchReqTable , PurchReqId) ,fieldNum(PurchRFQCaseTable , PurchReqId));
qbdsCheck.joinMode(JoinMode::NoExistsJoin);


_sysTableLookup.parmQuery(query);
_sysTableLookup.addLookupfield(fieldNum(PurchReqTable, PurchReqId));
_sysTableLookup.addLookupfield(fieldNum(PurchReqTable, PurchReqName ));

_sysTableLookup.performFormLookup();

//cancel the call to super() to prevent the system from trying to show 
//the lookup form twice and cause an error.
FormControlCancelableSuperEventArgs cancelableSuperEventArgs = e as FormControlCancelableSuperEventArgs;
cancelableSuperEventArgs.CancelSuperCall();
    

class D
{
    int a=10;
    D()
    {
        System.out.println(a);
    }
    public static void main(String[] args){
        
        D r = new D();
        
    }
}

class D
{
    int a=10;
    D()
    {
        System.out.println(a);
    }
    public static void main(String[] args){
        
        D r = new D();
        
    }
}

class D
{
    int a=10;
    public static void main(String[] args){
        
        D r = new D();
        System.out.println(r.a);
    }
}

// Rename Description tab

add_filter( 'woocommerce_product_tabs', 'misha_rename_description_tab' );

function misha_rename_description_tab( $tabs ) {

    $tabs[ 'description' ][ 'title' ] = 'Penerangan Produk';

    return $tabs;

}

​

final class D
{
    void number()
    {
        System.out.println("true");
    }
    
}
class P extends D // it will show error as its ssinged as final ....
{
   
    void number()
    {
        System.out.println("true");
    }
    
}

class O
{
    public static void main(String[] args)
    {
        P r = new P();
        r.number();
        
}
}

PEAS is an AI agent representation system that focuses on evaluating the performance of the environment, sensors, and actuators. We need to be aware of our job environment to create an agent. The PEAS system aids in defining the task environment. Performance, Environment, Actuators, and Sensors are abbreviated as PEAS. AI algorithms can be written more effectively by identifying PEAS.


Performance measures: These are the parameters used to measure the performance of the agent. How well the agent is carrying out a particular assigned task.
Environment: It is the task environment of the agent. The agent interacts with its environment. It takes perceptual input from the environment and acts on the environment using actuators.
Actuators: These are the means of performing calculated actions on the environment. For a human agent; hands and legs are the actuators.
Sensors: These are the means of taking the input from the environment. For a human agent; ears, eyes, and nose are the sensors.

Examples of PEAS Descriptors
1. PEAS Descriptor of Automated Car Driver
Performance

Safety − The automated system needs to be able to operate the vehicle securely without rushing.

Optimized Speed − Depending on the environment, automated systems should be able to maintain the ideal speed.

Journey − The end-user should have a comfortable journey thanks to automated systems.

Environment

Roads − Automated automobile drivers ought to be able to go on any type of route, from local streets to interstates.

Traffic Conditions − For various types of roadways, there are various traffic conditions to be found.

Actuators

Steering wheel − to point an automobile in the appropriate direction.

Gears and accelerators − adjusting the car's speed up or down.

Sensors

In-car driving tools like cameras, sonar systems, etc. are used to collect environmental data.

Intelligent Agents:
An intelligent agent is an autonomous entity which act upon an environment using sensors and actuators for achieving goals. An intelligent agent may learn from the environment to achieve their goals. A thermostat is an example of an intelligent agent.

Simple Reflex Agent
Model-based reflex agent
Goal-based agents
Utility-based agent
Learning agent

https://www.javatpoint.com/types-of-ai-agents

class Final 
{
    public static void main(String[] args)
    {
        final int a=20;// fial value now it cannot be changed 
        System.out.print(a);
        
        a=20;// cannot assinged once again
        System.out.print(a);
    }
}

interface D
{
    default void call()
    {
        plus(10,20);
    }
    private void plus(int x,int y)
    {
        System.out.println("plus answer will be "+(x+y));
    }
}
class X implements D
{
    public void subtract(int x, int y)
    {
        System.out.println("subtract answer will be "+(x-y));
    }
}
class C
{
    public static void main(String[] args)
    {
        X r= new X();
        r.call();
        r.subtract(20,10);
    }
}

interface A
{
    public static void Show()
    {
        System.out.println("okay bhai");
    }
}
class  D
{
    public static void main(String[] args)
    {
        A.Show();
    }
}

interface A
{
    void S();
    void P();
    default void L()
    {
        System.out.println("hii baby");
    }
}
class D implements A
{
    public void S()
    {
        System.out.println("class D");
    }
    public void P()
    {
        System.out.println("class P");
    }
}
class p
{
    public static void main(String[] args)
    {
        D r= new D();
        r.S();
        r.P();
        r.L();
    }
}

Adversarial search is a search, where we examine the problem which arises when we try to plan ahead of the world and other agents are planning against us.


The environment with more than one agent is termed as multi-agent environment, in which each agent is an opponent of other agent and playing against each other. Each agent needs to consider the action of other agent and effect of that action on their performance.

So, Searches in which two or more players with conflicting goals are trying to explore the same search space for the solution, are called adversarial searches, often known as Games.

Chess, checkers, and tic-tac-toe are the three most popular games that can be solved via adversarial search. 

In many real-world applications, such as financial decision-making and military operations, adversarial search is used.

Formalization of the problem:
A game can be defined as a type of search in AI which can be formalized of the following elements:
Initial state: It specifies how the game is set up at the start.
Player(s): It specifies which player has moved in the state space.
Action(s): It returns the set of legal moves in state space.
Result(s, a): It is the transition model, which specifies the result of moves in the state space.
Terminal-Test(s): Terminal test is true if the game is over, else it is false at any case. The state where the game ends is called terminal states.
Utility(s, p): A utility function gives the final numeric value for a game that ends in terminal states s for player p. It is also called payoff function. For Chess, the outcomes are a win, loss, or draw and its payoff values are +1, 0, ½. And for tic-tac-toe, utility values are +1, -1, and 0.

Example: Tic-Tac-Toe game tree:
The following figure is showing part of the game-tree for tic-tac-toe game. Following are some key points of the game:

There are two players MAX and MIN.
Players have an alternate turn and start with MAX.
MAX maximizes the result of the game tree
MIN minimizes the result.

https://static.javatpoint.com/tutorial/ai/images/ai-adversarial-search.png

From the initial state, MAX has 9 possible moves as he starts first. MAX place x and MIN place o, and both player plays alternatively until we reach a leaf node where one player has three in a row or all squares are filled.
Both players will compute each node, minimax, the minimax value which is the best achievable utility against an optimal adversary.
Suppose both the players are well aware of the tic-tac-toe and playing the best play. Each player is doing his best to prevent another one from winning. MIN is acting against Max in the game.
So in the game tree, we have a layer of Max, a layer of MIN, and each layer is called as Ply. Max place x, then MIN puts o to prevent Max from winning, and this game continues until the terminal node.
In this either MIN wins, MAX wins, or it's a draw. This game-tree is the whole search space of possibilities that MIN and MAX are playing tic-tac-toe and taking turns alternately.

How to write a great documentation (in 5 points)

1. Use question and answer look (more like FAQs)
2. Use pointers wherever possible
    a. maximum 5, preferably 3
    b. if goes beyond 5, try making sub-points instead
3. Diagrams wherever possible. a 🖼 is worth a 1000 words
4. Be precise, but accurate. And have  w h i t e  s p a c e s , increases readability.
5. Avoid similar synonyms, generous adjectives, spellnig and grammatical the mistakes
    a. repeat same words already used to refer something
    b. have links to go to something previously explained
    c. Avoid external links, instead provide a brief. Add link only for confidence (reduces distraction)

console.log("start");
setTimeout(function(){
console.log("hey I am good")},3000) ;                             
console.log("end");

output-
start
end
hey I am good

// show dir inside image
docker run --rm -it --entrypoint=/bin/bash imagename

Machine learning: It deals with developing algorithms that can learn from data. ML algorithms are used in various applications, including image recognition, spam filtering, and natural language processing.
For example, to identify a simple object such as an apple or orange.

Deep learning: It is a branch of machine learning that harnesses artificial neural networks to acquire knowledge from data. Deep learning algorithms effectively solve various problems, including NLP, image recognition and speech recognition.

Natural language processing: It deals with the interaction between computers and human language. NLP techniques are used to understand and process human language and in various applications, including machine translation, speech recognition, and text analysis.

Robotics: It is a field of engineering that deals with robot design, construction, and operation. Robots can perform tasks automatically in various industries, including manufacturing, healthcare, and transportation.
For example, car assembly lines, in hospitals, office cleaner, serving 
foods and preparing foods in hotels etc. 

Expert systems: They are computer programs designed to mimic human experts' reasoning and decision-making abilities. Expert systems are used in various applications, including medical diagnosis, financial planning, and customer service.

In First-Order Logic, inference is used to derive new facts or sentences from existing ones. 

Universal Generalization
Universal generalization is a valid inference rule that states that if premise P(c) is true for any arbitrary element c in the universe of discourse, we can arrive at the conclusion x P. (x).
It can be represented as:
https://tutorialforbeginner.com/images/tutorial/ai-inference-in-first-order-logic.png
Example: Let's represent, P(c): "A byte contains 8 bits", so "All bytes contain 8 bits."for ∀ x P(x) , it will also be true.

Universal Instantiation
A valid inference rule is universal instantiation, often known as universal elimination or UI. It can be used to add additional sentences many times.
The new knowledge base is logically equal to the existing knowledge base.
The UI rule say that we can infer any sentence P(c) by substituting a ground term c (a constant within domain x) from ∀ x P(x) for any object in the universe of discourse.'
It can be represented as
https://tutorialforbeginner.com/images/tutorial/ai-inference-in-first-order-logic.png
Example: 1 IF "Every person like ice-cream"=> ∀x P(x) so we can infer that
"John likes ice-cream" => P(c)

'Existential Instantiation:
Existential instantiation is also known as Existential Elimination, and it is a legitimate first-order logic inference rule.
It can only be used to replace the existential sentence once.
This rule states that for a new constant symbol c, one can deduce P(c) from the formula given in the form of x P(x).
https://tutorialforbeginner.com/images/tutorial/ai-inference-in-first-order-logic3.png
Example: 1

From the given sentence: ∃x Crown(x) ∧ OnHead(x, John),

So we can infer: Crown(K) ∧ OnHead( K, John), as long as K does not appear in the knowledge base.

Existential introduction
An existential generalization is a valid inference rule in first-order logic that is also known as an existential introduction.
This rule argues that if some element c in the universe of discourse has the property P, we can infer that something in the universe has the attribute P.
It's written like this:
https://tutorialforbeginner.com/images/tutorial/ai-inference-in-first-order-logic4.png
Example: Let's say that,
"Priyanka got good marks in English."
"Therefore, someone got good marks in English."
 

First Order Logic in Artificial Intelligence is a technique used for knowledge representation. It is an extension of propositional logic and unlike propositional logic, it is sufficiently expressive in representing any natural language construct. First Order Logic in AI is also known as Predicate Logic or First Order Predicate Logic. It is a robust technique to represent objects as well as their relationships. Unlike propositional logic, First Order Logic in Artificial Intelligence doesn't only include facts but also different other entities as listed below.

Objects:
Objects can denote any real-world entity or any variable. E.g., A, B, colours, theories, circles etc.
Relations:
Relations represent the links between different objects. Relations can be unary(relations defined for a single term) and n-ary(relations defined for n terms). E.g., blue, round (unary); friends, siblings (binary); etc.
Functions:
Functions map their input object to the output object using their underlying relation. Eg: father_of(), mother_of() etc.

Parts of First Order Logic
First-order logic in Artificial Intelligence comprises two main components, which are as follows.

Syntax:
Syntax represents the rules to write expressions in First Order Logic in Artificial Intelligence.
Semantics:
Semantics refers to the techniques that we use to evaluate an expression of First Order Logic in AI. 

it is a class of search algorithm that  have no additional information on the goal node other than the one provided in the problem definition.  have no additional information on the goal node other than the one provided in the problem definition. Uninformed search is also called Blind search. These algorithms can only generate the successors and differentiate between the goal state and non goal state. 

The following uninformed search algorithms are discussed in this section.

Depth First Search
Breadth First Search
Uniform Cost Search

Depth-first search-
Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures.
 The algorithm starts at the root node and explores as far as possible along each branch before backtracking. 
It uses last in- first-out strategy and hence it is implemented using a stack.
example-link for image
https://media.geeksforgeeks.org/wp-content/uploads/question-3-e1547112515247.png
Path:   S -> A -> B -> C -> G 
d        = the depth of the search tree 
n^i        = number of nodes in level i        
Time complexity: Equivalent to the number of nodes traversed in DFS. 
T(n) = 1 + n^2 + n^3 + ... + n^d = O(n^d)        
Space complexity: 
maximum storage space required at any point of dfs.
 S(n) = O(n*d)
Completeness: DFS is complete if the search tree is finite, meaning for a given finite search tree, DFS will come up with a solution if it exists. 
Optimality: DFS is not optimal, meaning the number of steps in reaching the solution, or the cost spent in reaching it is high. 

Breadth-first search 
Breadth-first search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree root and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level. It is implemented using a queue.

example-same image
Path: S -> D -> G 
 s        = the depth of the shallowest solution. 
n^i        = number of nodes in level i        . 
Time complexity: Equivalent to the number of nodes traversed in BFS until the shallowest solution. T(n) = 1 + n^2 + n^3 + ... + n^s = O(n^s)        
Space complexity: Equivalent to how large can the fringe get. S(n) = O(n^s)        
Completeness: BFS is complete, meaning for a given search tree, BFS will come up with a solution if it exists. 

Optimality: BFS is optimal as long as the costs of all edges are equal. 

Uniform Cost Search: 
UCS is different from BFS and DFS because here the costs come into play. In other words, traversing via different edges might not have the same cost. The goal is to find a path where the cumulative sum of costs is the least. 

Path: S -> A -> B -> G 
Cost: 5 
Let C        = cost of solution. 
 epsilon      = arcs cost. 

Then C /epsilon =        effective depth 

Time complexity:   T(n) = O(n^C\epsilon)        , Space complexity:   S(n) = O(n^C/repsilon)

UCS is complete only if states are finite and there should be no loop with zero weight.
UCS is optimal only if there is no negative cost.

    <!DOCTYPE html>
    <html>
      <head>
        <title>Title of webpage</title>
     </head>
      <body>
        <h1>
          Hello, I'm a webpage.
        </h1>
      </body>
    </html>

"""
Exercise 1.10: Evaluate a Gaussian Function
"""

from math import pi, exp, sqrt

m = 0
s = 2
x = 1

y = (1 / (sqrt(2 * pi) * s)*exp((-1/2) * (((x - m)/s) ** 2)))
print(y)

'''
Sample run:
    y = 0.176032663
'''
    

.\rte\Scripts\activatecd 
datasci-codex-api
poetry shell
uvicorn src.app:app --reload

# check version
aws --version

# update CLI
pip install --upgrade awscli

# list S3 buckets
aws s3api list-buckets
aws s3 ls
aws s3 ls s3://dir_name/subdir_name

# set up config
# touch ~/.aws/config
[sso-session my_session]
sso_start_url = https://xxxx-login.awsapps.com/start/
sso_region = us-east-2
sso_registration_scopes = sso:account:access

[profile cwb-d]
output = json
region = us-east-2
sso_session = my_session
sso_account_id = 123456789
sso_role_name = my_role

# authenticate
export AWS_PROFILE=cwb-d
aws sso login --sso-session my_session --no-browser

Searchingis a step by step procedure to solve a search-problem in a given search space. A search problem can have three main factors:
Search Space: Search space represents a set of possible solutions, which a system may have.
Start State: It is a state from where agent begins the search.
Goal test: It is a function which observe the current state and returns whether the goal state is achieved or not.

Properties of Search Algorithms:
Completeness: A search algorithm is said to be complete if it guarantees to return a solution if at least any solution exists for any random input.

Optimality: If a solution found for an algorithm is guaranteed to be the best solution (lowest path cost) among all other solutions, then such a solution for is said to be an optimal solution.

Time Complexity: Time complexity is a measure of time for an algorithm to complete its task.

Space Complexity: It is the maximum storage space required at any point during the search, as the complexity of the problem.

Reactive Machines-
Purely reactive machines are the most basic types of Artificial Intelligence.
Such AI systems do not store memories or past experiences for future actions.
These machines only focus on current scenarios and react on it as per possible best action.
EXAMPLE-IBM's Deep Blue system,Google's AlphaGo

Limited Memory-
Limited memory machines can store past experiences or some data for a short period of time.
These machines can use stored data for a limited time period only.
Self-driving cars are one of the best examples of Limited Memory systems. These cars can store recent speed of nearby cars, the distance of other cars, speed limit, and other information to navigate the road.

Theory of Mind-
Theory of Mind AI should understand the human emotions, people, beliefs, and be able to interact socially like humans.
This type of AI machines are still not developed, but researchers are making lots of efforts and improvement for developing such AI machines.
FOR EXAMPLE-SOPHIA,it can identify animals and human beings and act act like a human but the research is not yet compketed.

Self-Awareness-
Self-awareness AI is the future of Artificial Intelligence. These machines will be super intelligent, and will have their own consciousness, sentiments, and self-awareness.
These machines will be smarter than human mind.
Self-Awareness AI does not exist in reality still and it is a hypothetical concept.
for example-the feeling of i want to play and I know I want to play.first sentence is a charcterstic of theory of mind but second sentence shows the sense of consiousness which is a charcterstic of self awarness machines.

Creating an expert system-
  
 Implementing human intelligence in machines-

Enhancing Efficiency and Automation-
One of the primary goals of AI is to streamline processes and enhance efficiency across industries. Automation powered by AI algorithms can handle repetitive tasks with precision and speed.

Decision-Making and Predictive Analytics-
 Through the power of machine learning, AI algorithms can analyze vast amounts of data to predict trends, identify patterns, and even foresee potential outcomes. 

Personalization and User Experience-
As AI systems become more sophisticated, they aim to provide personalized experiences for users. Recommendation engines and personalized content delivery are examples of AI’.

Natural Language Processing and Understanding-

import java.util.LinkedList;
import java.util.Queue;

public class Main { 
  public static void main(String[] args) {
    Queue songs = new LinkedList<>();
    songs.add("Szmaragdy i Diamenty");
    songs.add("Ja uwielbiam ją");
    songs.add("Chłop z Mazur");

    System.out.println("Playlista na dziś: " + songs);
    for (int i = 0; i < songs.size(); i++) {
        System.out.println("gram: " + songs.poll() +
              " [następnie: " + songs.peek() + "]");
    }
}
} 

<div class="src-shared-react-components-QuickStats-style___value___qrL0B">150</div>