Programmeerprobleem

[jhnbk]

okay, nu mijn versie van het digit probleem in python

Code: Selecteer alles

def digit(getal,i):

	if i==1:

		return getal%10

	else:

		return digit(getal/10,i-1)

@CloudedHeaven: lijkt mij correct, maar wilt ni compileren bij mij

[jhnbk]

in haskell, maar dat heb ik nu even bekeken hoe het moet dus ben ik niet zeker

Code: Selecteer alles

digit getal i | i==1 = getal 'mod' 10

 | i>1 = digit(getal 'div' 10, i-1)

@Mods: plaats mijn berichten maar samen, edit ging niet meer

[CloudedHeaven]

Code: Selecteer alles

def digit(getal,i):

	if i==1:

		return getal%10

	else:

		return digit(getal/10,i-1)

Ik moest er ff over denken, maar eleganter zal het wel niet opgelost kunnen worden

[jhnbk]

recursief is altijd mooi

wie iets eleganter vindt moet het zeker posten

[qrnlk]

Eleganter dan een tail recursion? Ik kan me het niet voorstellen.

[EvilBro]

De Haskell code werkt niet. Tevens was ik benieuwd naar een versie die het probleem volledig oplost (dus niet alleen hoe je een digit uit een 5 cijferig getal krijgt). Ik zal even een overdreven Java variant geven:

Code: Selecteer alles

public class Test {

public static void main(String[] args) {

Test anObject = new Test();

System.out.println("Start");

anObject.printNumbers();

System.out.println("End");

}

private void printNumbers() {

for (int number = 10000; number < 100000; number++) {

int[] digits = splitNumberIntoDigits(number);

if (noZeros(digits) &&

noDuplicates(digits) &&

firstDigitCondition(digits) &&

secondDigitCondition(digits) &&

thirdDigitCondition(digits) &&

fourthDigitCondition(digits) &&

fifthDigitCondition(digits)) {

System.out.println("A hit: " + number);

}

}

}

private int[] splitNumberIntoDigits(int number) {

int[] digits = new int[5];

String aNumberString = new Integer(number).toString();

for (int i = 0; i < 5; i++) {

digits[i] = Integer.parseInt("" + aNumberString.charAt(i));

}

return digits;

}

private boolean noZeros(int[] digits) {

for (int i = 0; i < 5; i++) {

if (digits[i] == 0) {

return false;

}

}

return true;

}

private boolean noDuplicates(int[] digits) {

for (int i = 0; i < 4; i++) {

for (int j = i + 1; j < 5; j++) {

if (digits[i] == digits[j]) {

return false;

}

}

}

return true;

}

private boolean firstDigitCondition(int[] digits) {

if (isPrime(digits[0])) {

return true;

}

return false;

}

private boolean isPrime(int number) {

if (number < 2) {

return false;

}

for (int i = 2; i < number; i++) {

if (number % i == 0) {

return false;

}

}

return true;

}

private boolean secondDigitCondition(int[] digits) {

return (digits[1] == digits[4] - digits[0]);

}

private boolean thirdDigitCondition(int[] digits) {

return (digits[2] == 2 * digits[0]);

}

private boolean fourthDigitCondition(int[] digits) {

return (digits[3] == digits[2] + 3);

}

private boolean fifthDigitCondition(int[] digits) {

return (digits[4] == Math.abs(digits[0] - digits[3]));

}

}

[jhnbk]

Eleganter dan een tail recursion? Ik kan me het niet voorstellen.

ken ik niet, kun je ene link geven met een voorbeeld?

mijn oplossing voor het probleem in python

Code: Selecteer alles

for a in [2,3,5,7]:

for b in range(1,10):

for c in range(1,10):

for d in range(1,10):

for e in range(1,10):

#a is juist

if b==e-a and c==2*a and d==c+3 and e==d-a:

solution=[a,b,c,d,e]

solution.sort()

double=False

for i in range(5):

try:

if solution[i]==solution[i-1]:

double=True

break

except IndexError:

pass

if double==False:

print a,b,c,d,e

geeft als oplossing

23475

[qrnlk]

http://en.wikipedia.org/wiki/Tail_recursion

Mooie oplossing in python.

[EvilBro]

mijn oplossing voor het probleem in python

Ik denk dat het de bedoeling is om alle getallen tussen 9999 en 100000 te evalueren (niet alleen de mogelijke getallen). Priemgetallen 'voorzeggen' vind ik ook valsspelen...

Code: Selecteer alles

cout << "23475";

[jhnbk]

Mooie oplossing in python.

thx

die tail recursion is wel interessant, maar vermits ik programmeren zelf heb geleerd ben ik daar niet veel mee

edit: @EvilBro: ik zal direct mijn vals gespeel rechtzetten

voila

Code: Selecteer alles

def digit(getal,i):

if i==1:

return getal%10

else:

return digit(getal/10,i-1)

for getal in range(10000,100000):

e=digit(getal,1)

d=digit(getal,2)

c=digit(getal,3)

b=digit(getal,4)

a=digit(getal,5)

if b==e-a and c==2*a and d==c+3 and e==d-a and a in [2,3,5,7]:

solution=[a,b,c,d,e]

solution.sort()

double=False

for i in range(5):

try:

if solution[i]==solution[i-1]:

double=True

break

except IndexError:

pass

if double==False:

print a,b,c,d,e

kan sneller door direct een lijst te gebruiken (was te lui, ik wou copy paste doen)

uiteraard is de vorige code sneller

uiteraard speel ik nog vals met die priemgetallen

Code: Selecteer alles

def ispriem(getal):

if getal==1:

return False

for i in range(2,getal):

if getal%i==0:

return False

return True

is beter, en snel genoeg voor getal<10

[qrnlk]

Ik ben vandaag echter de hele dag aan het programmeren geweest in ruby dus mogelijk dat ik ze zie vliegen nu maar volgens mij die try ... except er uit halen als je range(4) doet en de test over solution == solution[i+1] tenminste ik denk dat de reden is dat je een -1 element probeert te gebruiken?

wat doet range(n)?

[Schwartz]

Ben druk bezig om in APRAS de compiler te herschrijven die uitgebracht kan worden.

Maar er moet dan ook een HTM editor komen die foutloos werkt en die ik erbij kan leveren.

Ik wil zelf ook nog een editor erbij maken waarbij men de routinen kan dichtklappen zoals vroeger bij de ATARI GFA basic.

Ik moet alles alleen doen en het is mijn hobby , dus geen haast mee.

Als je leuke routinen in pascal erbij wilt hebben kun je ze gerust naar mijn email zenden.

Wel getest en 100% goed werkend, en geen onnodig recursieve toestanden die de snelheid van een routine eruit haalt.

Ik had een keer een routine die ik na enige aanpassing 20 keer sneller kon laten functioneren.

En goed van remarks voorzien zodat ik weet wat er allemaal gaande is.

En geen verwijzingen naar andere routinen die er niet bij geleverd worden.

Ik ben vooral op zoek naar routinen inzake natuurkunde, ingenieursvakken etc.

(alleen de simpele die vaak voorkomen)

[EvilBro]

@jhnbk: Ik kan niet ontdekken waar je controleert dat een oplossing geen nullen bevat. Of doe je dit niet en heb je de mazzel dat de rest van de voorwaarden al deze mogelijke oplossingen al uitsluiten?

@qrnlk: Google?

[qrnlk]

@qrnlk: Google?

lui en moe

[jhnbk]

@qrnlk: je hebt uiteraard gelijk, ik heb niet goed nagedacht

wat doet range? enkele voorbeelden:

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(1,5)

[1, 2, 3, 4]

>>> range(1,10,2)

[1, 3, 5, 7, 9]

>>> range(10,1,-2)

[10, 8, 6, 4, 2]

>>>

@EvilBro: mijn 1e oplossing hield daar rekening mee, mijn 2de eigenlijk onrechtstreeks (0 kan daar volgens mij niet)