Grapje of echt niet? :')

Als je niet kan programmeren is het niet zo raar dat je zulke dingen niet kan lezen

Ik kan het wel lezen en dat probleem is inderdaad erg makkelijk. Als ik zo naar de problemen kijk echter wordt rekentijd telkens een fiks probleem als je zulke brute-force algorithmes blijft gebruiken.

Dan heb je simpele wiskundetruukjes nodig om het rekenen te versnellen. Helaas is mijn wiskundekennis lang niet fundamenteel genoeg, anders was ik graag aan de slag gegaan

quote:

---

Op 17 March 2010 21:59 schreef WhiteRider het volgende:
Grapje of echt niet? :')

---

Overigens gebruik je op 1 regel boolean en integer operatoren door elkaar heen.

Gaat toevallig goed omdat nul evalueert tot boolean false en alles ongelijk nul tot boolean true, maar eigenlijk horen die uitroeptekentjes daar niet.

Dat kon ik er dan weer niet uithalen

Ja, dit wordt al gauw vrij zwaar ja. Eens kijken hoe ver ik kom, de tweede vind ik al wat lastiger.

quote:

---

Op 17 March 2010 22:05 schreef WhiteRider het volgende:
Ja, dit wordt al gauw vrij zwaar ja. Eens kijken hoe ver ik kom, de tweede vind ik al wat lastiger.

---

Die is niet moeilijk.

Fibonacci reeks programmeren en elke waarde die even is optellen totdat je een waarde (niet de som, maar een waarde uit de reeks) vindt die boven 4 miljoen komt.

Althans, als je brute force mag is het niet moeilijk

[Dit bericht is gewijzigd door ZelThoR op 17-03-2010 22:08]

Ja, zat te kutten met x en y correct ophogen met het getal, maar was aanvankelijk veel makkelijker dan gedacht.

Opgelost in ieder geval. Wel weer met een loopje uiteraard. :')

EDIT:
I estimate that I had written about 3 million lines
of assembler code in my whole life. Now, code only
when strictly necessary.

Phi (golden ratio) is the approximate ratio between
two consecutive terms in a Fibonacci sequence.
The ratio between consecutive even terms approaches
phi^3 (4.236068) because each 3rd term is even.
Use a calculator and round the results to the nearest
integer when calculating the next terms:

2,8,34,.. multiplying by 4.236068 each time: 144,610,
2584,10946,46368,196418 & 832040

The sum is 1089154

My codeless regards,
Rudy.



Damn, scherp, hehe.

[Dit bericht is gewijzigd door WhiteRider op 17-03-2010 22:18]

Precies, dat bedoel ik dus, dat had ik niet kunnen bedenken Wordt zoveel makkelijker als je een stevige wiskundebasis hebt!

[Dit bericht is gewijzigd door ZelThoR op 17-03-2010 22:20]

quote:

---

Op 17 March 2010 21:59 schreef WhiteRider het volgende:
Grapje of echt niet? :')

---

Echt niet.


Dit soort dingen is meer mijn kopje thee.

Dat kon ik vroeger ook! Veel mechanica-kennis is weer weggezakt. hehehe.

Dolle boel. 1 getal verkeerd in je matrix en er klopt geen hol meer van.

Haha, daar begrijp ik weer niet zoveel van.

What is the largest prime factor of the number 600851475143 ?


Ja, dat ga ik dan weer niet met brute force doen, dan crasht m'n servertje. Echt geen idee nog hoe ik een reeks priemgetallen ga generen zonder ze even handmatig in te vullen. :')

Dat heb ik ook eens gedaan bij vector en matrix rekenen, maar toen waren de vergelijkingen al gegeven. Het ging om het juist opstellen van de matrix en de bewerking daar op. Mooi werk in Matlab.

Pff, deze was wel erg lastig. Zo te lezen op internet was ik niet de enige die er moeite mee had. Moest even opzoeken wat een prime factor precies is, maar kwam hiermee:

http://www.codedump.be/code/601/

Dacht eerst dat dat een getal was dat in het kwadraat niet hoger was dan getal X, maar dat was dus niet zo.

Dit werkt wel, maar is ongelofelijk langzaam.

[Dit bericht is gewijzigd door WhiteRider op 17-03-2010 23:57]

quote:

---

Op 17 March 2010 21:22 schreef powertieke het volgende:
Ben je een bikkel?

Project Euler

Asjeblieft!

---

Grootste deel daarvan is trouwens ook prima gewoon met pen en papier op te lossen zonder te hoeven programmeren.

Ik vind dit een leuk topic.

quote:

---

Op 18 March 2010 2:02 schreef Hades het volgende:
Grootste deel daarvan is trouwens ook prima gewoon met pen en papier op te lossen zonder te hoeven programmeren.

---

Het geinige van de een aantal van die opgaven is dat ze er 2 versies van hebben. 1 met een kleine getallenreeks (die je gemakkelijk kan brute forcen), en een tweede versie met een veel grotere getallenreeks zodat je wel een slimmere manier moet vinden omdat anders je computer over 25 jaar nog niet klaar is.

Wat ook leuk is, is dat de opdrachten inderdaad meer wiskundige vraagstukken zijn, waardoor je in sommige gevallen helemaal niet hoeft te programmeren, en al helemaal niet gebonden bent aan een bepaalde programmeertaal.

Klopt, maar die met die priemgetallen was voor mij niet te doen. Uiteindelijk het startgetal van de loop verlaagd van sqrt(getal) naar 7000, nadat ik het antwoord had opgezocht. De methode werkt, maar is vanaf 75000 (sqrt dus) niet te doen.

#!/usr/bin/python



import math



def findLargestPrime(theNumber):

    factors = []

    for factor in xrange(1, int(math.sqrt(theNumber)+1)):

        if theNumber % factor == 0:

            nap = 0

            for divider in xrange(2, factor):

                if factor % divider == 0:

                    nap = 1

                    break

            if nap == 0 :

                prime = factor   

        

    return prime

    

print findLargestPrime(600851475143) 

nr.3 in Python

Onoverzichtelijk zo zonder accolades, hehe. Zal wel helemaal drama zijn als er niet ge-indent wordt.

Significant Whitespace!

Verkeerd geïndente code geeft syntax errors.

[edit]Oh ja, en 4 (Brute force natuurlijk)

#!/usr/bin/python



def isPalindrome(theNum):

    theNum = str(theNum)

    partlength = int(len(theNum) / 2)

    if theNum[:partlength] == theNum[-partlength:][::-1]:

        return True

    else :

        return False



def findPalindrome(numberOfDigits):

    num = int("1"+("0"*numberOfDigits))

    largestPalindrome = 0

    for a in xrange(num):

        for b in xrange(num):

            if isPalindrome(a*(num-b)):

                result = (a)*(num-b)

                if result > largestPalindrome:

                    largestPalindrome = result

                    break

            

    return largestPalindrome



print findPalindrome(3)

[Dit bericht is gewijzigd door powertieke op 18-03-2010 17:00]

4 was wel leuk, heb ik zo opgelost:

function problem4(){



	$iCurLargest = 0;

	$iLargest = 999;

	

	while($iLargest > 100){

	

		$iLargest2 = 999;

	

		while($iLargest2 > 100){

		

			$iPalin = ($iLargest * $iLargest2);

			$sPalin = (string)$iPalin;

			$sPalinRev = strrev($sPalin);

		

			if($sPalin == $sPalinRev){



				if($iPalin > $iCurLargest){

				

					$iCurLargest = $iPalin;

					

				}

				

			}

		

			$iLargest2--;

		

		}

		

		$iLargest--;



	}

	

	return $iCurLargest;

	

}

Misschien toch weer een keer Tomcat voor JAVA installeren, want met PHP gaat het allemaal wel erg langzaam. Ben nu met 7 bezig, het 10001e priemgetal vinden. Hij is al een paar minuten bezig, maar m'n code is ongeveer hetzelfde als bijvoorbeeld code in Python die ik vond, maar dat script deed er nog geen seconde over. (???)

function problem7(){



	$aPrimes = array();

	$iCur = 0;

	$i = 1;

	

	while($i < 150000){

	

		$bPrime = TRUE;

		

		for($j = 2; $j < $i; $j++){

		

			if($i <> $j){

		

				$iResult = ($i / $j);

				

			}

			

			if(!is_float($iResult)){

			

				$bPrime = FALSE;

				

			}

		}



		if($bPrime == TRUE){

		

			$iCur++;

			

			if($iCur == 10001){

			

				return $i;

				

			}

		

		}

		

		$i++;

		

	}

}

Die 150000 is overigens een aanname.

Hoe lang deed jou scriptje over 5?

Bij mij in de eerste versie +/-20 sec, in de tweede 1.5 sec