---

Hejsa newsgroup.

Jeg har aldrig fået sat mig rigtigt ind i hvordan pointere virker, så jeg
har brug for lidt hjælp.

Jeg har en variable "char **tekster"som peger på en liste med tekster
(der slutter med NULL) . Nu vil jeg gerne have sorteret alle
tekststrenge som forekommer mere end en gang fra, sådan at følgende
kun vil udskrive en af hvert tekststreng:

do{
   printf("%s\n", *tekster);
while(*tekster++);

Hvordan kan jeg gøre det på den enkleste måde.

Mvh. Mads Sejersen

---

> Jeg har aldrig fået sat mig rigtigt ind i hvordan pointere virker, så jeg
> har brug for lidt hjælp.
> Jeg har en variable "char **tekster"som peger på en liste med tekster
> (der slutter med NULL) . Nu vil jeg gerne have sorteret alle
> tekststrenge som forekommer mere end en gang fra, sådan at følgende
> kun vil udskrive en af hvert tekststreng:
> do{
> printf("%s\n", *tekster);
> while(*tekster++);
> Hvordan kan jeg gøre det på den enkleste måde.

Den enkelste måde er at smide strengene ind i Excel eller lign., sortere og
derefter slette dupletter (kræver ingen kendskab til pointere)

En bedre måde er at lave et binært søgetræ (kræver nogen kendskab til
pointere). Se evt.
http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/niemann/s_bin.htm

Det kan selvfølgelig også laves på "billigere" måder, men den rigtige er altså
en form for binær søgning.

---

>> Nu vil jeg
>> gerne have sorteret alle tekststrenge som forekommer
>> mere end en gang fra, sådan at følgende kun vil udskrive
>> en af hvert tekststreng
[snip]
>> Hvordan kan jeg gøre det på den enkleste måde.
>
> Den enkelste måde er at smide strengene ind i Excel eller
> lign., sortere og derefter slette dupletter (kræver ingen
> kendskab til pointere)



Eller bruge
sort filnavn | uniq


Men algoritmen er god. Sorter først, og fjern så dubletter.

> En bedre måde er at lave et binært søgetræ (kræver nogen
> kendskab til pointere). Se evt.
> http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/niemann/s_bin.htm

Det er under alle omstændigheder en opgave, der kræver nogen
pointer-manipulation. Hvis det udelukkende er for at lære at
manipulere pointere, er her en alternativ mulighed:

1. Lav et array med pointere til leddene i listen
2. Definer en sammenligningsfunktion
3. Brug den færdiglavede qsort til at sortere arrayet
4. Gennemløb arrayet for at finde dubletter, men slet
slet leddene i listen.

> Det kan selvfølgelig også laves på "billigere" måder, men
> den rigtige er altså en form for binær søgning.

Et alternativ mere (under forudsætningen at du har
mulighed for at bruge en hashtabel).

opret hashtabel
for hvert led gør
hvis strengen er i hashtabellen
så fjern leddet fra listen
ellers indsæt den i hashtabellen

Fælles for løsningerne er

- gennemløb
- sletning af led

Det binære træ er den "rigtige" måde at gøre det på.
Det første alternativ har også det rigtige tidsforbrug.
Det sidste alternativ er simpelt; og har et fint tidsforbrug
(lidt afhæning af hashtabellen).

--
Jens Axel Søgaard

---

I artikel <3d937ea0$0$69050$edfadb0f@dspool01.news.tele.dk>, skrev "Jens
Axel Søgaard" <usenet@soegaard.net>:

[snip]
> Det binære træ er den "rigtige" måde at gøre det på. Det første
> alternativ har også det rigtige tidsforbrug. Det sidste alternativ er
> simpelt; og har et fint tidsforbrug (lidt afhæning af hashtabellen).

Tak for hjælpen alle sammen.
Jeg tror jeg lægger ud med at bruge qsort-metoden. Når
så det virker vil jeg kaste mig over binære søgetræer ... det for jeg
sikkert alligevel brug for senere. Hashtabeller må vente lidt endnu.

Mvh. Mads Sejersen

---

Mads Sejersen skrev:

>Jeg tror jeg lægger ud med at bruge qsort-metoden. Når
>så det virker vil jeg kaste mig over binære søgetræer ...

Binære søgetræer er for viderekomne. Der er mange andre emner som
du vil have mere ud af at bruge energi på først.

--
Bertel
http://bertel.lundhansen.dk/   FIDUSO: http://fiduso.dk/

---

I artikel <i3q7pu0ahp9tptn6udd3qfubj86bpt415f@news.telia.dk>, skrev
"Bertel Lund Hansen" <nospam@lundhansen.dk>:

> Mads Sejersen skrev:
>
>>Jeg tror jeg lægger ud med at bruge qsort-metoden. Når så det virker vil
>>jeg kaste mig over binære søgetræer ...
>
> Binære søgetræer er for viderekomne. Der er mange andre emner som du vil
> have mere ud af at bruge energi på først.

Jeps ... som f.eks. qsort metoden. Er der ikke en der kan komme med et
konkret eksempel (ligesom det c++ eksempel der er givet). Enten kan mine
forsøg ikke sortere listen, eller også går programmet ned

Mvh. Mads Sejersen

---

"Mads Sejersen" <Psyco@mailme.dk> wrote in message
news:3d97028d$0$18148$edfadb0f@dspool01.news.tele.dk...

> Enten kan mine
> forsøg ikke sortere listen, eller også går programmet ned

Hvordan ser dine forsøg ud ?

Venlig hilsen

Mogens Hansen

---

I artikel <an72uv$2167$1@news.cybercity.dk>, skrev "Mogens Hansen"
<mogens_h@dk-online.dk>:

> Hvordan ser dine forsøg ud ?

Sådan her. Men det er en kombination af hvad jeg har kunne finde på
nettet og hvad jeg har fået til at fungere. Bl.a. skal længden også
findes dynamisk, da listens størrelse ikke er kendt på forhånd.
Og så skal den selvfølgelig også sortere listen

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

int cmp_str(const void *str1, const void *str2){
   char *s1, *s2;
   s1 = (char *)str1;
   s2 = (char *)str2;
   return strcmp(s1, s2);
}

int main(int argc, char **argv){
   char *test[] = {
      "Tekst1",
      "Tekst2",
      "Tekst1",
      "Tekst3",
      "Tekst2",
      0
   };
   int len = 5, i;
   
   qsort(&test[len], len, sizeof(char *), cmp_str);
   for(i = 0; i < len; i++){
      printf("%d\n", test[i]);
   }
   return 0;
}

---

"Mads Sejersen" <Psyco@mailme.dk> wrote in message
news:3d971292$0$70331$edfadb0f@dspool01.news.tele.dk...

> Sådan her. Men det er en kombination af hvad jeg har kunne finde på
> nettet og hvad jeg har fået til at fungere. Bl.a. skal længden også
> findes dynamisk, da listens størrelse ikke er kendt på forhånd.
> Og så skal den selvfølgelig også sortere listen

Det er tæt på

>
> #include <string.h>
> #include <stdlib.h>
> #include <stdio.h>
>
> int cmp_str(const void *str1, const void *str2){
> char *s1, *s2;
> s1 = (char *)str1;
> s2 = (char *)str2;
> return strcmp(s1, s2);
> }
>
> int main(int argc, char **argv){
> char *test[] = {
> "Tekst1",
> "Tekst2",
> "Tekst1",
> "Tekst3",
> "Tekst2",
> 0
> };
> int len = 5, i;
>
> qsort(&test[len], len, sizeof(char *), cmp_str);

Hvorfor "&test[len]" ?
Du får fat i det sidste element - 0 pointeren!

Hvilken type har "&test[len]" ?
Det er den type som cmp_str modtager.

> for(i = 0; i < len; i++){
> printf("%d\n", test[i]);

Hvad betyder format-specifieren "%d" ?
Hvorfor bruger du den ?

> }
> return 0;
> }

Når du har svaret på de spørgsmål når du formodentlig frem til noget i
retningen af

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

int cmp_str(const void *str1, const void *str2)
{
char **s1, **s2;
s1 = (char **)str1;
s2 = (char **)str2;
return strcmp(*s1, *s2);
}

int main(int argc, char **argv){
char *test[] = {
"Tekst1",
"Tekst2",
"Tekst1",
"Tekst3",
"Tekst2",
0
};
char** p = test;
int len = 0, i;
while(*p) {
++p;
++len;
}

qsort(test, len, sizeof(char *), cmp_str);
for(i = 0; i < len; i++){
printf("%s\n", test[i]);
}
return 0;
}

Venlig hilsen

Mogens Hansen

---

Mogens Hansen <mogens_h@dk-online.dk> skrev:

> Når du har svaret på de spørgsmål når du formodentlig frem til noget i
> retningen af

Herunder er mit forslag. Det adskiller sig ved:

- En masse "const" erklæringer.
- Antallet af strenge i test (len) beregnes af oversætteren.
- Ingen afsluttende 0-pointer i test.


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

int cmp_str(const void *str1, const void *str2)
{
const char **s1, **s2;
s1 = (const char **)str1;
s2 = (const char **)str2;
return strcmp(*s1, *s2);
}

int main(int argc, char **argv){
const char *test[] = {
"Tekst1",
"Tekst2",
"Tekst1",
"Tekst3",
"Tekst2",
};
const size_t len = sizeof test / sizeof test[0];

qsort(test, len, sizeof(const char *), cmp_str);
for(size_t i = 0; i < len; i++){
printf("%s\n", test[i]);
}
return 0;
}

---

I artikel <slrnapef3s.139.bjensen@ask.ask>, skrev "Byrial Jensen"
<bjensen@nospam.dk>:

> Herunder er mit forslag. Det adskiller sig ved:
>
> - En masse "const" erklæringer.

Det er der selvfølgelig ikke noget i vejen for at sætte ind. Gør de
egentlig programmet hurtigere/sikrer mod forkert andvendelse/er god
programmeringsskik???

> - Antallet af strenge i test (len) beregnes af oversætteren.

I en af de tidligere indlæg skrev jeg at det skulle findes dynamisk. Jeg
skal nemlig bruge sorteringen i et andet program hvor jeg ikke kender
størrelsen på forhånd. Eksemplet jeg gav var bare et minimalt eksempel så
jeg kunne få qsort til at virke, og let finde fejlen hvis det ikke var
tilfældet...

> - Ingen afsluttende 0-pointer i test.

.... og derfor skal der være en afsluttende 0-pointer.

Men ellers tak for hjælpen.

Mvh. Mads Sejersen

---

Mads Sejersen <Psyco@mailme.dk> skrev:
> I artikel <slrnapef3s.139.bjensen@ask.ask>, skrev "Byrial Jensen"
><bjensen@nospam.dk>:
>
>> Herunder er mit forslag. Det adskiller sig ved:
>>
>> - En masse "const" erklæringer.
>
> Det er der selvfølgelig ikke noget i vejen for at sætte ind. Gør de
> egentlig

> programmet hurtigere/

Ja, i visse tilfælde kan en oversætter udnytte oplysningen til at
lave bedre oversættelser. Det er dog næppe tilfældet her.

> sikrer mod forkert andvendelse/

Ja.

> er god programmeringsskik???

Ja. Det gør programmet lettere at læse og sætte sig ind i, og derved
nemmere at vedligeholde. Det giver endvidere mulighed for
oversætter-tjek af om man overholder intentionerne.

Jeg erklærede indholdet af de enkelte strenge i test for const
fordi de initialiseres med "string literals". Disse har af
historiske årsager typen "char *", men ikke desto mindre er det
udefineret adfærd at forsøge at ændre indholdet som derfor altid
bør kaldes "const".

Jeg tilføjede const til (char **) typerne i cmp_str fordi de peger
på strengene i test som erklæres const i main.

Jeg erklærede len const fordi værdien i mit program beregnes af
oversætteren og ikke ændrer sig.

>> - Antallet af strenge i test (len) beregnes af oversætteren.
>
> I en af de tidligere indlæg skrev jeg at det skulle findes dynamisk. Jeg
> skal nemlig bruge sorteringen i et andet program hvor jeg ikke kender
> størrelsen på forhånd. Eksemplet jeg gav var bare et minimalt eksempel så
> jeg kunne få qsort til at virke, og let finde fejlen hvis det ikke var
> tilfældet...

O.k., det bemærkede jeg ikke. Jeg syntes bare det så overflødigt ud
i Mogens' program, så jeg ville vise hvordan man sætter
oversætteren til at tælle antal elementer i et array.

---

I artikel <an7bfm$2b6k$2@news.cybercity.dk>, skrev "Mogens Hansen"
<mogens_h@dk-online.dk>:

> Det er tæt på

[snip]

> Hvorfor "&test[len]" ?
> Du får fat i det sidste element - 0 pointeren!

Fordi jeg så noget lignende i et eksempel hvor der blev sorteret en
int-array. Jeg må indrømme at jeg heller ikke forstod hvorfor.

> Hvilken type har "&test[len]" ?
> Det er den type som cmp_str modtager.

Så er det jo nok char*

>> for(i = 0; i < len; i++){
>> printf("%d\n", test[i]);
>
> Hvad betyder format-specifieren "%d" ? Hvorfor bruger du den ?

Hehe ... den betyder "udskriv en int". Det er bare mig der ikke tænker
mig om før jeg skriver. Jeg er godt klar over at der skal bruges %s.

> Når du har svaret på de spørgsmål når du formodentlig frem til noget i
> retningen af
>
> #include <string.h>
> #include <stdlib.h>
> #include <stdio.h>
>
> int cmp_str(const void *str1, const void *str2) {
> char **s1, **s2;
> s1 = (char **)str1;
> s2 = (char **)str2;
> return strcmp(*s1, *s2);
> }

Er det forkert at skrive

int cmp_str(const void *str1, const void *str2){
   char *s1, char *s2;
   s1 = (char *)str1;
   s2 = (char *)str2;
   return strcmp(s1, s2);
}

Min compiler brokker sig nemlig ikke og det virker, så det kunne tyde på
at det er overflødigt at lave de ekstra pointere. Men hvis det er
forkert/dårlig programmeringsstil, så vil jeg gerne lige vide det.

I hvert fald virker det nu, så tusind tak for hjælpen.

Mvh. Mads Sejersen

---

"Mads Sejersen" <Psyco@mailme.dk> wrote in message
news:3d9761b7$0$69061$edfadb0f@dspool01.news.tele.dk...
> I artikel <an7bfm$2b6k$2@news.cybercity.dk>, skrev "Mogens Hansen"
> <mogens_h@dk-online.dk>:

[8<8<8<]
> > Hvilken type har "&test[len]" ?
> > Det er den type som cmp_str modtager.
>
> Så er det jo nok char*

Nej.
Det er "char**"

[8<8<8<]
> Er det forkert at skrive
>
> int cmp_str(const void *str1, const void *str2){
> char *s1, char *s2;
> s1 = (char *)str1;
> s2 = (char *)str2;
> return strcmp(s1, s2);
> }

Det kommer an på hvad du bruger cmp_str til.
I det konkrete tilfælde er det absolut forkert.
Har du prøvet om det kører og om det gør nogen forskel ?

> Min compiler brokker sig nemlig ikke og det virker, så det kunne tyde på
> at det er overflødigt at lave de ekstra pointere.

Det at din compiler ikke brokker sig, er fordi compilerens type-check
effektivt er sat ud af spillet ved de påkrævede cast og ved at der ikke er
nogen type-mæssig sammenhæng (set fra compileren) mellem "qsort", "cmp_str"
og "test" i programmet.

Det er en af de store problemer ved qsort.

Nå man sammenligner med C++ Standard Library funktionen "std::sort" med
"qsort", som jeg brugte i et tidligere svar, vil man se at "std::sort" ikke
lider af de svagheder. Der er fuldt type-check på compile-time - og så kører
den tilmed typisk hurtigere.

> Men hvis det er
> forkert/dårlig programmeringsstil, så vil jeg gerne lige vide det.

Det er forkert.


Du skrev i dit første indlæg, at du aldrig rigtigt har fået sat dig ind i
hvordan pointere virker.
Jeg kan varmt anbefale, at du sætter dig ned og laver nogle tegninger af
hvordan data-strukturen i det lille program er.
Du skal også lave nogle tegninger af data-strukturen i de programmer, der
ikke virker.
Det er absolut en forudsætning for at kunne skrive stabile programmer, med
den slags teknikker som er anvendt.

Venlig hilsen

Mogens Hansen

---

I artikel <an8kb4$n3c$1@news.cybercity.dk>, skrev "Mogens Hansen"
<mogens_h@dk-online.dk>:

> Nej.
> Det er "char**"

OK

> Det kommer an på hvad du bruger cmp_str til. I det konkrete tilfælde er
> det absolut forkert. Har du prøvet om det kører og om det gør nogen
> forskel ?

Det kører og der er ingen forskel ... det er derfor jeg var i tvivl.

>> Min compiler brokker sig nemlig ikke og det virker, så det kunne tyde
>> på at det er overflødigt at lave de ekstra pointere.
>
> Det at din compiler ikke brokker sig, er fordi compilerens type-check
> effektivt er sat ud af spillet ved de påkrævede cast og ved at der ikke
> er nogen type-mæssig sammenhæng (set fra compileren) mellem "qsort",
> "cmp_str" og "test" i programmet.

Ok ... så holder jeg mig til det du skrev i eksemplet.

> Det er en af de store problemer ved qsort.
>
> Nå man sammenligner med C++ Standard Library funktionen "std::sort" med
> "qsort", som jeg brugte i et tidligere svar, vil man se at "std::sort"
> ikke lider af de svagheder. Der er fuldt type-check på compile-time - og
> så kører den tilmed typisk hurtigere.

Findes der ingen c-alternativer til qsort???

>> Men hvis det er
>> forkert/dårlig programmeringsstil, så vil jeg gerne lige vide det.
>
> Det er forkert.

Ok

> Du skrev i dit første indlæg, at du aldrig rigtigt har fået sat dig ind
> i hvordan pointere virker.
> Jeg kan varmt anbefale, at du sætter dig ned og laver nogle tegninger af
> hvordan data-strukturen i det lille program er. Du skal også lave nogle
> tegninger af data-strukturen i de programmer, der ikke virker.
> Det er absolut en forudsætning for at kunne skrive stabile programmer,
> med den slags teknikker som er anvendt.

Ja, det lyder som en god øvelse. Det prøver jeg

Mvh. Mads Sejersen

---

"Mads Sejersen" <Psyco@mailme.dk> wrote in message
news:3d9866cf$0$18115$edfadb0f@dspool01.news.tele.dk...
> I artikel <an8kb4$n3c$1@news.cybercity.dk>, skrev "Mogens Hansen"
> <mogens_h@dk-online.dk>:

[8<8<8<]
> > Det kommer an på hvad du bruger cmp_str til. I det konkrete tilfælde er
> > det absolut forkert. Har du prøvet om det kører og om det gør nogen
> > forskel ?
>
> Det kører og der er ingen forskel ... det er derfor jeg var i tvivl.

Er det rigtigt ?
Det lyder helt utroligt - men udefineret opførsel kan naturligvis godt være
noget der ligner det ønskede.
Har du prøvet at tage en debugger og inspicere "s1" og "s2" i cmp_str ?

Venlig hilsen

Mogens Hansen

---

Mogens Hansen <mogens_h@dk-online.dk> skrev:
> "Mads Sejersen" <Psyco@mailme.dk> wrote in message
>> I artikel <an8kb4$n3c$1@news.cybercity.dk>, skrev "Mogens Hansen"
>
>> > Det kommer an på hvad du bruger cmp_str til. I det konkrete tilfælde er
>> > det absolut forkert. Har du prøvet om det kører og om det gør nogen
>> > forskel ?
>>
>> Det kører og der er ingen forskel ... det er derfor jeg var i tvivl.
>
> Er det rigtigt ?
> Det lyder helt utroligt

Nej, det lyder faktisk meget troligt.

Arrayet test er i eksemplet initialiseret således:

char *test[] =
{
"Tekst1",
"Tekst2",
"Tekst1",
"Tekst3",
"Tekst2",
0
};

Der er kun 3 forskellige strenge, hver på 7 tegn inkl. det
afsluttende '\0'. Det vil være naturligt at forestille sig at en
oversætter vil lægge dem efter hinanden et sted i hukommelsen i
den rækkefølge de optræder i første gang. F.eks. således:

0x12345670: 'T', 'e', 'k', 's', 't', '1', '\0'
0x12345677: 'T', 'e', 'k', 's', 't', '2', '\0'
0x1234567E: 'T', 'e', 'k', 's', 't', '3', '\0'

Når strcmp() fodres med pointere til adresserne, vil den begynde at
sammenligne dem (adresserne) som tekster. De mindst betydende 8 bit
i adresserne kommer på little endian-maskiner som f.eks. pc'er med
i86-kompatible CPU'er, til at svare til det første tegn i en streng.
Da adresserne med god sandsynlighed har voksende værdier på de
mindst betydende 8 bit svarende til det første tegn i en streng,
finder jeg det troligt at de tilsyneladende bliver sorteret
"korrekt".

>- men udefineret opførsel kan naturligvis godt være
> noget der ligner det ønskede.

Netop, men man skal naturligvis ikke satse på det. Bedre
testeksempler ville med garanti også have afsløret fejlen i det
konkrete tilfælde.

---

Mads Sejersen <Psyco@mailme.dk> skrev:
> I artikel <an7bfm$2b6k$2@news.cybercity.dk>, skrev "Mogens Hansen"
><mogens_h@dk-online.dk>:
>
>> int cmp_str(const void *str1, const void *str2) {
>> char **s1, **s2;
>> s1 = (char **)str1;
>> s2 = (char **)str2;
>> return strcmp(*s1, *s2);
>> }
>
> Er det forkert at skrive
>
> int cmp_str(const void *str1, const void *str2){
>    char *s1, char *s2;
>    s1 = (char *)str1;
>    s2 = (char *)str2;
>    return strcmp(s1, s2);
> }
>
> Min compiler brokker sig nemlig ikke og det virker, så det kunne tyde på
> at det er overflødigt at lave de ekstra pointere. Men hvis det er
> forkert/dårlig programmeringsstil, så vil jeg gerne lige vide det.

Oversætteren brokker sig ikke fordi du tvinger den til ikke at
brokke sig. Det er ideen - og samtidig faren - ved at bruge
eksplicitte cast til at ændre typen på variable, her str1 og str2.

Funktionen cmp_str kaldes af qsort med pointere til 2
array-elementer. Da et array-element er "pointer til char" (char *),
vil en pointer til et array-element være "pointer til pointer til
char" (char **), og argumenterne skal castes til dette.

(Jeg vil helst sætte const-erklæringer på også. Det forklarer jeg i
næste indlæg).

---

[ Mads Sejersen ]

[ ... ]

> Jeg har aldrig fået sat mig rigtigt ind i hvordan pointere virker,
> så jeg har brug for lidt hjælp.


@Book{lang:linden94,
author =     {Linden, Peter van der},
title =     {Expert {C} Programming: Deep {C} Secrets},
publisher =     SSP,
year =     {1994},
pages = {xxvi + 353},
ISBN = {0-131-77429-8},
LCCN = {QA76.73.C15V356 1994}
}


> Jeg har en variable "char **tekster"som peger på en liste med
> tekster (der slutter med NULL).


To presiseringer: en liste og en vector/array/tabell er to
forskjellige ting på norsk. Jeg antar at det samme gjelder dansk.

Du har vel noe som ligner på det andre argumentet til main:

+------ tekster
|
v
+-+
|----->"the"
+-+
|----->"quick"
+-+
|----->"brown"
+-+
|----->"fox"
+-+
|---||
+-+



> Nu vil jeg gerne have sorteret alle tekststrenge som forekommer mere
> end en gang fra, sådan at følgende kun vil udskrive en af hvert
> tekststreng:


@Book{prog:pearls,
author =     {Bentley, Jon},
title =     {Programming Pearls},
edition = {Second},
publisher =     AW,
year =     {2000},
ISBN = {0-201-65788-0},
pages = {239 + xi},
url = {http://www.cs.bell-labs.com/cm/cs/pearls/}
}





ivr
--
<peder> igorr: tcl ja... det er fra de dypeste avgrunnene i helvete det...
<peder> php er bare fra foajeen
            -- pederst på irc

---

I artikel <xjv4rccbg1i.fsf@vestavind.ifi.uio.no>, skrev "Igor V. Rafienko"
<igorr@ifi.uio.no>:

Det er sikkrt nogle gode bøger ... men jeg har desværre ikke råd til at
gå ud og investerer i dem lige nu

Mvh. Mads Sejersen

---

[ Mads Sejersen ]

[ ... ]

> Det er sikkrt nogle gode bøger ... men jeg har desværre ikke råd til
> at gå ud og investerer i dem lige nu


Iallfall en del av skattepengene betalt til den Norske Stat går til
finansiering av kunnskapsformidling, deriblant biblioteker. Det kan
umulig være annerledes i Danmark, kan det vel?





ivr
--
<peder> igorr: tcl ja... det er fra de dypeste avgrunnene i helvete det...
<peder> php er bare fra foajeen
            -- pederst på irc

---

I artikel <xjvk7l4dgvd.fsf@refabogi.ifi.uio.no>, skrev "Igor V. Rafienko"
<igorr@ifi.uio.no>:


> Iallfall en del av skattepengene betalt til den Norske Stat går til
> finansiering av kunnskapsformidling, deriblant biblioteker. Det kan
> umulig være annerledes i Danmark, kan det vel?

Ah ... det tænkte jeg ikke på. Jeg prøver lykken.

Mvh. Mads Sejersen

---

Den 29 Sep 2002 16:12:38 +0200 skrev Igor V. Rafienko:
>[ Mads Sejersen ]
>
>[ ... ]
>
>> Det er sikkrt nogle gode bøger ... men jeg har desværre ikke råd til
>> at gå ud og investerer i dem lige nu
>
>
>Iallfall en del av skattepengene betalt til den Norske Stat går til
>finansiering av kunnskapsformidling, deriblant biblioteker. Det kan
>umulig være annerledes i Danmark, kan det vel?

Jo, vi har skam biblioterer i DK, men EDB-bøger køber de vist i den
blå avis. De har masser af old-gamle bøger (OS/2 2.0, Turbo Pascal 5),
men skal man bruge nye bøger, skal de først skaffes fra et andet
bibliotek (hovedbiblioteket, eller et universitetsbibliotek), og det
tager laaaaang tid.

Mvh
Kent
--
Avoid the Gates of Hell. Use Linux
(Unknown source)

---

"Mads Sejersen" <Psyco@mailme.dk> wrote in message
news:3d937397$0$70344$edfadb0f@dspool01.news.tele.dk...

[8<8<8<]
> Hvordan kan jeg gøre det på den enkleste måde.

Hvis det er C++ kan du bruge Standard Library til det.

Algoritmerne
std::sort
std::unique
gør tilsammen præcist hvad du har behov for, og det er en meget effektiv
implementering.

<code>
#include <algorithm>
#include <functional>
#include <iterator>
#include <iostream>
#include <cstring>

const char* texts[] =
{ "text 1",
"text 2",
"duplicate 1",
"duplicate 1",
"text 3",
"duplicate 2",
"text 4",
"duplicate 2",
"duplicate 2",
"text 5",
0
};

inline bool less_char_ptr(const char* s1, const char* s2)
{
return std::strcmp(s1, s2) < 0;
}

inline bool equal_char_ptr(const char* s1, const char* s2)
{
return std::strcmp(s1, s2) == 0;
}

int main()
{
using namespace std;

const char** text_begin = texts;
const char** text_end = texts;
while(*text_end) ++text_end;

sort(text_begin, text_end, ptr_fun(less_char_ptr));
text_end = unique(text_begin, text_end, ptr_fun(equal_char_ptr));
copy(text_begin, text_end,
ostream_iterator<const char*, char>(cout, "\n"));
}
</code>

udskriver
<output>
duplicate 1
duplicate 2
text 1
text 2
text 3
text 4
text 5
</output>

Venlig hilsen

Mogens Hansen

---

"Mogens Hansen" wrote:
>> Hvordan kan jeg gøre det på den enkleste måde.
> Hvis det er C++ kan du bruge Standard Library til det.
> Algoritmerne
> std::sort
> std::unique
> gør tilsammen præcist hvad du har behov for, og det er en meget effektiv
> implementering.

Godt svar :)

---

I artikel <an1rkk$25n$1@sunsite.dk>, skrev "Morten F. Hansen"
<SpamRUs@127.0.0.1>:

> "Mogens Hansen" wrote:
>>> Hvordan kan jeg gøre det på den enkleste måde.
>> Hvis det er C++ kan du bruge Standard Library til det. Algoritmerne
>> std::sort
>> std::unique
>> gør tilsammen præcist hvad du har behov for, og det er en meget
>> effektiv implementering.
>
> Godt svar :)

Fuldstændig enig ... men desværre er det ikke C++

Mvh. Mads Sejersen

---

"Mogens Hansen" <mogens_h@dk-online.dk> wrote in message
news:an1pcg$24ff$1@news.cybercity.dk...

En alternativ løsning, som dog næppe er mere effektiv:

<code>
#include <iterator>
#include <iostream>
#include <set>
#include <string>

const char* texts[] =
{ "text 1",
"text 2",
"duplicate 1",
"duplicate 1",
"text 3",
"duplicate 2",
"text 4",
"duplicate 2",
"duplicate 2",
"text 5",
0
};

int main()
{
using namespace std;

const char** text_begin = texts;
const char** text_end = texts;
while(*text_end) ++text_end;

set<string> unique_texts(text_begin, text_end);
copy(unique_texts.begin(), unique_texts.end(),
ostream_iterator<string, char>(cout, "\n"));
}
</code>

Den er næppe mere effekt (primært pga. en del heap-allokeringer), men den er
kortere at skrive og ændrer ikke på det originale array.

Venlig hilsen

Mogens Hansen