En algoritme er en sekvens af instruktioner, der udføres i en forudbestemt rækkefølge for at løse et problem eller fuldføre et arbejde. En funktion er en kodeblok, der kan kaldes og udføres fra andre dele af programmet.

Et sæt instruktioner til at løse et problem eller udføre en bestemt aktivitet. Inden for datalogi bruges algoritmer til en bred vifte af operationer, fra grundlæggende matematik til indviklet databehandling.

En af de almindelige algoritmer, der bruges i C, er sorteringsalgoritmen. En sorteringsalgoritme arrangerer en samling af elementer i en bestemt rækkefølge, såsom numerisk eller alfabetisk.

Der er mange sorteringsalgoritmer, hver med fordele og ulemper. De mest almindelige sorteringsalgoritmer i C er quicksort, fletning og sortering.

En af nøglefunktionerne ved C er pointerunderstøttelse. Dette muliggør effektiv manipulation af datastrukturer såsom arrays, køer osv. Dette gør den velegnet til implementering af algoritmer, der kræver kompleks datamanipulation, såsom sortering og algoritmisk søgning.

Et af de berømte eksempler på softwarebibliotek implementeret i C er Standard Template Library (STL). Dette bibliotek giver en bred vifte af algoritmer til opgaver såsom sortering, søgning og manipulation af datastrukturer.

Funktioner af algoritmen

Den definerer flere vigtige funktioner i algoritmen, herunder:

Indgange: Algoritmer skal modtage input, der kan repræsenteres som værdier eller data.Produktion: Algoritmen skal producere noget output. Det kan være en konsekvens af et problem eller en løsning designet til at løse det.Klarhed: Algoritmer skal defineres præcist ved hjælp af utvetydige instruktioner, som en computer eller et andet system kan følge utvetydigt.Endelighed: Algoritmen kræver et begrænset antal trin. Det betyder, at det skal afsluttes efter at have udført et vist antal kommandoer.Gyldighed: Algoritmen skal være gyldig. Den skulle med andre ord kunne producere en løsning på det problem, som algoritmen er designet til at løse inden for rimelig tid.Effektivitet:En algoritme skal være effektiv, hvilket vil sige, at den skal være i stand til at producere en løsning på det problem, den er designet til at løse inden for rimelig tid.Generelt:En algoritme skal være generel, hvilket betyder, at den kan anvendes på en bred vifte af problemer i stedet for at være specifik for et enkelt problem.

Algoritmeanalyse

Algoritmisk analyse er processen med at evaluere algoritmens ydeevne i form af effektivitet, kompleksitet og andre kriterier. Dette gøres typisk for at evaluere mange algoritmer og vælge den optimale løsning til et bestemt problem eller en software.

Analyse af algoritmer involverer normalt måling af deres tid og rum kompleksitet.

Som med pladskompleksitet, der beskriver mængden af ​​hukommelse eller diskplads, der er nødvendig, beskriver tidskompleksitet, hvor længe en algoritme bestemmer at udføre en opgave.

Der er forskellige måder at analysere tidskompleksiteten af ​​algoritmer, såsom Big O og Omega notation. Omega-symbolet giver en øvre grænse for algoritmens tidskompleksitet, mens Omega-symbolet giver en nedre grænse.

Ud over måling af tid og rumkompleksitet omfatter algoritmeanalyse også andre kriterier såsom stabilitet, parallelitet og skalerbarhed.

Stabilitet:- Dette refererer til algoritmens evne til at opretholde den relative rækkefølge af elementerne i datasættet.Parallelisering:- Dette refererer til kapaciteten til at udføre operationer parallelt på tværs af flere processorer.Skalerbarhed:- På den anden side refererer det til en algoritmes evne til at håndtere store mængder data og andre input.

De omfatter to typer analyser.

de er:-

1. Forudgående analyse.
2. Posterior analyse.

Forudgående analyse

Prior er en metode til algoritmeanalyse, der fokuserer på at estimere ydeevnen af ​​en algoritme baseret på dens matematiske egenskaber uden faktisk at udføre algoritmen.

Denne tilgang giver dig mulighed for at analysere tids- og rumkompleksiteten af ​​algoritmer og andre målinger uden at skulle implementere og køre algoritmerne.

Posterior analyse

Posterior analyse er på den anden side en metode til algoritmeanalyse, der rent faktisk udfører algoritmen og måler dens ydeevne.

Denne tilgang giver mere præcise og detaljerede oplysninger om algoritmens ydeevne, men kræver implementering og eksekvering af algoritmen.

Algoritme kompleksitet

Algoritmisk kompleksitet er et mål til at måle effektiviteten og ydeevnen af ​​algoritmen. Algoritmer evalueres normalt i forhold til den tid og det rum, der kræves for at løse et problem eller opnå et specifikt mål.

To faktorer bruges i kompleksiteten af ​​algoritmen.

de er:-

1. Tidsfaktor.
2. Plads faktor.

Tidsfaktor

• Den tid, en algoritme skal bruge for at udføre en opgave, kaldes tidskompleksitet. Den måles normalt ved antallet af operationer eller trin, en algoritme skal udføre for at løse et problem.
• Tidskompleksiteten af ​​en algoritme er vigtig, fordi den bestemmer, hvor lang tid det tager at udføre og kan have en væsentlig indflydelse på programmets og systemets ydeevne.
• Tidskompleksiteten af ​​en algoritme kan udtrykkes ved hjælp af Big O notation, en måde at udtrykke en øvre grænse for tidskompleksiteten af ​​en algoritme.
• En algoritme med tidskompleksitet O(n) betyder, at den tid, der kræves for at køre algoritmen, er direkte proportional med størrelsen af ​​inputdataene (n).
• Andre almindelige tidskompleksiteter er O(n^2) kvadratisk kompleksitet og O(log n) logaritmisk kompleksitet.

Rumanalyse

• På den anden side refererer pladskompleksitet til mængden af ​​hukommelse eller lagerplads, der kræves for at udføre algoritmen.
• Dette er vigtigt, fordi det bestemmer antallet af ressourcer, der kræves for at køre algoritmer, der kan påvirke den overordnede ydeevne af din applikation eller dit system.
• Hvis rumkompleksiteten af ​​algoritmen er O(n), bruger den en mængde hukommelse, der vokser lineært med størrelsen af ​​inputtet.
• Hvis algoritmen har O(1) pladskompleksitet, bruger den en fast mængde hukommelse uanset størrelsen på inputtet.

Hvordan man skriver en algoritme

1. Definer først det problem, du vil have algoritmen til at løse.

Antag for eksempel, at vi vil skrive en algoritme til at finde den maksimale værdi fra en liste med tal.

2. Opdel problemet i mindre, håndterbare trin.

• Initialiser 'max'-variablen til den første værdi på listen.
• For hver efterfølgende værdi på listen, sammenlign med 'max'.
• Hvis værdien er større end 'max', skal du indstille 'max' til den værdi.
• Fortsæt med at gøre dette, indtil hver værdi på listen er blevet sammenlignet.
• Returnerer den endelige 'max' værdi.

3. Skriv din algoritme i pseudokode eller et programmeringssprog.

præity zinta

Algoritme skrevet i pseudokode:

 MAX (list) max = list[0] For i = 1 the length of the list list IF[i] > max max = list[i] End for Maximum return Maximum end 

4. Test din algoritme for at sikre, at den er korrekt og effektiv.

Du kan teste algoritmen ved at indtaste forskellige lister med tal og kontrollere, at den returnerer den maksimale korrekte værdi. Du kan også analysere tidskompleksiteten af ​​din algoritme for at bestemme, hvor godt den skaleres til større input.

Eksempel:-

Input: [1, 5, 2, 7, 3]

Udgang: 7.

Forklaring: 7 er den maksimale værdi på listen.

5. Optimer algoritmen.

Se efter måder at optimere algoritmer for at gøre dem hurtigere og mere effektive. Dette kan involvere ændring af pseudokode eller implementering af mere effektive datastrukturer eller algoritmer.

Grundlæggende skrivning af algoritmer

Eksempel: - Summen af ​​to heltal.

Trin 1 - Kom igang

Trin 2 - Erklær tre heltal a, b, c

Trin 3 - Definer værdierne af a og b

Trin 4 - Tilføj værdierne af a og b

Trin 5 - Gem output fra trin 4 i c

Trin 6 - Tryk c

Trin 7 - Hold op

Type af algoritmer, der bruges i C-sprog.

1. Sorteringsalgoritmer

C giver et rigt sæt af datatyper og operatorer, der kan bruges til at implementere forskellige sorteringsalgoritmer såsom boblesortering, indsættelsessortering og hurtig sortering.

Disse algoritmer er nyttige i mange applikationer, fordi de kan bruges til at sortere data af forskellige størrelser og typer.

Der er forskellige sorteringsalgoritmer.

de er:-

(i) Boblesortering: En ukompliceret sorteringsalgoritme, der sammenligner komponenter i nærheden gentagne gange og skifter dem ud, hvis de er ude af drift.

hvordan man konverterer heltal til streng java

Algoritmen for boblesortering er: -

1. Start med en usorteret liste over elementer.
2. Sammenlign de to første elementer på listen. Hvis det første element er større end det andet element, skal du bytte dem.
3. Gå videre til det næste par elementer, og gentag trin 2, indtil slutningen af ​​listen er nået.
4. Gentag trin 2 og 3 igen for hvert punkt på listen. det kaldes pas.
5. Gentag trin 2-4 for hele listen. Når du gentager afleveringerne, vil elementerne 'boble op' til deres korrekte position i den sorterede liste.
6. Når et pass er gennemført, og der ikke er foretaget bytte, sorteres listen, og algoritmen kan stoppe.
7. Den endelige sorterede liste returneres.

(ii) Indsættelsessortering : en sorteringsmetode, der opretter en sorteret liste med ét enkelt element ad gangen ved at placere hvert enkelt på det passende sted.

Algoritmen for indsættelsessortering er: -

1. Initialiser en tom sorteret liste og en usorteret liste over de elementer, der skal sorteres.
2. Det første medlem fra den usorterede liste skal tages og placeres i den passende position i den sorterede liste.
3. Gentag trin 2 for hvert efterfølgende element i den usorterede liste.
4. Sammenlign det aktuelle element med elementerne i den sorterede liste, startende med elementet umiddelbart til venstre.
5. Skift de to elementer, hvis det aktuelle element er mindre end elementet til venstre for det.
6. Hvis det aktuelle element er større end elementet til venstre for det, skal du indsætte det på dens korrekte position i den sorterede liste.
7. Gentag trin 4-6 for hvert efterfølgende element i den usorterede liste.
8. Når alle elementer er blevet behandlet, vil den sorterede liste indeholde alle elementer i den rigtige rækkefølge.
9. Sorteringsprocessen er afsluttet.

(iii) Udvælgelsessortering : en sorteringsmetode, der konsekvent starter den sorterede liste med den mindste detalje fra den uordnede liste.

Algoritmen for udvælgelsessortering er: -

1. Begynd med at indstille det primære element i listen som min-elementet.
2. Gentag gennem de resterende elementer på listen, og sammenlign hver enkelt med det aktuelle minimum.
3. Indstil et nyt minimum, hvis et element viser sig at være mindre end det eksisterende.
4. Skift det aktuelle minimum til det første element på listen, når det når sin konklusion.
5. For den resterende usorterede del af listen, gentag trin 2-4, men start med det andet punkt på listen (da det første element allerede er sorteret).
6. Fortsæt med at sortere listen på denne måde, indtil det hele er sorteret.

(iv) Hurtig sortering : En opdel-og-hersk sorteringsalgoritme, der vælger et pivotelement og opdeler listen i underlister afhængigt af om elementerne er færre end eller flere end pivoten. Derefter sorteres underlisterne gentagne gange, indtil hele listen er sorteret.

Algoritmen for hurtig sortering er: -

1. Vælg et pivotelement fra listen. Dette er typisk det første element, men det kan også være et tilfældigt element eller medianen af ​​listen.
2. Opdel listen i to underlister: en indeholdende elementer mindre end pivoten og en indeholdende elementer større end pivoten.
3. Sorter rekursivt underlisten, der indeholder elementer, der er mindre end pivoten, ved hjælp af den samme proces.
4. Brug den samme procedure til rekursivt at sortere underlisten over poster, der er større end pivoten.
5. Sammensæt de sorterede underlister med pivotelementet imellem for at danne en fuldt sorteret liste.
6. Returner den fuldt sorterede liste.

(v) Lot går : Opdel-og-hersk-sorteringsalgoritmen opdeler listen i to halvdele, sorterer hver halvdel og fletter derefter de to halvdele i sorteret rækkefølge.

Flet-sorteringsalgoritme:

1. Lav to underlister ud af listen: en med elementer under pivoten og en med elementer over pivoten.
2. Producerer en ny sorteret underliste ved iterativt at flette underlister, indtil der kun eksisterer én underliste. Dette vil være din sorterede liste.
3. Trin til at flette to undermapper:-
4. Opret en tom liste til at indeholde de sorterede elementer.
5. Sammenligner det første element i hver underliste.
6. Tilføjer det mindre element til den nye liste og fjerner det fra den overordnede underliste.
7. Gentag trin 2 og 3, indtil en liste er helt tom.
8. Tilføjer de resterende elementer fra andre underlister til en ny liste.
9. Erstatter den flettede underliste med den nye sorterede liste.
10. Gentag denne proces, indtil alle underlister er slået sammen til én sorteret liste.

(vi) Dyngesortering : En sorteringsalgoritme, der sorterer elementer ved hjælp af en datastruktur kaldet heap.

Dette er klassifikationsalgoritmen:

Byg max bunke: Start med den første ikke-bladsknude, sammenlign hver knude med dens underordnede knudepunkter og erstat knudepunkterne med den største af dens underordnede knudepunkter for at tilfredsstille egenskaben max heap.Byt rod med sidste element: Skift roden (største element) med det sidste element i stakken.
1. Stable resten af ​​elementerne. Startende fra roden sammenlignes hver node med dens børn, og bytter noder med deres ældre børn, indtil max heap-egenskaben er opfyldt.
2. Gentag trin 2 og 3 med de nyligt stablede elementer, bortset fra det sidste element i den korrekte position.
3. Gentag denne proces, indtil der kun er ét element tilbage i stakken. Dette er nu ordnet.
Hobe ned: Startende fra rodnoden sammenligner den elementer med sine børn og bytter med den største af de to, indtil max heap-egenskaben er opfyldt.Hobe op: Start med det sidste element i heapen, sammenlign det med dets overordnede element, og skift det med det overordnede element for at opfylde max heap-egenskaben.

(vii) Radix sortering : En sorteringsalgoritme, der sorterer elementer baseret på cifrene eller cifrene i deres binære repræsentation.

Algoritmen for Radix-sortering er: -

1. bestemme, hvor mange cifre der er indeholdt i inputlistens største element.
2. Initialiser en variabel, f.eks. ciffersted, til 1, som repræsenterer det aktuelle ciffersted.
3. Opret en tom liste for hver mulig cifferværdi fra 0 til 9.
4. Gentag gennem inputlisten og tilføj hvert element til den relevante liste baseret på værdien af ​​det aktuelle ciffersted.
5. Sammensæt alle listerne for at danne den nye liste i rækkefølgen af ​​cifferlisterne.
6. Multiplicer cifferPlacer med 10 for at flytte til det næste ciffersted.
7. Gentag trin 4-6 for hvert ciffersted, indtil alle cifre i det største element er blevet taget i betragtning.
8. Den endelige liste vil blive sorteret i stigende rækkefølge efter cifrene i elementerne.
9. Returner den endelige sorterede liste.

2. Søgealgoritmer

C giver også de nødvendige værktøjer til at implementere en række søgealgoritmer, såsom lineær søgning og binær søgning. Disse algoritmer kan hurtigt finde specifikke elementer i et datasæt, hvilket gør dem nyttige til en lang række applikationer.

Der er mange typer søgealgoritmer.

De er:-

(i) Lineær søgning : En grundlæggende søgealgoritme, der undersøger hvert element i listen én efter én, indtil den finder det ønskede element.

Algoritme til lineær søgning:-

1. Definer input for algoritmen: Input for en lineær søgealgoritme er en liste over elementer (eller et array) og et målelement, vi søger efter.
2. Initialiser en variabel kaldet 'indeks' til -1: Denne variabel vil blive brugt til at gemme indekset for målelementet, hvis det bliver fundet.
3. Gå gennem listen over elementer: Start fra det første element, tjek hvert element på listen et efter et.
4. Sammenlign det nuværende element med det ønskede element til evaluering: Hold indekset for det aktuelle element i indeksvariablen og forlad loopet, hvis det moderne element og målelementet er identiske.
5. Returner indekset for målelementet: Når løkken er fuldført, returneres værdien, der er gemt i indeksvariablen. Hvis målelementet ikke findes, vil værdien af ​​indekset være -1.

(ii) Binær søgning : En søgealgoritme, der fungerer ved at opdele fortegnelsen i halvdele og søgninger inden for disse halvdele, er mere tilbøjelige til at inkludere elementet.

Algoritme til binær søgning:-

1. Input: En sorteret liste med n elementer og et målelement x.
2. Initialiser variabler: Indstil det lave indeks til 0, det høje indeks til n-1 og mellem til (lav+høj)/2.
3. Start en loop: Mens det lave indeks er mindre end eller lig med det høje indeks, skal du gentage følgende trin.
4. Sammenlign det midterste element med x: Hvis det midterste element er lig med x, returner det midterste indeks.
5. Opdater det lave eller det høje indeks: Hvis x er større end det midterste element, skal du indstille det lave indeks til midt + 1. Ellers skal du indstille det høje indeks til mellem - 1.
6. Opdater midtindekset: Mid = (lav+høj)/2.
7. Slut på sløjfen: Hvis det lave indeks er større end det høje indeks, er x ikke på listen, og algoritmen returnerer en fejl.
8. Output: Indekset for x i listen eller fejlmeddelelsen.

(iii) Dybde-første søgning : En søgealgoritme, der undersøger hver gren så vidt det er muligt, før den vender rundt.

Følgende retningslinjer gælder for dybde-først-søgning:

1. vælg grafens startpunkt eller knudepunkt til at starte med.
2. Tilføj et besøgsmærke til det første toppunkt.
3. Placer det begyndende toppunkt direkte i en stak.
4. Indtil stakken er tom, skal du gentage følgende handlinger: -
   • Fjern stakkens øverste toppunkt.
   • Markér som besøgt, og indsæt hver ubesøgt nabo til det knækkede vertex i stakken.
5. Fortsæt denne proces, indtil alle hjørner i grafen er blevet besøgt.
6. Når alle hjørner er besøgt, er algoritmen færdig, og en dybde-første søgning udføres på grafen.

(iv) Bredde-først søgning : En søgealgoritme, der udforsker alle naboerne til en node, før den går til næste niveau.

Algoritmen for bredde-først søgning er: -

1. Start med rodnoden eller starttilstanden.
2. Tilføj rodnoden til en kø.
3. Tjek om køen er tom; hvis ja, afslut algoritmen.
4. Tag det første element fra køen og marker det som besøgt.
5. Forstærk den moderne node ved at tilføje alle dens ubesøgte naboer til køen.
6. Gentag trin 3 til 5, indtil den ønskede node er lokaliseret, eller køen er tom.
7. Returner stien fra den foreløbige tilstand til måltilstanden, hvis målknuden er fundet.
8. Afslut regelsættet og rapporter, at måltilstanden ikke blev identificeret, hvis køen er tom.

(v) Interpolationssøgning : En søgealgoritme, der bruger værdierne af de søgte elementer til at estimere positionen i indekset.

Det er vigtigt, at arrayet er jævnt fordelt. Ellers er det en algoritme.

Det fungerer som forventet.

Algoritmen kan opsummeres som følger.

1. Få inputlisten og nøgleværdien for at søge.
2. Initialiser de nederste og øvre variable ved det første og sidste indeks på listen.
3. Hvis den nedre værdi er mindre end eller lig med den højere værdi, så :-
   1. Beregn den anslåede placering ved hjælp af følgende formel:
      pos = lav + ((høj - lav) / (arr[høj] - arr[lav])) * (x - arr[lav]).
   2. Returner positionen, hvis den estimerede positionsværdi er en nøgleværdi.
   3. c) Hvis den estimerede positionsværdi er mindre end nøgleværdien, skal den indstilles lavere.
      Position + 1.
   4. d) Hvis værdien af ​​den estimerede position er større end nøglen Indstil værdi, position - 1 op.
4. Hvis nøgleværdien ikke findes, skal du returnere -1 for at angive, at værdien ikke er på listen.

(vi) Spring søgning : En søgemetode, der itererer over listen i trin med konstant længde, indtil den finder det relevante element eller bestemmer, at det ikke længere er til stede.

Springsøgningsalgoritmen er som følger:

1. Indstil først springstørrelsen til kvadratroden af ​​antallet af array-elementer.
2. Indstiller en variabel ved navn 'aktuel' til det første element i arrayet.
3. Itererer over arrayet ved at hoppe efter springstørrelse, mens en variabel kaldet 'jump' øges.
4. Gå videre til følgende spring, hvis det eksisterende element er mindre end det ønskede element.
5. Hvis det aktuelle element er større end målelementet, skal du udføre en lineær søgning mellem det aktuelle element og det forrige springelement for at finde målelementet.
6. Hvis målelementet ikke findes i arrayet, returnerer det -1 for at angive, at det ikke er i arrayet.
7. Hvis elementet findes, returnerer det elementets indeks i arrayet.

3. Grafalgoritmer

C's understøttelse af pointere og datastrukturer såsom arrays og linkede lister gør den velegnet til at implementere algoritmer, der manipulerer grafer, såsom at finde den korteste vej mellem to noder i en graf.

Der findes forskellige typer grafalgoritmer.

de er:-

Dijkstras algoritme: En algoritme, der finder den korteste vej mellem to knudepunkter i en graf ved løbende at opdatere den korteste afstand fra hver knude.Algoritme A*: En metode, der løbende opdaterer den korteste kurs til hver knude i en graf for at bestemme den korteste rute mellem dem.Prims algoritme: En tilgang til at finde ud af den vægtede forbundne grafs mindste spændingstræ.Kruskals algoritme: En tilgang til at identificere den sammenkædede vægtede grafs laveste spændingstræ.Bellman-Ford algoritme: En algoritme, der, selv når grafen har negative kantvægte, viser den korteste vej mellem en bestemt forsyningsknude og hver anden knude i netværket.

4. Kryptografiske algoritmer

C understøtter operationer på lavt niveau og effektiv datamanipulation, hvilket gør den ideel til implementering af algoritmer, der bruges i kryptografi, såsom datakryptering og dekrypteringsalgoritmer.

Der findes forskellige typer krypteringsalgoritmer.

verilog parameter

De er:-

Hash algoritmer: Disse algoritmer producerer output i fast størrelse (hash) fra input af vilkårlig størrelse. Eksempler inkluderer MD5, SHA-1 og SHA-2.Symmetriske nøglealgoritmer: Krypterings- og dekrypteringstrinene i sådanne algoritmer anvender den samme private nøgle. AES, DES og Blowfish er et par eksempler.Asymmetriske nøglealgoritmer: En offentlig nøgle og en ikke-offentlig nøgle bruges af disse metoder som separate nøgler til kryptering og dekryptering. Nogle eksempler omfatter RSA, ECC og DSA.Nøgleudvekslingsalgoritmer: Disse algoritmer tillader to parter at udveksle nøgler over en usikker kanal sikkert. For eksempel kan vi nævne Diffie-Hellman og Elliptic Curve Diffie-Hellman.

Fordele ved algoritmen

Algoritmer har mange fordele.

de er:-

Hastighed og effektivitet: Algoritmer kan behandle store mængder data hurtigt og præcist, hvilket gør dem nyttige til opgaver, der er for tidskrævende eller fejludsatte for folk at udføre.Konsistens: Algoritmer følger et sæt forudbestemte retningslinjer. Det kan producere konsistente resultater uden at blive påvirket af personlige skævheder og følelser.Automatisering: Algoritmer kan udføre opgaver automatisk, hvilket giver folk fri til at fokusere på mere komplekse eller kreative opgaver.Øget nøjagtighed: Algoritmer kan ofte opnå højere niveauer af nøjagtighed end mennesker, især når de håndterer store mængder data.Bedre beslutningstagning: Algoritmer hjælper os med at træffe mere informerede og objektive beslutninger ved at analysere data og identificere mønstre og tendenser, der ikke er let synlige for folk.Skalerbarhed: Algoritmer kan nemt skaleres op eller ned for at imødekomme skiftende krav og arbejdsbelastninger.

Ulemper ved algoritmen

Algoritmer er meget nyttige til programmering, men algoritmer har ulemper.

de er:-

Begrænset omfang: Algoritmer kan kun løse problemer inden for deres rækkevidde og er muligvis ikke i stand til at løse komplekse eller abstrakte problemer.Partiskhed: Algoritmer kan fastholde og forstærke skævheder i de data, der bruges til træning, hvilket fører til urimelige resultater.Utilstrækkelig gennemsigtighed: Mange algoritmer skjuler den proces, hvorigennem de når frem til deres konklusioner. Dette kan gøre det svært at tænke over eller kontrollere resultaterne.Tillid til dataenes finhed:Rigtigheden af ​​regelsættet er stærkt afhængig af finheden og anvendeligheden af ​​de data, der bruges i instruktionen. Unøjagtige eller unøjagtige virkninger kan være resultatet af fejlagtige data.begrænset tilpasningsevne:Algoritmer er designet til at følge retningslinjer og vil ikke tilpasse sig skiftende omstændigheder og forhold.