INPUT   = ./sample.txt
#INPUT  = ./sample_kurz.txt
#INPUT  = ./sample_mittel.txt
VERIFY  = /etc/passwd

# Ein Directory für Temporäres, kann jederzeit gelöscht werden
TMP     = ./tmp

MEASURE = /usr/bin/time --format "result: %C | %e | %S | %U | %x | %P"
DIFF    = diff
RM      = rm -f
CPP     = g++
COMPRESS=cd ./output/; ls | grep -v .gz | xargs gzip -9

runall: 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 \
       020 022 023 024 025 026 027 028 029 032 033 034 035 036 037 038 039 040 041 \
       042 043 044 045 046 047 048 052 053 054 055 057 058 059 060 061 062 063

dorun: allclean
       ulimit -t 120; make -k runall


allclean:
       $(RM) ./output/*
       $(RM) ./error/*

stat:
       cat error/* | grep "^result" | sed 's/^.*\.\/0/0/;s/\.[^\|]*//' | sort -n -k2 -r

# Programm 001 -- angepasst von: Peter

001:
       $(MEASURE) python ./001.py -a < $(INPUT) > ./output/001.txt 2> ./error/001.txt
       $(COMPRESS)

001-verify:
       $(DIFF) ./output/001.txt $(VERIFY)

001-clean:
       $(RM) ./output/001.txt


# Programm 002 -- Perl -- angepasst von: Nils

002:
       $(MEASURE) ./002.pl < $(INPUT) > ./output/002.txt 2> ./error/002.txt
       $(COMPRESS)

002-verify:
       $(DIFF) ./output/002.txt $(VERIFY)

002-clean:
       $(RM) ./output/002.txt


# Programm 003 -- Perl -- angepasst von: Nils

003:
       $(MEASURE) ./003.pl < $(INPUT) > ./output/003.txt 2> ./error/003.txt
       $(COMPRESS)

003-verify:
       $(DIFF) ./output/003.txt $(VERIFY)

003-clean:
       $(RM) ./output/003.txt


# Programm 004 -- Ruby angepasst von: Nils

004:
       $(MEASURE) ./004.rb $(INPUT) > ./output/004.txt 2> ./error/004.txt
       $(COMPRESS)

004-verify:
       $(DIFF) ./output/004.txt $(VERIFY)

004-clean:
       $(RM) ./output/004.txt


# Programm 005 -- Groovy angepasst von: Nils

005:
       $(MEASURE) groovy ./o005.groovy $(INPUT) > ./output/005.txt 2> ./error/005.txt
       $(COMPRESS)

005-verify:
       $(DIFF) ./output/005.txt $(VERIFY)

005-clean:
       $(RM) ./output/005.txt



# Programm 006 -- Tcl -- angepasst von: Nils und Achim

006:
       $(MEASURE) ./006.tcl $(INPUT) > ./output/006.txt 2> ./error/006.txt
       $(COMPRESS)

006-verify:
       $(DIFF) ./output/006.txt $(VERIFY)

006-clean:
       $(RM) ./output/006.txt


# Programm 007 -- Perl -- angepasst von: Nils

007:
       $(MEASURE) ./007.pl -f $(INPUT) > ./output/007.txt 2> ./error/007.txt
       $(COMPRESS)

007-verify:
       $(DIFF) ./output/007.txt $(VERIFY)

007-clean:
       $(RM) ./output/007.txt


# Programm 009 -- Ruby -- angepasst von: Nils

009:
       $(MEASURE) ruby ./009.rb < $(INPUT) > ./output/009.txt 2> ./error/009.txt
       $(COMPRESS)

009-verify:
       $(DIFF) ./output/009.txt $(VERIFY)

009-clean:
       $(RM) ./output/009.txt


# Programm 010 -- Python -- angepasst von: Nils

010:
       $(MEASURE) ./010.py < $(INPUT) > ./output/010.txt 2> ./error/010.txt

010-verify:
       $(DIFF) ./output/010.txt $(VERIFY)

010-clean:
       $(RM) ./output/010.txt


# Programm 011 -- Python -- angepasst von: Nils

011:
       $(MEASURE) ./011.py $(INPUT) > ./output/011.txt 2> ./error/011.txt

011-verify:
       $(DIFF) ./output/011.txt $(VERIFY)

011-clean:
       $(RM) ./output/011.txt


# Programm 012 -- Python -- angepasst von: Nils

012:
       $(MEASURE) ./012.py < $(INPUT) > ./output/012.txt 2> ./error/012.txt
       $(COMPRESS)

012-verify:
       $(DIFF) ./output/012.txt $(VERIFY)

012-clean:
       $(RM) ./output/012.txt


# Programm 013 -- angepasst von: Nils

013:
       $(MEASURE) ./013.py < $(INPUT) > ./output/013.txt 2> ./error/013.txt

013-verify:
       $(DIFF) ./output/013.txt $(VERIFY)

013-clean:
       $(RM) ./output/013.txt


# Programm 014 -- angepasst von: Nils

014:
       $(MEASURE) ./014.pl $(INPUT) > ./output/014.txt 2> ./error/014.txt

014-verify:
       $(DIFF) ./output/014.txt $(VERIFY)

014-clean:
       $(RM) ./output/014.txt


# Programm 015 -- Java angepasst von: Nils

015:
       cp ./015.java ./tmp/FootnoteProcessor.java
       cd ./tmp; javac FootnoteProcessor.java
       cd ./tmp; $(MEASURE) java FootnoteProcessor $(INPUT) > ../output/015.txt 2> ../error/015.txt
       $(COMPRESS)

015-verify:
       $(DIFF) ./output/015.txt $(VERIFY)

015-clean:
       $(RM) ./output/015.txt


# Programm 016 -- angepasst von Peter

016:
       $(MEASURE) python ./016.py $(INPUT) > ./output/016.txt 2> ./error/016.txt

016-verify:
       $(DIFF) ./output/016.txt $(VERIFY)

016-clean:
       $(RM) ./output/016.txt


# Programm 017 -- noch nicht angepasst (bitte entfernen) angepasst von:

017:
       $(MEASURE) ./017.tcl -t $(INPUT) > ./output/017.txt 2> ./error/017.txt

017-verify:
       $(DIFF) ./output/017.txt $(VERIFY)

017-clean:
       $(RM) ./output/017.txt


# Programm 018 -- noch nicht angepasst (bitte entfernen) angepasst von:

018:
       cd ./tmp; unzip -o -q ../018.java-eclipse.zip
       cd ./tmp/BibOrder/dist; $(MEASURE) java -jar BibOrder.jar $(INPUT) > ../../../output/018.txt 2> ../../../error/018.txt

018-verify:
       $(DIFF) ./output/018.txt $(VERIFY)

018-clean:
       $(RM) ./output/018.txt


# Programm 020 -- Java angepasst von: Nils

020:
       cp ./020.java ./tmp/textnumbers.java
       cd ./tmp; javac textnumbers.java
       cd ./tmp; $(MEASURE) java textnumbers $(INPUT) > ../output/020-stdout.txt 2> ../error/020.txt && mv *.neu.txt ./output/020.txt
       $(COMPRESS)

020-verify:
       $(DIFF) ./output/020.txt $(VERIFY)

020-clean:
       $(RM) ./output/020.txt


# Programm 021 -- noch nicht angepasst (bitte entfernen) angepasst von: Nils
# geht aber noch nicht, weil das Tool fest "footnotes.txt" einliest.
# das Programm enthält außer der fehlenden Angabe der Codierung auch noch einen Syntaxfehler in Zeile 44, Peter gedenkt es aus der Wertung rauszuschmeißen!

021:
       $(MEASURE) python ./021.py < $(INPUT) > ./output/021.txt 2> ./error/021.txt

021-verify:
       $(DIFF) ./output/021.txt $(VERIFY)

021-clean:
       $(RM) ./output/021.txt


# Programm 022 -- angepasst von: Nils

022:
       $(MEASURE) ./022.py < $(INPUT) > ./output/022.txt 2> ./error/022.txt

022-verify:
       $(DIFF) ./output/022.txt $(VERIFY)

022-clean:
       $(RM) ./output/022.txt


# Programm 023 -- angepasst von: Nils

023:
       $(MEASURE) ./023.awk < $(INPUT) > ./output/023.txt 2> ./error/023.txt

023-verify:
       $(DIFF) ./output/023.txt $(VERIFY)

023-clean:
       $(RM) ./output/023.txt


# Programm 024 -- noch nicht angepasst (bitte entfernen) angepasst von:

024:
       $(MEASURE) ./024.rb $(INPUT) > ./output/024.txt 2> ./error/024.txt
       $(COMPRESS)

024-verify:
       $(DIFF) ./output/024.txt $(VERIFY)

024-clean:
       $(RM) ./output/024.txt


# Programm 025 -- angepasst von: Peter

025:
       $(MEASURE) python ./025.py  $(INPUT) > ./output/025.txt 2> ./error/025.txt

025-verify:
       $(DIFF) ./output/025.txt $(VERIFY)

025-clean:
       $(RM) ./output/025.txt



# Programm 026 -- angepasst von: Nils

026:
       $(MEASURE) ./026.rb $(INPUT) > ./output/026.txt 2> ./error/026.txt

026-verify:
       $(DIFF) ./output/026.txt $(VERIFY)

026-clean:
       $(RM) ./output/026.txt


# Programm 027 -- angepasst von: Peter

027:
       $(MEASURE) ./027.awk < $(INPUT) > ./output/027.txt 2> ./error/027.txt
       $(COMPRESS)

027-verify:
       $(DIFF) ./output/027.txt $(VERIFY)

027-clean:
       $(RM) ./output/027.txt


# Programm 028 -- angepasst von: Peter

028:
       $(MEASURE) ./028.sh < $(INPUT) > ./output/028.txt 2> ./error/028.txt

028-verify:
       $(DIFF) ./output/028.txt $(VERIFY)

028-clean:
       $(RM) ./output/028.txt


# Programm 029 -- noch nicht angepasst (bitte entfernen) angepasst von:

029:
       $(MEASURE) ./029.tcl $(INPUT) > ./output/029.txt 2> ./error/029.txt

029-verify:
       $(DIFF) ./output/029.txt $(VERIFY)

029-clean:
       $(RM) ./output/029.txt


# Programm 031 -- bricht bei mir mit 3 Compilation-Errors ab: Peter

031:
       $(MEASURE) ./031.pl < $(INPUT) > ./output/031.txt 2> ./error/031.txt

031-verify:
       $(DIFF) ./output/031.txt $(VERIFY)

031-clean:
       $(RM) ./output/031.txt


# Programm 032 -- angepasst von: Peter

032:
       $(MEASURE) python ./032.py $(INPUT) > ./output/032.txt 2> ./error/032.txt
       $(COMPRESS)

032-verify:
       $(DIFF) ./output/032.txt $(VERIFY)

032-clean:
       $(RM) ./output/032.txt


# Programm 033 -- angepasst von: Nils

033:
       $(MEASURE) ./033.pl $(INPUT) > ./output/033.txt 2> ./error/033.txt

033-verify:
       $(DIFF) ./output/033.txt $(VERIFY)

033-clean:
       $(RM) ./output/033.txt


# Programm 034 -- noch nicht angepasst (bitte entfernen) angepasst von:

034:
       $(MEASURE) ./034.pl < $(INPUT) > ./output/034.txt 2> ./error/034.txt

034-verify:
       $(DIFF) ./output/034.txt $(VERIFY)

034-clean:
       $(RM) ./output/034.txt


# Programm 035 -- angepasst von: Peter

035:
       $(MEASURE) ./035.pl $(INPUT) > ./output/035.txt 2> ./error/035.txt
       $(COMPRESS)

035-verify:
       $(DIFF) ./output/035.txt $(VERIFY)

035-clean:
       $(RM) ./output/035.txt


# Programm 036 -- angepasst von: Peter

036:
       $(MEASURE) ./036.x86 < $(INPUT) > ./output/036.txt 2> ./error/036.txt

036-verify:
       $(DIFF) ./output/036.txt $(VERIFY)

036-clean:
       $(RM) ./output/036.txt


# Programm 037 -- angepasst von: Nils

037:
       ghc -o 037.bin -Wall -O2 --make 037.hs
       $(MEASURE) ./037.bin $(INPUT) > ./output/037.txt 2> ./error/037.txt

037-verify:
       $(DIFF) ./output/037.txt $(VERIFY)

037-clean:
       $(RM) ./output/037.txt



# Programm 039 -- angepasst von: Peter

039:
       $(MEASURE) ./039.awk < $(INPUT) > ./output/039.txt 2> ./error/039.txt
       $(COMPRESS)

039-verify:
       $(DIFF) ./output/039.txt $(VERIFY)

039-clean:
       $(RM) ./output/039.txt


# Programm 040 -- noch nicht angepasst (bitte entfernen) angepasst von:

040:
       $(MEASURE) ./040.py $(INPUT) > ./output/040.txt 2> ./error/040.txt

040-verify:
       $(DIFF) ./output/040.txt $(VERIFY)

040-clean:
       $(RM) ./output/040.txt


# Programm 041 -- angepasst von: Peter

041:
       $(MEASURE) ./041.pl < $(INPUT) > ./output/041.txt 2> ./error/041.txt

041-verify:
       $(DIFF) ./output/041.txt $(VERIFY)

041-clean:
       $(RM) ./output/041.txt


# Programm 042 -- angepasst von: Peter und Nils

042:
       cp ./042.main.cs ./042.class.cs ./tmp
       cd ./tmp; gmcs ./042.main.cs ./042.class.cs; mv 042.main.exe ..
       $(MEASURE) mono ./042.main.exe $(INPUT) > ./output/042.txt 2> ./error/042.txt

042-verify:
       $(DIFF) ./output/042.txt $(VERIFY)

042-clean:
       $(RM) ./output/042.txt



# Programm 045 -- angepasst von: Peter

045:
       $(MEASURE) ./045.py < $(INPUT) > ./output/045.txt 2> ./error/045.txt

045-verify:
       $(DIFF) ./output/045.txt $(VERIFY)

045-clean:
       $(RM) ./output/045.txt


# Programm 046 -- angepasst von: Peter

046:
       $(MEASURE) ./046.py $(INPUT) > ./output/046.txt 2> ./error/046.txt
       $(COMPRESS)

046-verify:
       $(DIFF) ./output/046.txt $(VERIFY)

046-clean:
       $(RM) ./output/046.txt


# Programm 047 -- angepasst von: Peter

047:
       $(MEASURE) ./047.py  $(INPUT) > ./output/047.txt 2> ./error/047.txt

047-verify:
       $(DIFF) ./output/047.txt $(VERIFY)

047-clean:
       $(RM) ./output/047.txt


# Programm 051 -- Java angepasst von: Nils
# compiled nicht ...

051:
       cp ./051.java ./tmp/Indexer.java
       cd ./tmp; javac Indexer.java
       cd ./tmp; $(MEASURE) java Indexer ../$(INPUT) > ../output/051.txt 2> ../error/051.txt

051-verify:
       $(DIFF) ./output/051.txt $(VERIFY)

051-clean:
       $(RM) ./output/051.txt


# Programm 054 -- angepasst von: Peter

054:
       $(MEASURE) ./054.pl  $(INPUT)  ./output/054.txt ./output/054b.txt 2> ./error/054.txt

054-verify:
       $(DIFF) ./output/054.txt $(VERIFY)

054-clean:
       $(RM) ./output/054.txt


# Programm 055 -- angepasst von: Peter

055:
       $(MEASURE) python ./055.py  $(INPUT) > ./output/055.txt 2> ./error/055.txt
       $(COMPRESS)

055-verify:
       $(DIFF) ./output/055.txt $(VERIFY)

055-clean:
       $(RM) ./output/055.txt


# Programm 057 -- noch nicht angepasst (bitte entfernen) angepasst von:

057:
       $(MEASURE) ruby ./057.rb < $(INPUT) > ./output/057.txt 2> ./error/057.txt

057-verify:
       $(DIFF) ./output/057.txt $(VERIFY)

057-clean:
       $(RM) ./output/057.txt


# Programm 058 -- angepasst von: Nils

058:
       $(MEASURE) ./058.rb $(INPUT) > ./output/058.txt 2> ./error/058.txt

058-verify:
       $(DIFF) ./output/058.txt $(VERIFY)

058-clean:
       $(RM) ./output/058.txt


# Programm 059 -- angepasst von: Peter

059:
       $(MEASURE) ./059.pl $(INPUT) > ./output/059.txt 2> ./error/059.txt
       $(COMPRESS)

059-verify:
       $(DIFF) ./output/059.txt $(VERIFY)

059-clean:
       $(RM) ./output/059.txt


# Programm 060 -- angepasst von: Peter

060:
       $(MEASURE) ./060.pl $(INPUT) > ./output/060.txt 2> ./error/060.txt

060-verify:
       $(DIFF) ./output/060.txt $(VERIFY)

060-clean:
       $(RM) ./output/060.txt


# Programm 061 -- ngepasst von: Peter

061:
       $(MEASURE) ./061.pl $(INPUT) > ./output/061.txt 2> ./error/061.txt
       $(COMPRESS)

061-verify:
       $(DIFF) ./output/061.txt $(VERIFY)

061-clean:
       $(RM) ./output/061.txt


# Programm 062 -- angepasst von: Peter

062:
       $(MEASURE) ./062.pl $(INPUT) > ./output/062.txt 2> ./error/062.txt

062-verify:
       $(DIFF) ./output/062.txt $(VERIFY)

062-clean:
       $(RM) ./output/062.txt


# Programm 063 -- angepasst von: Nils

063:
       $(MEASURE) ./063.rb $(INPUT) > ./output/063.txt 2> ./error/063.txt
       $(COMPRESS)

063-verify:
       $(DIFF) ./output/063.txt $(VERIFY)

063-clean:
       $(RM) ./output/063.txt


# ------------------------------------------


# groovy:
005:


# Programm 008 -- angepasst von: Nils
008:
       $(CPP) -o 008.bin 008.cpp
       $(MEASURE) ./008.bin $(INPUT) > ./output/008.txt 2> ./error/008.txt
       $(COMPRESS)

008-verify:
       $(DIFF) ./output/008.txt $(VERIFY)

008-clean:
       $(RM) ./output/008.txt


# Programm 019 -- angepasst von: Nils
019:
       $(CPP) -O2 -lpcrecpp 019.cpp -o 019.bin
       $(MEASURE) ./019.bin $(INPUT) > ./output/019.txt 2> ./error/019.txt

019-verify:
       $(DIFF) ./output/019.txt $(VERIFY)

019-clean:
       $(RM) ./output/019.txt


# Programm 030 -- angepasst von: Nils
# Offenbar braucht man dazu boost-1.35
030:
       $(CPP) -lboost_filesystem -lboost_program_options -o 030.bin 030.cpp
       $(MEASURE) ./030.bin $(INPUT) > ./output/030.txt 2> ./error/030.txt
       $(COMPRESS)

030-verify:
       $(DIFF) ./output/030.txt $(VERIFY)

030-clean:
       $(RM) ./output/030.txt


# Programm 038 -- angepasst von: Nils
038:
       $(CPP) -o 038.bin 038.cpp -lboost_regex
       $(MEASURE) ./038.bin $(INPUT) > ./output/038.txt 2> ./error/038.txt

038-verify:
       $(DIFF) ./output/038.txt $(VERIFY)

038-clean:
       $(RM) ./output/038.txt


# Programm 043 -- angepasst von: Nils
043:
       flex -o 043.cpp 043.f
       $(CPP) -o 043.bin 043.cpp -lstdc++ -lfl
       $(MEASURE) ./043.bin $(INPUT) > ./output/043.txt 2> ./error/043.txt
       $(COMPRESS)

043-verify:
       $(DIFF) ./output/043.txt $(VERIFY)

043-clean:
       $(RM) ./output/043.txt


# Programm 044 -- angepasst von: Nils
044:
       flex 044.ll && mv ./footnotes.cpp 044.cpp
       $(CPP) -O2 -pipe -o 044.bin 044.cpp
       $(MEASURE) ./044.bin < $(INPUT) > ./output/044.txt 2> ./error/044.txt
       $(COMPRESS)

044-verify:
       $(DIFF) ./output/044.txt $(VERIFY)

044-clean:
       $(RM) ./output/044.txt


# Programm 048 -- angepasst von: Nils
048:
       $(CPP) -o 048.bin 048.cpp
       $(MEASURE) ./048.bin $(INPUT) > ./output/048.txt 2> ./error/048.txt

048-verify:
       $(DIFF) ./output/048.txt $(VERIFY)

048-clean:
       $(RM) ./output/048.txt


# Programm 050 -- angepasst von: Nils
050:
       ocamlopt -o ./050.bin str.cmxa 050.ml
       $(MEASURE) ./050.bin $(INPUT) > ./output/050.txt 2> ./error/050.txt
       $(COMPRESS)

050-verify:
       $(DIFF) ./output/050.txt $(VERIFY)

050-clean:
       $(RM) ./output/050.txt


# Programm 052 -- angepasst von: Nils
052:
       $(CPP) -Wall -O2 -o 052.bin 052.cpp -lboost_regex-mt
       $(MEASURE) ./052.bin $(INPUT) > ./output/052.txt 2> ./error/052.txt

052-verify:
       $(DIFF) ./output/052.txt $(VERIFY)

052-clean:
       $(RM) ./output/052.txt


# Programm 053 -- angepasst von: Nils
053:
       $(CPP) -o 053.bin 053.cpp
       $(MEASURE) ./053.bin -f $(INPUT) > ./output/053.txt 2> ./error/053.txt
       $(COMPRESS)

053-verify:
       $(DIFF) ./output/053.txt $(VERIFY)

053-clean:
       $(RM) ./output/053.txt

You are viewing proxied material from gopher.rbfh.de. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.