individuelle Zahl x mal erneut um 1 erhöhen

[DasIch]

Vergiss dass es input gibt, list ist ein Built-in dass du nicht überschreiben willst/solltest.
Statt range nimm doch gleich xrange welches einen Iterator zurückliefert, dass ist schneller und solange du die Liste nicht brauchst imho die bessere Lösung.

Desweiteren ist `a` und Zeile 8 völlig überflüssig.

EDIT: Mist zu spät

[EyDu]

Ach mist, da habe ich wieder die offensichtliche Lösung vergessen:

Code: Alles auswählen

(lambda f, b, x: f(f,b,x))(lambda f, b, x: x and b+x+f(f, b, x-1)-1, int(raw_input("base:")), int(raw_input("x:")))

[veers]

Und noch eine..

Code: Alles auswählen

a = int(raw_input())
b = int(raw_input())
c = b-1
print a*b+ (c+1)*(c/2)+(c%2*((c/2)+1))

[yipyip]

Hab' auch noch einen...

Code: Alles auswählen

def adder(a, i, acc=()):

  if i >= 0:
    return adder(a, i-1, acc=((a, i),) + acc)
  else:
    return acc

a = int(raw_input('a? '))
i = int(raw_input('i? '))
print sum(a + i for a, i in adder(a, i-1))

yipyip

[Darii]

Warum benutzt eigentlich niemand einen Generator?

Code: Alles auswählen

def calc(x, y):
    while y:
        y -= 1
        yield x + y

x = int(raw_input('x := '))
y = int(raw_input('y := '))

print sum(calc(x, y))

[audax]

in meiner Lösung tu ich das. Ich benutz auch wirklich nur Generatoren

[Darii]

Ja ist klar yipyip tut das ja auch, ist aber noch lange kein Grund yield zu verschmähen.

[EyDu]

Man kann das Problem natürlich auch geometrisch auffassen:

Code: Alles auswählen

a = int(raw_input("Vorhanden: "))
n = int(raw_input("Benoetigt: "))

print n*(2*a+n-1)/2

[audax]

Ja ist klar yipyip tut das ja auch, ist aber noch lange kein Grund yield zu verschmähen.

Du baust allerdings nur xrange nach

@Ey:
Endlich mal ein ordentlicher Ansatz

[name]

Hier hätten wir mal die Lösung in Haskell. Wobei 150 die Zahl ist und 5 die Wiederholungen.

Code: Alles auswählen

sum (take 5 [150..])

Bzw als Funktion:

Code: Alles auswählen

foo x y = sum (take x [y..])

In Python hätt ichs so gemacht:

Code: Alles auswählen

x, y = (150, 5)
sum(xrange(x, x+y))

[BlackJack]

In Io:

Code: Alles auswählen

foo := method(x, y, x to(x + y - 1) asList sum)

[yipyip]

In Prolog:

Code: Alles auswählen

adder_acc(A, 0, 0).
adder_acc(A, N, A+M+REST) :-
    N > 0,
    M is N-1,
    adder_acc(A, M, REST).

adder(A, N, RESULT) :-
    adder_acc(A, N, M),
    RESULT is M.

yipyip

[BlackJack]

Da füge ich mal noch Scheme hinzu:

Code: Alles auswählen

(define (foo a b) (if (= b 0) 0 (+ a (foo (+ a 1) (- b 1)))))

Edit: Assembler (NASM-Format):

Code: Alles auswählen

; extern unsigned int foo(unsigned int a, int b);
global	foo
foo:
	mov	eax, [esp+4]
	shl	eax, 1
	dec	eax
	mov	ebx, [esp+8]
	add	eax, ebx
	mul	ebx
	shr	eax, 1
.return:
	ret

Edit2: Assemblerquelltext durch Variante ohne Schleife ersetzt.