5.2.1 (r) Napisz funkcję wyczysc, która usuwa z tablicy przechowywanyw niej napis (w sensie: umieszcza w niej poprawny napis o długości0). Napisz dwie wersje funkcji wyczysc dla napisów składających sięze znaków typu char i wchar_t.

void wyczysc(char *napis){
napis[0]=0;
int main()
{
    char tab[255] = "nfiaonsfkl";
    printf(" %s wypisalo",tab);
    wyczysc(tab);
    printf(" %s wypisalo",tab);
    return 0;
}
(r) 5.2.2Napisz funkcję dlugosc, która jako argument otrzymuje napisi zwraca jako wartość jego długość. Napisz dwie wersje funkcji dlugoscdla napisów składających się ze znaków typu char i wchar_t.
///cw 5_2_2
int dlugosc(char *napis){
    int i=0;
while(napis[i]!=0)
    i++;
return i;
}
int main{
    printf("\ncw 5_2_2\n");
    printf("%d\n",dlugosc("Programowanie strukturalne to bardzo przyjemny przedmiot"));
return 0;
}
5.2.3 Napisz funkcję porownaj, która jako argumenty otrzymuje dwa napisyi zwraca 1 gdy napisy są równe i 0 w przeciwnym przypadku. Napisz dwie wersje funkcji porownaj dla napisów składających się ze znaków typu char i wchar_t
int porownajnapisy(char *napis1,char *napis2){
    int dl1=dlugosc(napis1);
    int dl2=dlugosc(napis2);
    if(dl1==dl2)
        {tab[i]=tab1[j];
for(int i=0;i<=dl2-1;i++)
{
    if (napis1[i]!=napis2[i])
    {
        return 0;
    }
}
        return 1;
    }
    else
    {
      return 0;
    }
}
int main{
    printf("\ncw 5_2_3\n");
    printf("%d\n",porownajnapisy("pierwszy napis","drugi napis"));
    printf("%d\n",porownajnapisy("wziasc","wziazc"));
    printf("%d\n",porownajnapisy("wziac","wziac"));
return 0;
}
5.2.4(r,!) Napisz funkcję, która jako argumenty otrzymuje dwa napisy i zwraca wartość 1, gdy pierwszy napis jest wcześniejszy w kolejności leksykograficznej i 0 w przeciwnym przypadku Zakładamy, że oba napisy składają się ze znaków typu char, zawierająwyłącznie małe litery alfabetu łacińskiego, a system, na którym jest kompilowany i uruchamiany program, używa standardowego kodowania ASCII
int porownajslownikowo(char *napis1,char *napis2){
for(int i=0;(napis1[i]!=0)&&(napis2[i]!=0);i++)
{
    if (napis1[i]!=napis2[i])
    {
        return (napis1[i]<napis2[i])?1:0;
    }
    if (napis1[i]!=0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}
}
int main{
printf("\ncw 5_2_4\n");
    printf("%d\n",porownajslownikowo("arbuz","arbiter"));
printf("%d\n",porownajslownikowo("hulajdusza","hulajnoga"));
return 0;
}
5.2.5
Napisz funkcję przepisz, która otrzymuje dwie tablice znaków i przepisuje napis znajdujący się w pierwszej tablicy do drugiej tablicy. Zakładamy, że w drugiej tablicy jest wystarczająco dużo miejsca. Napiszdwie wersje funkcji przepisz dla napisów składających się ze znaków typu char i wchar_t.
void przepisz(char*napis1, char*napis2){
    for(int i=0;i<dlugosc(napis1);i++)
    {
        napis2[i]=napis1[i];
    }
    napis2[dlugosc(napis1)]=0;
}
///cw 5_2_5
printf("\ncw 5_2_5\n");
///w poleceniu mamy zaznaczone ze przepisujemy krotsze napisy pod dluzsze
char* pierwszy="arbuz";
char drugi[20]="arbiter";
wypisz(pierwszy);
wypisz(drugi);
przepisz(pierwszy,drugi);
wypisz(pierwszy);
wypisz(drugi);
5.2.6
6 Napisz funkcję kopiujn, która dostaje w argumentach dwie tablice znaków nap1, nap2 oraz liczbę n i przekopiowuje n pierwszych znaków z napisu przechowywanego w tablicy nap1 do tablicy nap2. W przypadku gdy napis w tablicy nap1 jest krótszy niż n znaków, funkcja powinna po prostu przepisać cały napis. Funkcja powinna zadbać o to,żeby na końcu napisu w tablicy nap2 znalazł się znak o kodzie 0.Zakładamy, że w docelowej tablicy jest wystarczająco dużo miejsca.Napisz dwie wersje funkcji: dla napisów składających się ze znaków
typu char i wchar_t.

void przepisznpierwszych(char*napis1, char*napis2, unsigned int n){
    for(int i=0;i<dlugosc(napis1)&&i<n;i++)
    {
        napis2[i]=napis1[i];
    }
    napis2[n]=0;
}
int main{
printf("\ncw 5_2_6\n");
char *pierwszy6="informatyka";
wypisz(pierwszy6);
char drugi6[30]="programowanie";
wypisz(drugi6);
przepisznpierwszych(pierwszy6,drugi6,6);
wypisz(pierwszy6);
wypisz(drugi6);
return 0;
}
5.2.7
(r) Napisz funkcję sklej otrzymującą jako argumenty trzy tablice
znaków i zapisującą do trzeciej tablicy konkatenację napisów znajdujących się w dwóch pierwszych tablicach (czyli dla napisów ”Ala m”i ”a kota” znajdujących się w pierwszych dwóch argumentach do trzeciej tablicy powinien zostać zapisany napis ”Ala ma kota”). Zakładamy, że w trzeciej tablicy jest wystarczająco dużo miejsca.Napisz dwie wersje funkcji sklej dla napisów składających się ze znaków typu char i wchar_t.
///cw 5_2_7
void sklej(char *napis1,char *napis2,char *napis3){
    int i,j;
for(i=0;napis1[i]!='\0';i++)
{
    napis3[i]=napis1[i];
}
for(j=0;napis2[j]!='\0';i++,j++)
{
    napis3[i]=napis2[j];
}
napis3[i]=0;
}
int main{
printf("\ncw 5_2_7\n");
char *pierwszy7="brzeczy";
char *drugi7="szczykiewicz";
char trzeci7[40]; ///wynik musi miec dlugosc
sklej(pierwszy7,drugi7,trzeci7);
wypisz(trzeci7);
return 0;}
5.2.8.
(r,!) Napisz funkcję, która otrzymuje w argumencie napis i podmieniaw nim wszystkie małe litery na duże litery.Zakładamy, że napis przechowywany jest w tablicy o elementach typu char, składa się wyłącznie z liter łacińskich i białych znaków, oraz że system ,na którym jest kompilowany i uruchamiany program, używa standardowego kodowania ASCII.
void maleduze(char *napis){
int i;
for(i=0;napis[i]!=0;i++)
{
    if ((napis[i]>='a')&&(napis[i]<='z'))
    {
        napis[i]=napis[i]+'a'-'A';
    }
}
}
int main{
printf("\ncw 5_2_8\n");
char napiszad8[40]="ten napis ma byc duzymi literami";
wypisz(napiszad8);
maleduze(napiszad8);
wypisz(napiszad8);
return 0;
}
5.2.9 (r) Napisz funkcję wytnij, która dostaje jako argumenty napis oraz dwie liczby całkowite n i m, i wycina z otrzymanego napisu znakio indeksach od n do m ( n 6 m). Otrzymany w argumencie napis może mieć dowolną liczbę znaków (w tym mniejszą od n lub m) Napisz dwie wersje funkcji wytnij dla napisów składających się ze znaków typu char i wchar_t.
void wytnij(char *napis, int n, int m){
   int i,j;
   ///ustala dlugosc napisu
   for (j=0;napis[j]!=0;j++){}
       if(j+1>m)
       {
           for (i=0;i+m<j;i++)
           {
               napis[n+i]=napis[m+i+1];
           }
       }
       else if((n<j)&&(j+1<=m))
       {
           napis[n]=0;
       }
}
int main{
printf("\ncw 5_2_9\n");
char napiszad9[40]="z tego napisu mamy cos wyciac";
wypisz(napiszad9);
wytnij(napiszad9,5,15);
wypisz(napiszad9);
return 0;
}
5.2.10(*,r) Napisz funkcję wytnij2, która dostaje jako argument dwa napisy nap1 i nap2, i wycina z napisu nap1 pierwsze wystąpienie w nim napisu nap2. Napisz dwie wersje funkcji wytnij2 dla napisów składających się ze znaków typu char i wchar_t
bool porownaj(char* napis1, char* napis2, int n){
int i;
for(i=0;(napis1[i]!=0)&&napis2[i]!=0;i++)
    if(napis1[n+i]!=napis2[i])
{
    return false;
}
if (napis2[i]==0)
{
    return true;
}
else
{
    return false;
}
}
void wytnij2(char* napis1, char* napis2){
int i, dl;
for(dl=0;napis2[dl]!=0;dl++){}
    for(i=0;napis1[i]!=0;i++)
{
    if (porownaj(napis1,napis2,i))
    {
        wytnij(napis1,i,i+dl-1);
        return;
    }
}
}
int main{
///cw 5_2_10
printf("\ncw 5_2_10\n");
char napiszad101[40]="napis z ktorego wycinami";
char napiszad102[40]="ktorego";
wytnij2(napiszad101,napiszad102);
wypisz(napiszad101);
return 0;
}
5.2.11
 (*,r) Napisz funkcję wytnijzw, która dostaje jako argument dwa napisy nap1 i nap2, i wycina z napisu nap1 wszystkie znaki występujące także w napisie nap2. Napisz dwie wersje funkcji wytnijz dla napisów składających się ze znaków typu char i wchar_t.
void wytnijzw(char* napis1, char* napis2){
int i,dl;
int
}
int main(){
printf("\ncw 5_2_11\n");
return 0;
}
5.2.13
 (*,r) Napisz funkcję wytnijtm, która dostaje jako argument dwa napisy nap1 i nap2 o równej długości i wycina z napisu nap1 znaki równeznakom występującym na tym samym miejscu w napisie nap2 (znako indeksie i usuwamy wtedy i tylko wtedy, gdy nap1[i]=nap2[i]). Napisz dwie wersje funkcji wytnijtm dla napisów składających się ze znaków typu char i wchar_t.

    void wytnijtesameznaki(char *napis1,char *napis2){
        int i,j;
        for(i=0,j=0;napis1[i]!=0;i++)
        {
    if (napis1[i]!=napis2[i])
    {
            napis1[j]=napis1[i];
        j++;
    }
        }
    napis1[j]=0;
}
int main(){
printf("\ncw 5_2_13\n");
char napiszad131[40]="arbuz";
char napiszad132[40]="arbiter";
wytnijtesameznaki(napiszad131,napiszad132);
wypisz(napiszad131);
    return 0;
}
5.2.15Napisz funkcję, która wypisuje na standardowym wyjściu otrzymany w argumencie napis. Napisz dwie wersje funkcji: dla napisów typu string i wstring
void wypisz(char * napis){
printf("%s\n",napis);
}
void wypiszwchara(wchar_t * napis){
printf("%ls\n",napis);
}
 printf("\ncw 5_2_4\n");
    printf("%d\n",porownajslownikowo("arbuz","arbiter"));
printf("%d\n",porownajslownikowo("hulajdusza","hulajnoga"));
5.2.16
Napisz funkcję, która dostaje jako argument tablicę znaków i wczytuje do niej napis ze standardowego wejścia. Napisz dwie wersje funkcji: dla tablicy składających się ze znaków typu char i wchar_t.

void wczytaj(char * napis){
scanf("%s",napis);
}

void wczytajwchara(wchar_t * napis){
scanf("%ls",napis);
}
int main(){
wczytaj(dfsdfsdf)
wczytajwchara(jkhjkj)
}
5.2.20
(r) Napisz funkcję godzina, która dostaje w argumentach trzy liczby całkowite godz, min i sek, zawierające odpowiednio godziny, minutyoraz sekundy, i zwraca jako wartość napis zawierający godzinę w formacie godz:min:sek, w którym wartości poszczególnych pól pochodzą ze zmiennych podanych w argumentach.Napisz dwie wersje funkcji godzina: zwracające napisy będące tablicami znaków typu char i typu wchar_t

char * godzina(int godz, int min, int sek){
char* wynik=malloc(9*sizeof(char));
sprintf(wynik,"%02d:%02d:%02d",godz,min,sek);
return wynik;
}
wchar_t * godzinawchar(int godz, int min, int sek){
wchar_t* wynik=malloc(9*sizeof(wchar_t));
swprintf(wynik,L"%02d:%02d:%02d",godz,min,sek);
return wynik;
}
5.2.22 Napisz funkcję sklej, która dostaje w argumentach trzy napisy i zwraca jako wartość napis powstały ze sklejenia napisów otrzymanych w argumentach. Napisz dwie wersje funkcji sklej operujące na napisach składającychsię ze znaków typu char i typu wchar_t.
char* sklejnapisy(char* napis1, char* napis2, char *napis3){
char* wynik=malloc((strlen(napis1)+strlen(napis2)+strlen(napis3)+1)*sizeof(char));
///strlen oblicza dlugosc lancucha, wymaga uzycia bibiloteki string.h
strcpy(wynik,napis1); ///pozwala umiescic stringa pod podany wskaznik
strcat(wynik,napis2); ///pozwala dolaczyc lancuch do konca lancucha znajdujacego sie we wskazanym miejscu
strcat(wynik,napis3);
return wynik;
}