Mathegenie gesucht

Ich wusste sonst nicht wohin damit und glaube hier passt es ganz gut ^^

Also, ich suche jemanden, der mir berechnet an welchem Tag genau -ausgehend vom 13.12.1978- eine Gigasekunde (=10^9 Sekunden ~ 31,7 Jahre) vergangen sind.

Vielelicht gibts auch was als Belohnung g

hi,

(ab heute 10:11) am Mittwoch, dem 8. September 2010, 00:46:40 GMT :slight_smile:

wo Du die Belohnung hinschicken kannst, steht im Impressum von bplaced.net :smiley:

ciao

Ne, passt eigentlich besser in die Relax Zone.

Du musst die Gigasekunde zunaechst in die groesste Einheit zerlegen, also in Jahre - dazu musst du wissen, wieviel Sekunden ein Jahr hat. Danach den Rest, der kein ganzes Jahr mehr darstellt, in Tage zerlegen. Dann kannst du schauen, welcher Tag genau das ist. Einen anderen Weg kenne ich nicht.

Ich uebrigens grad nicht am Computer, sonst haette ich dir das auch gleich ausgerechnet.

hola,

ich hab das eben einfach im kopf gerechnet - studenten können das, die sind nicht normal :ps:

ciao

miro ist ja ein Mathe Genie :ps:

ach, wenn du nur wüsstest, wie ich das gerechnet habe… ich hab die aufgabe einfach dem bplaced hosting cluster gegeben, das ergebnis war in weniger als 0.001sek fertig :ps:

:hammer:

Also doch nicht im Kopf? o.0 :ps:

naja, soweit miro = bplaced zutrifft, schon :smiley:

wollt ich auch grad posten…

na so hab ichs aber nicht gemacht :ps:

long long i = 1000000000;
short sec=0, min=0, hour=0, day=13, month=12, year=1978;

while(i-- > 0)
{
   sec++;
   if(sec >= 60) { sec=0; min++; }
   if(min >= 60) {min=0; hour++; }
   if(hour >= 24) { hour=0; day++; }
   if(day == 28 && month = 2 || day == 30 && !month_has_31(month) || day >= 31) {day=0; month++; }
   if(month > 12) {month=0; year++;}
}

so??? :ps:

näh, in assembler.

wo ist Dr.Thodt eigentlich? :smiley:

Zeig ma Quellcode :ps:

sry, darf ich nicht, ist bestandteil von für-uni-code :ps:

:ps: :hammer:

hab ich auf deinem PC gefunden:

	.file	"test.c"
.globl i
	.data
	.align 8
	.type	i, @object
	.size	i, 8
i:
	.quad	1000000000
.globl sec
	.bss
	.align 2
	.type	sec, @object
	.size	sec, 2
sec:
	.zero	2
.globl min
	.align 2
	.type	min, @object
	.size	min, 2
min:
	.zero	2
.globl hour
	.align 2
	.type	hour, @object
	.size	hour, 2
hour:
	.zero	2
.globl day
	.data
	.align 2
	.type	day, @object
	.size	day, 2
day:
	.value	13
.globl month
	.align 2
	.type	month, @object
	.size	month, 2
month:
	.value	12
.globl year
	.align 2
	.type	year, @object
	.size	year, 2
year:
	.value	1978
	.text
.globl month_has_31
	.type	month_has_31, @function
month_has_31:
.LFB2:
	pushq	%rbp
.LCFI0:
	movq	%rsp, %rbp
.LCFI1:
	movw	%di, -4(%rbp)
	cmpw	$0, -4(%rbp)
	jne	.L2
	cmpw	$7, -4(%rbp)
	jle	.L3
.L2:
	movzwl	-4(%rbp), %eax
	movzwl	%ax, %eax
	andl	$1, %eax
	xorl	$1, %eax
	testb	%al, %al
	jne	.L4
	cmpw	$7, -4(%rbp)
	jle	.L4
.L3:
	movw	$1, -6(%rbp)
	jmp	.L5
.L4:
	movw	$0, -6(%rbp)
.L5:
	movzwl	-6(%rbp), %eax
	leave
	ret
.LFE2:
	.size	month_has_31, .-month_has_31
	.section	.rodata
.LC0:
	.string	"%i.%i.%i %i:%i:%i"
	.text
.globl main
	.type	main, @function
main:
.LFB3:
	pushq	%rbp
.LCFI2:
	movq	%rsp, %rbp
.LCFI3:
	subq	$16, %rsp
.LCFI4:
	jmp	.L8
.L16:
	movzwl	sec(%rip), %eax
	addl	$1, %eax
	movw	%ax, sec(%rip)
	movzwl	sec(%rip), %eax
	cmpw	$59, %ax
	jle	.L9
	movw	$0, sec(%rip)
	movzwl	min(%rip), %eax
	addl	$1, %eax
	movw	%ax, min(%rip)
.L9:
	movzwl	min(%rip), %eax
	cmpw	$59, %ax
	jle	.L10
	movw	$0, min(%rip)
	movzwl	hour(%rip), %eax
	addl	$1, %eax
	movw	%ax, hour(%rip)
.L10:
	movzwl	hour(%rip), %eax
	cmpw	$23, %ax
	jle	.L11
	movw	$0, hour(%rip)
	movzwl	day(%rip), %eax
	addl	$1, %eax
	movw	%ax, day(%rip)
.L11:
	movzwl	day(%rip), %eax
	cmpw	$28, %ax
	jne	.L12
	movzwl	month(%rip), %eax
	cmpw	$2, %ax
	je	.L13
.L12:
	movzwl	day(%rip), %eax
	cmpw	$30, %ax
	jne	.L14
	movzwl	month(%rip), %eax
	movswl	%ax,%edi
	call	month_has_31
	testw	%ax, %ax
	je	.L13
.L14:
	movzwl	day(%rip), %eax
	cmpw	$30, %ax
	jle	.L15
.L13:
	movw	$0, day(%rip)
	movzwl	month(%rip), %eax
	addl	$1, %eax
	movw	%ax, month(%rip)
.L15:
	movzwl	month(%rip), %eax
	cmpw	$12, %ax
	jle	.L8
	movw	$0, month(%rip)
	movzwl	year(%rip), %eax
	addl	$1, %eax
	movw	%ax, year(%rip)
.L8:
	movq	i(%rip), %rax
	testq	%rax, %rax
	setg	%dl
	subq	$1, %rax
	movq	%rax, i(%rip)
	testb	%dl, %dl
	jne	.L16
	movzwl	sec(%rip), %eax
	movswl	%ax,%r8d
	movzwl	min(%rip), %eax
	movswl	%ax,%edx
	movzwl	hour(%rip), %eax
	movswl	%ax,%ecx
	movzwl	year(%rip), %eax
	movswl	%ax,%esi
	movzwl	month(%rip), %eax
	movswl	%ax,%edi
	movzwl	day(%rip), %eax
	cwtl
	movl	%r8d, (%rsp)
	movl	%edx, %r9d
	movl	%ecx, %r8d
	movl	%esi, %ecx
	movl	%edi, %edx
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	leave
	ret
.LFE3:
	.size	main, .-main
	.section	.eh_frame,"a",@progbits
.Lframe1:
	.long	.LECIE1-.LSCIE1
.LSCIE1:
	.long	0x0
	.byte	0x1
	.string	"zR"
	.uleb128 0x1
	.sleb128 -8
	.byte	0x10
	.uleb128 0x1
	.byte	0x3
	.byte	0xc
	.uleb128 0x7
	.uleb128 0x8
	.byte	0x90
	.uleb128 0x1
	.align 8
.LECIE1:
.LSFDE1:
	.long	.LEFDE1-.LASFDE1
.LASFDE1:
	.long	.LASFDE1-.Lframe1
	.long	.LFB2
	.long	.LFE2-.LFB2
	.uleb128 0x0
	.byte	0x4
	.long	.LCFI0-.LFB2
	.byte	0xe
	.uleb128 0x10
	.byte	0x86
	.uleb128 0x2
	.byte	0x4
	.long	.LCFI1-.LCFI0
	.byte	0xd
	.uleb128 0x6
	.align 8
.LEFDE1:
.LSFDE3:
	.long	.LEFDE3-.LASFDE3
.LASFDE3:
	.long	.LASFDE3-.Lframe1
	.long	.LFB3
	.long	.LFE3-.LFB3
	.uleb128 0x0
	.byte	0x4
	.long	.LCFI2-.LFB3
	.byte	0xe
	.uleb128 0x10
	.byte	0x86
	.uleb128 0x2
	.byte	0x4
	.long	.LCFI3-.LCFI2
	.byte	0xd
	.uleb128 0x6
	.align 8

ich bitte dich, dafür gäbs doch punkteabzüge ohne ende :ps:

:hammer: