C - Aufgaben 9

Hinweise für alle Aufgaben

Wenn die Erstellung von Funktionen ("Unterprogrammen") erwünscht ist, so muss zwar die Funktion, nicht jedoch das aufrufende Programm erstellt werden.

Wenn die Erstellung eines Projekts erwünscht ist, so müssen alle Teile (Dateien) des Projekts erstellt werden.

Die Funktionen sollen fehlerfrei funktionieren und eine kurze, aber eindeutige Dokumentation enthalten.

Die Kurz-Dokumentation (als Kommentar im Quelltext) enthält Angaben über die Verwendung (Funktionalität, Deklaration und Syntax), Angaben zu ihrer Person (Name, Klasse) und zur Version (VersNr, Datum).

Einige Aufgaben sind in 2 Versionen gestellt: erstellen sie unbedingt zuerst die Grundversion (Minimal-Anforderung). Entscheiden sie dann nach eigenem Ermessen, welche Erweiterungen sie zusätzlich erstellen.

Verwenden sie in der Test-Umgebung zur Eingabe von strings über die Konsole nicht die Funktion scanf() sondern besser die Funktion gets() aus der library <stdio.h>
(Syntax: char string[...]; gets(string); ).
Falls sie zwischendurch andere Konsolen-Funktionen verwenden (z.B. scanf() für Zahlen) so, können sie den allenfalls "unsauberen" Eingabepuffer mit Funktion fflush() aus der library <stdio.h> löschen
(Syntax: fflush(stdin); )

Die Lösungsvorschläge dieser Webseite umfassen ungefähr die Grundversionen der gestellten Aufgaben. Eine vollständige Ausarbeitung mit Erweiterungen, Testumgebung usw. finden sie in den Quelltext-Dateien, die jeweils über eigene Links zugänglich sind.

Funktion word_count

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Ermittlung der Anzahl von Worten in einer Zeichenkette (string).

Syntax:
int wc;
char mystring[...]; // keine Vorgaben über die Dimension notwendig
...
wc=word_count(mystring);

Grundversion: Die Funktion gibt die Anzahl gefundener Worte an das aufrufende Programm zurück. Ignorieren sie in dieser Version alle Sonderfälle, zählen sie nur durch Leerzeichen getrennte Worte.

Erweiterte Version:
+ Berücksichtigen sie Sonderfälle, wie z.B. führende oder folgende Leerzeichen (leading or trailing blanks), Mehrfach-Blanks, strings ausschliesslich aus blanks.
+ Als Zeichen für Wort-Zwischenräume dienen alle Kontrollzeichen <'0' sowie alle Zeichen von '\x3A' bis '\x3F'.
+ Falls ein string kein Ende-Zeichen enthält, so wird die Funktion nach 100 Zeichen (einstellbar) abgebrochen.

Lösungsvorschlag: ( file word-count mit 2 Versionen der Lösung)

int word_count(char *s) {
/*
Funktion word_count
Ermittlung der Anzahl von Worten in einer Zeichenkette (string)
Version 1.0 / 2002.04.01
Author: pstrainer@gmx.net
Syntax:
int wordcount(char*);
...
int wc;
char mystring[...];
...
wc=word_count(mystring);
Length: 14 lines of code
*/

int i,wc;

char c;

i=0;

// index of char in string

wc=0;

// word count

c='$';

while(c!='\0') {

c=s[i++];

// character tested

if(c==' ')wc++;

}

i--;

if(i>0)wc++;

return wc;
}

Funktion repeat_string

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Erstellen einer Zeichenkette (string) aus wiederholten Zeichenketten.

Syntax:
int n,sl;
char mystring[...],rep[...]; // keine Vorgaben über die Dimension notwendig
...
n=3;
repeat_string(n,rep,mystring); // Grundversion
// sl=repeat_string(n,rep,mystring); // Erweiterte Version

Grundversion: Die Funktion ersetzt den Inhalt des strings (mystring) durch eine beliebige Anzahl gleicher strings (rep).
Beispiel: Im oben angeführten Syntax-Beispiel (wenn n=3 und repstring="az") gibt die Funktion den string "azazaz" zurück. Berücksichtigen sie keine Sonderfälle, bearbeiten sie nur einfache nicht-leere rep-strings und n>0.

Erweiterte Version:
+ Wenn das Argument n<=0 ist, wird ein leerer string erzeugt.
+ Wenn das Argument n>100 ist, wird n=100 gesetzt (einstellbar).
+ Falls der repeat-string kein Ende enthält, so wird die Funktion nach 100 Zeichen (einstellbar) abgebrochen.
+ Falls die string-Länge (mystring) 100 Zeichen (einstellbar) überschreitet, so wird der string nur bis zu dieser Länge erzeugt.
+ Die Funktion gibt die Gesamtlänge des erzeugten strings an das aufrufende Programm zurück.

Lösungsvorschlag: ( file repeat_string mit 2 Versionen der Lösung)

int repeat_string(int nrep,char *r,char *s) {
/*
Funktion repeat_string
Erstellen einer Zeichenkette aus wiederholten Zeichenketten.
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
int repeat_string(int i,char*,char*);
...
int n,sl;
char mystring[...];
char rep[...];
...
sl=repeat_string(n,rep,mystring);
Length: 15 lines of code
*/

int i,j,n;

char c;

i=0;

// mystring index

for (n=0; n<nrep; n++) {

// rep counter

c='$';

j=0; // rep index

while (c!='\0') {

c=r[j++];

if (c!='\0') s[i++]=c;

}

s[i]='\0';

// terminate string

return i-1;
}

Funktion merge_string

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Zusammenführung (concatenate) von 2 Zeichenketten (strings).

Syntax:
int dl;
char src1[...],src2[...],dst[...]; // keine Vorgaben über die Dimension notwendig
...
merge_string(src1,src2,dst); // Grundfunktion
// dl=merge_string(src1,src2,dst) // Erweiterte Funktion

Grundversion: Die Funktion ersetzt den Inhalt von dst durch den Inhalt von src1+src2. Ignorieren sie alle Sonderfälle, z.B. leere strings. Verwenden sie keine library-Funktionen (z.B. strcpy() oder strcat() ), sondern programmieren sie selbst.

Erweiterte Version:
+ Die Funktion gibt zusätzlich die Länge des (neuen) strings dst an das aufrufende Programm zurück.
+ Falls ein source-string kein Ende-Zeichen enthält, so wird die Funktion nach 100 Zeichen (einstellbar) abgebrochen.
+ Die Größe des erzeugten string (dst) wird mit 100 Zeichen (einstellbar) begrenzt.
+ Optional werden Sonderzeichen <'\x20' ignoriert.

Lösungsvorschlag: ( file merge_string mit 2 Versionen der Lösung)

int merge_string(char *s1,char *s2,char *d) {
/*
Funktion merge_string
Zusammenführung (concatenate) von 2 Zeichenketten (strings).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
int merge_string(char*,char*,char*);
...
char src1[...];
char src2[...];
char dst[...];
...
merge_string(src1,src2,dst);
Length: 19 lines of code
*/

int i,j;

char c;

i=0;

// index for dst

j=0;

// index for src1

c='$';

while (c!='\0') {

c=s1[j++];

// character to test

if(c!='\0') d[i++]=c;

}

j=0;

// index for src2

c='$';

while (c!='\0') {

c=s2[j++];

// character to test

if(c!='\0') d[i++]=c;

}

d[i]='\0';

// terminate dst string

return i-1;
}

Funktion insert_string

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Einfügen (insert) einer Zeichenkette (string) in eine andere.

Syntax:
char mystring[...],insertstring[...];
int position;
... ...
insert_string(mystring,insertstring,position);

Grundversion: Die Funktion fügt den Inhalt von insertstring an der Position position in den string mystring ein.

Erweiterte Version:
+ Sichern sie die Funktion so ab, dass durch illegale Eingabe von position (<0 oder > Länge) kein Schaden entsteht.
+ Sichern sie die Funktion so ab, dass sie auch mit leeren Strings funktioniert.
+ Überlegen sie Varianten mit oder ohne Verwendung der Standard-Bibliotheks-Funktionen.

Lösungsvorschlag: ( insert_string mit 3 Versionen der Lösung)
Variante mit Verwendung von Standard-Funktionen:

void insert_string (char *x,char *z, int p) {
/*
Funktion insert_string
Insert string z into string x at position p

Version 1.0 / 2002.04.01
This version realized with library functions:
Autor: Peter Schindler, pstrainer@gmx.net

Syntax:
char mystring[...],insertstring[...];
int position;
... ...
insert_string(mystring,insertstring,position);

Length:
9 lines of code
*/
char buffer [line_maxlen];

if ((p>=0) && (p<=int(strlen(x)))) {// validity test
strcpy( buffer, x+p);// save end in buffer
x[p]='\0';// clip x
strcat( x, z );// copy dst to x
strcat(x,buffer);// copy end to x
}
}

Variante ohne Verwendung von Standard-Funktionen (ohne Kommentar):

void insert_string (char *x,char *z, int p) {

int i,j;

if ((p>=0) && (p<=int(my_strlen(x)))) {// validity test

i=my_strlen(x);// shift end
j=i+my_strlen(z);
while (j>p) {x[j--]=x[i--];}

i=p;// insert
j=0;
while (z[j]!='\0') {x[i++]=z[j++];}
}
}

int my_strlen(char *x) {
// calculate the length of a string.
// does the same as library function "strlen"
int i=0;
while (x[i]!='\0') {i++;}
return i;
}

Funktion replace_string

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Ersetzen (replace) von Mustern (strings) in Zeichenketten durch andere..

Syntax:
int replace_string(char*,char*,char*);
...
char string[...];
char src[...];
char dst[...];
int n;
...
n = replace_string(string,src,dst);

Grundversion: Die Funktion ersetzt jedes in der Zeichenkette string auftretende Muster src durch ein anderes Muster dst.

Erweiterte Version:
+ Die Funktion gibt die anzahl der durchgeführten Ersetzungen an das aufrugende Programm zurück.
+ Überlegen sie Varianten mit und ohne Verwendung der Standard-Bibliotheks-Funktionen.

Lösungsvorschlag: ( file replace_string mit 2 Versionen der Lösung)
Variante mit Verwendung von Standard-Funktionen:

int replace_string(char *x,char *src,char *dst) {
/*
Funktion replace_string
Ersetzen von Zeichenketten (substrings) in Zeichenketten (strings)

Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net

Syntax:
int replace_string(char*,char*,char*);
...
char string[...];
char src[...];
char dst[...];
int n;
...
n=replace_string(string,src,dst);

Return = Number of substrings replaced
Length: 30 lines of code (this function)
8 lines of code (sub version 1)
13 lines of code (sub version 2)

38-43 lines of code (total)
*/
char c,d;
int i,j,anf,lensrc,counter;

lensrc=strlen(src);
counter=i=j=0;
anf=-1;
c='$';
while (c!='\0') {
c=x[i];// string character
d=src[j];// src character

if (d=='\0') {// end of src ?
if (anf>=0) {
i=replace_sub(x,dst,anf,lensrc);
counter++;
}
anf=-1;
j=0;
}

if (c==d) {// match ?
if(anf<0) {anf=i;}// start of match
j++;// next match char
}

else if (anf>=0) {// no match ?
anf=-1;
j=0;
}

i++;// next string character
}
return counter;
}

int replace_sub (char *x,char *z, int p, int q) {
// cut q characters at position p
// insert string ins into string x at position p
// return next position to investigate
// Length: 8 lines of code
char buffer [line_maxlen];

strcpy( buffer, x+p+q);// copy end of x to buffer
x[p]='\0';// clip x
strcat( x, z );// copy dst to x
strcat(x,buffer);// copy end to x
return p+q-1;// return position to continue
}

Variante ohne Verwendung von Standard-Funktionen:

int replace_sub (char *x,char *z, int p, int q) {
// cut q characters at position p
// insert string ins into string x at position p
// return next position to investigate
// Length: 13 lines of code
char buffer [line_maxlen];
int i,j;

// copy end of x to buffer
i=p+q; j=0;// strcpy(buffer,x+p+q);
while (x[i]!='\0') {buffer[j++]=x[i++];}
buffer[j]='\0';

// copy dst to x
i=p; j=0;// strcat( x, z );
while (z[j]!='\0') {x[i++]=z[j++];}

// copy end to x
j=0;// strcat(x,buffer);
while (buffer[j]!='\0') {x[i++]=buffer[j++];}
x[i]='\0';

return p+q-1;// return position to continue
}

Projekt int_sum

Erstellen sie ein Bibliotheks-Projekt.

Das Projekt enthält folgende Teile: Header, Programm (main...), Funktionen-Bibliothek.

Funktionalität: Im Hauptprogramm werden 2 ganze Zahlen definiert (Minimal-Aufwand !), die von einem Unterprogramm in der Bibliothek addiert werden.

Syntax:
int a,b,s;
...
s=intsum(a,b); // Ergebnis s=a+b

Grundversion: Die geforderte Funktionalität (inkl. Dokumentation) mit minimalem Aufwand erstellen.

Erweiterte Version:
+ Einfache Eingabe und Ausgabe (Konsole) der Zahlen im Hauptprogramm (main);

Lösungsvorschlag: ( file int_sum enthält alle 3 Quelltext-Dateien, 2 Versionen)

/*
Projekt IntSum
Summe von 2 ganzen Zahlen (Bibliothek).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net

Files:
intsum.h (this file), intsum.cpp, testmain
*/

#ifndef _my_library
#define _my_library

#include <stdio.h>
#include <conio.h>

extern int intsum(int,int);

#endif

/*
Projekt IntSum
Summe von 2 ganzen Zahlen (Bibliothek).
Versionen 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
intsum.h, intsum.cpp, testmain (this file)
*/

#include "intsum.h"

void main (void) {
int a,b,s;
printf("Projekt IntSum\n");
a=123;
b=-23;
s=intsum(a,b);
printf("IntSum(%d,%d)=%d\n",a,b,s);
}

/*
Projekt IntSum

Summe von 2 ganzen Zahlen (Bibliothek).

Versionen 1.0 / 2002.04.01
Autor: Peter Schindler, pstrainer@gmx.net

Files:
intsum.h, intsum.cpp (this file), testmain
*/

#include "intsum.h"

int intsum(int z1,int z2) {
/*
Funktion intsum
Summe von 2 ganzen Zahlen
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
#include "intsum.h"
int a,b,s;
...
s=intsum(a,b);
Length: 3 lines of code
*/
return z1+z2;
}

Projekt print_string

Erstellen sie ein Bibliotheks-Projekt.

Das Projekt enthält folgende Teile: Header, Programm (main...), Funktionen-Bibliothek.

Funktionalität: Im Hauptprogramm wird eine Zeichenkette (string) definiert (Minimal-Aufwand !), die von einem Unterprogramm in der Bibliothek auf der Konsole ausgegeben wird.

Syntax:
char mystring[...];
...
print_string(mystring); // Ausgabe von mystring

Grundversion: Die geforderte Funktionalität (inkl. Dokumentation) mit minimalem Aufwand erstellen.

Erweiterte Version:
+ Einfache Eingabe des strings im Hauptprogramm (main);

Lösungsvorschlag: ( file print_string enthält alle 3 Quelltext-Dateien, 2 Versionen)

/*
Projekt PrintString
Summe von 2 ganzen Zahlen (Bibliothek).
Versionen 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
printstring.h (this file), printstring.cpp, testmain.cpp
*/

#ifndef _my_library
#define _my_library

#include <conio.h>
#include <stdio.h>
#include <string.h>

extern void print_string(char*);

#endif

/*
Projekt PrintString
Summe von 2 ganzen Zahlen (Bibliothek).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
printstring.h, printstring.cpp, testmain.cpp (this file)
*/

#include "printstring.h"

void main (void) {
char mystring[]="Viel Erfolg !";
printf("Projekt PrintString\n");
printf("mystring=");
print_string(mystring);
printf("\n");
}

/*
Projekt PrintString
Summe von 2 ganzen Zahlen (Bibliothek).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
printstring.h, printstring.cpp (this file), testmain.cpp
*/

#include "printstring.h"

void print_string(char *s) {
/*
Funktion printstring
Ausgabe einer Zeichenkette (string) auf der Konsole

Version 1.0 / 2002.04.01
Autor: Peter Schindler, pstrainer@gmx.net

Syntax:
#include "printstring.h"
char mystring[...];
...
print_string(mystring);
Length: 3 lines of code
*/
printf("%s",s);
}

Projekt calc_isqr

Erstellen sie ein Bibliotheks-Projekt.

Das Projekt enthält folgende Teile: Header, Programm (main...), Funktionen-Bibliothek.

Funktionalität: Im Hauptprogramm wird eine ganze Zahl (int) definiert (Minimal-Aufwand !). Von einem Unterprogramm in der Bibliothek wird das Quadrat dieser Zahl berechnet und an das aufrufende Programm zurückgegeben.

Syntax:
int i,q;
...
q=calc_isqr(i); // Berechnung des Zahlen-Quadrats (q=i*i)

Grundversion: Die geforderte Funktionalität (inkl. Dokumentation) mit minimalem Aufwand erstellen.

Erweiterte Version:
+ Einfache Eingabe und Ausgabe der Zahlen im Hauptprogramm (main);

Lösungsvorschlag: ( file calc_isqr enthält alle 3 Quelltext-Dateien, 2 Versionen)

/*
Projekt CalcIntSqr
Quadrat einer ganzen Zahl (Bibliothek).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
calcisqr.h (this file), calcisqr.cpp, testmain.cpp
*/

#ifndef _my_library
#define _my_library

#include <stdio.h>
#include <conio.h>

extern int isqr(int);

#endif

/*
Projekt CalcIntSqr
Quadrat einer ganzen Zahl (Bibliothek).
Versionen 1.0 / 2002.04.01
Autor: Peter Schindler, pstrainer@gmx.net
Files:
calcisqr.h, calcisqr.cpp, testmain.cpp (this file)
*/

#include "calcisqr.h"

void main (void) {
int i,q;
printf("Projekt IntSqr\n");
i=123;
q=isqr(i);
printf("IntSqr(%d)=%d\n",i,q);
}

/*
Projekt CalcIntSqr
Quadrat einer ganzen Zahl (Bibliothek).
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Files:
calcisqr.h, calcisqr.cpp (this file), testmain
*/

#include "calcisqr.h"

int isqr(int i) {
/*
Funktion isqr
Quadrat einer ganzen Zahl
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
#include "intsum.h"
int i,q;
...
q=isqr(i);
Length: 3 lines of code
*/
return i*i;
}

Funktion swap_elements

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Vertauschung von 2 Elementen eines Feldes (array).

Syntax:
int myarray[...]; // keine Vorgaben über die Dimension notwendig
int i,j,ok;
...
swap_elements(i,j,myarray); // Grundversion
// ok=swap_elements(i,j,myarray); // Erweiterte Version

Grundversion: Die Funktion vertauscht die gewünschten Elemente des Feldes. Dimension: 10 Elemente
Beispiel: wenn das Feld vor dem Aufruf von swap_elements den Inhalt {33,18,97,5...} hat und swap_elements(1,2,myarray) aufgerufen wird, so soll das Feld anschliessend den Inhalt {33,97,18,5...} haben.

Erweiterte Version:
+ Die Funktion ignoriert die Verwendung fehlerhafter Indices (i,j<0 oder >Feldlänge). An das aufrufende Programm wird ein Fehlercode zurückgegeben (0=Fehler, 1=ok).
* Hinweis: Initialisieren sie das Feld vor Gebrauch sinnvoll. Es wäre praktisch, zusätzlich eine kleine Funktion "print_array" zu erstellen...

Lösungsvorschlag: ( file swap_elements mit 2 Versionen der Lösung)

int swap_elements(int a,int z, int *i) {
/*
Funktion swap_elements
Vertauschung von 2 Elementen eines Feldes ganzer Zahlen (int array)
> Kontrolle der verwendeten Indices:
An das aufrufende Programm wird ein Fehlercode zurückgegeben:
0=Fehler, 1=ok
Bei Fehler wird das Feld nicht geändert.
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
int myarray[...];
int i,j,ok;
...
ok=swap_elements(i,j,myarray);
Length: 10 lines of code
*/

int j,ok=0;

if( (a>=0) && (a<array_length) && (z>=0) && (z<array_length) ) {

ok++;

j=i[a];

i[a]=i[z];

i[z]=j;

}

return ok;
}

Funktion sort_elements

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Ordnen von 2 Elementen eines Feldes (array).

Syntax:
int myarray[...]; // keine Vorgaben über die Dimension notwendig
int i,j,ok;
...
sort_elements(i,j,myarray); // Grundversion
// ok=sort_elements(i,j,myarray); // Erweiterte Version

Grundversion: Die Funktion sortiert die gewünschten Elemente des Feldes aufsteigend. Dimension: 5-10 Elemente
Beispiel: wenn das Feld vor dem Aufruf von sort_elements() den Inhalt {23,78,17,55...} hat und sort_elements(1,2,myarray) aufgerufen wird, so soll das Feld anschliessend den Inhalt {23,17,78,55...} haben.

Erweiterte Version:
+ Die Funktion ignoriert die Verwendung fehlerhafter Indices (i,j<0 oder >Feldlänge). An das aufrufende Programm wird ein Return-Code zurückgegeben (0=Fehler, 1=ok).
+ Erweiterung des return-Codes: 1=keine Änderung, 2=Elemente wurden getauscht.
* Hinweis: Initialisieren sie das Feld vor Gebrauch sinnvoll. Es wäre praktisch, zusätzlich eine kleine Funktion "print_array" zu erstellen...

Lösungsvorschlag: ( file sort_elements mit 2 Versionen der Lösung)

int sort_elements(int a,int z, int *i) {
/*
Funktion sort_elements
Sortierung von 2 Elementen eines Feldes ganzer Zahlen (int array)
> Kontrolle der verwendeten Indices:
An das aufrufende Programm wird ein Code zurückgegeben:
0=Fehler, 1=ok
Bei Fehler wird das Feld nicht geändert.
> Erweiterung des return-Codes: 1=keine Änderung, 2=sort-Änderung
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
int myarray[...];
int i,j,ok;
...
ok=sort_elements(i,j,myarray);
Length: 13 lines of code
*/

int j,ok=0;

if( (a>=0) && (a<array_length) && (z>=0) && (z<array_length) ) {
ok++;
if (i[a]>i[z]) {// sort ?
ok++;
j=i[a];
i[a]=i[z];
i[z]=j;
}
}
return ok;
}

Funktion toggle_elements

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Umkehrung eines Elementes eines Feldes (array).

Syntax:
int myarray[...]; // keine Vorgaben über die Dimension notwendig
int i;
...
toggle_element(i,myarray);

Grundversion: Die Funktion "invertiert" das gewünschte Elemente des Feldes, d.h. setzt myarray[i]=-myarray[i].
Dimension: 10 Elemente.
Beispiel: wenn das Feld vor dem Aufruf von toggle_element() den Inhalt {11,22,53,97...} hat und toggle_element(2,myarray) aufgerufen wird, so soll das Feld anschliessend den Inhalt {11,22,-53,97...} haben.

Erweiterte Version:
+ Die Funktion ignoriert die Verwendung fehlerhafter Indices (i,j<0 oder >Feldlänge). An das aufrufende Programm wird ein Return-Code zurückgegeben (0=Fehler, 1=ok).

Lösungsvorschlag: ( file toggle_elements mit 2 Versionen der Lösung)

int toggle_elements(int a,int *i) {
/*
Funktion toggle_element
Umkehrung eines Elements eines Feldes ganzer Zahlen (int array)
> Kontrolle der verwendeten Indices:
An das aufrufende Programm wird ein Code zurückgegeben:
0=Fehler, 1=ok
Bei Fehler wird das Feld nicht geändert.
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
Syntax:
int myarray[...];
int i,ok;
...
ok=toggle_element(i,myarray);
Length: 8 lines of code
*/

int ok=0;

if( (a>=0) && (a<array_length) ) {

ok++;

i[a]=-i[a];

}

return ok;
}

Funktion extr_elements

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Extrahieren von Elementen aus einem Feld (array) in ein anderes.

Syntax:
#define array_size ...

int src[...],dst[...];
int a,z,count;
... ...
count = extr_elements(a,z,src,dst);

Grundversion: Die Funktion durchsucht das Feld src nach Zahlen, die zwischen a und z liegen. Treffer (a<=src[i]<=z) kopiert die Funktion in das Feld dst, alle anderen Fälle werden ignoriert.

Erweiterte Version:
+ Die Funktion gibt die Anzahl der Treffer (count) an das aufrufende Programm zurück.

Lösungsvorschlag: ( extr_elements )

int extr_elements(int a, int z, int *src, int *dst) {
/*
Funktion extr_elements
Extract selected elements from array src to array dst.
Selection: a <= src[i] <= z

Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net

Syntax:
#define array_size ...

int src[...],dst[...];
int a,z;
... ...
extr_elements(a,z,src,dst);

Length:
9 lines of code
*/
int i,counter=0;

for (i=0;i<array_size;i++) {
if ( (src[i]>=a) && (src[i]<=z) ) {
dst[counter++]=src[i];
}
}

return counter;
}

Funktion count_1s

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Zählung aller gesetzten bits (bit=1) in einer Zeichenkette (string)

Syntax:
char mystring[...] // keine Vorgaben über die Dimension notwendig
int n1;
...
n1=count_1(mystring);

Lösungsvorschlag: ( file count_1s )

int count_1(char *s) {
/*
Funktion count_1
Zählung aller gesetzten bits (bit=1) in einer Zeichenkette (string)
Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net
> Vor Zählung wird jeder string auf char_max gekürzt, damit das
Ergebnis mit dem Konsolen-Display (beschränkter Platz) überein-
stimmt.
Syntax:
int count_1(char*);
...
int n1;
char mystring[...];
...
n1=count_1(mystring);
Length: 13 lines of code
*/
int i,sl,count=0;
sl=strlen(s);
for (i=0; i<sl; i++) _countbin(&count,s[i]);
return count;
}

void _countbin(int *cnt1,char byte) {
// count "1"s in a single byte
int i;
for (i=0;i<8;i++) {
*cnt1 += (byte & 1);
byte = byte >> 1;
}
}

Funktion set_bit

Erstellen sie eine Funktion, die folgende Arbeiten ausführt:
Setzen eines Bits in einem Byte auf einen gewünschten Wert.

Syntax:
unsigned char the_byte;
int bitposition, bitvalue;
...
set_bit(&the_byte,bitposition,bitvalue);

Lösungsvorschlag: ( set_bit )

void set_bit(unsigned char *c,int p,int v) {
/*
Funktion set_bit
Setzt ein Bit eines Bytes auf einen gewünschten Wert

Version 1.0 / 2002.04.01
Autor: pstrainer@gmx.net

Syntax:
unsigned char the_byte;
int bitposition, bitvalue;
...
set_bit(&the_byte,bitposition,bitvalue);

Parameter:
the_byte: 0...255
bitposition 0...7
bitvalue: 0 (clear this bit), 1 (set this bit)
Funktion arbeitet bei illegalen Parametern ohne Änderung.

Length:
13 lines of code
*/
unsigned char mask;
if ( (p>=0) && (p<=7) && (v>=0) && (v<=1) ) {
mask = 1 << p;// generate 00001000 type mask
if (v) {
*c = *c | mask;// set bit
}
else {
mask = ~mask;// invert to 11110111 type mask
*c = *c & mask;// clear bit
}
}
}