'E's fighting in there!' he stuttered, grabbing the captain's arm.
'All by himself?' said the captain.
'No, with everyone!' shouted Nobby, hopping from one foot to the other.
Hm, true. Maar ik wilde op deze manier ervoor zorgen dat er aan het eind iedereen wel zo'n beetje aan z,n trekken komt en dat wanneer deze topic ten einde is dat ik aan TS een nette lijst kan maken voor de overzichtelijkheid.NMe schreef op vrijdag 16 oktober 2009 @ 16:05:
[...]
Als je zo gek bent om dat actief bij te houden: be my guest.Het lijkt mij echter praktischer om gewoon wat zelfregulering in te brengen en andere mensen ook pro-actief mee te laten helpen.
En ja, ik ben gek.

[ Voor 5% gewijzigd door Verwijderd op 16-10-2009 16:31 ]
Mijn oplossing is best wel een stuk langer dan de oplossingen voor de vorige contest, ben ik zo'n brakke coder of is deze opdracht zoveel ingewikkelder?Doolhof generator
Schrijf een algoritme die een willekeurige doolhof kan maken met de volgende voorwaarden:
- Er mag maar één manier zijn waarop de doolhof is op te lossen. Alle overige weggetjes lopen dood of in een cirkel Ik heb dit uitgelegd als 1 van beide mogelijkheden, maar niet zowel doodlopend als een cirkel in een overige weg.
- De uitgang en de ingang van het doolhof is altijd op dezelfde plek.Ik heb 1 dezelfde plek als ingang en 1 dezelfde plek als uitgang, niet beide op dezelfde plaats omdat het anders zou conflicteren met de eerste regel (linksom en rechtsom)
- Interface is niet van belang, maar denk wel na over de output data.
Alle overige details vallen onder de artistieke vrijheid van de ontwikkelaar..
http://pastebin.com/f57b01953
Voorbeeld uitvoer:

Als er fouten in zitten is dat de schuld van het tijdstip

En pastebin heeft al mijn mooie unicode characters vernield
Het klopt dat de opdracht moeilijker is._js_ schreef op zaterdag 17 oktober 2009 @ 04:12:
Mijn oplossing is best wel een stuk langer dan de oplossingen voor de vorige contest, ben ik zo'n brakke coder of is deze opdracht zoveel ingewikkelder?
Woutert! Mooi dat juist jij er dan ook even een berichtje post!flashin schreef op vrijdag 16 oktober 2009 @ 10:45:
Wat een vet nerd-topic. Ik moet helaas wel werken, maar ik zie een aantal hele leuke oplossingen voor opdracht 1 en 2
Heb jij het niet veel te druk!
Het begon bij mij ook al te kriebelen maar het is nog wat vroeg en moet zo werken..
Misschien van de week eens opdracht 1 uitzoeken
*sowieso
Message decoder
Beschrijving: Het is de bedoeling met deze opdracht om een programma te ontwikkelen die vanuit een textbestand binair cijfers inleest, het omzet naar gewone letters om dan de text op het scherm weer te geven. Bijkomende verplichting is wel dat het niet mag uit maken hoe groot de textbestand is.Voorbeeld:
Hello world in binair: 0100100001100101011011000110110001101111001000000111011101101111011100100110110001100100
voorbeeld gebruik
1
| binair2txt message.txt |
output
1
| Hello world |
Info:
binair chart
Deel twee van de opdracht
Uiteraart wil je ook boodschappen opslaan in binair en een textbestand.Bouw het vorige programma dan ook zo om dat je kan kiezen tussen deze twee standen.
En maak het programma zo dat het niet uitmaakt wat de input en ouput is.
Voorbeeld gebruik
1
| binair2txt 0100100001100101011011000110110001101111001000000111011101101111011100100110110001100100 |
output
1
| Hello world |
Moeilijkheidsgraad: beginner/intermediate
Misschien ook even in de SP zetten Typnix?
'You like a gay cowboy and you look like a gay terrorist.' - James May
Een mogelijk resultaat:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| ###################################################################### # # # # ## ## # ######## # # # # ##### # # # # # # ### ## ## ##### ###### ### # # # ### # ## # ## # ## # ## ### ###### #### ########## #### # ##### # # # # # ## # # ### ####### ## ##### ### ### ## ## #### # ## ## ## ## ## # ### ### ## ## ##### #### # # ### ## # ## ### # # # # ## # ## # ## # ## ##### # ### # #### # # ## #### # ### #### ###### # # ## ## # # # ###### # # # # # # # # # # # ## ### # ## # ## # # # ###### # # # ### # ## ### # ## ### # # # # ## # ##### ## # ### ######### ## # ## # ## # # ### # # # ## # ## ### # # ######### # # # ### ### # # # # # # ### ## # ##### # ## ######## ######## #### ## # # ## # # ## ## # # # ## ## # # #### # # ## ##### # ### # # ## # # # # # ## # ## # # # ## ## # ### #### # ## ## # #### # # # ## # # ## # ### # # #### ### ## ## # ### # #### ### ### ##### # # ## # ## ### # # # # ## ## # #### # ## # ### ## ##### # # # #### # # ###### # # # # ###### # # ## ## # # ## ### # # # #### # ####### ### ###### # ### ###### ## ####### # # ### ## ## # # ####### # # # ### # ##### # # #### ### ### # ## ### # #### ### ### ## ## # ## # ### # ##### # ## # ## ### # ### #### ######## ## # # ####### # # ## ##### ### # # ## # # ## # # ## ###### ## # ######## # # # ## ##### ## # ## # # ## # ## # # ## ### # ############## # # ## ## # ## # # # # ## ## # ## # # # ## ################## # #### ## ## # # ## # ## # #### # # ## #### #################### ## # ## ## ### # #### # ### #### ## # ### #################### # # ## # ## ### ### ###### # # # # ######## ###################### # ## # # # ## ###### ## # # # # # ###################### ## # ### # ######## #### # ### ############################# # #### ####################################################################### Seed: -6507824028902311271 |
¸.·´¯`·.¸.·´¯`·.¸><(((º>¸.·´¯`·.¸><(((º>¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸<º)))><¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸
RechtsonderVerwijderd schreef op zaterdag 17 oktober 2009 @ 13:09:
Wil niet vervelend doen maar waar is de uitgang?
Okay, maar waar is dan de ingang, Is dat linksboven?
Ik zal blij zijn als ik klaar ben met leren want ik heb op dit moment niet eens de tijd om opdrachten te maken.
[ Voor 27% gewijzigd door Verwijderd op 17-10-2009 13:33 ]
Ja.Verwijderd schreef op zaterdag 17 oktober 2009 @ 13:23:
[...]
Okay, maar waar is dan de ingang, Is dat linksboven?
¸.·´¯`·.¸.·´¯`·.¸><(((º>¸.·´¯`·.¸><(((º>¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸<º)))><¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸
Decoden in Python:Verwijderd schreef op zaterdag 17 oktober 2009 @ 08:52:
Om de beginners van een nieuwe opdracht te voorzienMessage decoder
Beschrijving: Het is de bedoeling met deze opdracht om een programma te ontwikkelen die vanuit een textbestand binair cijfers inleest, het omzet naar gewone letters om dan de text op het scherm weer te geven. Bijkomende verplichting is wel dat het niet mag uit maken hoe groot de textbestand is.
Voorbeeld:
Hello world in binair: 0100100001100101011011000110110001101111001000000111011101101111011100100110110001100100
1
2
3
| s = '0100100001100101011011000110110001101111001000000111011101101111011100100110110001100100' splitted = map(lambda i: s[i:i+8], range(0, len(s), 8)) print ''.join(map(lambda b: chr(int(b, 2)), splitted)) |
Lambda's, map en filter zijn heerlijk om dit soort code compact te schrijven

Begin linksboven, einde rechtsonder
Nu met image generatie (Genereert naar C:\maze.png):
Code
¸.·´¯`·.¸.·´¯`·.¸><(((º>¸.·´¯`·.¸><(((º>¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸<º)))><¸.·´¯`·.¸.·´¯`·.¸.·´¯`·.¸
Dat laat ik me niet twee keer zeggen.HawVer schreef op vrijdag 16 oktober 2009 @ 09:00:Opdracht drie
Schrijf een algoritme die een willekeurige doolhof kan maken met de volgende voorwaarden:
- Er mag maar één manier zijn waarop de doolhof is op te lossen. Alle overige weggetjes lopen dood of in een cirkel
- De uitgang en de ingang van het doolhof is altijd op dezelfde plek.
- Interface is niet van belang, maar denk wel na over de output data.
Alle overige details vallen onder de artistieke vrijheid van de ontwikkelaar..
Broncode: maze.txt
Download: maze.ps
Voorbeelduitvoer: maze.pdf
Stuur 'm naar je PostScript Level 2 compatible printer voor een willekeurig gegenereerd doolhof (op basis van de systeemtijd), of open 'm met GhostScript. Het resultaat ziet er bijvoorbeeld zo uit:

Geen map nodigJanDM schreef op zaterdag 17 oktober 2009 @ 13:48:
Lambda's, map en filter zijn heerlijk om dit soort code compact te schrijven
1
| print chr(ord(pack("B8",$_))) for shift =~ m/.{8}/g; |
chr(ord()) is toch ook onnodig? gewoon alleen pack()veldsla schreef op zaterdag 17 oktober 2009 @ 15:19:
Geen map nodig. De command line variant:
Perl:
1 print chr(ord(pack("B8",$_))) for shift =~ m/.{8}/g;
Een wappie is iemand die gevallen is voor de (jarenlange) Russische desinformatiecampagnes.
Wantrouwen en confirmation bias doen de rest.
Dat is Perl, de mijne Python
Wow, gave oplossingSoultaker schreef op zaterdag 17 oktober 2009 @ 14:41:
Dat laat ik me niet twee keer zeggen.Mijn oplossing is geschreven in PostScript en genereert doolhoven op een hexagonaal grid (want rechthoekige grids zijn zo normaal). Paginagrootte en radius van het doolhof zijn instelbaar; optioneel kunnen de openingen ook at random gekozen worden (wat niet de opdracht was).
[ Voor 51% gewijzigd door user109731 op 17-10-2009 16:33 ]
Soultaker schreef op zaterdag 17 oktober 2009 @ 14:41:
[...]
Dat laat ik me niet twee keer zeggen.Mijn oplossing is geschreven in PostScript en genereert doolhoven op een hexagonaal grid (want rechthoekige grids zijn zo normaal). Paginagrootte en radius van het doolhof zijn instelbaar; optioneel kunnen de openingen ook at random gekozen worden (wat niet de opdracht was).
Broncode: maze.txt
Download: maze.ps
Voorbeelduitvoer: maze.pdf
Stuur 'm naar je PostScript Level 2 compatible printer voor een willekeurig gegenereerd doolhof (op basis van de systeemtijd), of open 'm met GhostScript. Het resultaat ziet er bijvoorbeeld zo uit:
[afbeelding]
Ik was zelf bezig met opdracht 1 in Excel maar daar ben ik maar mee gestopt want ik vond het te idioot
Nu met Land Rover Series 3 en Defender 90
Laten we eerst opdracht 3 afmaken, voordat je een nieuwe post.Verwijderd schreef op zaterdag 17 oktober 2009 @ 08:52:
Om de beginners van een nieuwe opdracht te voorzienMessage decoder
[ Voor 69% gewijzigd door TJHeuvel op 17-10-2009 17:14 ]
Tuurlijk...Ik ben hartstikke gek...chr ordJuup schreef op zaterdag 17 oktober 2009 @ 15:41:
[...]
chr(ord()) is toch ook onnodig? gewoon alleen pack()

Labyrint opdracht is te moeilijk voor een beginner. En dit topic is er om alle niveau's te proberen te bedienen.CyCloneNL schreef op zaterdag 17 oktober 2009 @ 17:11:
[...]
Laten we eerst opdracht 3 afmaken, voordat je een nieuwe post.
En ik zal de volgende keer, 2 of 3 opdrachten hier loslaten die zo'n alle niveau's zou kunnen doen.
Maar dat hangt ook een beetje af van jullie zelf hoe dat gaat.
[ Voor 21% gewijzigd door Verwijderd op 17-10-2009 17:24 ]
Verwijderd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| $start = ($_GET['start'] == '' ? ord('A') : ord($_GET['start'])); $end = ($_GET['end'] == '' ? ord('Z') : ord($_GET['end'])); $diff = $end - $start; for ($i = -$diff; $i <= $diff; $i++) { echo str_repeat(' ', $diff-($diff - abs($i))); echo chr($end - abs($i)); echo str_repeat(' ', ($diff - abs($i))*2-1); if ($end - abs($i) != $start) { echo chr($end - abs($i)); } echo PHP_EOL; } |
Geeft het volgende resultaat:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| A B B C C D D E E F F G G H H I I J J K K L L M M N N O O P P Q Q R R S S T T U U V V W W X X Y Y Z Z Y Y X X W W V V U U T T S S R R Q Q P P O O N N M M L L K K J J I I H H G G F F E E D D C C B B A |
Het had misschien wel op 2 regels gepast, maar vind het zo overzichtelijker.
[ Voor 58% gewijzigd door Verwijderd op 17-10-2009 19:52 ]
Waarom hou je de reikwijdte maar van A t/m G ipv A t/m Z? En je hebt de opdracht bijna goed, je mist nog een kleine detail.Verwijderd schreef op zaterdag 17 oktober 2009 @ 17:32:
Mijn oplossing voor het eerste deel van de eerste opdracht:
PHP:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 $start = ord('A'); $end = ord('G'); $diff = $end - $start; for ($i = -$diff; $i <= $diff; $i++) { echo str_repeat(' ', $diff-($diff - abs($i))); echo chr($end - abs($i)); echo str_repeat(' ', ($diff - abs($i))*2-1); if ($end - abs($i) != $start) { echo chr($end - abs($i)); } echo PHP_EOL; }
[ Voor 5% gewijzigd door Verwijderd op 17-10-2009 17:36 ]
Verwijderd
Aangepast. Nu neemt m'n post 5x zoveel ruimte in, vandaar dat ik hem tot de G liet gaan.Verwijderd schreef op zaterdag 17 oktober 2009 @ 17:35:
[...]
Waarom hou je de reikwijdte maar van A t/m G ipv A t/m Z? En je hebt de opdracht bijna goed, je mist nog een kleine detail.
Verwijderd
Mooi.Soultaker schreef op zaterdag 17 oktober 2009 @ 17:44:
Ik had je wel geloofd als je had gezegd dat 'ie ook tot Z werkt hoor.
Het tweede deel is bijna af.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| $start = ($_GET['start'] == '' ? ord('A') : ord($_GET['start'])); $end = ($_GET['end'] == '' ? ord('Z') : ord($_GET['end'])); $diff = $end - $start; $turn = (!is_numeric($_GET['turn']) ? 2 : ($_GET['turn'] % ($diff * 2))); for ($i = -$diff; $i <= $diff; $i++) { $offset[0] = $i + $turn; $offset[1] = $i - $turn; if ($i < 0) { $offset[0] += abs($diff); $offset[1] += abs($diff); } else { $offset[0] = $diff - abs($offset[0]); $offset[1] = $diff - abs($offset[1]); } if ($offset[0] < 0) { $offset[0] = abs($offset[0]); } if ($offset[0] > $diff) { $offset[0] = $diff - ($offset[0] % $diff); } if ($offset[1] < 0) { $offset[1] = abs($offset[1]); } if ($offset[1] > $diff) { $offset[1] = $diff - ($offset[1] % $diff); } echo str_repeat(' ', $diff-($diff - abs($i))); echo chr($start + $offset[0]); if ($i > -$diff && $i < $diff) { echo str_repeat(' ', ($diff - abs($i))*2-1); } if ($end - abs($i) != $start) { echo chr($start + $offset[1]); } echo PHP_EOL; } |
Resultaat:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| C D B E A F B G C H D I E J F K G L H M I N J O K P L Q M R N S O T P U Q V R W S X T Y U Z V Y W X X W Y V Z U Y T X S W R V Q U P T O S N R M Q L P K O J N I M H L G K F J E I D H C G B F A E B D C |
Werkt beide kanten op (positieve / negatieve "$turn").

Volgens mij is het wel met een HUGE omweg
Heb hem ook even online gezet, met wat $_GET variabelen erbij.
Hier: http://acc6635422.e3-srv9...php?start=A&end=Z&turn=10
[ Voor 89% gewijzigd door Verwijderd op 18-10-2009 01:01 ]
Je mist nog de kleine detail: er moet input komen van of een gebruiker of dat je dat zelf doet.Verwijderd schreef op zaterdag 17 oktober 2009 @ 17:39:
[...]
Aangepast. Nu neemt m'n post 5x zoveel ruimte in, vandaar dat ik hem tot de G liet gaan.
Voor de rest: goed gedaan
Verwijderd
Mis ik heull nie!Verwijderd schreef op zaterdag 17 oktober 2009 @ 19:16:
[...]
Je mist nog de kleine detail: er moet input komen van of een gebruiker of dat je dat zelf doet.
Voor de rest: goed gedaan
Oké, het is aangepast...
ik krijg d'r ook allemaal leestekens inVerwijderd schreef op zaterdag 17 oktober 2009 @ 19:53:
[...]
Mis ik heull nie!![]()
Oké, het is aangepast...
http://acc6635422.e3-srv9...php?start=A&end=b&turn=10
even naar uppercase omzetten denk ik :#
[ Voor 25% gewijzigd door Verwijderd op 17-10-2009 20:49 ]
Verwijderd
Nja, moet je beide als hoofdletter gebruiken, nu zitten er leestekens tussen de ASCII codes van de A en de b.Kaasplank schreef op zaterdag 17 oktober 2009 @ 20:11:
[...]
ik krijg d'r ook allemaal leestekens in
http://acc6635422.e3-srv9...php?start=A&end=b&turn=10
even naar uppercase omzetten denk ik :#
Jep, zie de variabele "turn".Verwijderd schreef op zaterdag 17 oktober 2009 @ 20:27:
Ik vind het wel creatief.![]()
Maar draait het ook?

Edit: http://acc6635422.e3-srv9...t=A&end=Z&turn=16&timer=1
Ah, soms faalt ie nog...
Fixed, line 24 en 33 "elseif" veranderd in "if"..

Bleh, gaat toch nog niet helemaal goed...

[ Voor 37% gewijzigd door Verwijderd op 18-10-2009 09:51 ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
| #include <iostream> #include <fstream> #include <sstream> #include <bitset> class binstring { friend std::istream& operator>>(std::istream& in, binstring& str); friend std::ostream& operator<<(std::ostream& in, const binstring& str); public: binstring() : m_str() { } binstring(const std::string& str) : m_str(str) { } const std::string& get() const { return m_str; } private: std::string m_str; }; std::istream& operator>>(std::istream& in, binstring& str) { std::ostringstream oss; do { std::bitset<8> bits; in >> bits; oss << static_cast<char>(bits.to_ulong()); } while (!in.eof()); str.m_str = oss.str(); return in; } std::ostream& operator<<(std::ostream& os, const binstring& str) { for (std::string::const_iterator it = str.m_str.begin(), end = str.m_str.end(); it != end; ++it) { std::bitset<8> bits(*it); os << bits; } return os; } int main(int argc, char** argv) { if (argc != 2) { std::cerr << "Wat moet ik hiermee? Gebruik me zo: " << argv[0] << " <bestandsnaam>" << std::endl; return -1; } std::string name(argv[0]); std::string file(argv[1]); if (name.find("bin2txt.exe") != std::string::npos) { std::ifstream in(file.c_str()); binstring binstr; if (!in.is_open()) { std::cerr << "Bestand " << file << " bestaat volgens mij niet." << std::endl; return -1; } in >> binstr; std::cout << binstr.get() << std::endl; } else if (name.find("txt2bin.exe") != std::string::npos) { std::string str; std::ofstream out(file.c_str()); std::getline(std::cin, str); out << binstring(str); } else { std::cerr << "Identiteitscrisis! Ik zou graag 'bin2txt' of 'txt2bin' heten zodat ik weet wat te doen!" << std::endl; return -1; } return 0; } |
Compileren op Win32 natuurlijk
ASSUME makes an ASS out of U and ME
Omdat ik dat over het algemeen een bad practice vind.Verwijderd schreef op zaterdag 17 oktober 2009 @ 21:21:
Waarom je gebruik je niet:
C++:
1 using namespace std;
Scheelde je weer wat typwerk
ASSUME makes an ASS out of U and ME
Hoezo dat?H!GHGuY schreef op zondag 18 oktober 2009 @ 08:50:
[...]
Omdat ik dat over het algemeen een bad practice vind.
Dat is alsof je de namespace System.* voor namespace van je C#/VB.NET programma gebruikt.
[Te koop: 3D printers] [Website] Agile tools: [Return: retrospectives] [Pokertime: planning poker]
[ Voor 34% gewijzigd door Zoijar op 18-10-2009 13:10 ]
Natuurlijk is het in dit geval niet echt een issue, omdat ik niet denk dat mensen hun code voor deze opdrachtjes verwachten te hergebruiken
-niks-
Verwijderd
Ik had zin om weer te prologgen, dus bij deze.
Ongetwijfeld kan er met prolog een betere geschreven worden
Sorry voor de slechte leesbaarheid, als ik voor mezelf programmeer hou ik het graag kort.
Maar het spreekt eigenlijk wel voor zich.
Starten gaat met "a.", of als je een eigen alfabet mee wilt geven: "a(['@','b','1'])."
Met het normale alfabet geeft dit de bekende output, dus die heb ik hier niet ingeplakt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
| :- dynamic l/2. %% main predikaat %% a :- a([],0,B),c(B,0,[],[D|E]), reverse(E,F), append(F,[D|E],A), writeToFile(A). a(B) :- as(B),c(B,0,[],[D|E]), reverse(E,F), append(F,[D|E],A), writeToFile(A). as([H|_]) :- assert(l([H], 0)). a(A,26,A). a(A,B,E) :- b(A,B,D), C is B+1, a(D,C,E). %% letters uit standaard alfabet pakken %% b(_,0,D) :- l(D,0). b(A,B,C) :- l(D,B), append(A, D, C). %% main functie voor padding met spaties %% c([],_,A,A). c([A|B],C,D,E) :- d(A,F,C), g(F,H,C), G is C+1, c(B,G,[H|D],E). %% interne padding %% d(A,B,C) :- e([A],D,C), append([A],D,B). e([A],[],_):- l([A], 0). e(A,B,C) :- f(C,[],D), append(D,A,B). f(A,B,B) :- A < 1. f(A,B,C) :- A == 1, append([' '],B,E), D is A-1, f(D,E,C). f(A,B,C) :- A > 1, append([' ',' '],B,E), D is A-1, f(D,E,C). %% externe padding %% g(A,B,C) :- D is 26-C, j(D,[],F), append(F,A,B). j(A,B,B) :- A < 1. j(A,B,C) :- A > 0, append([' '],B,E), D is A-1, j(D,E,C). %% output functies %% writeToFile(A) :- open('results.txt',write,B), writeToFileHelper(A, B), close(B). writeToFileHelper([],_). writeToFileHelper([A|B],C) :- writeToFileHelper2(A,C), nl(C), writeToFileHelper(B,C). writeToFileHelper2([],_). writeToFileHelper2([A|B],C) :- write(C,A), writeToFileHelper2(B,C). %% data voor gebruik standaard alfabet %% l([a], 0). l([b], 1). l([c], 2). l([d], 3). l([e], 4). l([f], 5). l([g], 6). l([h], 7). l([i], 8). l([j],9). l([k],10). l([l],11). l([m],12). l([n],13). l([o],14). l([p],15). l([q],16). l([r],17). l([s],18). l([t],19). l([u],20). l([v],21). l([w],22). l([x],23). l([y],24). l([z],25). |
edit:
Mijn poging in Prolog: (inclusief lezen van invoer)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| :- initialization(main). main :- atom_chars('ABCDEFGHIJKLMNOPQRSTUVWXYZ', A), get_char(C), take_upto(A, C, L), diamond(L). diamond(L) :- mirror(L, A), reverse(L, R), mirror(R, B), diamond(A, B). diamond(_, []). diamond(L, [C|Cs]) :- writeln(C, L), diamond(L, Cs). take_upto([C|_], C, [C]). take_upto([X|Xs], C, [X|Ys]) :- take_upto(Xs, C, Ys). mirror([H|T], U) :- reverse([H|T], S), append(S, T, U). writeln(_, []) :- nl. writeln(C, [D|Xs]) :- (C=D, E=C; E=' '), put_char(E), writeln(C, Xs). |
Waarom hebben we trouwens geen syntax highlight voor Prolog?
[ Voor 105% gewijzigd door Soultaker op 18-10-2009 23:50 . Reden: weg met lower_upper ]
Onvoorstelbaar!
1
2
| A simple program that echoes a line, character by character: ,[.[-],] |
En van de drie verschillende talen waarin ik code heb gepost in dit topic was er niet één supported door de syntax highlighter.
Waarom test je niet gewoon op bin2text (als substring) ipv bin2text.exe ?H!GHGuY schreef op zaterdag 17 oktober 2009 @ 21:18:
Compileren op Win32 natuurlijk(of je linux binaries .exe noemen)
Verwijderd
Nee hoorSoultaker schreef op zondag 18 oktober 2009 @ 18:32:
@KarpetKing: je hebt ook last van de bug dat je a op de eerste en laatste regel dubbel print.
Regel 21 verhindert dat:
e([A],[],_):- l([A], 0).
Helaas crasht jouw implementatie mijn swipl, na een error over dat main/2 undefined is.
Wat me verwart.
Kga zelf ook maar eens nadenken over opdracht 3.
De eerste oplossing zal waarschijnlijk een "it ain't pretty but it works" oplossing zijn
Ah, ik begrijp de verwarring: je programma produceert vier antwoorden, waaronder twee keer de goede en twee keer de verkeerde. Als ik het programma stop na het eerste antwoord staat het goede antwoord in het bestand, maar als ik alle antwoorden laat printen wordt dat bestand nog drie keer overschreven en eindigt de verkeerde uitvoer in 't bestand (dat is dus wat ik deed).Verwijderd schreef op zondag 18 oktober 2009 @ 22:47:
Nee hoor
Regel 21 verhindert dat:
e([A],[],_):- l([A], 0).
Het probleem zit 'm precies in regel 21 die je al aanhaalt. Die regel voegt de mogelijkheid toe om een lijst met één enkele a te produceren, maar voorkomt niet dat er gebacktrackt wordt waardoor alsnog het foute antwoord gegenereerd wordt. Om dat op te lossen kun je een cut toevoegen:
21
| e([A],[],_):- l([A], 0), !. |
Overigens genereert je programma dan nog meerdere matches, en dat komt doordat je op regel 12 een overbodige clausule hebt staan (overblijfsel van debugging?). Die kun je dus ook weggooien.
Hmz, ik test met GNU Prolog, en ik gebruik lower_upper, wat geen standaardfunctie lijkt te zijn (dat geldt op zich ook voor append en reverse, maar die kent SWI Prolog wél). Ik heb de code in mijn post aangepast. Die verwacht nu dus wel een hoofdletter als invoer anders faalt 'ie alsnog.Helaas crasht jouw implementatie mijn swipl, na een error over dat main/2 undefined is.
Wat me verwart.
1
| print "".join(map(lambda x: '0' + bin(ord(x))[2:], input())) |
De string moet je wel tussen single quotes invoeren anders herkent de python interpreter het niet als een string.
Onvoorstelbaar!
Ik ben in iedergeval van plan om een nieuwe reeks opdrachten op die dag te posten.
Verwijderd
Bedankt voor de verbeteringen. Ik had moeten kijken naar meerdere oplossingen. Regel 12 was inderdaad een overblijfsel
Ik ben niet bekent met initialization, maar dat statement lijkt een probleem te zijn voor SWI Prolog. Zonder dat werkt de nieuwe code uitstekend.
De code is mooi trouwens, veel mooiere Prolog dan de mijne
Om dat je met using statements heel makkelijk last krijgt van namespace bleeding in C++.Verwijderd schreef op zondag 18 oktober 2009 @ 13:27:
Ja,maar als je weet dat je broncode alleen maar standaard zal gebruiken zonder het gebruik van een andere namespace dan hoeft het toch niet gezien te worden als een bad practice?
ex-FE Programmer: CMR:DiRT2,DiRT 3, DiRT Showdown, GRID 2, Mad Max
Compileer maar eens naar: c:\bin2txt\txt2bin.exehostname schreef op zondag 18 oktober 2009 @ 22:24:
[...]
Waarom test je niet gewoon op bin2text (als substring) ipv bin2text.exe ?
en dan zie je meteen waarom
ASSUME makes an ASS out of U and ME
Solitaire oplosser
Solitaire is een bordspel in de vorm van een kruis. Het heeft 32 velden en 31 van deze velden staan stenen.Een enkele veld is leeg.
Regels
Regels zijn makkelijk:De bedoeling is dat je met 1 steen over een andere steen springt om deze uit het spel te halen.
Je hebt het spel opgelost als er 1 steen overblijft. De stenen mogen horizontaal en verticaal bewogen worden. Maar er mag niet schuin over gesprongen worden.
En per beurt mag er maar 1x gesprongen worden van lege plek naar lege plek.
Uitgebreide uitleg Solitaire
Uiteraard is het begin makkelijk maar dit zal moeilijker worden zodra er meer stenen eruit zijn. En het aantal mogelijkheden meer worden.
Opdracht 1: Maak een engine om dit spel op te lossen door de computer.
En zorg ervoor dat de stappen ook na te trekken zijn.
Moeilijkheidsgraad: medior tot gevorderd.
[ Voor 15% gewijzigd door Verwijderd op 19-10-2009 23:22 ]
Aan de doolhof opdracht had ik, bij wijze van, ook kunnen voldoen met het volgende:
I=Ingang, U=Uitgang
1
2
3
4
5
6
7
| print "######" print "I # U" if rnd mod 2 = 0 then print "# ##" else print "# #" print "######" |
En dan sloof ik me nog uit
Voor je solitaire opdracht, zoals jij 'm omschreven hebt, zou ik dus al voldoen met:
1
| ###############################. |
Voila. 32 velden, 1 leeg. En spring maar raak
Een goede contest begint met een duidelijk afgebakende opdracht; anders ben je appels met peren aan 't vergelijken.
[ Voor 35% gewijzigd door RobIII op 19-10-2009 22:44 ]
There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.
Je eigen tweaker.me redirect
Over mij
Gecorrigeert. En ik kan niet altijd even sterke opdrachten verzinnen/verkrijgen. Dus dat gaat wat moeizaam.RobIII schreef op maandag 19 oktober 2009 @ 22:34:
Nu zijn de regels van solitaire "alom bekend" maar ik vind de opdracht(en) wel telkens nogal te wensen over laten; er staat nu (bijv.) nergens dat je niet schuin mag "springen" en altijd maar 1 "plek" mag (over)springen. De regels zoals je ze nu hier uit legt laten dus (te) veel aan de verbeelding over en hebben het risico verkeerd geïnterpreteerd te worden.
Het is pseudocode, en dat telt dus nietAan de doolhof opdracht had ik, bij wijze van, ook kunnen voldoen met het volgende:
I=Ingang, U=Uitgang
code:
1 2 3 4 5 6 7 print "######" print "I # U" if rnd mod 2 = 0 then print "# ##" else print "# #" print "######"
En dan sloof ik me nog uit
Zal er voortaan op letten.Een goede contest begint met een duidelijk afgebakende opdracht; anders ben je appels met peren aan 't vergelijken.
[ Voor 4% gewijzigd door Verwijderd op 19-10-2009 22:54 ]
Ik mis nog steeds dat je maar "1 plek" mag springen (bijvoorbeeld) of dat je (natuurlijk) niet mag springen over een "lege" plek. Nu zeg ik dit niet om te nitpicken of om te zeiken (en again; de regels van Solitaire zijn toch wel bekend), maar de opdrachten laten (te) veel aan de verbeelding over. De regels zijn te "vaag" en voor meerdere interpretaties vatbaar. En dat wil je, imho, niet.Verwijderd schreef op maandag 19 oktober 2009 @ 22:53:
Gecorrigeert. En ik kan niet altijd even sterke opdrachten verzinnen/verkrijgen. Dus dat gaat wat moeizaam.
Boeie. Het is (zo goed als) VB
Ik zeg het ook niet (alleen) specifiek tegen jou maar in 't algemeen. Wat mij betreft is een contest leuk(er) als iedereen 'tzelfde doel voor ogen heeft en tot nu toe blijken er telkens wat interpretatieverschillen (mogelijk) wat de lol er natuurlijk een beetje van af haalt.Verwijderd schreef op maandag 19 oktober 2009 @ 22:53:
En vergeet niet dat ik niet het doolhof opdracht heb gegeven.
There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.
Je eigen tweaker.me redirect
Over mij
Nog een keer verbetert.RobIII schreef op maandag 19 oktober 2009 @ 22:59:
Ik mis nog steeds dat je maar "1 plek" mag springen (bijvoorbeeld) of dat je (natuurlijk) niet mag springen over een "lege" plek. Nu zeg ik dit niet om te nitpicken of om te zeiken (en again; de regels van Solitaire zijn toch wel bekend), maar de opdrachten laten (te) veel aan de verbeelding over. De regels zijn te "vaag" en voor meerdere interpretaties vatbaar. En dat wil je, imho, niet.
Heel ergBoeie. Het is (zo goed als) VB
Het is ook geen contest, daar zit het verschil in. IMO is dit topic ervoor om elkaar uit te dagen op het vlak van het geven van oplossingen voor een bepaalde opdracht in zijn/haar bekende programmeer/scripttaal,Ik zeg het ook niet (alleen) specifiek tegen jou maar in 't algemeen. Wat mij betreft is een contest leuk(er) als iedereen 'tzelfde doel voor ogen heeft en tot nu toe blijken er telkens wat interpretatieverschillen (mogelijk) wat de lol er natuurlijk een beetje van af haalt.
En natuurlijk het geven van opdrachten.
Liever zie ik ook geen quick and dirty solutions voor een opdracht. Maar ik kan niets doen aan de onwil van een ander.
Koeieletters
Opdracht1: Schrijf een programma die na invoer van letters, diezelfde letters uitspuugt maar dan 9 lijnen groot.En gemaakt van de * character.
Voorbeeld:
1
2
3
4
5
6
7
8
9
| ****** ************* ********** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ******** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ***** **** ********** |
Moeilijkheidsgraad: beginner
[ Voor 3% gewijzigd door Verwijderd op 20-10-2009 21:24 ]
Dat wordt denk ik heel saai of heel omslachtig.Verwijderd schreef op dinsdag 20 oktober 2009 @ 21:23:Koeieletters
Opdracht1: Schrijf een programma die na invoer van letters, diezelfde letters uitspuugt maar dan 9 lijnen groot.
En gemaakt van de * character.
Voorbeeld:
code:
1 2 3 4 5 6 7 8 9 ****** ************* ********** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ******** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ***** **** **********
Moeilijkheidsgraad: beginner
Saai:
alles in constants.
omslachtig:
iets met vector parsing
Op die manier valt er misschien meer te halen uit de opdrachten en wordt ook het forum beter benut. Mensen die solitair problemen willen oplossen kunnen dat net zo goed bij Facebook of Project Euler doen. De meerwaarde van een topic op GoT is juist dat er discussie over problemen/oplossingen mogelijk is. (Iets minder vaak problemen posten betekent ook dat je meer tijd hebt om ze netjes uit te werken, waar RobIII ook -niet onterecht- om vroeg.)
Ten tweede, wat betreft het solitairespel: deze lijkt me minstens zo moeilijk als de doolhofopgave, en daar waagden (in ieder geval tot nu toe) maar een paar mensen zich aan. Ik zou willen voorstellen om een simpeler bord dan het Engelse bord toe te voegen als eerste helft van de opgave. (De wiki geeft als voorbeeld een driehoek, maar een driehoek is misschien juist weer lastiger te programmeren; als ik werkende code heb kan ik misschien een voorstel doen voor een rechthoekig bord dat ook een zinnige oplossing heeft.)
Console application in C#:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| static byte[,] letters = new byte[26, 9] { { 8, 20, 34, 34, 62, 34, 34, 34, 34 }, { 60, 34, 34, 60, 34, 34, 34, 34, 60}, { 28, 34, 32, 32, 32, 32, 32, 34, 28}, { 56, 36, 34, 34, 34, 34, 34, 36, 56}, { 62, 32, 32, 32, 56, 32, 32, 32, 62}, { 62, 32, 32, 32, 56, 32, 32, 32, 32}, { 30, 32, 32, 32, 38, 34, 34, 34, 28}, { 34, 34, 34, 62, 34, 34, 34, 34, 34}, { 28, 8, 8, 8, 8, 8, 8, 8, 28}, { 56, 8, 8, 8, 8, 8, 8, 40, 16}, { 34, 34, 36, 36, 40, 52, 36, 34, 34}, { 32, 32, 32, 32, 32, 32, 32, 32, 62}, { 34, 54, 42, 34, 34, 34, 34, 34, 34}, { 34, 50, 42, 38, 34, 34, 34, 34, 34}, { 28, 34, 34, 34, 34, 34, 34, 34, 28}, { 60, 34, 34, 34, 60, 32, 32, 32, 32}, { 28, 34, 34, 34, 34, 34, 34, 28, 14}, { 60, 34, 34, 34, 60, 48, 40, 36, 34}, { 28, 34, 32, 32, 28, 2, 2, 34, 28}, { 62, 42, 8, 8, 8, 8, 8, 8, 8}, { 34, 34, 34, 34, 34, 34, 34, 34, 28}, { 34, 34, 34, 34, 34, 34, 34, 20, 8}, { 34, 34, 34, 34, 34, 34, 34, 42, 20}, { 34, 34, 20, 20, 8, 20, 20, 34, 34}, { 34, 34, 20, 20, 8, 8, 8, 8, 8}, { 62, 34, 4, 4, 8, 8, 16, 18, 62} }; static void Main(string[] args) { foreach (string arg in args) { for (int l = 0; l < 9; l++) { foreach (char c in arg.ToUpper()) { if ((c - 65) >= 0 && (c - 65) < 26) Console.Write(GetBits(letters[(byte)c - 65, l])); } Console.WriteLine(); } Console.WriteLine(); } Console.ReadKey(); } static string GetBits(byte data) { string b = ""; for (int i = 7; i >= 0; i--) b += ((data & (1 << i)) == 0) ? " " : "*"; return b; } |
Eerste opzetje. Old-school ftw \0/ Aanroepen met "letters.exe the quick brown fox jumps over the lazy dog" ofzo. En nee, ik heb geen zin om 't "font" verder 'mooi' te maken ofzo. Dat laat ik aan de pietlutten over
[edit1]
Oh, en 't werkt alleen met a-z/A-Z Dus ik heb ook geen zin om diakritische tekens, cijfers en andere symbolen in 't "font" op te nemen
[edit2]
En dan naar de wat compactere/waarom-makkelijk-doen-als-'t-moeilijk-kan versie toe werken:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| static UInt64[] letters = new UInt64[26] { 0x81422223E222222, 0x3C22223C2222223C, 0x1C2220202020221C, 0x3824222222222438, 0x3E2020382020203E, 0x3E20203820202020, 0x1E2020262222221C, 0x2222223E22222222, 0x1C0808080808081C, 0x3808080808082810, 0x2222242834242222, 0x202020202020203E, 0x22362A2222222222, //A-M 0x22322A2622222222, 0x1C2222222222221C, 0x3C2222223C202020, 0x1C22222222221C0E, 0x3C22223C30282422, 0x1C22201C0202221C, 0x3E2A080808080808, 0x222222222222221C, 0x2222222222221408, 0x2222222222222A14, 0x2222140814142222, 0x2222140808080808, 0x3E0404080810123E //N-Z }; static void Main(string[] args) { foreach (string arg in args) Console.WriteLine(GetWord(arg.ToUpper())); Console.ReadKey(); } static string GetWord(string data) { StringBuilder p = new StringBuilder((data.Length * 64) + 16); for (int l = 0; l < 8; l++) p.AppendLine(GetLine(data, l)); return p.ToString(); } static string GetLine(string data, int line) { StringBuilder p = new StringBuilder(data.Length * 8); foreach (char c in data) if (c >= 65 && c <= 90) //A-Z only p.Append(GetBits((byte)(letters[(byte)c - 65] >> ((7 - line) * 8)))); return p.ToString(); } static string GetBits(byte data) { StringBuilder p = new StringBuilder(8); for (int i = 7; i >= 0; i--) p.Append(((data & (1 << i)) == 0) ? " " : "*"); return p.ToString(); } |
Hierboven heb ik wel even gefoefeld met de "9 lijnen" regel; hier worden er maar 8 gebruikt. Maar met wat creatief devven kan 9 lijnen ook in een UInt64 door bijv. de 1 van de 2 meest linkse kolommen die nu toch niet gebruikt worden van de bitmaps weg te laten, dat geeft weer ruimte voor een lijn meer:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| static UInt64[] letters = new UInt64[26] { 0X8288913E4489122, 0X3C4489E22448913C, 0X1C4481020408111C, 0X3848891224489238, 0X3E4081038408103E, 0X3E40810384081020, 0X1E4081026448911C, 0X224489F224489122, 0X1C1020408102041C, 0X3810204081021410, 0X2244912286891122, 0X204081020408103E, 0X226CA91224489122, //A-M 0X2264A93224489122, 0X1C4489122448911C, 0X3C448913C4081020, 0X1C44891224488E0E, 0X3C448913C60A1222, 0X1C448101C040911C, 0X3E54204081020408, 0X224489122448911C, 0X2244891224488A08, 0X2244891224489514, 0X224450A082851122, 0X224450A081020408, 0X3E4410208104093E //N-Z }; static void Main(string[] args) { foreach (string arg in args) Console.WriteLine(GetWord(arg.ToUpper())); Console.ReadKey(); } static string GetWord(string data) { StringBuilder p = new StringBuilder((data.Length * 63) + 18); for (int l = 0; l < 9; l++) p.AppendLine(GetLine(data, l)); return p.ToString(); } static string GetLine(string data, int line) { StringBuilder p = new StringBuilder(data.Length * 7); foreach (char c in data) if (c >= 65 && c <= 90) //A-Z only p.Append(GetBits((byte)(letters[(byte)c - 65] >> ((8 - line) * 7)))); return p.ToString(); } static string GetBits(byte data) { StringBuilder p = new StringBuilder(7); for (int i = 6; i >= 0; i--) p.Append(((data & (1 << i)) == 0) ? " " : "*"); return p.ToString(); } |
Voila. 9 Lijnen. Bitmaps even herberekend wegens de 7bit breedte van de letters en her-en-der wat constantes aangepast om in te spelen op die nieuwe breedte/hoogte van de letters.
C:\Users\Rob.Devcorner>letters.exe the quick brown fox jumps over the lazy dog ***** * * ***** * * * * * * * * * * * ***** * * * * *** * * * * * * * * * * * * * * * ***** *** * * *** *** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * *** * * * * * * * *** *** *** *** * * **** **** *** * * * * * * * * * * * * ** * * * * * * * * * * * * **** * * * * * * * ** * * **** * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * * * * * * * * **** * * *** * * * * ***** *** * * * * * * * * * * * * * * * * * *** * * * * * * * * * * * * * * * * * * * *** * * *** * * * * **** *** * * * ** ** * * * * * * * * * * * * * * * * * * * * * * * * * * **** *** * * * * * * * * * * * * * * * * * * * * * * * * *** * * * *** *** * * ***** **** * * * * * * * * * * * * * * * * * * * * * * * * * *** **** * * * * * ** * * * * * * * * * * * * * * *** * ***** * * ***** * * ***** * * * * * * * * * * * ***** * * * * *** * * * * * * * * * * * * * * * ***** * * ***** * * * * * * * * * * * * * * * * * * * * * * ***** * * * * * * * * * * * * * * * * * * ***** * * ***** * *** *** **** * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * *** *** ***
Zelfde idee, alleen wat compacter geschreven en als enige verschil dat alle woorden nu op 1 'regel' verschijnen in plaats van 1 woord per 'regel':
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| static UInt64[] letters = new UInt64[26] { 0X8288913E4489122, 0X3C4489E22448913C, 0X1C4481020408111C, 0X3848891224489238, 0X3E4081038408103E, 0X3E40810384081020, 0X1E4081026448911C, 0X224489F224489122, 0X1C1020408102041C, 0X3810204081021410, 0X2244912286891122, 0X204081020408103E, 0X226CA91224489122, //A-M 0X2264A93224489122, 0X1C4489122448911C, 0X3C448913C4081020, 0X1C44891224488E0E, 0X3C448913C60A1222, 0X1C448101C040911C, 0X3E54204081020408, 0X224489122448911C, 0X2244891224488A08, 0X2244891224489514, 0X224450A082851122, 0X224450A081020408, 0X3E4410208104093E //N-Z }; static void Main(string[] args) { Console.BufferWidth = (string.Join(" ", args).Length * 7) + 1; for (int l = 0; l < 9; l++) foreach (char c in string.Join(new string(' ', 7), args).ToUpper() + Environment.NewLine) if (c >= 65 && c <= 90) //A-Z only for (int i = 6; i >= 0; i--) Console.Write(((((byte)(letters[(byte)c - 65] >> ((8 - l) * 7))) & (1 << i)) == 0) ? " " : "*"); else Console.Write(c); Console.ReadKey(); } |
C:\Users\Rob.Devcorner>letters.exe the quick brown fox jumps over the lazy dog ***** * * ***** *** * * *** *** * * **** **** *** * * * * ***** *** * * *** * * * * **** *** *** * * ***** **** ***** * * ***** * * ***** * * *** *** **** * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * ** ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ***** * * * * * * * * * **** * * * * * * * ** * * * * * * * * * * * * * * * * * * * * * ***** * * * * * * * * * * * * * * * *** * * * * * * * * * * **** * * * * * * *** * * * * * * * * **** *** * * * * *** **** * * * *** * ***** * * * * * * * ** * * * * * * * * * * ** * * * ** * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ***** *** *** *** *** * * **** * * *** * * * * * *** * * * *** * * * *** *** * ***** * * * * * ***** ***** * * ***** * *** *** ***
En daar kan vast nog het één en ander af, maar daar heb ik nu geen zin meer in
[ Voor 250% gewijzigd door RobIII op 21-10-2009 02:19 ]
There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.
Je eigen tweaker.me redirect
Over mij
Point taken. 1 week it is.Soultaker schreef op dinsdag 20 oktober 2009 @ 21:52:
@Typnix: is het een idee om de opdrachten een beetje apart te houden qua tijd? Als je bijvoorbeeld eens per week een opdracht post (of een makkelijke en een moeilijke) dan werkt iedereen aan dezelfde opdracht en is er meer gelegenheid om oplossingen/algoritmen/implementatietechnieken vergelijken. Dat lijkt me leuker dan dat alle opdrachten een beetje door elkaar staan en iedereen met een ander probleem bezig is (of z'n oplossing nog niet af heeft als de volgende opdracht alweer gepost wordt).
Op die manier valt er misschien meer te halen uit de opdrachten en wordt ook het forum beter benut. Mensen die solitair problemen willen oplossen kunnen dat net zo goed bij Facebook of Project Euler doen. De meerwaarde van een topic op GoT is juist dat er discussie over problemen/oplossingen mogelijk is. (Iets minder vaak problemen posten betekent ook dat je meer tijd hebt om ze netjes uit te werken, waar RobIII ook -niet onterecht- om vroeg.)
Het Doolhof opdracht heb ik niet geoppert. Maar ik kan niet goed zien wat te moeilijk is voor de mensen.Ten tweede, wat betreft het solitairespel: deze lijkt me minstens zo moeilijk als de doolhofopgave, en daar waagden (in ieder geval tot nu toe) maar een paar mensen zich aan. Ik zou willen voorstellen om een simpeler bord dan het Engelse bord toe te voegen als eerste helft van de opgave. (De wiki geeft als voorbeeld een driehoek, maar een driehoek is misschien juist weer lastiger te programmeren; als ik werkende code heb kan ik misschien een voorstel doen voor een rechthoekig bord dat ook een zinnige oplossing heeft.)
Of dat ze geen zin hebben. En nogmaals je mag altijd een opdracht op de DM sturen. Sterker nog: ik daag jullie uit om met goeie opdrachten te komen. Dan hebben we er met z,n alle plezier aan.
Zoals ik al had gezegt in de opdracht is solitaire een bordspel in de vorm van kruis. De driehoek is een variant.
Met een beetje zoeken had je als snel een duidelijker beeld kunnen hebben.
De link is slechts een uitleg hoe het spel zelf werkt. Maar goed, als je een beter opdracht heb: dan hou ik me zeker aanbevolen.
1
2
| #include <iostream> void main(int i,char **a){char c;i=0;while(a[1][i]!=0){c<<=1;if(a[1][i]=='1')c|=1;if(i++%8==7)std::cout<<c;}} |
Geen 'echte' oneliner natuurlijk, maar toch geinig dat het zo kort kan
PS: Mijn maze generator is ook klaar, die komt vanavond vanaf thuus.
[ Voor 16% gewijzigd door Dricus op 22-10-2009 16:22 . Reden: Nog 2 tekens minder :P ]
Stel niet uit tot morgen wat je vandaag nog tot morgen kunt uitstellen...
edit:
Een echte one-liner:
1
| main(int i,char**a){char v,*x=a[1];for(i=0;*x;)v+=v+*x++-'0',++i&7||putchar(v);} |
[ Voor 22% gewijzigd door Soultaker op 22-10-2009 17:36 ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| package net.tweakers.programmeervuur; import java.awt.Font; import java.awt.Graphics2D; import java.awt.image.BufferedImage; public class Koeieletters { public static void main(String[] a) { String w = (a.length > 0) ? "" : "The quick brown fox jumps over the lazy dog"; for (String p : a) w += (p + " "); w.trim(); BufferedImage i = new BufferedImage(w.length() * 7, 9, BufferedImage.TYPE_BYTE_BINARY); Graphics2D g = i.createGraphics(); g.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 11)); g.drawString(w, 0, 7); for (int y = 0; y < i.getHeight(); y++) for (int x = 0; x < i.getWidth(); x++) System.out.print((y != 0 && x == 0 ? "\r\n" : "") + (i.getRGB(x, y) == -1 ? '*' : ' ')); } } |
***** ** * ** ** ** * ** ** ** * * * * * * * * * * * * * ** *** ** **** ** *** **** * *** * ** ** ** *** *** ***** ** **** *** ** ** **** ** ** *** * ** ** **** *** *** *** *** ** ** ***** * ** *** * *** ***** *** *** ** * *** ** ** * ** * * * * ** * * * * * * * ** * ** * * * * ** * * * * * * * * * * * * ** * * * * * * * * ** * ** * * * * * * * * * * * ** * * * ** * * * ***** * * * * * * *** * * * * * * * * * * * * * * * * * * * * * * *** * * * * ***** * * * * ***** * **** * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *** *** *** **** **** ** ** ***** **** ** *** ***** **** *** * * *** *** **** *** ** ** * ** ********* **** **** *** ** **** **** *** *** *** **** ***** ****** ***** * ***** *** **** * * * * * *** *** *** *** ***
[ Voor 103% gewijzigd door BalusC op 23-10-2009 00:47 . Reden: bugfix + inkorten ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| using System; using System.Drawing; class Program { static void Main(string[] args) { string t = args.Length > 0 ? string.Join(" ", args) : "The quick brown fox jumps over the lazy dog"; Bitmap c = new Bitmap(t.Length * 9, 20); using (Graphics g = Graphics.FromImage(c)) //Create graphics object and draw text in bitmap g.DrawString(t, new Font("Courier New", 8, FontStyle.Bold), Brushes.White, 0, 0); Console.BufferWidth = c.Width + 1; //Set console width for (int y = 0; y < c.Height; y++) for (int x = 0; x < c.Width; x++) Console.Write((x == 0 ? "\r\n" : "") + ((c.GetPixel(x, y).GetBrightness() > 0) ? "*" : " ")); c.Dispose(); } } |
********* ** *** *** *** ** ** *** *** * ** * ** ** ** ** ** ** ** * ** * **** **** ********* ****** ***** ** ** ***** *** ** ******** ******** ***** **** *** *** ***** *** ************** ***** **** *** ******* *** ** ***** **** **** ***** **** ****** ** ** ** ** ** ** ** ** ** ** ** * **** ** ** *** * ** **** * ** ** ** ** ** ** ** ** ** ** ** ** * *** ** ** * ** ** ** **** ** *** * ** ** **** ** ** ** ** ** ** ** ** ** ** ****** ** ** ** ** ** ** **** ** ** ** ** **** * ** ** ** ** ** ** *** ** ** ** ** * *** ** **** ** ** * * ****** ** ** ** ******** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** * ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** * *** ** * ** ** ** *** ** ** ** * ** **** ** ** ** ** ** ** **** *** *** ***** ***** ********** **** *** ** ****** ***** **** ** ** *** *** ***** **** *** *** ** ******* * ****** ***** **** *** ***** ***** *** *** ******** ****** **** ***** ** ** ** ** ***** **** ***** ****
Zo ziet 't er werkelijk uit:


Afhankelijk van 't font natuurlijk werken nu, itt de vorige poging, wél alle tekens. Then again, als je zin hebt het 'hardcoded font' in de vorige poging uit te breiden is het natuurlijk ook daar geen probleem
Nog wat compacter; zonder usings, zonder onnodige variabelen en zonder netjes zaken te disposen (boeie
1
2
3
4
5
6
7
8
9
10
| class Program { static void Main(string[] args) { string t = args.Length > 0 ? string.Join(" ", args) : "The quick brown fox jumps over the lazy dog"; System.Drawing.Bitmap c = new System.Drawing.Bitmap(t.Length * 9, 20); System.Drawing.Graphics.FromImage(c).DrawString(t, new System.Drawing.Font("Courier New", 8, System.Drawing.FontStyle.Bold), System.Drawing.Brushes.White, 0, 0); System.Console.BufferWidth = c.Width + 1; for (int y = 0; y < c.Height; y++) for (int x = 0; x < c.Width; x++) System.Console.Write((x == 0 ? "\r\n" : "") + ((c.GetPixel(x, y).GetBrightness() > 0) ? "*" : " ")); } } |
[ Voor 28% gewijzigd door RobIII op 23-10-2009 00:19 . Reden: Logica foutje eruit gehaald ]
There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.
Je eigen tweaker.me redirect
Over mij
Ik ben zeker geen Java programmeur. Ik heb 7 jaar C/C++ geprogrammeerd. De laatste 5 jaar programmeer ik voornamelijk in C#. C/C++ blijft wel echt m'n 'oude liefde', hobbydingetjes zoals dit doe ik het liefst met C++ of gewoon lekker in C. Normaal gesproken is mijn programmeerstijl alleen niet zo minimalistisch, eerder vrij verbose. Het minimalistisch programmeren wat ik de eerste 2 opdrachten heb geprobeerd zie ik dus een beetje als een ludieke oefening met als doel om de ins en outs van C/C++ weer een beetje op te vijzelen. Wat dat betreft zijn jouw reacties erg leerzaam, dank daarvoor
Hierbij dan ook meteen mijn maze generator. Hierbij heb ik niet het doel gehad om een minimalistisch programma neer te zetten, dus deze code is stukken beter leesbaar. De uitdaging met deze opdracht was voor mij vooral om een nette datastructuur voor het doolhof te verzinnen. Dit is op zich aardig gelukt, al denk ik dat het nog wel een stukje beter kan, maar ik heb even niet zoveel tijd meer om hier nog verder naar te kijken.
Anyways, klikkerdeklik hier voor de code. Ik heb het maar ff via pastebin gedaan, 186 regels code is een beetje veel van het goede om in een post te proppen.
Sample output (ingang linksboven, uitgang rechtsonder, of andersom, wat jij wil



Stel niet uit tot morgen wat je vandaag nog tot morgen kunt uitstellen...
1. Het is voor de fun.RobIII schreef op maandag 19 oktober 2009 @ 22:34:
Nu zijn de regels van solitaire "alom bekend" maar ik vind de opdracht(en) wel telkens nogal te wensen over laten; er staat nu (bijv.) nergens dat je niet schuin mag "springen" en altijd maar 1 "plek" mag (over)springen. De regels zoals je ze nu hier uit legt laten dus (te) veel aan de verbeelding over en hebben het risico verkeerd geïnterpreteerd te worden.
Aan de doolhof opdracht had ik, bij wijze van, ook kunnen voldoen met het volgende:
I=Ingang, U=Uitgang
code:
1 2 3 4 5 6 7 print "######" print "I # U" if rnd mod 2 = 0 then print "# ##" else print "# #" print "######"
En dan sloof ik me nog uit
Voor je solitaire opdracht, zoals jij 'm omschreven hebt, zou ik dus al voldoen met:
code:
1 ###############################.
Voila. 32 velden, 1 leeg. En spring maar raak
Een goede contest begint met een duidelijk afgebakende opdracht; anders ben je appels met peren aan 't vergelijken.
2. Het is geen contest
3. Er is niets willekeurigs aan je uitvoering want er is maar één weg naar de uitgang.
4. Doe gewoon gezellig ipv te miepen..
http://hawvie.deviantart.com/
Erg mooi stukje code! Zou je eens kort kunnen uitleggen hoe je algoritme werkt? Dat zie ik nog niet meteen.Dricus schreef op donderdag 22 oktober 2009 @ 19:30:
Hierbij dan ook meteen mijn maze generator. Hierbij heb ik niet het doel gehad om een minimalistisch programma neer te zetten, dus deze code is stukken beter leesbaar. De uitdaging met deze opdracht was voor mij vooral om een nette datastructuur voor het doolhof te verzinnen. Dit is op zich aardig gelukt, al denk ik dat het nog wel een stukje beter kan, maar ik heb even niet zoveel tijd meer om hier nog verder naar te kijken.
[ Voor 7% gewijzigd door writser op 22-10-2009 22:57 ]
Onvoorstelbaar!
Oke hij miept, maar ik vind deze opgave ook niet zo sterk als de vorige. Ten eerste schijnen er meerdere solitaire-borden te bestaan volgens de site. Ten tweede kun je wat moeilijker je uitkomsten vergelijken met andere spelers, het ziet er niet zo gaaf uit als een doolhof bijvoorbeeld. Ten derde staan er al uitgewerkte oplossingen op de wikipedia pagina. Misschien is het leuker om 4 of 5 solitaire-situaties in een tekstbestand aan te leveren en de vraag te stellen: kun je ze oplossen en zo ja, in hoeveel zetten?HawVer schreef op donderdag 22 oktober 2009 @ 20:17:
[...]
1. Het is voor de fun.
2. Het is geen contest
3. Er is niets willekeurigs aan je uitvoering want er is maar één weg naar de uitgang.
4. Doe gewoon gezellig ipv te miepen..
Mijn oneliner in python:
1
| print 'x:x=ex,lj,ck,Pf,DP,GI,JH,mG,GI,ik,gi,LJ,JH,Hl,lj,jh,CK,pF,AC,CK,Mg,gi,ac,ck,kI,dp,pF,FD,DP,Pp,ox' |
Voor de rest een prima initiatief dit topic, hulde!
Onvoorstelbaar!
Ah, ik gokte dat omdat je dingen als a\[1][i] !=0 schrijft wat in Java noodzakelijk is omdat je een char of int niet als conditie mag gebruiken (dat moet een expressie van type boolean zijn). In C ben ik zelfs in normale code geneigd gewoon a\[1][i] te schrijven en dat levert hier toch weer drie karakters op!Dricus schreef op donderdag 22 oktober 2009 @ 19:30:
Ik ben zeker geen Java programmeur. Ik heb 7 jaar C/C++ geprogrammeerd.
Nette oplossing! Al had RobIII's bitmap font meer street cred.
[ Voor 9% gewijzigd door BalusC op 22-10-2009 23:21 ]
Mijn algoritme is een randomized implementatie van Kruskal's algoritme. Dit is een bekende manier om perfecte doolhoven (doolhoven zonden 'loops') te maken. Er zijn simpelere algoritmen, maar deze vond ik gewoon leuk om te maken, vandaar deze keuze.
Ondertussen ben ik erachter gekomen dat mijn datastructuur veel simpeler kan. De nieuwe code is hier te vinden. Mijn vorige versie had een struct Wall, waarin bijgehouden werd of hij horizontaal of verticaal was en welke 2 cellen de wall van elkaar scheidde. Deze nieuwe versie stelt een doolhof voor als een ruitjespapier waarop je door bepaalde hokjes zwart te maken en andere leeg te laten een doolhof kunt maken. Dit is veel eenvoudiger te implementeren, dus het aantal regels code is met 50 verminderd tot 136

@Soultaker: Ja, die notatiewijze is voor mij een soort automatisme wat er met de jaren is ingeslopen. Persoonlijk vind ik a[1][i] != 0 als boolean expressie leesbaarder dan a[1][i].
Stel niet uit tot morgen wat je vandaag nog tot morgen kunt uitstellen...
Ik denk trouwens dat er niet veel simpelere algoritmen zijn om een echt willekeurig doolhof te genereren. _js_ en TheCoolGamer hadden als eerste oplossingen met een ad-hoc algoritme gepost, en die zijn toch nog wel iets langer (zelfs dan mijn PostScript code!)
Onvoorstelbaar!
Fair enough, als je de code voor de benodigde datastructuren niet meerekent is het algoritme niet veel minder complex dan Kruskal (in mijn implementatie 1 regel effectieve code minder). Deze manier zorgt echter wel voor een nieuwe vermindering van het aantal regels code van 136 naar 109. Dit zou je gemakkelijk kunnen zien als een vermindering in complexiteit
Stel niet uit tot morgen wat je vandaag nog tot morgen kunt uitstellen...
Maakt niet uit, je bent niet de enige. Kennis van algoritmen is ook niet echt mijn sterkste punt, maar da's dan ook niet mijn feitelijke werk
[ Voor 3% gewijzigd door BalusC op 23-10-2009 17:16 ]
Overigens is het voor mij de eerste keer dat ik met dit soort algoritmes aan de slag ga. Maar dat maakt het alleen maar interessanter.
[ Voor 19% gewijzigd door D-Raven op 23-10-2009 17:40 ]
edit:
Oh, mijn uitleg ging over Dricus code hier, niet de laaste post met randomized DFS.
[ Voor 23% gewijzigd door Soultaker op 23-10-2009 19:05 ]
Mijn algoritme garandeert niet alleen dat het doolhof oplosbaar is, maar ook dat alle hokjes vanuit ieder willekeurig ander hokje op de 1 of andere manier bereikbaar zijn. Hierdoor is het doolhof per definitie altijd oplosbaar, onafhankelijk van de plek van de in- en uitgang. Het globale principe is dat het algoritme zich een weg "graaft" door een doolhof met dichte muren.
Ik zal proberen het enigszins duidelijk uit te leggen. Stapsgewijs gaat het als volgt:
- Maak een doolhof met alleen maar dichte muren
- Selecteer een (willekeurig) hokje CurrentCell om mee te starten (ik selecteer hier het hokje naast de uitgang)
- Vervolgens worden de volgende stappen recursief doorlopen:
- Markeer CurrentCell als bezocht
- Itereer in willekeurige volgorde door alle buurhokjes CurrentNeighbor van CurrentCell die nog niet als bezocht zijn gemarkeerd en doe het volgende:
- Maak de muur tussen CurrentCell en CurrentNeighbor open
- Voer de stappen a en b uit met CurrentNeighbor als CurrentCell (hier ontstaat dus recursie)
[ Voor 3% gewijzigd door Dricus op 23-10-2009 19:12 ]
Stel niet uit tot morgen wat je vandaag nog tot morgen kunt uitstellen...
Ik heb jou oplossing geport naar c#. Dit hielp mij om een soort mentale voorstelling te maken van wat er gebeurd. Ik snap nu ook waarom er altijd een oplossing is. Ook al loopt de laatste vertakking zegmaar net voor de uitgang (eigenlijk ingang dus). Als deze vertakking zichzelf of iets anders kruist zal hij verder vertakken bij de eerst volgende neighbor die nog niet bezocht is. Dit zal dan uiteindelijk het gat bij de ingang zijn. Waardoor er dus een opening tussen de vertakking en de ingang wordt gecreëerd.Dricus schreef op vrijdag 23 oktober 2009 @ 19:00:
Ik zal proberen het enigszins duidelijk uit te leggen. Stapsgewijs gaat het als volgt:Je kunt het je als volgt voorstellen (niet helemaal accuraat, maar het geeft de grote lijnen wel weer): Eerst wordt er een willekeurig pad gemaakt net zolang totdat het pad zichzelf kruist. Daarna worden er vertakkingen gemaakt die ook weer net zolang doorgaan tot ze zichzelf of een ander pad kruisen. Van die vertakkingen worden ook weer vertakkingen gemaakt, enzovoort enzoverder, net zolang tot alle hokjes als bezocht zijn gemarkeerd.
- Maak een doolhof met alleen maar dichte muren
- Selecteer een (willekeurig) hokje CurrentCell om mee te starten (ik selecteer hier het hokje naast de uitgang)
- Vervolgens worden de volgende stappen recursief doorlopen:
- Markeer CurrentCell als bezocht
- Itereer in willekeurige volgorde door alle buurhokjes CurrentNeighbor van CurrentCell die nog niet als bezocht zijn gemarkeerd en doe het volgende:
- Maak de muur tussen CurrentCell en CurrentNeighbor open
- Voer de stappen a en b uit met CurrentNeighbor als CurrentCell (hier ontstaat dus recursie)
Gebaseerd op dit algoritme kan men ook aannemen dat de allereerste vertakking de grootste kans heeft om ook meteen de langste te zijn welke doorloopt zonder zichzelf of de rand tegen te komen.
Als je het eenmaal begrijpt is t eigenlijk retesimpel
Ik moest overigens wel even vloeken toen ik erachter kwam dat er geen array/list shuffle implementatie is in .Net
Klinkt ingewikkeld maar valt best mee, je kunt het zo moeilijk maken als je wilt. 3D mazes als output bijvoorbeeld. Of je blijft bij standaard/perfect mazes.
Bovendien wil ik niet te lang in 1 keer doorzeveren op 1 onderwerp. Dan hak ik het liever in stukken.
Een doolhof oplosser zou ik pas na een maand willen opperen.
Oplossingsmogelijkheden:
- logica
- brute force
- knuth's algorithm
- combinaties
- ?
Als je netjes programmeert kan je ook 16x16 doen bijvoorbeeld?
[ Voor 16% gewijzigd door armageddon_2k1 op 27-10-2009 07:51 ]
Engineering is like Tetris. Succes disappears and errors accumulate.
Hulde voor je uitleg, erg duidelijkDricus schreef op vrijdag 23 oktober 2009 @ 19:00:
@Deathraven (ik neem trouwens aan dat je het over mijn laatste oplossing hebt):
Mijn algoritme garandeert niet alleen dat het doolhof oplosbaar is, maar ook dat alle hokjes vanuit ieder willekeurig ander hokje op de 1 of andere manier bereikbaar zijn. Hierdoor is het doolhof per definitie altijd oplosbaar, onafhankelijk van de plek van de in- en uitgang. Het globale principe is dat het algoritme zich een weg "graaft" door een doolhof met dichte muren.
Ik zal proberen het enigszins duidelijk uit te leggen. Stapsgewijs gaat het als volgt:Je kunt het je als volgt voorstellen (niet helemaal accuraat, maar het geeft de grote lijnen wel weer): Eerst wordt er een willekeurig pad gemaakt net zolang totdat het pad zichzelf kruist. Daarna worden er vertakkingen gemaakt die ook weer net zolang doorgaan tot ze zichzelf of een ander pad kruisen. Van die vertakkingen worden ook weer vertakkingen gemaakt, enzovoort enzoverder, net zolang tot alle hokjes als bezocht zijn gemarkeerd.
- Maak een doolhof met alleen maar dichte muren
- Selecteer een (willekeurig) hokje CurrentCell om mee te starten (ik selecteer hier het hokje naast de uitgang)
- Vervolgens worden de volgende stappen recursief doorlopen:
- Markeer CurrentCell als bezocht
- Itereer in willekeurige volgorde door alle buurhokjes CurrentNeighbor van CurrentCell die nog niet als bezocht zijn gemarkeerd en doe het volgende:
- Maak de muur tussen CurrentCell en CurrentNeighbor open
- Voer de stappen a en b uit met CurrentNeighbor als CurrentCell (hier ontstaat dus recursie)
@Hierboven
Sudoku oplosser is leuk maar ik denk dat 95% van de mensen hier wel eens zoiets heeft gemaakt
Als je dan een oplosser wilt maken kan je misschien beter een ander spel kiezen, als Reversi, Rubics Cube enzo
[ Voor 5% gewijzigd door Phyxion op 27-10-2009 08:03 ]
'You like a gay cowboy and you look like a gay terrorist.' - James May
Voor de beginners zat ik ook te denken aan een soort van "interpreter" die een file moet openen met x, y coordinaten en daarvan een figuur maakt.
Of een goede Go playerVerwijderd schreef op dinsdag 27 oktober 2009 @ 08:13:
Ik kan ook het opdracht opperen van het maken van een oplosser voor schaken
Onvoorstelbaar!
The Zits Code
Algemeen: Jeremy staat niet bekend om zijn organisatorisch vermogen, Maar hij is wil veranderen. Zijn plan is om briefjes neer te leggen overal in huis wat hem moet helpen herinneren van de taken die gedaan moeten worden op de juiste manier. Maar Jeremy had ook het plan opgevat om wat er op de briefjes komt te staan te versleutelen zodat zijn ouders niet gaan zeuren. Maar wel op een eenvoudige manier zodat hij de boodschap makkelijk kan terughalen.Opdracht: Voeg een boodschap van M karakters in met uiteraard spaties. Deze woorden moeten gedraaid worden op een met de klok meegaande spiraal waar het startpunt linksboven ligt gekeken vanuit een vierkant.
De lengte en de breedte van de vierkant die het spiraal insluit is gelijk aan de wortel van P.
En P is het kleinste perfecte vierkant wat weer gelijk aan of groter is dan M.
Als M minder is dan P dan moeten de overige locaties gevuld worden met het karakter '$'.
En schrijf een versleutelde boodschap door de karakters 1 regel per keer weer te geven vanaf de top.
More background info: http://acmicpc-live-archi...uevoportal/data/p3817.pdf
2: Gezien het feit dat jeremy eventueel de boodschap misinterpreteren is het ook van belang dat hij de boodschap kan ontsleutelen mocht hij het niet snappen.
Schrijf het programma zo dat beide opties via de CLI gekozen kunnen worden.
Niveau: Alle niveau's
Even ter verduidelijking: de voorbeeldinvoer wordt als volgt in een 6x6 vierkant gepackt:
a | b | c | d | f | |
t | u | w | x | g | |
s | 6 | 7 | $ | y | h |
r | 5 | $ | $ | z | |
q | 4 | 3 | 1 | j | |
p | n | m | l | k |
De uitvoer is dan simpelweg de concatenatie van de rijen in het vierkant.
Que? Wat is dan >= M? Een zijde van P? De oppervlakte van P? De omtrek? P is het vierkant, dat is op zichzelf geen getal.Verwijderd schreef op woensdag 28 oktober 2009 @ 08:52:
En P is het kleinste perfecte vierkant wat weer gelijk aan of groter is dan M.
[ Voor 3% gewijzigd door .oisyn op 28-10-2009 12:15 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Volgens mij is P het aantal plekken in het vierkant, dus breedte x hoogte. Dus dan klopt het dat P altijd groter of gelijk is aan M (aantal karakters van de boodschap). De voorwaarde is dat de wortel van P altijd een geheel getal oplevert. Bij een vierkant van 6x6 is P dus 36..oisyn schreef op woensdag 28 oktober 2009 @ 12:14:
[...]
Que? Wat is dan >= M? Een zijde van P? De oppervlakte van P? De omtrek? P is het vierkant, dat is op zichzelf geen getal.
http://hawvie.deviantart.com/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| using System; using System.Text; class Program { static void Main(string[] args) { Console.WriteLine(ZitsCode(string.Join(" ", args))); Console.ReadKey(); } private static string ZitsCode(string value) { if (string.IsNullOrEmpty(value)) throw new ArgumentOutOfRangeException("Value cannot be null or empty"); int s = (int)Math.Ceiling(Math.Sqrt(value.Length)); char[,] m = new char[s, s]; int x = 0, y = 0, xd = 1, yd = 0, xx = s - 1, yx = xx, xn = 0, yn = 1; foreach (char c in value) { m[x, y] = c; if ((x == xx) && (xd == 1)) { xd = 0; yd = 1; xx--; } if ((y == yx) && (yd == 1)) { xd = -1; yd = 0; yx--; } if ((x == xn) && (xd == -1)) { xd = 0; yd = -1; xn++; } if ((y == yn) && (yd == -1)) { xd = 1; yd = 0; yn++; } x += xd; y += yd; } StringBuilder r = new StringBuilder((s * s) + ((s - 1) * 2)); for (y = 0; y < s; y++) for (x = 0; x < s; x++) r.Append(((x == 0 && y > 0) ? "\r\n" : "") + m[x, y]); return r.ToString(); } } |
C:\Users\Rob\Zitscode.exe The quick brown fox jumps over the lazy dog The qui ps ovec m dogrk uy jz tb al ehr xof nwo C:\Users\Rob\Zitscode.exe abcd fgh jklmn pqrstu wxyz1 34567 abcd f tu wxg s67 yh r5 z q43 1j p nmlk
Nu nog "decoden" en kleiner maken... Maar dat wordt vanavond (als ik zin en tijd heb
[ Voor 3% gewijzigd door RobIII op 28-10-2009 13:05 ]
There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.
Je eigen tweaker.me redirect
Over mij