Zum Inhalt springen

rolliwitsch

Mitglieder
  • Gesamte Inhalte

    9
  • Benutzer seit

  • Letzter Besuch

Beiträge von rolliwitsch

  1. Vielen Dank!

    immerhin kann ich selbst festlegen, ob ich meine Funktion rekursiv oder iterativ aufrufe,

    für welchen Zahlenbereich meine Funktion gültig ist (unsigned int || signed int)

    und ob ich einen Selection-Sort auf das Minimum, das Maximum oder Beides beziehe. Praktisch läuft ein Selection-Sort schneller, wenn ich nicht nur das Minimum, sondern auch das Maximum einbeziehe, dies zeigt mir ein Versuch.

    Viele Grüße ;-)

  2. hi danke Euch!!!

    nun habe ich wirklich einmal eine Frage. Das Selection-Sort schnappt sich nur das Minimum. Ich habe Selection-Sort schon umgeschrieben, dass es sich nur das Maximum schnappt und an die richtige Position schiebt.

    Das geht natürlich auch.

    Meine Frage ist die: Wenn ich ein Array durchlaufe, was um Gottes Namen spricht dagegen, außer dem Minimum, oder dem Maximum, nicht gleich BEIDES zu ermitteln und zum Sortieren an die richtige Position zu schieben!?

    Oder, die Frage mal etwas heretischer gestellt: Haben die Publisher von Selection-Sort das nicht hinbekommen?

    Viele Grüße!

    Btw.: Was wirklich Ressourcen spart, vermeidet Rekursionen, ruft dazu bestimmte Funktionen iterativ auf. Bei Rekursionen legt das OS einen zusätzlichen Stack im Speicher an. Desterwegen postete ich obenstehende Sortierfunktion als NICHT rekursiv.

  3. hi Fangemeinde,

    die Tage habe ich den Selection Sort etwas aufgebohrt, hier der Code

    
    // keine Rekursion, Funktion muss iterativ aufgerufen werden!
    
    void xSort(int * p, int start, int stop){
    
    	unsigned long min = 0xffffFFFF; // GAZ, Größte Anzunehmende Zahl unsigned int
    
    	unsigned long max = 0;
    
    	int posmin;
    
    	int posmax;
    
    	int i;
    
    	for(i = start; i < stop; i++){
    
    		if( p[i] < min ) { 
    
    			min = p[i];
    
    			posmin = i;
    
    		}
    
    		if( p[i] > max ) {
    
    			max = p[i];
    
    			posmax = i;
    
    		}
    
    	}
    
    
    	// nun die Zahlen auf den richtigen Positionen ablegen
    
    	// merke wert auf p[start]
    
    	unsigned long wsta = p[start];
    
    	p[start] = min;
    
    	p[posmin] = wsta;
    
    
    	// posmax ist posmin, wenn max auf start stand
    
    	if(posmax == start){posmax = posmin;}
    
    
    	// merke wert auf p[stop-1]
    
    	unsigned long wsto = p[stop-1];
    
    
    	p[stop-1] = max;
    
    	p[posmax] = wsto;
    
    }
    
    /*************************************************************************/
    
    // Biepiel Funktionsaufruf
    
    int main(){
    
    	int i;
    
    	int zn[] = {1,2,3,4,5};
    
    
    	int size = sizeof(zn)/sizeof(int);
    
    	printf("zn hat %d Zahlen\n", size);
    
    
    	// iteration über xSort
    
    	for(i = 0; i < size - i; i++) xSort(zn, i, size - i);
    
    
    	// Ausgabe
    
    	for(i = 0; i < size; i++) printf ("%d\n", zn[i]);
    
    
    	return 0;
    
    }
    
    
    

    Dabei wird ein Zahlen-Array mit bspw. 10 Zahlen lediglich nur fünfmal durchlaufen, danach ist es sortiert. Ein Array mit 11 Zahlen wird sechsmal durchlaufen. Das macht diese Sortierfunktion sehr performant.

    Funktionsweise: Bei jedem Durchlauf wird das Minimum UND das Maximum ermittelt, sowie die Positionen dieser Werte im Array. Das Minimum tauscht dann seinen Platz mit der Startposition und dem dortigen Wert. Das Maximum tauscht den Platz mit der Stopposition. Das ist der Gewinn dieses Algorithmus gegenüber einem Selection Sort, bei dem lediglich das Minimum verschoben wird.

    Viele Grüße!

  4. 1. Aufgabe:

    Uns wird der Adressbereich 192.168.80.0/23 zugewiesen

    Wir sollen darin 6 Subnetze mit je maximal 50 Hosts aufbauen.

    Ist die Aufgabe lösbar? Welche Netze sind einrichtbar und welche Netzmaske wird

    dafür benötigt?

    Bestimmen Sie die Hostadressen für das 4.Subnetz

    Die Aufgabe ist lösbar. Du teils ein Basisnetz in Subnetze, indem Du die Maskenlänge verlängerst:

    
    F:\_c\exe>netcalc 192.168.80.0/23 26
    
    
    Basis-Netz mit Maskenlaenge 23 und 510 Hosts
    
    
    Netzadresse     Broadcastadresse
    
    192.168.80.0    192.168.81.255
    
    
    8 Subnetze mit Maskenlaenge 26 (je 62 Hosts):
    
    
    192.168.80.0    192.168.80.63
    
    192.168.80.64   192.168.80.127
    
    192.168.80.128  192.168.80.191
    
    192.168.80.192  192.168.80.255
    
    192.168.81.0    192.168.81.63
    
    192.168.81.64   192.168.81.127
    
    192.168.81.128  192.168.81.191
    
    192.168.81.192  192.168.81.255
    
    
    Die Anzahl der Hosts ergibt sich aus der Maskenlänge:
    
    F:\_c\exe>netcalc
    
    
    IP-Calculator zum Berechnen von Subnetzen
    
    
    Netzmaske        Maskenlaenge/Bit  Anzahl moeglicher Hosts
    
    255.255.255.255         32                     1
    
    255.255.255.254         31                     0
    
    255.255.255.252         30                     2
    
    255.255.255.248         29                     6
    
    255.255.255.240         28                    14
    
    255.255.255.224         27                    30
    
    255.255.255.192         26                    62
    
    255.255.255.128         25                   126
    
    255.255.255.0           24                   254
    
    255.255.254.0           23                   510
    
    255.255.252.0           22                  1022
    
    255.255.248.0           21                  2046
    
    255.255.240.0           20                  4094
    
    255.255.224.0           19                  8190
    
    255.255.192.0           18                 16382
    
    255.255.128.0           17                 32766
    
    255.255.0.0             16                 65534
    
    255.254.0.0             15                131070
    
    255.252.0.0             14                262142
    
    255.248.0.0             13                524286
    
    255.240.0.0             12               1048574
    
    255.224.0.0             11               2097150
    
    255.192.0.0             10               4194302
    
    255.128.0.0              9               8388606
    
    255.0.0.0                8              16777214
    
    254.0.0.0                7              33554430
    
    252.0.0.0                6              67108862
    
    248.0.0.0                5             134217726
    
    240.0.0.0                4             268435454
    
    224.0.0.0                3             536870910
    
    192.0.0.0                2            1073741822
    
    128.0.0.0                1            2147483646
    
    0.0.0.0                  0            4294967293
    
    
    Options: f:/tools/netcalc.exe [ip.ip.ip.ip/masklen] [Neue Maskenlaenge]
    
    

    Viele Grüße!

  5. mir sind leider noch keine fertigen Libs untergekommen. Aber Du hast doch so etwas sehr schnell implementiert, es sind doch bloß ein paar Bitverknüpfungen pro Okttet und ein paar Shifts.

    Ok, in der Tat hab ich schon angefangen, eine kleine Lib zu schreiben. Falls Interesse, kann ich das ja mal hier veröffentlichen, untenstehend schon mal eine Auswahl der bisherigen Funktionen.

    Viele Grüße!

    
       /* Struktur für ein Netz */
    
    
    struct netx{
    
    	unsigned long ipaddr;   // IP-Adresse numerisch
    
    	int masklen;            // 0..30
    
    	unsigned long netmask;  // Netzmaske numerisch
    
    	unsigned long netaddr;  // Netzadresse numerisch
    
    	unsigned long bcaddr;   // Broadcastadresse numerisch
    
    	char netmasks[20];      // Netzmaske als String like 255.0.0.0
    
    	char ipaddrs[20];       // IP-Adresse als String like 172.31.11.12
    
    	char netaddrs[20];      // Netzadresse als String like 0.0.0.0
    
    	char bcaddrs[20];       // Broadcastadresse als String like 255.255.255.255
    
    	char defaultclass[20];  // Default Class A, B, C, D, E
    
    };
    
    
    /*************************************************************************/
    
    
       /* Funktionen dieser Library */
    
    
    // splittet nach "." und "/"
    
    // nice to use for 172.31.32.0/24
    
    void split(int * ar, char buffer[]);
    
    
    // rechnet ip (4 Oktetten einzeln übergeben) nach numerisch
    
    // und gibt ipnum zurück
    
    int ip_to_num(int a, int b, int c, int d);
    
    
    // rechnet aus numerischer IP die 4 Oktetten zurück
    
    // legt die 4 Oktetten auf eine Array, was per Pointer übergeben wurde
    
    void num_to_okt(int * ar, unsigned long ipnum);
    
    
    // legt den IP-String auf das übergebene Array
    
    void ipdots(char * ips, unsigned long ipnum);
    
    
    // ermittelt die Default Class aus der ersten Oktette
    
    // 0 class   A   0-127
    
    // 10 class  B   128-191
    
    // 110 class C   192-223
    
    // 111 class D   224-239
    
    // 1111 class E  ab 240
    
    void default_class(char buffer[], int okt);
    
    
    // ip-Adresse validieren
    
    int valip(int a, int b, int c, int d);
    
    
    // ein IP-String wie 255.255.255.255/30 darf nicht länger als 18 sein
    
    int valips(char buffer[]);
    
    
    // maskenlänge zu einer uint 32 bit Zahl umrechnen
    
    // masklen 0..30 !!!
    
    // gibt -1 zurück, wenn Maskenlänge nicht passt, z.B. wenn die Bits
    
    // nicht aufeinanderfolgend sind
    
    int masklen_to_num(int masklen);
    
    
    // numerische Maske (32 unsigned int) nach Maskenl. 0..32 umrechnen
    
    int num_to_masklen(unsigned long n);
    
    
    
    // gibt die Netzadresse numerisch zurück (ipnum, maskenum)
    
    int get_netaddr(unsigned long ipnum, unsigned long masknum);
    
    
    // gibt die Broadcastadresse numerisch zurück (ipnum, maskenum)
    
    int get_bcaddr(unsigned long ipnum, unsigned long masknum);
    
    
    // Funktion belebt das struct net mit Werten
    
    // Übergabe der Oktetten einer beliebigen IP-Adresse
    
    // Übergabe der Maskenlänge 0..30
    
    void fillnet(struct netx *, int o1, int o2, int o3, int o4, int mlen);
    
    
    

  6. Hallo Welt ;)

    1995 habe ich als Quereinsteiger mit c und c++ angefangen die Geheimnisse der Programmierung zu begreifen. Jobmäßig war das später aber nicht gefragt, und so habe ich ein paar Jahre kein Stück code geschrieben.

    1998 entdeckte ich das Internet und schrieb meine ersten CGI-Scripts in Perl. Die Grundlagen der Programmierung kannte ich ja von c her und so habe ich mich in Perl ganz ordentlich entwickelt, sowohl privat als auch beruflich: Viele Jahre programmiere ich Webanwendungen mit DB-Anbindung und pure Perl-Scripts fürs Netzwerkmanagement.

    Dieses Jahr Ostern habe ich meine Liebe zu c wiederentdeckt ;)

    Da mein spezielles Interesse der Kalenderrechnung gilt, habe ich seit Ostern meine erste große Library in c geschrieben, sie heißt julian-lib, benannt nach dem genialen Römischen Kaiser Julius Cäsar. Mit dieser lib ist es möglich, jeden Tag ab dem 1.1.4713 vor Christus bis heute eindeutig zu bestimmen, z.B. den Wochentag, den Julianischen Tag, die Kalenderwoche nach DIN 1355 usw.

    Auf diese lib aufbauend habe ich auch schon ein paar kleine aber feine Kommandozeilenprogramme geschrieben, u.a. eins was dem cal for UNIX nachempfunden ist: Es zeigt einen beliebigen Monat als ASCII.

    Mein vorerst letztes Programm ist ein IP-Calculator zur Berechnung von Netzadresse und Broadcastadresse sowie zur Kalkulation von Subnetzen, welche sich aus der Teilung eines Basis-Netzes ergeben....

    Und so denke ich, dass ich hier evntl. öfters bin :)

    Viele Grüße!

Fachinformatiker.de, 2024 by SE Internet Services

fidelogo_small.png

Schicke uns eine Nachricht!

Fachinformatiker.de ist die größte IT-Community
rund um Ausbildung, Job, Weiterbildung für IT-Fachkräfte.

Fachinformatiker.de App

Download on the App Store
Get it on Google Play

Kontakt

Hier werben?
Oder sende eine E-Mail an

Social media u. feeds

Jobboard für Fachinformatiker und IT-Fachkräfte

×
×
  • Neu erstellen...