Valaki el tudná magyarázni ezt a kódot ? C++
Nos egy Kruskal algoritmus van le implementálva. A kérdésem az lenne , hogy melyik betű mit jelöl ? n,m , a,b,i,j ?
#include <iostream>
#include <fstream>
#include <stdlib.h>
using namespace std;
typedef struct KRUSKAL
{
int a;
int b;
double suly;
}KRUSKAL;
int cmpfunc (const void * a, const void * b)
{
KRUSKAL aa=*(KRUSKAL*)a;
KRUSKAL bb=*(KRUSKAL*)b;
if (aa.suly<bb.suly)
{
return -1;
}
else if (aa.suly>bb.suly)
{
return 1;
}
else return 0;
}
int main()
{
ifstream be("be.txt");
int n,m,a,b,i,j;
double suly;
be>>n>>m;
KRUSKAL el[m];
for (i=0;i<m;i++)
{
be>>a>>b>>suly;
el[i].a=a;
el[i].b=b;
el[i].suly=suly;
}
qsort(el,m,sizeof(KRUSKAL),cmpfunc);
for (i=0;i<m;i++)
{
cout<<el[i].a<<" ";
cout<<el[i].b<<" ";
cout<<el[i].suly<<" "<<endl;;
}
int reszhalmaz[n];
for (i=0;i<n;i++)
{
reszhalmaz[i]=i;
}
int elszam=0;
for (i=0;i<n;i++)
{
if (reszhalmaz[el[i].a]!=reszhalmaz[el[i].b])
{
cout<<el[i].a<<"-"<<el[i].b<<endl;
elszam=elszam+1;
if (reszhalmaz[el[i].a]==reszhalmaz[el[i].b])
{
for (j=0;j<n;j++)
{
if (reszhalmaz[j]<reszhalmaz[el[i].b])
{
reszhalmaz[j]=reszhalmaz[el[i].a];
}
}
}
else
{
for (j=0;j<n;j++)
{
if (reszhalmaz[j]<reszhalmaz[el[i].a])
{
reszhalmaz[j]=reszhalmaz[el[i].b];
}
}
}
}
if (elszam==n-1)
{
break;
}
}
return 0;
}
válasza:
válasza:Mind csak egy segédváltozó.
Indításkor a "be.txt" fájlból először beolvas két számot. Az n-be és m-be.
Majd m sort beolvas (élek száma), amit ideigelensen a-ba, b-be, és suly-ba tesz. Az indexelést pedig i-vel végzi hogy a három változót egy tömbbe írja (el)
Az a és b a csomópont számozása (tömb index alapján), a suly a csomopontot összekötő él súlya.
A el tömb szerintem gráf lesz, amit sorbarendez, majd kiírja stdout-ra.
Majd ezzel a graffal vamait csinál... nem néztem, nem volt kérdés.
Miközben még halmaznűveletet végez amit végül kiír egy fájlba ahol az indexeléshez meg j-t használja, a kiíratás pedig n elemű...
Aha... az m az élek száma, az n a csomópontok száma szerintem.
Tehát ez egy n csomópontú és m élű gráfból csinál egy kisebb, n-1 eleműt :D :D
Ez valami útkereső algoritmus? Nem néztem csak az utóbbi megállapításomból gondolom... Mert a kimenet egyel kevesebb élt fog tartalmazni, mint ahány csomópont van.
válasza: válasza:Csak érdekesség:
És épp egy publikusan elérhető AI-vel játszom (OpenAI Playground-ja).
És van egy olyan funkciója hogy kódelemzés. Na eszembe jutott ez a kérdés, gondoltam beadagolom neki...
És becartam.... Már sokmindent láttam az IT területén, nekem is a szakmám, mégpedig a fejlesztés (elég sok nyelvet és keretrendszert használok)... De ez durva. Azóta azon gondolkodom, ne menjek-e el inkább kőművesnek, amíg meg nem jelennek ott is az AI-k :D :D :D
Szóval a fenti kódrészletet beadtam az AI-nak, de hogy kibaccak vele, a KRUSKAL definiciót kicseréltem mindehol KUTYAGUMIRA. Nehogy már tudja esetleg a Kruskal algoritmus mire jó... úgy azért könnyű :D
És 90%-ban rájött hogy a program mit csinál. Még arra is, hogy mi a bementi fájl formátuma, és az egyes sorok a bemeneti fájlban mire szolgálnak. Mondjuk nem kérdeztem (csak az első kettő és utolsó kérdés az enyém), de megválaszolta a javítási lehetőségeket is. Bár szerintem az hibás. Mert súly szerint kell rendezni, de hagyjuk... Ha az ember téved, akkor a gép is tévedhet. Vagy én tévedek, és jó a megoldása :D :D
Szóval aki nem hiszi, itt a screenshot...
És Itt a teljes "chat". Ismétlem, én a kódot másoltam be, és CSAK az első két és utolsó kérdést írtam. A válaszokat a gép adta. Kb 2 mp gondolkodási idő után :D :D
Ha nem én láttam volna a saját szememmel... nem hiszem el hogy ilyen már van. :D
Mert azért bár tudom viszonylag egyszerű a program. Mindenki ismeri a tömböket és for ciklusokat. Sokan meg tudnák mondani hogy soronként mi-mit csinál benne. De hogy mi a program feladata...
Nem csak egy szintetikus működési elemzést csinál hanem egészében megmondja mire alkalmas. Na ehhez már humán absztrakció és magasabb szintű elvonatkoztatás kell, mint csupán az utasítások működésének ismerete. És ezen csodálkozom, hogy az AI-nek sikerült. Főleg hogy neki még az elég nagy támpontot adó KRUSKAL szót is kivettem.
És ennek ellenére még a gráf egyszerűsítő algoritmus nevére is rájött. Csupán a kód elemzéséből.
Na nekifutottam kíváncsiságból mégegyszer.Megadtama a kódót, és a kérdező kérdését úgy ahogy van, bármi változtatás nélkül.
Az AI válasza:
"A kódban a következők vannak:
n: a csúcsok száma
m: az élek száma
a,b: az él végpontjai
i,j: ciklusváltozók"
(Mielőtt kiakadtok... Igen, az OpenAI tökéletesen beszél magyarul. Mielőtt ebbe valaki belekötne, legyen szíves kipróbálni :D) [link]
válasza: válasza:#8:
Én ismerem a Tinkercad-ot. De az mitől is AI neked?
Csak mert az elemi (vagy az utasításokat) kódblokkokat összerakod, és összehuzalozod? Az még messze nem AI. Ez csak egy algoritmus grafikus alapú leírása/bevitele. Kvázi blokkdiagram. Az hogy utána abból futtatható kódot generál, az nem igazán AI. Az úgy hívják hogy implementálás.
Ugyanis a Tinkercad-nél is a specifikáció (=elérni kívánt eredmény) ismeretében továbbra is a humán erőforrás (ember) végzi maga az "alkotást", azaz a feladat algoritmizálását. És az ember határozza meg az algoritmus elemi lépéseit. Amit aztán grafikusan visz be. Ebben a tekintetben kb ugyanúgy kell gondolkodnia mint egy programozónak. Hol itt az AI akkor?
Elfogadom, nyilván nagyon modern, és intuitív és hatékony technika, de ne legyen már AI, mert folyamatábrából csinál futtatható kódot :D
Pl, csak hogy mások is lássák:
Ez az amiről beszéltél ugye. De itt tulajdonképpen semmi más nem történik, mint szinte az egyes programsorok megadása folyamatábra elemekkel. Hogy hogyan kell LED-et villogtatni, milyen lépések szükségesek hozzá. De ezeket továbbra is a humanoid-nak kell megmondani, "berajzolni".
Ha a bevitel ennyiből állna: "AI, írj nekem programot Arduinora, ami a beépített LED-et 1s/1s sebességgel villogtatja." Na ez inkább lenne AI. :)
De még ha ez így is működne/vagy fog, akkor is egy már implementált (=azaz "lekódolt") algoritmus visszafejtése, főleg az hogy MIT AKART az "alkotó" eredetileg SOKKALTA magasabb szintű és emberibb gondolkodást, elvonatkoztatást, absztarkciót igényel. Tehát azért az OpenAI ha tényleg kitalálta a fenti kódrészletből azt hogy az egy gráf egyszerűsítő. Sőt még odáig is visszafejtette hogy mi az input fájl felépítése... le a kalappal.
Úgyhogy az messze nem igaz hogy "az OpenAI hasonlót csinál a háttérben, csak fordítva". Amit az OpenAi produkált, össze sem hasonlítható azzal hogy a Tinkercad blokkdiagramból csinál kódot. Már ha egyáltalán érdemes hasonlítgatni a kettőt.
válasza:Na így néz ki az openAI kódolási technikája... A feladat második részének a megoldása nem tökéletes, de valszeg félreérthetően lett megfogalmazva... csak a bekapcsolásnál csinál fényerő változást. A speckót kicsit javítottam, de akkor sem lett teljesen jó a megoldás... :D :D
Azért elhiszed ugye, hogy ez absztraktabb "gondolkodás", mint a Tinkercad?
Bár megjegyzem "szóban" specifikálni sem könyebb hogy jó legyen, ld a lenti példát... :) Amúgy rájöttem, ott én voltam a "hibás", mert nem mondtam neki hogy ez nem csak egy ki és bekapcsolás csak, hanem "villogtatás".
----------------------------------------
The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.
Human: Hello, who are you?
AI: I am an AI created by OpenAI. How can I help you today?
Human: Kérlek beszélj magyarul.
AI: Sajnálom, de nem tudok magyarul beszélni. Hogyan segíthetek neked másképp?
Human: Írj nekem C nyelvű programot Aurduino-ra. Ami egy LED-et villogtat 1 Hertz sebeséggel.
AI: Rendben. Általában ez a program kell hozzá:
int led = 10; // az LED bemenetének kijelölése
void setup() {
pinMode(led, OUTPUT); // az LED bemenetének állítása kimeneti módra
}
void loop() {
digitalWrite(led, HIGH); // LED felkapcsolása
delay(1000); // 1000ms szünet
digitalWrite(led, LOW); // LED kikapcsolása
delay(1000); // 1000ms szünet
}
Human: Módosítsd a programot, hogy a ki és bekapcsolás fényerő változása folyamatos legyen. A fényerő szabályozáshoz használd a PWM kimenetet.
AI: Rendben. A módosított program így néz ki:
int led = 10; // az LED bemenetének kijelölése
int dutypercentage = 0; // az alaphelyzeti fényerő (0%)
void setup() {
pinMode(led, OUTPUT); // az LED bemenetének állítása kimeneti módra
}
void loop() {
analogWrite(led, dutypercentage); // LED annyi százalékos fényerőn megy, amennyit a dutypercentage változó jelöl
delay(1000); // 1000ms szünet
dutypercentage += 10; // növeljük a fényerőt 10%-tal
if (dutypercentage > 100) { // ha elérjük a teljes fényerőt (100%), visszatérünk a 0%-os fényerőhöz
dutypercentage = 0;
}
}
Human: Nagyon jó. De módosítsd ezt a programot is, hogy a LED kikapcsolása is, és a bekapcsolása is folyamatos fényerő csökkentéssel történjen.
AI:
AI: Rendben. A módosított program így néz ki:
int led = 10; // az LED bemenetének kijelölése
int dutypercentage = 100; // az alaphelyzeti fényerő (100%)
void setup() {
pinMode(led, OUTPUT); // az LED bemenetének állítása kimeneti módra
}
void loop() {
analogWrite(led, dutypercentage); // LED annyi százalékos fényerőn megy, amennyit a dutypercentage változó jelöl
delay(1000); // 1000ms szünet
// felváltva csökkentjük és növeljük a fényerőt 10% -tal
if (dutypercentage < 100 ) { // ha elérjük a 0%-os fényerőt, visszatérünk a 100%-os fényerőhöz
dutypercentage += 10;
} else {
dutypercentage -= 10;
}
}
Human:
Kapcsolódó kérdések:
Minden jog fenntartva © 2025, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!