Data commit
This commit is contained in:
Ingy döt Net
parent
7387c8f97b
commit
cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
2
Task/Hofstadter-Q-sequence/00-META.yaml
Normal file
2
Task/Hofstadter-Q-sequence/00-META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
from: http://rosettacode.org/wiki/Hofstadter_Q_sequence
|
||||
22
Task/Hofstadter-Q-sequence/00-TASK.txt
Normal file
22
Task/Hofstadter-Q-sequence/00-TASK.txt
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
The [[wp:Hofstadter_sequence#Hofstadter_Q_sequence|Hofstadter Q sequence]] is defined as:
|
||||
<big>
|
||||
:: <math>\begin{align}
|
||||
Q(1)&=Q(2)=1, \\
|
||||
Q(n)&=Q\big(n-Q(n-1)\big)+Q\big(n-Q(n-2)\big), \quad n>2.
|
||||
\end{align}</math>
|
||||
</big>
|
||||
|
||||
It is defined like the [[Fibonacci sequence]], but whereas the next term in the Fibonacci sequence is the sum of the previous two terms, in the Q sequence the previous two terms tell you how far to go back in the Q sequence to find the two numbers to sum to make the next term of the sequence.
|
||||
|
||||
|
||||
;Task:
|
||||
* Confirm and display that the first ten terms of the sequence are: 1, 1, 2, 3, 3, 4, 5, 5, 6, and 6
|
||||
* Confirm and display that the 1000<sup>th</sup> term is: 502
|
||||
|
||||
|
||||
;Optional extra credit
|
||||
* Count and display how many times a member of the sequence is less than its preceding term for terms up to and including the 100,000<sup>th</sup> term.
|
||||
* Ensure that the extra credit solution ''safely'' handles being initially asked for an '''n'''<sup>th</sup> term where '''n''' is large.
|
||||
<br>(This point is to ensure that caching and/or recursion limits, if it is a concern, is correctly handled).
|
||||
<br><br>
|
||||
|
||||
15
Task/Hofstadter-Q-sequence/11l/hofstadter-q-sequence.11l
Normal file
15
Task/Hofstadter-Q-sequence/11l/hofstadter-q-sequence.11l
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
V qseq = [0] * 100001
|
||||
qseq[1] = 1
|
||||
qseq[2] = 1
|
||||
|
||||
L(i) 3 .< qseq.len
|
||||
qseq[i] = qseq[i - qseq[i-1]] + qseq[i - qseq[i-2]]
|
||||
|
||||
print(‘The first 10 terms are: ’qseq[1..10].map(q -> String(q)).join(‘, ’))
|
||||
print(‘The 1000'th term is ’qseq[1000])
|
||||
|
||||
V less_than_preceding = 0
|
||||
L(i) 2 .< qseq.len
|
||||
I qseq[i] < qseq[i-1]
|
||||
less_than_preceding++
|
||||
print(‘Times a member of the sequence is less than its preceding term: ’less_than_preceding)
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
* Hofstrader q sequence for any n - 18/10/2015
|
||||
HOFSTRAD CSECT
|
||||
USING HOFSTRAD,R15 set base register
|
||||
MVC Q,=F'1' q(1)=1
|
||||
MVC Q+4,=F'1' q(2)=1
|
||||
LA R4,1 i=1
|
||||
LOOPI C R4,N do i=1 to n
|
||||
BH ELOOPI
|
||||
C R4,=F'3' if i>=3 then
|
||||
BL NOTREC
|
||||
LR R1,R4 i
|
||||
SLA R1,2 i*4
|
||||
L R2,Q-8(R1) q(i-1)
|
||||
LR R1,R4 i
|
||||
SR R1,R2 i-q(i-1)
|
||||
SLA R1,2 *4
|
||||
L R2,Q-4(R1) r2=q(i-q(i-1))
|
||||
LR R1,R4 i
|
||||
SLA R1,2 i*4
|
||||
L R3,Q-12(R1) q(i-2)
|
||||
LR R1,R4 i
|
||||
SR R1,R3 i-q(i-2)
|
||||
SLA R1,2 *4
|
||||
L R3,Q-4(R1) r3=q(i-q(i-2))
|
||||
AR R2,R3 r2=r2+r3
|
||||
LR R1,R4 i
|
||||
SLA R1,2 i*4
|
||||
ST R2,Q-4(R1) q(i)=q(i-q(i-1))+q(i-q(i-2))
|
||||
NOTREC C R4,=F'10' if i<=10
|
||||
BNH PRT
|
||||
C R4,N or i=n then
|
||||
BNE NOPRT
|
||||
PRT XDECO R4,XD edit i
|
||||
MVC PG+2(4),XD+8 output i
|
||||
LR R1,R4 i
|
||||
SLA R1,2 i*4
|
||||
L R2,Q-4(R1) q(i)
|
||||
XDECO R2,XD edit q(i)
|
||||
MVC PG+10(4),XD+8 output q(i)
|
||||
XPRNT PG,80 print buffer
|
||||
NOPRT LA R4,1(R4) i=i+1
|
||||
B LOOPI
|
||||
ELOOPI XR R15,R15 set return code
|
||||
BR R14 return to caller
|
||||
PG DC CL80'n=...., q=....' buffer
|
||||
XD DS CL12 temporary variable
|
||||
LTORG insert literals for addressability
|
||||
N DC F'1000' n=1000
|
||||
Q DS 1000F array q(1000)
|
||||
YREGS
|
||||
END HOFSTRAD
|
||||
|
|
@ -0,0 +1,122 @@
|
|||
puts: equ 9 ; CP/M call to print a string
|
||||
org 100h
|
||||
;;; Generate the first 1000 members of the Q sequence
|
||||
lxi b,3 ; Start at 3rd element (1 and 2 already defined)
|
||||
genq: dcx b ; BC = N-1
|
||||
call q
|
||||
mov e,m ; DE = Q(N-1)
|
||||
inx h
|
||||
mov d,m
|
||||
inx b ; BC = (N-1)+1 = N
|
||||
xchg ; HL = Q(N-1)
|
||||
call neg ; HL = -Q(N-1)
|
||||
dad b ; HL = N-Q(N-1)
|
||||
push b ; Keep N
|
||||
mov b,h ; BC = N-Q(N-1)
|
||||
mov c,l
|
||||
call q ; HL = *Q(N-Q(N-1))
|
||||
mov e,m ; DE = Q(N-Q(N-1))
|
||||
inx h
|
||||
mov d,m
|
||||
pop b ; Restore N
|
||||
push d ; push Q(N-Q(N-1))
|
||||
dcx b ; BC = N-2
|
||||
dcx b
|
||||
call q ; DE = Q(N-2)
|
||||
mov e,m
|
||||
inx h
|
||||
mov d,m
|
||||
inx b ; BC = (N-2)+2 = N
|
||||
inx b
|
||||
xchg ; HL = Q(N-2)
|
||||
call neg ; HL = -Q(N-2)
|
||||
dad b ; HL = N-Q(N-2)
|
||||
push b ; Keep N
|
||||
mov b,h ; BC = N-Q(N-2)
|
||||
mov c,l
|
||||
call q ; HL = *Q(N-Q(N-2))
|
||||
mov a,m ; HL = Q(N-Q(N-2))
|
||||
inx h
|
||||
mov h,m
|
||||
mov l,a
|
||||
pop b ; Restore N
|
||||
pop d ; pop Q(N-Q(N-1))
|
||||
dad d ; HL = Q(N-Q(N-1))+Q(N-Q(N-2))
|
||||
xchg ; DE = Q(N-Q(N-1))+Q(N-Q(N-2))
|
||||
call q ; HL = *Q(N)
|
||||
mov m,e ; Store Q(N)
|
||||
inx h
|
||||
mov m,d
|
||||
inx b ; N = N+1
|
||||
lxi h,-1001
|
||||
dad b ; Are we there yet?
|
||||
jnc genq
|
||||
;;; Print first 10 terms
|
||||
lxi d,m10
|
||||
mvi c,puts
|
||||
call 5
|
||||
lxi b,1 ; Start at term 1
|
||||
mvi d,10 ; 10 terms
|
||||
p10: push b ; Save counters
|
||||
push d
|
||||
call prterm ; Print current term
|
||||
pop d ; Restore counters
|
||||
pop b
|
||||
inx b ; Next term
|
||||
dcr d ; Repeat 10 times
|
||||
jnz p10
|
||||
;;; Print 1000th term
|
||||
lxi d,m1000
|
||||
mvi c,puts
|
||||
call 5
|
||||
lxi b,1000 ; 1000th term
|
||||
;;; Print Q(BC)
|
||||
prterm: call q ; Load term into HL
|
||||
mov a,m
|
||||
inx h
|
||||
mov h,m
|
||||
mov l,a
|
||||
lxi b,num ; Push pointer to end of number buffer
|
||||
push b
|
||||
lxi b,-10 ; Divisor
|
||||
dgt: lxi d,-1 ; Quotient
|
||||
divlp: inx d
|
||||
dad b
|
||||
jc divlp
|
||||
mvi a,'0'+10
|
||||
add l ; Make ASCII digit
|
||||
pop h ; Get pointer
|
||||
dcx h
|
||||
mov m,a ; Store digit
|
||||
push h
|
||||
xchg ; HL = next quotient
|
||||
mov a,h ; More digits?
|
||||
ora l
|
||||
jnz dgt
|
||||
pop d ; Print string
|
||||
mvi c,puts
|
||||
jmp 5
|
||||
;;; Set HL = -HL
|
||||
neg: dcx h
|
||||
mov a,h
|
||||
cma
|
||||
mov h,a
|
||||
mov a,l
|
||||
cma
|
||||
mov l,a
|
||||
ret
|
||||
;;; Set HL to memory location of Q(BC)
|
||||
q: push d ; Keep DE
|
||||
mov h,b ; HL = 2*(BC-1)
|
||||
mov l,c
|
||||
dcx h
|
||||
dad h
|
||||
lxi d,qq ; Add to start of sequence
|
||||
dad d
|
||||
pop d
|
||||
ret
|
||||
m10: db 'The first 10 terms are: $'
|
||||
m1000: db 13,10,'The 1000th term is: $'
|
||||
db '*****' ; Placeholder for number
|
||||
num: db ' $'
|
||||
qq: dw 1,1 ; Q sequence stored here, starting with 1, 1
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
puts: equ 9 ; MS-DOS syscall to print a string
|
||||
cpu 8086
|
||||
org 100h
|
||||
section .text
|
||||
;;; Generate first 1000 elements of Q sequence
|
||||
mov dx,3 ; DX = N
|
||||
mov di,Q+4 ; DI = place to store elements
|
||||
mov cx,998 ; Generate 998 more terms
|
||||
genq: mov si,dx ; SI = N
|
||||
sub si,[di-2] ; SI -= Q[N-1]
|
||||
mov bp,dx ; BP = N
|
||||
sub bp,[di-4] ; BP -= Q[N-2]
|
||||
dec si ; SI = 2*(SI-1) (0-indexed, 2 bytes/term)
|
||||
shl si,1
|
||||
dec bp ; Same for BP
|
||||
shl bp,1
|
||||
mov ax,[si+Q] ; Load Q[n-Q[n-1]]
|
||||
add ax,[bp+Q] ; Add Q[n-Q[n-2]]
|
||||
stosw ; Store as Q[n]
|
||||
inc dx ; Increment N
|
||||
loop genq
|
||||
;;; Print first 10 elements
|
||||
mov ah,puts
|
||||
mov dx,m10
|
||||
int 21h
|
||||
mov cx,10
|
||||
mov bx,1
|
||||
p10: call prterm
|
||||
inc bx
|
||||
loop p10
|
||||
;;; Print 1000th element
|
||||
mov ah,puts
|
||||
mov dx,m1000
|
||||
int 21h
|
||||
mov bx,1000
|
||||
;;; Print the term in BX
|
||||
prterm: push bx ; Save term
|
||||
dec bx
|
||||
shl bx,1
|
||||
mov ax,[bx+Q] ; Load term into AX
|
||||
mov bp,10 ; Divisor
|
||||
mov bx,num ; Number buffer pointer
|
||||
.dgt: xor dx,dx
|
||||
div bp ; Divide number by 10
|
||||
dec bx
|
||||
add dl,'0' ; DX = remainder, add '0'
|
||||
mov [bx],dl ; Stored digit
|
||||
test ax,ax ; Done yet?
|
||||
jnz .dgt ; If not, find next digit
|
||||
mov dx,bx ; Print the number
|
||||
mov ah,puts
|
||||
int 21h
|
||||
pop bx ; Restore term
|
||||
ret
|
||||
section .data
|
||||
m10: db 'First 10 terms are: $'
|
||||
m1000: db 13,10,'1000th term is: $'
|
||||
db '*****' ; Number placeholder
|
||||
num: db ' $'
|
||||
Q: dw 1,1
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#!/usr/local/bin/a68g --script #
|
||||
|
||||
INT n = 100000;
|
||||
main:
|
||||
(
|
||||
INT flip;
|
||||
[n]INT q;
|
||||
|
||||
q[1] := q[2] := 1;
|
||||
|
||||
FOR i FROM 3 TO n DO
|
||||
q[i] := q[i - q[i - 1]] + q[i - q[i - 2]] OD;
|
||||
|
||||
FOR i TO 10 DO
|
||||
printf(($g(0)$, q[i], $b(l,x)$, i = 10)) OD;
|
||||
|
||||
printf(($g(0)l$, q[1000]));
|
||||
|
||||
flip := 0;
|
||||
FOR i TO n-1 DO
|
||||
flip +:= ABS (q[i] > q[i + 1]) OD;
|
||||
|
||||
printf(($"flips: "g(0)l$, flip))
|
||||
)
|
||||
14
Task/Hofstadter-Q-sequence/ALGOL-M/hofstadter-q-sequence.alg
Normal file
14
Task/Hofstadter-Q-sequence/ALGOL-M/hofstadter-q-sequence.alg
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
begin
|
||||
integer array Q[1:1000];
|
||||
integer n;
|
||||
|
||||
Q[1] := Q[2] := 1;
|
||||
for n := 3 step 1 until 1000 do
|
||||
Q[n] := Q[n-Q[n-1]] + Q[n-Q[n-2]];
|
||||
|
||||
write("The first 10 terms are:");
|
||||
write("");
|
||||
for n := 1 step 1 until 10 do writeon(Q[n]);
|
||||
|
||||
write("The 1000th term is:", Q[1000]);
|
||||
end
|
||||
39
Task/Hofstadter-Q-sequence/ALGOL-W/hofstadter-q-sequence.alg
Normal file
39
Task/Hofstadter-Q-sequence/ALGOL-W/hofstadter-q-sequence.alg
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
begin % find elements of the Hofstader Q sequence Q(1) = Q(2) = 1 %
|
||||
% Q(n) = Q( n - Q( n - 1 ) ) + Q( n - Q( n - 2 ) ) for n > 2 %
|
||||
integer MAX_Q;
|
||||
max_Q := 100000;
|
||||
begin
|
||||
integer array Q ( 1 :: MAX_Q );
|
||||
integer array xQ ( 1 :: 10 );
|
||||
integer ltCount;
|
||||
logical valuesOk;
|
||||
% expected values of the first 10 elements %
|
||||
xQ( 1 ) := xQ( 2 ) := 1;
|
||||
xQ( 3 ) := 2; xQ( 4 ) := xQ( 5 ) := 3; xQ( 6 ) := 4;
|
||||
xQ( 7 ) := xQ( 8 ) := 5; xQ( 9 ) := xQ( 10 ) := 6;
|
||||
% calculate the sequence and count how often Q( n ) < Q( n - 1 ) %
|
||||
ltCount := 0;
|
||||
Q( 1 ) := Q( 2 ) := 1;
|
||||
for n := 3 until MAX_Q do begin
|
||||
Q( n ) := Q( n - Q( n - 1 ) ) + Q( n - Q( n - 2 ) );
|
||||
if Q( n ) < Q( n - 1 ) then ltCount := ltCount + 1
|
||||
end for_n ;
|
||||
valuesOk := true;
|
||||
write( "The first 10 terms of the Hofstader Q sequence:" );
|
||||
for i := 1 until 10 do begin
|
||||
writeon( i_w := 1, s_w := 0, " ", Q( i ) );
|
||||
if Q( i ) not = xQ( i ) then begin
|
||||
writeon( i_w := 1, s_w := 0, "-EXPECTED-", xQ( i ) );
|
||||
valuesOk := false
|
||||
end if_Q_i_ne_xQ_i
|
||||
end for_i ;
|
||||
write( i_w := 1, s_w := 0, "The 1000th term is: ", Q( 1000 ) );
|
||||
if Q( 1000 ) not = 502 then begin
|
||||
writeon( "-EXPECTED-502" );
|
||||
valuesOk := false
|
||||
end if_Q_100_ne_502 ;
|
||||
if valuesOk then write( " (Computed values are as expected)" )
|
||||
else write( "Values NOT as expected" );
|
||||
write( i_w := 1, s_w := 0, "Q(n) < Q(n-1) ", ltCount," times for n up to ", MAX_Q )
|
||||
end
|
||||
end.
|
||||
8
Task/Hofstadter-Q-sequence/APL/hofstadter-q-sequence.apl
Normal file
8
Task/Hofstadter-Q-sequence/APL/hofstadter-q-sequence.apl
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
∇ Q_sequence;seq;size
|
||||
size←100000
|
||||
seq←{⍵,+/⍵[(1+⍴⍵)-¯2↑⍵]}⍣(size-2)⊢1 1
|
||||
|
||||
⎕←'The first 10 terms are:', seq[⍳10]
|
||||
⎕←'The 1000th term is:', seq[1000]
|
||||
⎕←(+/ 2>/seq),'terms were preceded by a larger term.'
|
||||
∇
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
.text
|
||||
.global _start
|
||||
_start: ldr r6,=qs @ R6 = base register for Q array
|
||||
@@@ Write first 2 elements
|
||||
mov r0,#1 @ Q(1) and Q(2) are 1
|
||||
strh r0,[r6,#4]
|
||||
strh r0,[r6,#8]
|
||||
@@@ Generate 100 thousand elements
|
||||
mov r1,#0x86A0
|
||||
movt r1,#1 @ 0x186A0 = 100.000
|
||||
mov r0,#3 @ Starting at element 3
|
||||
1: sub r2,r0,#1 @ r2 = n-1
|
||||
ldr r2,[r6,r2,lsl#2] @ r2 = Q[r2]
|
||||
sub r2,r0,r2 @ r2 = n-Q[r2]
|
||||
ldr r2,[r6,r2,lsl#2] @ r2 = Q[r2]
|
||||
sub r3,r0,#2 @ r3 = n-2
|
||||
ldr r3,[r6,r3,lsl#2] @ r3 = Q[r3]
|
||||
sub r3,r0,r3 @ r3 = n-Q[r3]
|
||||
ldr r3,[r6,r3,lsl#2] @ r3 = Q[r3]
|
||||
add r2,r2,r3 @ r2 += r3
|
||||
str r2,[r6,r0,lsl#2] @ Q[n] = r2
|
||||
add r0,r0,#1 @ n++
|
||||
cmp r0,r1
|
||||
bls 1b @ If r0<=r1, generate next
|
||||
@@@ Print first 10 elements
|
||||
ldr r1,=f10m
|
||||
bl pstr
|
||||
mov r8,#1 @ Start at element 1
|
||||
1: ldr r0,[r6,r8,lsl#2] @ Grab current element
|
||||
bl pnum @ Print it
|
||||
ldr r1,=space @ Print a space
|
||||
bl pstr
|
||||
add r8,r8,#1
|
||||
cmp r8,#10 @ Keep going until 10 elements printed
|
||||
bls 1b
|
||||
ldr r1,=nl @ Print newline
|
||||
bl pstr
|
||||
@@@ Print 1000th element
|
||||
ldr r1,=f1000m
|
||||
bl pstr
|
||||
mov r8,#1000 @ Grab 1000th element
|
||||
ldr r0,[r6,r8,lsl#2]
|
||||
bl pnum
|
||||
ldr r1,=nl @ Print newline
|
||||
bl pstr
|
||||
@@@ Find how many times a member is less than its preceding term
|
||||
mov r0,#0 @ counter
|
||||
mov r1,#0x86A0 @ max element
|
||||
movt r1,#1
|
||||
mov r2,#1 @ value of previous element
|
||||
mov r3,#2 @ number of current element
|
||||
2: ldr r4,[r6,r3,lsl#2] @ get value of current element
|
||||
cmp r2,r4 @ if previous more than current
|
||||
addhi r0,r0,#1 @ then increment counter
|
||||
mov r2,r4 @ current el is now prevous el
|
||||
add r3,r3,#1 @ increment element index
|
||||
cmp r3,r1 @ are we there yet?
|
||||
bls 2b @ if not, keep going
|
||||
bl pnum @ otherwise, print the number
|
||||
ldr r1,=ltermm @ and the corresponding message
|
||||
bl pstr
|
||||
mov r0,#0 @ and then exit
|
||||
mov r7,#1
|
||||
swi #0
|
||||
@@@ Print a length-prefixed string (in r1)
|
||||
pstr: push {r7,lr} @ Save syscall and link registers
|
||||
mov r0,#1 @ 1 = stdout
|
||||
ldrb r2,[r1],#1 @ Get length and advance r1
|
||||
mov r7,#4 @ Write
|
||||
swi #0
|
||||
pop {r7,pc}
|
||||
@@@ Print unsigned number in r0 using Linux
|
||||
pnum: push {r7,lr} @ Save syscall and link registers
|
||||
ldr r7,=qs @ May as well use R7 as buffer pointer
|
||||
1: mov r1,#10 @ Div-mod by 10
|
||||
bl divmod
|
||||
add r1,r1,#'0 @ This makes an ASCII digit
|
||||
strb r1,[r7,#-1]! @ Store it in the buffer
|
||||
tst r0,r0 @ Are there more digits?
|
||||
bne 1b @ If so, calculate them
|
||||
mov r0,#1 @ 1 = stdout
|
||||
mov r1,r7 @ Start of number in R1
|
||||
ldr r2,=qs @ Calculate length
|
||||
sub r2,r2,r1
|
||||
mov r7,#4 @ 4 = write
|
||||
swi #0
|
||||
pop {r7,pc}
|
||||
@@@ Division routine: r0=r0/r1, r1=r0%r1
|
||||
divmod: mov r2,#0 @ R2 = counter
|
||||
1: cmp r1,r0 @ Double R1 until R1>R0
|
||||
lslls r1,r1,#1
|
||||
addls r2,r2,#1
|
||||
bls 1b
|
||||
mov r3,#0
|
||||
2: lsl r3,r3,#1
|
||||
subs r0,r0,r1 @ Trial subtraction
|
||||
addhs r3,r3,#1 @ If it worked, mark
|
||||
addlo r0,r0,r1 @ If it didn't, undo
|
||||
lsr r1,r1,#1 @ Halve R1
|
||||
subs r2,r2,#1 @ Decrement counter
|
||||
bhs 2b @ Keep going until zero
|
||||
mov r1,r0 @ R1 = modulus
|
||||
mov r0,r3 @ R0 = quotient
|
||||
bx lr
|
||||
.data
|
||||
space: .ascii "\x1 "
|
||||
nl: .ascii "\x1\n"
|
||||
f10m: .ascii "\x18The first 10 terms are: "
|
||||
f1000m: .ascii "\x14The 1000th term is: "
|
||||
ltermm: .ascii "' terms were preceded by a larger term.\n"
|
||||
.bss
|
||||
.align 4
|
||||
.space 8 @ Buffer for number output
|
||||
qs: .space 4 * 100001 @ One word per term
|
||||
22
Task/Hofstadter-Q-sequence/AWK/hofstadter-q-sequence.awk
Normal file
22
Task/Hofstadter-Q-sequence/AWK/hofstadter-q-sequence.awk
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
#!/usr/bin/awk -f
|
||||
BEGIN {
|
||||
N = 100000
|
||||
print "Q-sequence(1..10) : " Qsequence(10)
|
||||
Qsequence(N,Q)
|
||||
print "1000th number of Q sequence : " Q[1000]
|
||||
for (n=2; n<=N; n++) {
|
||||
if (Q[n]<Q[n-1]) NN++
|
||||
}
|
||||
print "number of Q(n)<Q(n+1) for n<=100000 : " NN
|
||||
}
|
||||
|
||||
function Qsequence(N,Q) {
|
||||
Q[1] = 1
|
||||
Q[2] = 1
|
||||
seq = "1 1"
|
||||
for (n=3; n<=N; n++) {
|
||||
Q[n] = Q[n-Q[n-1]]+Q[n-Q[n-2]]
|
||||
seq = seq" "Q[n]
|
||||
}
|
||||
return seq
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
PROC Main()
|
||||
DEFINE MAX="1000"
|
||||
INT ARRAY q(MAX+1)
|
||||
INT i
|
||||
|
||||
q(1)=1 q(2)=1
|
||||
FOR i=3 TO MAX
|
||||
DO
|
||||
q(i)=q(i-q(i-1))+q(i-q(i-2))
|
||||
OD
|
||||
|
||||
FOR i=1 TO 10
|
||||
DO
|
||||
PrintF("%I: %I%E",i,q(i))
|
||||
OD
|
||||
PrintF("%I: %I%E",MAX,q(MAX))
|
||||
RETURN
|
||||
59
Task/Hofstadter-Q-sequence/Ada/hofstadter-q-sequence.ada
Normal file
59
Task/Hofstadter-Q-sequence/Ada/hofstadter-q-sequence.ada
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
with Ada.Text_IO;
|
||||
|
||||
procedure Hofstadter_Q_Sequence is
|
||||
|
||||
type Callback is access procedure(N: Positive);
|
||||
|
||||
procedure Q(First, Last: Positive; Q_Proc: Callback) is
|
||||
-- calls Q_Proc(Q(First)); Q_Proc(Q(First+1)); ... Q_Proc(Q(Last));
|
||||
-- precondition: Last > 2
|
||||
|
||||
Q_Store: array(1 .. Last) of Natural := (1 => 1, 2 => 1, others => 0);
|
||||
-- "global" array to store the Q(I)
|
||||
-- if Q_Store(I)=0, we compute Q(I) and update Q_Store(I)
|
||||
-- else we already know Q(I) = Q_Store(I)
|
||||
|
||||
function Q(N: Positive) return Positive is
|
||||
begin
|
||||
if Q_Store(N) = 0 then
|
||||
Q_Store(N) := Q(N - Q(N-1)) + Q(N-Q(N-2));
|
||||
end if;
|
||||
return Q_Store(N);
|
||||
end Q;
|
||||
|
||||
begin
|
||||
for I in First .. Last loop
|
||||
Q_Proc(Q(I));
|
||||
end loop;
|
||||
end Q;
|
||||
|
||||
procedure Print(P: Positive) is
|
||||
begin
|
||||
Ada.Text_IO.Put(Positive'Image(P));
|
||||
end Print;
|
||||
|
||||
Decrease_Counter: Natural := 0;
|
||||
Previous_Value: Positive := 1;
|
||||
|
||||
procedure Decrease_Count(P: Positive) is
|
||||
begin
|
||||
if P < Previous_Value then
|
||||
Decrease_Counter := Decrease_Counter + 1;
|
||||
end if;
|
||||
Previous_Value := P;
|
||||
end Decrease_Count;
|
||||
|
||||
begin
|
||||
Q(1, 10, Print'Access);
|
||||
-- the first ten terms of the sequence are: 1, 1, 2, 3, 3, 4, 5, 5, 6, and 6
|
||||
Ada.Text_IO.New_Line;
|
||||
|
||||
Q(1000, 1000, Print'Access);
|
||||
-- the 1000'th term is: 502
|
||||
Ada.Text_IO.New_Line;
|
||||
|
||||
Q(2, 100_000, Decrease_Count'Access);
|
||||
Ada.Text_IO.Put_Line(Integer'Image(Decrease_Counter));
|
||||
-- how many times a member of the sequence is less than its preceding term
|
||||
-- for terms up to and including the 100,000'th term
|
||||
end Hofstadter_Q_Sequence;
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
q: new [1 1]
|
||||
n: 2
|
||||
while [n<1001][
|
||||
'q ++ (get q n-q\[n-1]) + get q n-q\[n-2]
|
||||
n: n+1
|
||||
]
|
||||
|
||||
print ["First ten items:" first.n: 10 q]
|
||||
print ["1000th item:" q\[999]]
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
SetBatchLines, -1
|
||||
Q := HofsQSeq(100000)
|
||||
|
||||
Loop, 10
|
||||
Out .= Q[A_Index] ", "
|
||||
|
||||
MsgBox, % "First ten:`t" Out "`n"
|
||||
. "1000th:`t`t" Q[1000] "`n"
|
||||
. "Flips:`t`t" Q.flips
|
||||
|
||||
HofsQSeq(n) {
|
||||
Q := {1: 1, 2: 1, "flips": 0}
|
||||
Loop, % n - 2 {
|
||||
i := A_Index + 2
|
||||
, Q[i] := Q[i - Q[i - 1]] + Q[i - Q[A_Index]]
|
||||
if (Q[i] < Q[i - 1])
|
||||
Q.flips++
|
||||
}
|
||||
return Q
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
limite = 100000
|
||||
dim Q[limite+1]
|
||||
cont = 0
|
||||
Q[1] = 1
|
||||
Q[2] = 1
|
||||
for i = 3 to limite
|
||||
Q[i] = Q[i-Q[i-1]] + Q[i-Q[i-2]]
|
||||
if Q[i] < Q[i-1] then cont += 1
|
||||
next i
|
||||
|
||||
print "Primeros 10 términos: ";
|
||||
for i = 1 to 10
|
||||
print Q[i] + " ";
|
||||
next i
|
||||
|
||||
print "Término número 1000: "; Q[1000]
|
||||
print "Términos menores que los anteriores: "; cont
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
PRINT "First 10 terms of Q = " ;
|
||||
FOR i% = 1 TO 10 : PRINT ;FNq(i%, c%) " "; : NEXT : PRINT
|
||||
PRINT "1000th term = " ; FNq(1000, c%)
|
||||
PRINT "100000th term = " ; FNq(100000, c%)
|
||||
PRINT "Term is less than preceding term " ; c% " times"
|
||||
END
|
||||
|
||||
DEF FNq(n%, RETURN c%)
|
||||
LOCAL i%,q%()
|
||||
IF n% < 3 THEN = 1 ELSE IF n% = 3 THEN = 2
|
||||
DIM q%(n%)
|
||||
q%(1) = 1 : q%(2) = 1 : q%(3) = 2
|
||||
c% = 0
|
||||
FOR i% = 3 TO n%
|
||||
q%(i%) = q%(i% - q%(i%-1)) + q%(i% - q%(i%-2))
|
||||
IF q%(i%) < q%(i%-1) THEN c% += 1
|
||||
NEXT
|
||||
= q%(n%)
|
||||
15
Task/Hofstadter-Q-sequence/BCPL/hofstadter-q-sequence.bcpl
Normal file
15
Task/Hofstadter-Q-sequence/BCPL/hofstadter-q-sequence.bcpl
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
get "libhdr"
|
||||
|
||||
let start() be
|
||||
$( let Q = vec 1000
|
||||
Q!1 := 1
|
||||
Q!2 := 1
|
||||
|
||||
for n = 3 to 1000 do
|
||||
Q!n := Q!(n-Q!(n-1)) + Q!(n-Q!(n-2))
|
||||
|
||||
writes("The first 10 terms are:")
|
||||
for n = 1 to 10 do writef(" %N", Q!n)
|
||||
|
||||
writef("*NThe 1000th term is: %N*N", Q!1000)
|
||||
$)
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
( 0:?memocells
|
||||
& tbl$(memo,!memocells+1) { allocate array }
|
||||
& ( Q
|
||||
=
|
||||
. !arg:(1|2)&1
|
||||
| !arg:>2
|
||||
& ( !arg:>!memocells:?memocells { Array is too small. }
|
||||
& tbl$(memo,!memocells+1) { Let array grow to needed size. }
|
||||
| { Array is not too small. }
|
||||
)
|
||||
& ( !(!arg$memo):>0 { Set index to !arg. Return value at index if > 0 }
|
||||
| Q$(!arg+-1*Q$(!arg+-1))+Q$(!arg+-1*Q$(!arg+-2))
|
||||
: ?(!arg$?memo) { Set index to !arg. Store value just found. }
|
||||
)
|
||||
)
|
||||
& 0:?i
|
||||
& whl
|
||||
' (1+!i:~>10:?i&put$(str$(Q$!i " ")))
|
||||
& put$\n
|
||||
& whl'(1+!i:~>1000:?i&Q$!i)
|
||||
& out$(Q$1000)
|
||||
& 0:?previous:?lessThan:?i
|
||||
& whl
|
||||
' ( 1+!i:~>100000:?i
|
||||
& Q$!i
|
||||
: ( <!previous&1+!lessThan:?lessThan
|
||||
| ?
|
||||
)
|
||||
: ?previous
|
||||
)
|
||||
& out$!lessThan
|
||||
);
|
||||
20
Task/Hofstadter-Q-sequence/C++/hofstadter-q-sequence.cpp
Normal file
20
Task/Hofstadter-Q-sequence/C++/hofstadter-q-sequence.cpp
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
#include <iostream>
|
||||
|
||||
int main() {
|
||||
const int size = 100000;
|
||||
int hofstadters[size] = { 1, 1 };
|
||||
for (int i = 3 ; i < size; i++)
|
||||
hofstadters[ i - 1 ] = hofstadters[ i - 1 - hofstadters[ i - 1 - 1 ]] +
|
||||
hofstadters[ i - 1 - hofstadters[ i - 2 - 1 ]];
|
||||
std::cout << "The first 10 numbers are: ";
|
||||
for (int i = 0; i < 10; i++)
|
||||
std::cout << hofstadters[ i ] << ' ';
|
||||
std::cout << std::endl << "The 1000'th term is " << hofstadters[ 999 ] << " !" << std::endl;
|
||||
int less_than_preceding = 0;
|
||||
for (int i = 0; i < size - 1; i++)
|
||||
if (hofstadters[ i + 1 ] < hofstadters[ i ])
|
||||
less_than_preceding++;
|
||||
std::cout << "In array of size: " << size << ", ";
|
||||
std::cout << less_than_preceding << " times a number was preceded by a greater number!" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
64
Task/Hofstadter-Q-sequence/C-sharp/hofstadter-q-sequence.cs
Normal file
64
Task/Hofstadter-Q-sequence/C-sharp/hofstadter-q-sequence.cs
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace HofstadterQSequence
|
||||
{
|
||||
class Program
|
||||
{
|
||||
// Initialize the dictionary with the first two indices filled.
|
||||
private static readonly Dictionary<int, int> QList = new Dictionary<int, int>
|
||||
{
|
||||
{1, 1},
|
||||
{2, 1}
|
||||
};
|
||||
|
||||
private static void Main()
|
||||
{
|
||||
int lessThanLast = 0;
|
||||
/* Initialize our variable that holds the number of times
|
||||
* a member of the sequence was less than its preceding term. */
|
||||
|
||||
for (int n = 1; n <= 100000; n++)
|
||||
{
|
||||
int q = Q(n); // Get Q(n).
|
||||
|
||||
if (n > 1 && QList[n - 1] > q) // If Q(n) is less than Q(n - 1),
|
||||
lessThanLast++; // then add to the counter.
|
||||
|
||||
if (n > 10 && n != 1000) continue; /* If n is greater than 10 and not 1000,
|
||||
* the rest of the code in the loop does not apply,
|
||||
* and it will be skipped. */
|
||||
|
||||
if (!Confirm(n, q)) // Confirm Q(n) is correct.
|
||||
throw new Exception(string.Format("Invalid result: Q({0}) != {1}", n, q));
|
||||
|
||||
Console.WriteLine("Q({0}) = {1}", n, q); // Write Q(n) to the console.
|
||||
}
|
||||
|
||||
Console.WriteLine("Number of times a member of the sequence was less than its preceding term: {0}.",
|
||||
lessThanLast);
|
||||
}
|
||||
|
||||
private static bool Confirm(int n, int value)
|
||||
{
|
||||
if (n <= 10)
|
||||
return new[] {1, 1, 2, 3, 3, 4, 5, 5, 6, 6}[n - 1] == value;
|
||||
if (n == 1000)
|
||||
return 502 == value;
|
||||
throw new ArgumentException("Invalid index.", "n");
|
||||
}
|
||||
|
||||
private static int Q(int n)
|
||||
{
|
||||
int q;
|
||||
|
||||
if (!QList.TryGetValue(n, out q)) // Try to get Q(n) from the dictionary.
|
||||
{
|
||||
q = Q(n - Q(n - 1)) + Q(n - Q(n - 2)); // If it's not available, then calculate it.
|
||||
QList.Add(n, q); // Add it to the dictionary.
|
||||
}
|
||||
|
||||
return q;
|
||||
}
|
||||
}
|
||||
}
|
||||
24
Task/Hofstadter-Q-sequence/C/hofstadter-q-sequence.c
Normal file
24
Task/Hofstadter-Q-sequence/C/hofstadter-q-sequence.c
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define N 100000
|
||||
int main()
|
||||
{
|
||||
int i, flip, *q = (int*)malloc(sizeof(int) * N) - 1;
|
||||
|
||||
q[1] = q[2] = 1;
|
||||
|
||||
for (i = 3; i <= N; i++)
|
||||
q[i] = q[i - q[i - 1]] + q[i - q[i - 2]];
|
||||
|
||||
for (i = 1; i <= 10; i++)
|
||||
printf("%d%c", q[i], i == 10 ? '\n' : ' ');
|
||||
|
||||
printf("%d\n", q[1000]);
|
||||
|
||||
for (flip = 0, i = 1; i < N; i++)
|
||||
flip += q[i] > q[i + 1];
|
||||
|
||||
printf("flips: %d\n", flip);
|
||||
return 0;
|
||||
}
|
||||
26
Task/Hofstadter-Q-sequence/CLU/hofstadter-q-sequence.clu
Normal file
26
Task/Hofstadter-Q-sequence/CLU/hofstadter-q-sequence.clu
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
q_seq = proc (n: int) returns (sequence[int])
|
||||
q: array[int] := array[int]$[1,1]
|
||||
for i: int in int$from_to(3,n) do
|
||||
array[int]$addh(q, q[i-q[i-1]] + q[i-q[i-2]])
|
||||
end
|
||||
return(sequence[int]$a2s(q))
|
||||
end q_seq
|
||||
|
||||
start_up = proc ()
|
||||
po: stream := stream$primary_output()
|
||||
|
||||
q: sequence[int] := q_seq(100000)
|
||||
stream$puts(po, "First 10 terms:")
|
||||
for i: int in int$from_to(1,10) do
|
||||
stream$puts(po, " " || int$unparse(q[i]))
|
||||
end
|
||||
|
||||
stream$puts(po, "\n1000th term: " || int$unparse(q[1000]))
|
||||
|
||||
flips: int := 0
|
||||
for i: int in int$from_to(2, sequence[int]$size(q)) do
|
||||
if q[i-1]>q[i] then flips := flips + 1 end
|
||||
end
|
||||
|
||||
stream$putl(po, "\nflips: " || int$unparse(flips))
|
||||
end start_up
|
||||
40
Task/Hofstadter-Q-sequence/COBOL/hofstadter-q-sequence.cobol
Normal file
40
Task/Hofstadter-Q-sequence/COBOL/hofstadter-q-sequence.cobol
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
IDENTIFICATION DIVISION.
|
||||
PROGRAM-ID. Q-SEQ.
|
||||
|
||||
DATA DIVISION.
|
||||
WORKING-STORAGE SECTION.
|
||||
01 SEQ.
|
||||
02 Q PIC 9(3) OCCURS 1000 TIMES.
|
||||
02 Q-TMP1 PIC 9(3).
|
||||
02 Q-TMP2 PIC 9(3).
|
||||
02 N PIC 9(4).
|
||||
01 DISPLAYING.
|
||||
02 ITEM PIC Z(3).
|
||||
02 IX PIC Z(4).
|
||||
|
||||
PROCEDURE DIVISION.
|
||||
MAIN-PROGRAM.
|
||||
PERFORM GENERATE-SEQUENCE.
|
||||
PERFORM SHOW-ITEM
|
||||
VARYING N FROM 1 BY 1
|
||||
UNTIL N IS GREATER THAN 10.
|
||||
SET N TO 1000.
|
||||
PERFORM SHOW-ITEM.
|
||||
STOP RUN.
|
||||
|
||||
GENERATE-SEQUENCE.
|
||||
SET Q(1) TO 1.
|
||||
SET Q(2) TO 1.
|
||||
PERFORM GENERATE-ITEM
|
||||
VARYING N FROM 3 BY 1
|
||||
UNTIL N IS GREATER THAN 1000.
|
||||
|
||||
GENERATE-ITEM.
|
||||
COMPUTE Q-TMP1 = N - Q(N - 1).
|
||||
COMPUTE Q-TMP2 = N - Q(N - 2).
|
||||
COMPUTE Q(N) = Q(Q-TMP1) + Q(Q-TMP2).
|
||||
|
||||
SHOW-ITEM.
|
||||
MOVE N TO IX.
|
||||
MOVE Q(N) TO ITEM.
|
||||
DISPLAY 'Q(' IX ') = ' ITEM.
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
(defn qs [q]
|
||||
(let [n (count q)]
|
||||
(condp = n
|
||||
0 [1]
|
||||
1 [1 1]
|
||||
(conj q (+ (q (- n (q (- n 1))))
|
||||
(q (- n (q (- n 2)))))))))
|
||||
|
||||
(defn qfirst [n] (-> (iterate qs []) (nth n)))
|
||||
|
||||
(println "first 10:" (qfirst 10))
|
||||
(println "1000th:" (last (qfirst 1000)))
|
||||
(println "extra credit:" (->> (qfirst 100000) (partition 2 1) (filter #(apply > %)) count))
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
first 10: [1 1 2 3 3 4 5 5 6 6]
|
||||
1000th: 502
|
||||
extra credit: 49798
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
hofstadterQ = do ->
|
||||
memo = [ 1 ,1, 1]
|
||||
Q = (n) ->
|
||||
result = memo[n]
|
||||
if typeof result != 'number'
|
||||
result = memo[n] = Q(n - Q(n - 1)) + Q(n - Q(n - 2))
|
||||
result
|
||||
|
||||
# some results:
|
||||
console.log 'Q(' + i + ') = ' + hofstadterQ(i) for i in [1..10]
|
||||
console.log 'Q(1000) = ' + hofstadterQ(1000)
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
(defparameter *mm* (make-hash-table :test #'equal))
|
||||
|
||||
;;; generic memoization macro
|
||||
(defmacro defun-memoize (f (&rest args) &body body)
|
||||
(defmacro hash () `(gethash (cons ',f (list ,@args)) *mm*))
|
||||
(let ((h (gensym)))
|
||||
`(defun ,f (,@args)
|
||||
(let ((,h (hash)))
|
||||
(if ,h ,h
|
||||
(setf (hash) (progn ,@body)))))))
|
||||
|
||||
;;; def q
|
||||
(defun-memoize q (n)
|
||||
(if (<= n 2) 1
|
||||
(+ (q (- n (q (- n 1))))
|
||||
(q (- n (q (- n 2)))))))
|
||||
|
||||
;;; test
|
||||
(format t "First of Q: ~a~%Q(1000): ~a~%Bumps up to 100000: ~a~%"
|
||||
(loop for i from 1 to 10 collect (q i))
|
||||
(q 1000)
|
||||
(loop with c = 0 with last-q = (q 1)
|
||||
for i from 2 to 100000
|
||||
do (let ((next-q (q i)))
|
||||
(if (< next-q last-q) (incf c))
|
||||
(setf last-q next-q))
|
||||
finally (return c)))
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
(let ((cc (make-array 3 :element-type 'integer
|
||||
:initial-element 1
|
||||
:adjustable t
|
||||
:fill-pointer 3)))
|
||||
(defun q (n)
|
||||
(when (>= n (length cc))
|
||||
(loop for i from (length cc) below n do (q i))
|
||||
(vector-push-extend
|
||||
(+ (aref cc (- n (aref cc (- n 1))))
|
||||
(aref cc (- n (aref cc (- n 2)))))
|
||||
cc))
|
||||
(aref cc n)))
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
include "cowgol.coh";
|
||||
|
||||
# Generate 1000 terms of the Q sequence
|
||||
var Q: uint16[1001];
|
||||
Q[1] := 1;
|
||||
Q[2] := 1;
|
||||
|
||||
var n: @indexof Q := 3;
|
||||
while n <= 1000 loop
|
||||
Q[n] := Q[n-Q[n-1]] + Q[n-Q[n-2]];
|
||||
n := n + 1;
|
||||
end loop;
|
||||
|
||||
# Print first 10 terms
|
||||
print("The first 10 terms are: ");
|
||||
n := 1;
|
||||
while n <= 10 loop
|
||||
print_i16(Q[n]);
|
||||
print_char(' ');
|
||||
n := n + 1;
|
||||
end loop;
|
||||
print_nl();
|
||||
|
||||
# Print 1000th term
|
||||
print("The 1000th term is: ");
|
||||
print_i16(Q[1000]);
|
||||
print_nl();
|
||||
19
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-1.d
Normal file
19
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-1.d
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
import std.stdio, std.algorithm, std.functional, std.range;
|
||||
|
||||
int Q(in int n) nothrow
|
||||
in {
|
||||
assert(n > 0);
|
||||
} body {
|
||||
alias mQ = memoize!Q;
|
||||
if (n == 1 || n == 2)
|
||||
return 1;
|
||||
else
|
||||
return mQ(n - mQ(n - 1)) + mQ(n - mQ(n - 2));
|
||||
}
|
||||
|
||||
void main() {
|
||||
writeln("Q(n) for n = [1..10] is: ", iota(1, 11).map!Q);
|
||||
writeln("Q(1000) = ", Q(1000));
|
||||
writefln("Q(i) is less than Q(i-1) for i [2..100_000] %d times.",
|
||||
iota(2, 100_001).count!(i => Q(i) < Q(i - 1)));
|
||||
}
|
||||
19
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-2.d
Normal file
19
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-2.d
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
import std.stdio, std.algorithm, std.range, std.array;
|
||||
|
||||
uint Q(in int n) nothrow
|
||||
in {
|
||||
assert(n > 0);
|
||||
} body {
|
||||
__gshared static Appender!(int[]) s = [0, 1, 1];
|
||||
|
||||
foreach (immutable i; s.data.length .. n + 1)
|
||||
s ~= s.data[i - s.data[i - 1]] + s.data[i - s.data[i - 2]];
|
||||
return s.data[n];
|
||||
}
|
||||
|
||||
void main() {
|
||||
writeln("Q(n) for n = [1..10] is: ", iota(1, 11).map!Q);
|
||||
writeln("Q(1000) = ", Q(1000));
|
||||
writefln("Q(i) is less than Q(i-1) for i [2..100_000] %d times.",
|
||||
iota(2, 100_001).count!(i => Q(i) < Q(i - 1)));
|
||||
}
|
||||
31
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-3.d
Normal file
31
Task/Hofstadter-Q-sequence/D/hofstadter-q-sequence-3.d
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
import std.stdio;
|
||||
|
||||
int[100_000] Q;
|
||||
|
||||
void main() {
|
||||
Q[0] = 1;
|
||||
Q[1] = 1;
|
||||
|
||||
for (int i = 2; i < 100_000; i++)
|
||||
{
|
||||
Q[i] = Q[i - Q[i - 1]] + Q[i - Q[i - 2]];
|
||||
}
|
||||
|
||||
write("Q(1..10) : ");
|
||||
for (int i = 0; i < 10; i++)
|
||||
{
|
||||
write(" ", Q[i]);
|
||||
}
|
||||
writeln;
|
||||
|
||||
write("Q(1000) : ");
|
||||
writeln(Q[999]);
|
||||
|
||||
int lt = 0;
|
||||
for (int i = 1; i < 100_000; i++)
|
||||
{
|
||||
if( Q[i-1] > Q[i] ) lt++;
|
||||
}
|
||||
|
||||
writefln("Q(i) is less than Q(i-1) for i [2..100_000] %d times.", lt);
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
int Q(int n) => n>2 ? Q(n-Q(n-1))+Q(n-Q(n-2)) : 1;
|
||||
|
||||
main() {
|
||||
for(int i=1;i<=10;i++) {
|
||||
print("Q($i)=${Q(i)}");
|
||||
}
|
||||
print("Q(1000)=${Q(1000)}");
|
||||
}
|
||||
42
Task/Hofstadter-Q-sequence/Dart/hofstadter-q-sequence-2.dart
Normal file
42
Task/Hofstadter-Q-sequence/Dart/hofstadter-q-sequence-2.dart
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
class Q {
|
||||
Map<int,int> _table;
|
||||
|
||||
Q() {
|
||||
_table=new Map<int,int>();
|
||||
_table[1]=1;
|
||||
_table[2]=1;
|
||||
}
|
||||
|
||||
int q(int n) {
|
||||
// if the cache is not filled until n-1, fill it starting with the lowest entries first
|
||||
// this avoids doing a recursion from n to 2 (e.g. if you call q(1000000) first)
|
||||
// this doesn't happen in the tasks calls since the cache is filled ascending
|
||||
if(_table[n-1]==null) {
|
||||
for(int i=_table.length;i<n;i++) {
|
||||
q(i);
|
||||
}
|
||||
}
|
||||
if(_table[n]==null) {
|
||||
_table[n]=q(n-q(n-1))+q(n-q(n-2));
|
||||
}
|
||||
|
||||
return _table[n];
|
||||
}
|
||||
}
|
||||
|
||||
main() {
|
||||
Q q=new Q();
|
||||
|
||||
for(int i=1;i<=10;i++) {
|
||||
print("Q($i)=${q.q(i)}");
|
||||
}
|
||||
print("Q(1000)=${q.q(1000)}");
|
||||
|
||||
int count=0;
|
||||
for(int i=2;i<=100000;i++) {
|
||||
if(q.q(i)<q.q(i-1)) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
print("value is smaller than previous $count times");
|
||||
}
|
||||
17
Task/Hofstadter-Q-sequence/Dart/hofstadter-q-sequence-3.dart
Normal file
17
Task/Hofstadter-Q-sequence/Dart/hofstadter-q-sequence-3.dart
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
main() {
|
||||
List<int> q=new List<int>(100001);
|
||||
q[1]=q[2]=1;
|
||||
|
||||
int count=0;
|
||||
for(int i=3;i<q.length;i++) {
|
||||
q[i]=q[i-q[i-1]]+q[i-q[i-2]];
|
||||
if(q[i]<q[i-1]) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
for(int i=1;i<=10;i++) {
|
||||
print("Q($i)=${q[i]}");
|
||||
}
|
||||
print("Q(1000)=${q[1000]}");
|
||||
print("value is smaller than previous $count times");
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
type TIntArray = array of integer;
|
||||
|
||||
procedure FillHofstadterArray(var HA: TIntArray);
|
||||
{Fill array with Hofstader numbers}
|
||||
{Preset array size to the number of terms you want}
|
||||
var I: integer;
|
||||
begin
|
||||
{Starting condition}
|
||||
HA[1]:=1; HA[2]:=1;
|
||||
{Fill array up to last item}
|
||||
for I:=3 to High(HA) do HA[I]:=HA[I-HA[I-1]]+HA[I-HA[I-2]];
|
||||
end;
|
||||
|
||||
|
||||
procedure ShowHofstadterNumbers(Memo: TMemo);
|
||||
{Fill array with a }
|
||||
var I, LessCount: integer;
|
||||
var QArray: TIntArray;
|
||||
begin
|
||||
{Select the number of items we want}
|
||||
SetLength(QArray,100000);
|
||||
{Fill array}
|
||||
FillHofstadterArray(QArray);
|
||||
{Display first 10}
|
||||
for I:=1 to 10 do Memo.Lines.Add(Format('%4d: %4d',[I,QArray[I]]));
|
||||
Memo.Lines.Add(Format('%4d: %4d',[1000,QArray[1000]]));
|
||||
{Count number the number of times Q(n)<Q(n-1)}
|
||||
LessCount:=0;
|
||||
for I:=1 to High(QArray) do
|
||||
if QArray[I]>QArray[I-1] then Inc(LessCount);
|
||||
Memo.Lines.Add('Count of Q(n)<Q(n-1) = '+IntToStr(LessCount));
|
||||
end;
|
||||
20
Task/Hofstadter-Q-sequence/Draco/hofstadter-q-sequence.draco
Normal file
20
Task/Hofstadter-Q-sequence/Draco/hofstadter-q-sequence.draco
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
proc nonrec make_Q([*] word q) void:
|
||||
word n;
|
||||
q[1] := 1;
|
||||
q[2] := 1;
|
||||
for n from 3 upto dim(q,1)-1 do
|
||||
q[n] := q[n-q[n-1]] + q[n-q[n-2]]
|
||||
od
|
||||
corp
|
||||
|
||||
proc nonrec main() void:
|
||||
word MAX = 1000;
|
||||
word i;
|
||||
[MAX+1] word q;
|
||||
make_Q(q);
|
||||
|
||||
write("The first 10 terms are:");
|
||||
for i from 1 upto 10 do write(" ", q[i]) od;
|
||||
writeln();
|
||||
writeln("The 1000th term is: ", q[1000])
|
||||
corp
|
||||
35
Task/Hofstadter-Q-sequence/ERRE/hofstadter-q-sequence.erre
Normal file
35
Task/Hofstadter-Q-sequence/ERRE/hofstadter-q-sequence.erre
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
PROGRAM HOFSTADER_Q
|
||||
|
||||
!
|
||||
! for rosettacode.org
|
||||
!
|
||||
|
||||
DIM Q%[10000]
|
||||
|
||||
PROCEDURE QSEQUENCE(Q,FLAG%->SEQ$)
|
||||
! if FLAG% is true accumulate sequence in SEQ$
|
||||
! (attention to string var lenght=255)
|
||||
! otherwise calculate values in Q%[] only
|
||||
|
||||
LOCAL N
|
||||
Q%[1]=1
|
||||
Q%[2]=1
|
||||
SEQ$="1 1"
|
||||
IF NOT FLAG% THEN Q=NUM END IF
|
||||
FOR N=3 TO Q DO
|
||||
Q%[N]=Q%[N-Q%[N-1]]+Q%[N-Q%[N-2]]
|
||||
IF FLAG% THEN SEQ$=SEQ$+STR$(Q%[N]) END IF
|
||||
END FOR
|
||||
END PROCEDURE
|
||||
|
||||
BEGIN
|
||||
NUM=10000
|
||||
QSEQUENCE(10,TRUE->SEQ$)
|
||||
PRINT("Q-sequence(1..10) : ";SEQ$)
|
||||
QSEQUENCE(1000,FALSE->SEQ$)
|
||||
PRINT("1000th number of Q sequence : ";Q%[1000])
|
||||
FOR N=2 TO NUM DO
|
||||
IF Q%[N]<Q%[N-1] THEN NN+=1 END IF
|
||||
END FOR
|
||||
PRINT("Number of Q(n)<Q(n+1) for n<=10000 : ";NN)
|
||||
END PROGRAM
|
||||
23
Task/Hofstadter-Q-sequence/EchoLisp/hofstadter-q-sequence.l
Normal file
23
Task/Hofstadter-Q-sequence/EchoLisp/hofstadter-q-sequence.l
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
(define RECURSE_BUMP 500) ;; minimum of chrome:500 safari:1000 firefox:2000
|
||||
|
||||
;; count flips
|
||||
(define (flips N)
|
||||
(for/sum ((n (in-range 2 (1+ N))))
|
||||
#:when (< (Q n) (Q (1- n))) 1))
|
||||
|
||||
(cache-size 120000)
|
||||
(define (Q n)
|
||||
;; prevent browser stack overflow at low-cost
|
||||
(when (zero? (modulo n RECURSE_BUMP)) (for ((i (in-range 0 n RECURSE_BUMP ))) (Q i)))
|
||||
(+ (Q (- n (Q (1- n)))) (Q (- n (Q (- n 2))))))
|
||||
(remember 'Q #(1 1 1)) ;; memoize and init
|
||||
|
||||
|
||||
;; first call : check stack OK
|
||||
(Q 100000) → 48157
|
||||
|
||||
(for ((i 11)) (write (Q i)))
|
||||
1 1 1 2 3 3 4 5 5 6 6
|
||||
|
||||
(Q 1000) → 502
|
||||
(flips 100000) → 49798
|
||||
60
Task/Hofstadter-Q-sequence/Eiffel/hofstadter-q-sequence.e
Normal file
60
Task/Hofstadter-Q-sequence/Eiffel/hofstadter-q-sequence.e
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
class
|
||||
APPLICATION
|
||||
|
||||
create
|
||||
make
|
||||
|
||||
feature
|
||||
|
||||
make
|
||||
-- Test output of the feature hofstadter_q_sequence.
|
||||
local
|
||||
count, i: INTEGER
|
||||
test: ARRAY [INTEGER]
|
||||
do
|
||||
io.put_string ("%NFirst ten numbers: %N")
|
||||
test := hofstadter_q_sequence (10)
|
||||
across
|
||||
test as ar
|
||||
loop
|
||||
io.put_string (ar.item.out + "%T")
|
||||
end
|
||||
test := hofstadter_q_sequence (100000)
|
||||
io.put_string ("1000th:%N")
|
||||
io.put_integer (test [1000])
|
||||
io.put_string ("%NNumber of Flips:%N")
|
||||
from
|
||||
i := 2
|
||||
until
|
||||
i > 100000
|
||||
loop
|
||||
if test [i] < test [i - 1] then
|
||||
count := count + 1
|
||||
end
|
||||
i := i + 1
|
||||
end
|
||||
io.put_integer (count)
|
||||
end
|
||||
|
||||
hofstadter_q_sequence (lim: INTEGER): ARRAY [INTEGER]
|
||||
-- Hofstadter Q Sequence up to 'lim'.
|
||||
require
|
||||
lim_positive: lim > 0
|
||||
local
|
||||
q: ARRAY [INTEGER]
|
||||
i: INTEGER
|
||||
do
|
||||
create Result.make_filled (1, 1, lim)
|
||||
Result [1] := 1
|
||||
Result [2] := 1
|
||||
from
|
||||
i := 3
|
||||
until
|
||||
i > lim
|
||||
loop
|
||||
Result [i] := Result [i - Result [i - 1]] + Result [i - Result [i - 2]]
|
||||
i := i + 1
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
defmodule Hofstadter do
|
||||
defp flip(v2, v1) when v1 > v2, do: 1
|
||||
defp flip(_v2, _v1), do: 0
|
||||
|
||||
defp list_terms(max, n, acc), do: Enum.map_join(n..max, ", ", &acc[&1])
|
||||
|
||||
defp hofstadter(n, n, acc, flips) do
|
||||
IO.puts "The first ten terms are: #{list_terms(10, 1, acc)}"
|
||||
IO.puts "The 1000'th term is #{acc[1000]}"
|
||||
IO.puts "Number of flips: #{flips}"
|
||||
end
|
||||
defp hofstadter(max, n, acc, flips) do
|
||||
qn1 = acc[n-1]
|
||||
qn = acc[n - qn1] + acc[n - acc[n-2]]
|
||||
hofstadter(max, n+1, Map.put(acc, n, qn), flips + flip(qn, qn1))
|
||||
end
|
||||
|
||||
def main(max \\ 100_000) do
|
||||
acc = %{1 => 1, 2 => 1}
|
||||
hofstadter(max+1, 3, acc, 0)
|
||||
end
|
||||
end
|
||||
|
||||
Hofstadter.main
|
||||
30
Task/Hofstadter-Q-sequence/Erlang/hofstadter-q-sequence.erl
Normal file
30
Task/Hofstadter-Q-sequence/Erlang/hofstadter-q-sequence.erl
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
%% @author Jan Willem Luiten <jwl@secondmove.com>
|
||||
%% Hofstadter Q Sequence for Rosetta Code
|
||||
|
||||
-module(hofstadter).
|
||||
-export([main/0]).
|
||||
-define(MAX, 100000).
|
||||
|
||||
flip(V2, V1) when V1 > V2 -> 1;
|
||||
flip(_V2, _V1) -> 0.
|
||||
|
||||
list_terms(N, N, Acc) ->
|
||||
io:format("~w~n", [array:get(N, Acc)]);
|
||||
list_terms(Max, N, Acc) ->
|
||||
io:format("~w, ", [array:get(N, Acc)]),
|
||||
list_terms(Max, N+1, Acc).
|
||||
|
||||
hofstadter(N, N, Acc, Flips) ->
|
||||
io:format("The first ten terms are: "),
|
||||
list_terms(9, 0, Acc),
|
||||
io:format("The 1000'th term is ~w~n", [array:get(999, Acc)]),
|
||||
io:format("Number of flips: ~w~n", [Flips]);
|
||||
hofstadter(Max, N, Acc, Flips) ->
|
||||
Qn1 = array:get(N-1, Acc),
|
||||
Qn = array:get(N - Qn1, Acc) + array:get(N - array:get(N-2, Acc), Acc),
|
||||
hofstadter(Max, N+1, array:set(N, Qn, Acc), Flips + flip(Qn, Qn1)).
|
||||
|
||||
main() ->
|
||||
Tmp = array:set(0, 1, array:new(?MAX)),
|
||||
Acc = array:set(1, 1, Tmp),
|
||||
hofstadter(?MAX, 2, Acc, 0).
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
// Populate an array with values of Hofstadter Q sequence. Nigel Galloway: August 26th., 2020
|
||||
let fQ N=let g=Array.length N in N.[0]<-1; N.[1]<-1;(for g in 2..g-1 do N.[g]<-N.[g-N.[g-1]]+N.[g-N.[g-2]])
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
let Q=Array.zeroCreate<int>10 in fQ Q; printfn "%A" Q
|
||||
let Q=Array.zeroCreate<int>1000 in fQ Q; printfn "%d" (Array.last Q)
|
||||
|
|
@ -0,0 +1 @@
|
|||
let Q=Array.zeroCreate<int>100000 in fQ Q; printfn "%d" (Q|>Seq.pairwise|>Seq.sumBy(fun(n,g)->if n>g then 1 else 0))
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
let Q=Array.zeroCreate<int>2500000000 in fQ Q; printfn "%d" (Array.last Q)
|
||||
let Q=Array.zeroCreate<int>5000000000 in fQ Q; printfn "%d" (Array.last Q)
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
( scratchpad ) : next ( seq -- newseq )
|
||||
dup 2 tail* over length [ swap - ] curry map
|
||||
[ dupd swap nth ] map 0 [ + ] reduce suffix ;
|
||||
|
||||
( scratchpad ) { 1 1 } 1000 [ next ] times dup 10 head . 999 swap nth .
|
||||
{ 1 1 2 3 3 4 5 5 6 6 }
|
||||
502
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
Func Hq(n) = if n<2 then 1 else
|
||||
Array qq[n+1];
|
||||
qq[1] := 1;
|
||||
qq[2] := 1;
|
||||
for i = 3, n do
|
||||
qq[i]:=qq[i-qq[i-1]]+qq[i-qq[i-2]]
|
||||
od;
|
||||
Return(qq[n]);
|
||||
fi;
|
||||
.
|
||||
|
||||
for i=1 to 10 do !Hq(i);!' ' od;
|
||||
Hq(1000)
|
||||
27
Task/Hofstadter-Q-sequence/Forth/hofstadter-q-sequence.fth
Normal file
27
Task/Hofstadter-Q-sequence/Forth/hofstadter-q-sequence.fth
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
100000 constant N
|
||||
|
||||
: q ( n -- addr ) cells here + ;
|
||||
|
||||
: qinit
|
||||
1 0 q !
|
||||
1 1 q !
|
||||
N 2 do
|
||||
i i 1- q @ - q @
|
||||
i i 2 - q @ - q @
|
||||
+ i q !
|
||||
loop ;
|
||||
|
||||
: flips
|
||||
." flips: "
|
||||
0 N 1 do
|
||||
i q @ i 1- q @ < if 1+ then
|
||||
loop . cr ;
|
||||
|
||||
: qprint ( n -- )
|
||||
0 do i q @ . loop cr ;
|
||||
|
||||
qinit
|
||||
10 qprint
|
||||
999 q @ . cr
|
||||
flips
|
||||
bye
|
||||
30
Task/Hofstadter-Q-sequence/Fortran/hofstadter-q-sequence.f
Normal file
30
Task/Hofstadter-Q-sequence/Fortran/hofstadter-q-sequence.f
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
Calculate the Hofstadter Q-sequence, using a big array rather than recursion.
|
||||
INTEGER ENUFF
|
||||
PARAMETER (ENUFF = 100000)
|
||||
INTEGER Q(ENUFF) !Lots of memory these days.
|
||||
|
||||
Q(1) = 1 !Initial values as per the definition.
|
||||
Q(2) = 1
|
||||
Q(3:) = -123456789!This will surely cause trouble!
|
||||
DO I = 3,ENUFF !For values beyond the second,
|
||||
Q(I) = Q(I - Q(I - 1)) + Q(I - Q(I - 2)) !Reach back according to the last two values.
|
||||
END DO
|
||||
Cast forth results as per the specification.
|
||||
WRITE (6,1) Q(1:10) !Should be 1 1 2 3 3 4 5 5 6 6...
|
||||
1 FORMAT ("First ten values:",10I2) !Known to be one-digit numbers.
|
||||
WRITE (6,*) "Q(1000) =",Q(1000) !Should be 502.
|
||||
WRITE (6,3) ENUFF,COUNT(Q(2:ENUFF) < Q(1:ENUFF - 1)) !Please don't create a temporary array!
|
||||
3 FORMAT ("Count of those elements 2:",I0,
|
||||
1 " which are less than their predecessor: ",I0) !Should be 49798.
|
||||
Curry favour by allowing enquiries.
|
||||
10 WRITE (6,11) ENUFF
|
||||
11 FORMAT ("Nominate an index (in 1:",I0,"): ",$) !Obviously, the $ says don't start a new line.
|
||||
READ (5,*,END = 999, ERR = 999) I !Ask for a number, with precautions.
|
||||
IF (I.GT.0 .AND. I.LE.ENUFF) THEN !A good number, but, within range?
|
||||
WRITE (6,12) I,Q(I) !Yes. Reveal the requested value.
|
||||
12 FORMAT ("Q(",I0,") = ",I0) !This should do.
|
||||
GO TO 10 !And ask again.
|
||||
END IF ! WHILE read(5,*) i & i > 0 & i < enuff DO write(6,*) "Q(",i,")=",Q(i);
|
||||
Closedown.
|
||||
999 WRITE (6,*) "Bye."
|
||||
END
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
Const limite = 100000
|
||||
|
||||
Dim As Long Q(limite), i, cont = 0
|
||||
|
||||
Q(1) = 1
|
||||
Q(2) = 1
|
||||
For i = 3 To limite
|
||||
Q(i) = Q(i-Q(i-1)) + Q(i-Q(i-2))
|
||||
If Q(i) < Q(i-1) Then cont += 1
|
||||
Next i
|
||||
|
||||
Print "Primeros 10 terminos: ";
|
||||
For i = 1 To 10
|
||||
Print Q(i) &" ";
|
||||
Next i
|
||||
Print
|
||||
|
||||
Print "Termino numero 1000: "; Q(1000)
|
||||
|
||||
Print "Terminos menores que los anteriores: " &cont
|
||||
End
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
10 DIM Q!(1000)
|
||||
20 Q(1) = 1: Q(2) = 1
|
||||
30 FOR N = 3 TO 1000
|
||||
40 Q(N) = Q(N - Q(N - 1)) + Q(N - Q(N - 2))
|
||||
50 NEXT N
|
||||
60 FOR N = 1 TO 10
|
||||
70 PRINT Q(N)
|
||||
80 NEXT N
|
||||
90 PRINT Q(1000)
|
||||
46
Task/Hofstadter-Q-sequence/Go/hofstadter-q-sequence.go
Normal file
46
Task/Hofstadter-Q-sequence/Go/hofstadter-q-sequence.go
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
var m map[int]int
|
||||
|
||||
func initMap() {
|
||||
m = make(map[int]int)
|
||||
m[1] = 1
|
||||
m[2] = 1
|
||||
}
|
||||
|
||||
func q(n int) (r int) {
|
||||
if r = m[n]; r == 0 {
|
||||
r = q(n-q(n-1)) + q(n-q(n-2))
|
||||
m[n] = r
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func main() {
|
||||
initMap()
|
||||
// task
|
||||
for n := 1; n <= 10; n++ {
|
||||
showQ(n)
|
||||
}
|
||||
// task
|
||||
showQ(1000)
|
||||
// extra credit
|
||||
count, p := 0, 1
|
||||
for n := 2; n <= 1e5; n++ {
|
||||
qn := q(n)
|
||||
if qn < p {
|
||||
count++
|
||||
}
|
||||
p = qn
|
||||
}
|
||||
fmt.Println("count:", count)
|
||||
// extra credit
|
||||
initMap()
|
||||
showQ(1e6)
|
||||
}
|
||||
|
||||
func showQ(n int) {
|
||||
fmt.Printf("Q(%d) = %d\n", n, q(n))
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
qSequence = tail qq where
|
||||
qq = 0 : 1 : 1 : map g [3..]
|
||||
g n = qq !! (n - qq !! (n-1)) + qq !! (n - qq !! (n-2))
|
||||
|
||||
-- Output:
|
||||
*Main> (take 10 qSequence, qSequence !! (1000-1))
|
||||
([1,1,2,3,3,4,5,5,6,6],502)
|
||||
(0.00 secs, 525044 bytes)
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
import Data.Array
|
||||
|
||||
qSequence n = arr
|
||||
where
|
||||
arr = listArray (1,n) $ 1:1: map g [3..n]
|
||||
g i = arr!(i - arr!(i-1)) +
|
||||
arr!(i - arr!(i-2))
|
||||
|
||||
gradualth m k arr -- gradually precalculate m-th item
|
||||
| m <= v = pre `seq` arr!m -- in steps of k
|
||||
where -- to prevent STACK OVERFLOW
|
||||
pre = foldl1 (\a b-> a `seq` arr!b) [u,u+k..m]
|
||||
(u,v) = bounds arr
|
||||
|
||||
qSeqTest m n = let arr = qSequence $ max m n in
|
||||
( take 10 . elems $ arr -- 10 first items
|
||||
, gradualth m 10000 $ arr -- m-th item
|
||||
, length . filter (> 0) -- reversals in n items
|
||||
. _S (zipWith (-)) tail . take n . elems $ arr )
|
||||
|
||||
_S f g x = f x (g x)
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
Prelude Main> qSeqTest 1000 100000 -- reversals in 100,000
|
||||
([1,1,2,3,3,4,5,5,6,6],502,49798)
|
||||
(0.09 secs, 18879708 bytes)
|
||||
|
||||
Prelude Main> qSeqTest 1000000 100000 -- 1,000,000-th item
|
||||
([1,1,2,3,3,4,5,5,6,6],512066,49798)
|
||||
(2.80 secs, 87559640 bytes)
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
q = qq (listArray (1,2) [1,1]) 1 where
|
||||
qq ar n = (arr!n) : qq arr (n+1) where
|
||||
l = snd (bounds ar)
|
||||
step n =arr!(n - (fromIntegral (arr!(n - 1)))) +
|
||||
arr!(n - (fromIntegral (arr!(n - 2))))
|
||||
arr :: Array Int Integer
|
||||
arr | n <= l = ar
|
||||
| otherwise = listArray (1, l*2)$
|
||||
([ar!i | i <- [1..l]] ++
|
||||
[step i | i <- [l+1..l*2]])
|
||||
|
||||
main = do
|
||||
putStr("first 10: "); print (take 10 q)
|
||||
putStr("1000-th: "); print (q !! 999)
|
||||
putStr("flips: ")
|
||||
print $ length $ filter id $ take 100000 (zipWith (>) q (tail q))
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
import Data.Array
|
||||
import Data.Int (Int64)
|
||||
|
||||
q = qq [listArray (1,2) [1,1]] 1 where
|
||||
qq a n = seek aa n : qq aa (1 + n) where
|
||||
aa | n <= l = a
|
||||
| otherwise = listArray (l+1,l*2) (take l $ drop 2 lst):a
|
||||
where
|
||||
l = snd (bounds $ head a)
|
||||
lst = seek a (l-1):seek a l:(ext lst (l+1))
|
||||
ext (q1:q2:qs) i = (g (i-q2) + g (i-q1)):ext (q2:qs) (1+i)
|
||||
g = seek aa
|
||||
seek (ar:ars) n
|
||||
| n >= fst (bounds ar) = ar ! n
|
||||
| otherwise = seek ars n
|
||||
|
||||
-- Only a perf test. Task can be done exactly the same as above
|
||||
main = print $ sum qqq
|
||||
where
|
||||
qqq :: [Int64]
|
||||
qqq = map fromIntegral $ take 3000000 q
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
100 PROGRAM "QSequen.bas"
|
||||
110 LET LIMIT=1000
|
||||
120 NUMERIC Q(1 TO LIMIT)
|
||||
130 LET Q(1),Q(2)=1
|
||||
140 FOR I=3 TO LIMIT
|
||||
150 LET Q(I)=Q(I-Q(I-1))+Q(I-Q(I-2))
|
||||
160 NEXT
|
||||
170 PRINT "First 10 terms:"
|
||||
180 FOR I=1 TO 10
|
||||
190 PRINT Q(I);
|
||||
200 NEXT
|
||||
210 PRINT :PRINT "Term 1000:";Q(1000)
|
||||
39
Task/Hofstadter-Q-sequence/Icon/hofstadter-q-sequence.icon
Normal file
39
Task/Hofstadter-Q-sequence/Icon/hofstadter-q-sequence.icon
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
link printf
|
||||
|
||||
procedure main()
|
||||
|
||||
V := [1, 1, 2, 3, 3, 4, 5, 5, 6, 6]
|
||||
every i := 1 to *V do
|
||||
if Q(i) ~= V[i] then stop("Assertion failure for position ",i)
|
||||
printf("Q(1 to %d) - verified.\n",*V)
|
||||
|
||||
q := Q(n := 1000)
|
||||
v := 502
|
||||
printf("Q[%d]=%d - %s.\n",n,v,if q = v then "verified" else "failed")
|
||||
|
||||
invcount := 0
|
||||
every i := 2 to (n := 100000) do
|
||||
if Q(i) < Q(i-1) then {
|
||||
printf("Q(%d)=%d < Q(%d)=%d\n",i,Q(i),i-1,Q(i-1))
|
||||
invcount +:= 1
|
||||
}
|
||||
printf("There were %d inversions in Q up to %d\n",invcount,n)
|
||||
end
|
||||
|
||||
|
||||
|
||||
procedure Q(n) #: Hofstader Q sequence
|
||||
static S
|
||||
initial S := [1,1]
|
||||
|
||||
if q := S[n] then return q
|
||||
else {
|
||||
q := Q(n - Q(n - 1)) + Q(n - Q(n - 2))
|
||||
if *S = n - 1 then {
|
||||
put(S,q)
|
||||
return q
|
||||
}
|
||||
else
|
||||
runerr(500,n)
|
||||
}
|
||||
end
|
||||
8
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-1.j
Normal file
8
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-1.j
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
Qs=:0 1 1
|
||||
Q=: verb define
|
||||
n=. >./,y
|
||||
while. n>:#Qs do.
|
||||
Qs=: Qs,+/(-_2{.Qs){Qs
|
||||
end.
|
||||
y{Qs
|
||||
)
|
||||
1
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-2.j
Normal file
1
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-2.j
Normal file
|
|
@ -0,0 +1 @@
|
|||
Q=: 1:`(+&$:/@:- $:@-& 1 2)@.(>&2)"0 M.
|
||||
6
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-3.j
Normal file
6
Task/Hofstadter-Q-sequence/J/hofstadter-q-sequence-3.j
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
Q 1+i.10
|
||||
1 1 2 3 3 4 5 5 6 6
|
||||
Q 1000
|
||||
502
|
||||
+/2>/\ Q 1+i.100000
|
||||
49798
|
||||
46
Task/Hofstadter-Q-sequence/Java/hofstadter-q-sequence.java
Normal file
46
Task/Hofstadter-Q-sequence/Java/hofstadter-q-sequence.java
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public class HofQ {
|
||||
private static Map<Integer, Integer> q = new HashMap<Integer, Integer>(){{
|
||||
put(1, 1);
|
||||
put(2, 1);
|
||||
}};
|
||||
|
||||
private static int[] nUses = new int[100001];//not part of the task
|
||||
|
||||
public static int Q(int n){
|
||||
nUses[n]++;//not part of the task
|
||||
if(q.containsKey(n)){
|
||||
return q.get(n);
|
||||
}
|
||||
int ans = Q(n - Q(n - 1)) + Q(n - Q(n - 2));
|
||||
q.put(n, ans);
|
||||
return ans;
|
||||
}
|
||||
|
||||
public static void main(String[] args){
|
||||
for(int i = 1; i <= 10; i++){
|
||||
System.out.println("Q(" + i + ") = " + Q(i));
|
||||
}
|
||||
int last = 6;//value for Q(10)
|
||||
int count = 0;
|
||||
for(int i = 11; i <= 100000; i++){
|
||||
int curr = Q(i);
|
||||
if(curr < last) count++;
|
||||
last = curr;
|
||||
if(i == 1000) System.out.println("Q(1000) = " + curr);
|
||||
}
|
||||
System.out.println("Q(i) is less than Q(i-1) for i <= 100000 " + count + " times");
|
||||
|
||||
//Optional stuff below here
|
||||
int maxUses = 0, maxN = 0;
|
||||
for(int i = 1; i<nUses.length;i++){
|
||||
if(nUses[i] > maxUses){
|
||||
maxUses = nUses[i];
|
||||
maxN = i;
|
||||
}
|
||||
}
|
||||
System.out.println("Q(" + maxN + ") was called the most with " + maxUses + " calls");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
var hofstadterQ = function() {
|
||||
var memo = [1,1,1];
|
||||
var Q = function (n) {
|
||||
var result = memo[n];
|
||||
if (typeof result !== 'number') {
|
||||
result = Q(n - Q(n-1)) + Q(n - Q(n-2));
|
||||
memo[n] = result;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
return Q;
|
||||
}();
|
||||
|
||||
for (var i = 1; i <=10; i += 1) {
|
||||
console.log('Q('+ i +') = ' + hofstadterQ(i));
|
||||
}
|
||||
|
||||
console.log('Q(1000) = ' + hofstadterQ(1000));
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
(() => {
|
||||
'use strict';
|
||||
|
||||
// hofQSeq :: Int -> [Int]
|
||||
const hofQSeq = x =>
|
||||
x > 2 ? tail(foldl((Q, n) =>
|
||||
n < 3 ? Q : Q.concat(
|
||||
Q[n - Q[n - 1]] + Q[n - Q[n - 2]]
|
||||
), [0, 1, 1],
|
||||
range(1, x))) : (x > 0 ? take(x, [1, 1]) : undefined);
|
||||
|
||||
|
||||
// GENERIC FUNCTIONS -------------------------------------------
|
||||
|
||||
// foldl :: (b -> a -> b) -> b -> [a] -> b
|
||||
const foldl = (f, a, xs) => xs.reduce(f, a),
|
||||
|
||||
// range :: Int -> Int -> [Int]
|
||||
range = (m, n) =>
|
||||
Array.from({
|
||||
length: Math.floor(n - m) + 1
|
||||
}, (_, i) => m + i),
|
||||
|
||||
// tail :: [a] -> [a]
|
||||
tail = xs => xs.length ? xs.slice(1) : undefined,
|
||||
|
||||
// last :: [a] -> a
|
||||
last = xs => xs.length ? xs.slice(-1)[0] : undefined,
|
||||
|
||||
// Int -> [a] -> [a]
|
||||
take = (n, xs) => xs.slice(0, n);
|
||||
|
||||
// TEST --------------------------------------------------------
|
||||
return {
|
||||
firstTen: hofQSeq(10),
|
||||
thousandth: last(hofQSeq(1000)),
|
||||
'Q<Q-1UpTo10E5': hofQSeq(100000)
|
||||
.reduce((a, x, i, xs) => x < xs[i - 1] ? a + 1 : a, 0)
|
||||
};
|
||||
})();
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
{"firstTen":[1, 1, 2, 3, 3, 4, 5, 5, 6, 6],
|
||||
"thousandth":502,
|
||||
"Q<Q-1UpTo10E5":49798}
|
||||
28
Task/Hofstadter-Q-sequence/Jq/hofstadter-q-sequence-1.jq
Normal file
28
Task/Hofstadter-Q-sequence/Jq/hofstadter-q-sequence-1.jq
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
# For n>=2, Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2))
|
||||
def Q:
|
||||
def Q(n):
|
||||
n as $n
|
||||
| (if . == null then [1,1,1] else . end) as $q
|
||||
| if $q[$n] != null then $q
|
||||
else
|
||||
$q | Q($n-1) as $q1
|
||||
| $q1 | Q($n-2) as $q2
|
||||
| $q2 | Q($n - $q2[$n - 1]) as $q3 # Q(n - Q(n-1))
|
||||
| $q3 | Q($n - $q3[$n - 2]) as $q4 # Q(n - Q(n-2))
|
||||
| ($q4[$n - $q4[$n-1]] + $q4[$n - $q4[$n -2]]) as $ans
|
||||
| $q4 | setpath( [$n]; $ans)
|
||||
end ;
|
||||
|
||||
. as $n | null | Q($n) | .[$n];
|
||||
|
||||
# count the number of times Q(i) > Q(i+1) for 0 < i < n
|
||||
def flips(n):
|
||||
(reduce range(3; n) as $n
|
||||
([1,1,1]; . + [ .[$n - .[$n-1]] + .[$n - .[$n - 2 ]] ] )) as $q
|
||||
| reduce range(0; n) as $i
|
||||
(0; . + (if $q[$i] > $q[$i + 1] then 1 else 0 end)) ;
|
||||
|
||||
# The three tasks:
|
||||
((range(0;11), 1000) | "Q(\(.)) = \( . | Q)"),
|
||||
|
||||
(100000 | "flips(\(.)) = \(flips(.))")
|
||||
20
Task/Hofstadter-Q-sequence/Jq/hofstadter-q-sequence-2.jq
Normal file
20
Task/Hofstadter-Q-sequence/Jq/hofstadter-q-sequence-2.jq
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
$ uname -a
|
||||
Darwin Mac-mini 13.3.0 Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64 x86_64
|
||||
$ time jq -r -n -f hofstadter.jq
|
||||
Q(0) = 1
|
||||
Q(1) = 1
|
||||
Q(2) = 1
|
||||
Q(3) = 2
|
||||
Q(4) = 3
|
||||
Q(5) = 3
|
||||
Q(6) = 4
|
||||
Q(7) = 5
|
||||
Q(8) = 5
|
||||
Q(9) = 6
|
||||
Q(10) = 6
|
||||
Q(1000) = 502
|
||||
flips(100000) = 49798
|
||||
|
||||
real 0m0.562s
|
||||
user 0m0.541s
|
||||
sys 0m0.011s
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
function hofstQseq(n, typerst::Type=Int)
|
||||
nmax = maximum(n)
|
||||
r = Vector{typerst}(nmax)
|
||||
r[1] = 1
|
||||
if nmax ≥ 2 r[2] = 1 end
|
||||
for i in 3:nmax
|
||||
r[i] = r[i - r[i - 1]] + r[i - r[i - 2]]
|
||||
end
|
||||
return r[n]
|
||||
end
|
||||
|
||||
println("First ten elements of sequence: ", join(hofstQseq(1:10), ", "))
|
||||
println("1000-th element: ", hofstQseq(1000))
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
seq = hofstQseq(1:100_000)
|
||||
cnt = count(diff(seq) .< 0)
|
||||
println("$cnt elements are less than the preceding one.")
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
// version 1.1.4
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val q = IntArray(100_001)
|
||||
q[1] = 1
|
||||
q[2] = 1
|
||||
for (n in 3..100_000) q[n] = q[n - q[n - 1]] + q[n - q[n - 2]]
|
||||
print("The first 10 terms are : ")
|
||||
for (i in 1..10) print("${q[i]} ")
|
||||
println("\n\nThe 1000th term is : ${q[1000]}")
|
||||
val flips = (2..100_000).count { q[it] < q[it - 1] }
|
||||
println("\nThe number of flips for the first 100,000 terms is : $flips")
|
||||
}
|
||||
14
Task/Hofstadter-Q-sequence/MAD/hofstadter-q-sequence.mad
Normal file
14
Task/Hofstadter-Q-sequence/MAD/hofstadter-q-sequence.mad
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
NORMAL MODE IS INTEGER
|
||||
VECTOR VALUES FMT = $2HQ(,I4,3H) =,I4*$
|
||||
|
||||
DIMENSION Q(1000)
|
||||
Q(1) = 1
|
||||
Q(2) = 1
|
||||
THROUGH FILL, FOR N=3, 1, N.G.1000
|
||||
FILL Q(N) = Q(N-Q(N-1)) + Q(N-Q(N-2))
|
||||
|
||||
THROUGH SHOW, FOR N=1, 1, N.G.10
|
||||
SHOW PRINT FORMAT FMT, N, Q(N)
|
||||
PRINT FORMAT FMT, 1000, Q(1000)
|
||||
|
||||
END OF PROGRAM
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
function Q = Qsequence(N)
|
||||
%% zeros are used to pre-allocate memory, this is not strictly necessary but can significantly improve performance for large N
|
||||
Q = [1,1,zeros(1,N-2)];
|
||||
for n=3:N
|
||||
Q(n) = Q(n-Q(n-1))+Q(n-Q(n-2));
|
||||
end;
|
||||
end;
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
Q := proc( n )
|
||||
option remember, system;
|
||||
if n = 1 or n = 2 then
|
||||
1
|
||||
else
|
||||
thisproc( n - thisproc( n - 1 ) ) + thisproc( n - thisproc( n - 2 ) )
|
||||
end if
|
||||
end proc:
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
> seq( Q( i ), i = 1 .. 10 );
|
||||
1, 1, 2, 3, 3, 4, 5, 5, 6, 6
|
||||
|
||||
> Q( 1000 );
|
||||
502
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
> flips := 0:
|
||||
> for i from 2 to 100000 do
|
||||
> if L[ i ] < L[ i - 1 ] then
|
||||
> flips := 1 + flips
|
||||
> end if
|
||||
> end do:
|
||||
> flips;
|
||||
49798
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
Qflips := proc( n )
|
||||
local a := Array( 1 .. n );
|
||||
a[ 1 ] := 1;
|
||||
a[ 2 ] := 1;
|
||||
for local i from 3 to n do
|
||||
a[ i ] := a[ i - a[ i - 1 ] ] + a[ i - a[ i - 2 ] ]
|
||||
end do;
|
||||
local flips := 0;
|
||||
for i from 2 to n do
|
||||
if a[ i ] < a[ i - 1 ] then
|
||||
flips := 1 + flips
|
||||
end if
|
||||
end do;
|
||||
flips
|
||||
end proc:
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
> Qflips( 10^5 );
|
||||
49798
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
Hofstadter[1] = Hofstadter[2] = 1;
|
||||
Hofstadter[n_Integer?Positive] := Hofstadter[n] = Block[{$RecursionLimit = Infinity},
|
||||
Hofstadter[n - Hofstadter[n - 1]] + Hofstadter[n - Hofstadter[n - 2]]
|
||||
]
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
Hofstadter /@ Range[10]
|
||||
{1,1,2,3,3,4,5,5,6,6}
|
||||
Hofstadter[1000]
|
||||
502
|
||||
Count[Differences[Hofstadter /@ Range[100000]], _?Negative]
|
||||
49798
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
cache = {1:1, 2:1}
|
||||
|
||||
Q = function(n)
|
||||
if not cache.hasIndex(n) then
|
||||
q = Q(n - Q(n-1)) + Q(n - Q(n-2))
|
||||
cache[n] = q
|
||||
end if
|
||||
return cache[n]
|
||||
end function
|
||||
|
||||
for i in range(1,10)
|
||||
print "Q(" + i + ") = " + Q(i)
|
||||
end for
|
||||
print "Q(1000) = " + Q(1000)
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
main :: [sys_message]
|
||||
main = [Stdout (lay (map showq ([1..10] ++ [1000])))]
|
||||
where showq n = "q!" ++ show n ++ " = " ++ show (q!n)
|
||||
|
||||
q :: [num]
|
||||
q = 0 : 1 : 1 : map f [3..] where f n = q!(n - q!(n-1)) + q!(n - q!(n-2))
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
MODULE QSequence;
|
||||
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
|
||||
|
||||
VAR n: CARDINAL;
|
||||
Q: ARRAY [1..1000] OF CARDINAL;
|
||||
|
||||
BEGIN
|
||||
Q[1] := 1;
|
||||
Q[2] := 1;
|
||||
FOR n := 3 TO 1000 DO
|
||||
Q[n] := Q[n-Q[n-1]] + Q[n-Q[n-2]];
|
||||
END;
|
||||
|
||||
WriteString("The first 10 terms are:");
|
||||
FOR n := 1 TO 10 DO
|
||||
WriteCard(Q[n],2);
|
||||
END;
|
||||
WriteLn();
|
||||
|
||||
WriteString("The 1000th term is:");
|
||||
WriteCard(Q[1000],4);
|
||||
WriteLn();
|
||||
END QSequence.
|
||||
14
Task/Hofstadter-Q-sequence/Nim/hofstadter-q-sequence.nim
Normal file
14
Task/Hofstadter-Q-sequence/Nim/hofstadter-q-sequence.nim
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
var q = @[1, 1]
|
||||
for n in 2 ..< 100_000: q.add q[n-q[n-1]] + q[n-q[n-2]]
|
||||
|
||||
echo q[0..9]
|
||||
assert q[0..9] == @[1, 1, 2, 3, 3, 4, 5, 5, 6, 6]
|
||||
|
||||
echo q[999]
|
||||
assert q[999] == 502
|
||||
|
||||
var lessCount = 0
|
||||
for n in 1 ..< 100_000:
|
||||
if q[n] < q[n-1]:
|
||||
inc lessCount
|
||||
echo lessCount
|
||||
16
Task/Hofstadter-Q-sequence/OCaml/hofstadter-q-sequence.ocaml
Normal file
16
Task/Hofstadter-Q-sequence/OCaml/hofstadter-q-sequence.ocaml
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
(* valid results for n in 0..119628 *)
|
||||
let seq_hofstadter_q n =
|
||||
let a = Bigarray.(Array1.create int16_unsigned c_layout n) in
|
||||
let () =
|
||||
for i = 0 to pred n do
|
||||
a.{i} <- if i < 2 then 1 else a.{i - a.{pred i}} + a.{i - a.{i - 2}}
|
||||
done
|
||||
in
|
||||
Seq.init n (Bigarray.Array1.get a)
|
||||
|
||||
let () =
|
||||
let count_backflip (a, c) b = b, if b < a then succ c else c
|
||||
and hq = seq_hofstadter_q 100_000 in
|
||||
let () = Seq.(hq |> take 10 |> iter (Printf.printf " %u")) in
|
||||
let () = Seq.(hq |> drop 999 |> take 1 |> iter (Printf.printf "\n%u\n")) in
|
||||
hq |> Seq.fold_left count_backflip (0, 0) |> snd |> Printf.printf "%u\n"
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
MODULE Hofstadter;
|
||||
IMPORT
|
||||
Out;
|
||||
|
||||
VAR
|
||||
i,count,q,prev: LONGINT;
|
||||
founds: ARRAY 100001 OF LONGINT;
|
||||
|
||||
PROCEDURE Q(n: LONGINT): LONGINT;
|
||||
BEGIN
|
||||
IF founds[n] = 0 THEN
|
||||
CASE n OF
|
||||
1 .. 2:
|
||||
founds[n] := 1
|
||||
ELSE founds[n] := Q(n - Q(n - 1)) + Q(n - Q(n - 2))
|
||||
END
|
||||
END;
|
||||
RETURN founds[n]
|
||||
END Q;
|
||||
|
||||
BEGIN
|
||||
(* first ten numbers in the sequence *)
|
||||
FOR i := 1 TO 10 DO
|
||||
Out.String("At ");Out.LongInt(i,0);Out.String(":> ");Out.LongInt(Q(i),4);Out.Ln
|
||||
END;
|
||||
|
||||
Out.String("1000th value: ");Out.LongInt(Q(1000),4);Out.Ln;
|
||||
|
||||
prev := 1;
|
||||
FOR i := 2 TO 100000 DO
|
||||
q := Q(i);
|
||||
IF q < prev THEN INC(count) END;
|
||||
prev := q
|
||||
END;
|
||||
Out.String("terms less than the previous: ");Out.LongInt(count,4);Out.Ln
|
||||
END Hofstadter.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
: QSeqTask
|
||||
| q i |
|
||||
ListBuffer newSize(100000) dup add(1) dup add(1) ->q
|
||||
0 3 100000 for: i [
|
||||
q add(q at(i q at(i 1-) -) q at(i q at(i 2 -) -) +)
|
||||
q at(i) q at(i 1-) < ifTrue: [ 1+ ]
|
||||
]
|
||||
q left(10) println q at(1000) println println ;
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
Q=vector(1000);Q[1]=Q[2]=1;for(n=3,#Q,Q[n]=Q[n-Q[n-1]]+Q[n-Q[n-2]]);
|
||||
Q1=vecextract(Q,"1..10");
|
||||
print("First 10 terms: "Q1,if(Q1==[1, 1, 2, 3, 3, 4, 5, 5, 6, 6]," (as expected)"," (in error)"));
|
||||
print("1000-th term: "Q[1000],if(Q[1000]==502," (as expected)"," (in error)"));
|
||||
20
Task/Hofstadter-Q-sequence/PL-I/hofstadter-q-sequence-1.pli
Normal file
20
Task/Hofstadter-Q-sequence/PL-I/hofstadter-q-sequence-1.pli
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
/* Hofstrader Q sequence for any "n". */
|
||||
|
||||
H: procedure options (main); /* 28 January 2012 */
|
||||
declare n fixed binary(31);
|
||||
|
||||
put ('How many values do you want? :');
|
||||
get (n);
|
||||
|
||||
begin;
|
||||
declare Q(n) fixed binary (31);
|
||||
declare i fixed binary (31);
|
||||
|
||||
Q(1), Q(2) = 1;
|
||||
do i = 1 upthru n;
|
||||
if i >= 3 then Q(i) = ( Q(i - Q(i-1)) + Q(i - Q(i-2)) );
|
||||
if i <= 20 then put skip list ('n=' || trim(i), Q(i));
|
||||
end;
|
||||
put skip list ('n=' || trim(i), Q(i));
|
||||
end;
|
||||
end H;
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
declare tally fixed binary (31) initial (0);
|
||||
|
||||
do i = 1 to n-1;
|
||||
if Q(i) > Q(i+1) then tally = tally + 1;
|
||||
end;
|
||||
put skip data (tally);
|
||||
35
Task/Hofstadter-Q-sequence/PL-M/hofstadter-q-sequence.plm
Normal file
35
Task/Hofstadter-Q-sequence/PL-M/hofstadter-q-sequence.plm
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
100H:
|
||||
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
|
||||
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
|
||||
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
|
||||
|
||||
PRINT$NUMBER: PROCEDURE (N);
|
||||
DECLARE S (7) BYTE INITIAL ('..... $');
|
||||
DECLARE (N, P) ADDRESS, C BASED P BYTE;
|
||||
P = .S(5);
|
||||
DIGIT:
|
||||
P = P - 1;
|
||||
C = N MOD 10 + '0';
|
||||
N = N / 10;
|
||||
IF N > 0 THEN GO TO DIGIT;
|
||||
CALL PRINT(P);
|
||||
END PRINT$NUMBER;
|
||||
|
||||
DECLARE Q (1001) ADDRESS;
|
||||
DECLARE N ADDRESS;
|
||||
|
||||
Q(1)=1;
|
||||
Q(2)=1;
|
||||
DO N=3 TO LAST(Q);
|
||||
Q(N) = Q(N-Q(N-1)) + Q(N-Q(N-2));
|
||||
END;
|
||||
|
||||
CALL PRINT(.'THE FIRST 10 TERMS ARE: $');
|
||||
DO N=1 TO 10;
|
||||
CALL PRINT$NUMBER(Q(N));
|
||||
END;
|
||||
|
||||
CALL PRINT(.(13,10,'THE 1000TH TERM IS: $'));
|
||||
CALL PRINT$NUMBER(Q(1000));
|
||||
CALL EXIT;
|
||||
EOF
|
||||
24
Task/Hofstadter-Q-sequence/Pascal/hofstadter-q-sequence.pas
Normal file
24
Task/Hofstadter-Q-sequence/Pascal/hofstadter-q-sequence.pas
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
Program HofstadterQSequence (output);
|
||||
|
||||
const
|
||||
limit = 100000;
|
||||
|
||||
var
|
||||
q: array [1..limit] of longint;
|
||||
i, flips: longint;
|
||||
|
||||
begin
|
||||
q[1] := 1;
|
||||
q[2] := 1;
|
||||
for i := 3 to limit do
|
||||
q[i] := q[i - q[i - 1]] + q[i - q[i - 2]];
|
||||
for i := 1 to 10 do
|
||||
write(q[i], ' ');
|
||||
writeln;
|
||||
writeln(q[1000]);
|
||||
flips := 0;
|
||||
for i := 1 to limit - 1 do
|
||||
if q[i] > q[i+1] then
|
||||
inc(flips);
|
||||
writeln('Flips: ', flips);
|
||||
end.
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
my @Q = (0,1,1);
|
||||
push @Q, $Q[-$Q[-1]] + $Q[-$Q[-2]] for 1..100_000;
|
||||
say "First 10 terms: [@Q[1..10]]";
|
||||
say "Term 1000: $Q[1000]";
|
||||
say "Terms less than preceding in first 100k: ",scalar(grep { $Q[$_] < $Q[$_-1] } 2..100000);
|
||||
21
Task/Hofstadter-Q-sequence/Perl/hofstadter-q-sequence-2.pl
Normal file
21
Task/Hofstadter-Q-sequence/Perl/hofstadter-q-sequence-2.pl
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
#!/usr/bin/perl
|
||||
use warnings;
|
||||
use strict;
|
||||
|
||||
my @hofstadters = ( 1 , 1 );
|
||||
while ( @hofstadters < 100000 ) {
|
||||
my $nextn = @hofstadters + 1;
|
||||
# array index counting starts at 0 , so we have to subtract 1 from the numbers!
|
||||
push @hofstadters , $hofstadters [ $nextn - 1 - $hofstadters[ $nextn - 1 - 1 ] ]
|
||||
+ $hofstadters[ $nextn - 1 - $hofstadters[ $nextn - 2 - 1 ]];
|
||||
}
|
||||
for my $i ( 0..9 ) {
|
||||
print "$hofstadters[ $i ]\n";
|
||||
}
|
||||
print "The 1000'th term is $hofstadters[ 999 ]!\n";
|
||||
my $less_than_preceding = 0;
|
||||
for my $i ( 0..99998 ) {
|
||||
$less_than_preceding++ if $hofstadters[ $i + 1 ] < $hofstadters[ $i ];
|
||||
}
|
||||
print "Up to and including the 100000'th term, $less_than_preceding terms are less " .
|
||||
"than their preceding terms!\n";
|
||||
35
Task/Hofstadter-Q-sequence/Perl/hofstadter-q-sequence-3.pl
Normal file
35
Task/Hofstadter-Q-sequence/Perl/hofstadter-q-sequence-3.pl
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#!perl
|
||||
use strict;
|
||||
use warnings;
|
||||
package Hofstadter;
|
||||
sub TIEARRAY {
|
||||
bless [undef, 1, 1], shift;
|
||||
}
|
||||
sub FETCH {
|
||||
my ($self, $n) = @_;
|
||||
die if $n < 1;
|
||||
if( $n > $#$self ) {
|
||||
my $start = $#$self + 1;
|
||||
$#$self = $n; # pre-allocate for efficiency
|
||||
for my $nn ( $start .. $n ) {
|
||||
my ($a, $b) = (1, 2);
|
||||
$_ = $self->[ $nn - $_ ] for $a, $b;
|
||||
$_ = $self->[ $nn - $_ ] for $a, $b;
|
||||
$self->[$nn] = $a + $b;
|
||||
}
|
||||
}
|
||||
$self->[$n];
|
||||
}
|
||||
|
||||
package main;
|
||||
|
||||
tie my (@q), "Hofstadter";
|
||||
|
||||
print "@q[1..10]\n";
|
||||
print $q[1000], "\n";
|
||||
|
||||
my $count = 0;
|
||||
for my $n ( 2 .. 100_000 ) {
|
||||
$count++ if $q[$n] < $q[$n - 1];
|
||||
}
|
||||
print "Extra credit: $count\n";
|
||||
27
Task/Hofstadter-Q-sequence/Phix/hofstadter-q-sequence.phix
Normal file
27
Task/Hofstadter-Q-sequence/Phix/hofstadter-q-sequence.phix
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
(phixonline)-->
|
||||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
|
||||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">Q</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
|
||||
|
||||
<span style="color: #008080;">function</span> <span style="color: #000000;">q</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">)</span>
|
||||
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">></span><span style="color: #000000;">l</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">l</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
|
||||
<span style="color: #000000;">Q</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">-</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]]+</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">-</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]]</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
|
||||
<span style="color: #008080;">return</span> <span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
|
||||
|
||||
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">q</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (or collect one by one)</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"First ten terms: %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">10</span><span style="color: #0000FF;">]})</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1000th: %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1000</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"100,000th: %,d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100_000</span><span style="color: #0000FF;">))</span>
|
||||
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
|
||||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100_000</span> <span style="color: #008080;">do</span>
|
||||
<span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]<</span><span style="color: #000000;">Q</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Flips up to 100,000: %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">})</span>
|
||||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
|
||||
<span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
|
||||
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"100,000,000th: %,d (%3.2fs)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">q</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100_000_000</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">})</span>
|
||||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
|
||||
<!--
|
||||
11
Task/Hofstadter-Q-sequence/Picat/hofstadter-q-sequence.picat
Normal file
11
Task/Hofstadter-Q-sequence/Picat/hofstadter-q-sequence.picat
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
go =>
|
||||
println([q(I) : I in 1..10]),
|
||||
println(q1000=q(1000)),
|
||||
Q = {q(I) : I in 1..100_000},
|
||||
println(flips=sum({1 : I in 2..100_000, Q[I-1] > Q[I]})),
|
||||
nl.
|
||||
|
||||
table
|
||||
q(1) = 1.
|
||||
q(2) = 1.
|
||||
q(N) = q(N-q(N-1)) + q(N-q(N-2)).
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue