Wiki

1[1, 7, 8, 4, 2, 1, 4]
2Original array:  [  1,   7,   8,   4,   2,   1,   4]
3
4Prefix averages: [1.0, 4.0, 5.3, 5.0, 4.4, 3.8, 3.9]
5
6-> Delete [1, 7, 8], with maximum average 5.3
7-> New array -> [4, 2, 1, 4]
8[1, 7, 8, 4, 2, 1, 4]
9^       ^
10[4, 2, 1, 4]
11^ ^
12[2, 1, 4]
13^       ^
14[]
15from fractions import Fraction
16def find_array_reductions(nums: List[int]) -> List[int]:
17    """Return list of lengths of max average prefix reductions."""
18
19    def max_prefix_avg(arr: List[int]) -> Tuple[float, int]:
20        """Return value and length of max average prefix in arr."""
21        if len(arr) == 0:
22            return (-math.inf, 0)
23
24        best_length = 1
25        best_average = Fraction(0, 1)
26        running_sum = 0
27
28        for i, x in enumerate(arr, 1):
29            running_sum += x
30            new_average = Fraction(running_sum, i)
31            if new_average >= best_average:
32                best_average = new_average
33                best_length = i
34
35        return (float(best_average), best_length)
36
37    removed_lengths = []
38    total_removed = 0
39
40    while total_removed < len(nums):
41        _, new_removal = max_prefix_avg(nums[total_removed:])
42        removed_lengths.append(new_removal)
43        total_removed += new_removal
44
45    return removed_lengths
46# Lengths of the segments in the upper convex hull
47# of the cumulative sum graph
48def upperSumHullLengths(arr):
49    if len(arr) < 2:
50        if len(arr) < 1:
51            return []
52        else:
53            return [1]
54    
55    hull = [(0, 0),(1, arr[0])]
56    for x in range(2, len(arr)+1):
57        # this has x coordinate x-1
58        prevPoint = hull[len(hull) - 1]
59        # next point in cumulative sum
60        point = (x, prevPoint[1] + arr[x-1])
61        # remove points not on the convex hull
62        while len(hull) >= 2:
63            p0 = hull[len(hull)-2]
64            dx0 = prevPoint[0] - p0[0]
65            dy0 = prevPoint[1] - p0[1]
66            dx1 = x - prevPoint[0]
67            dy1 = point[1] - prevPoint[1]
68            if dy1*dx0 < dy0*dx1:
69                break
70            hull.pop()
71            prevPoint = p0
72        hull.append(point)
73    
74    return [hull[i+1][0] - hull[i][0] for i in range(0, len(hull)-1)]
75
76
77print(upperSumHullLengths([  1,   7,   8,   4,   2,   1,   4]))
78

1[1, 7, 8, 4, 2, 1, 4]
2Original array:  [  1,   7,   8,   4,   2,   1,   4]
3
4Prefix averages: [1.0, 4.0, 5.3, 5.0, 4.4, 3.8, 3.9]
5
6-> Delete [1, 7, 8], with maximum average 5.3
7-> New array -> [4, 2, 1, 4]
8[1, 7, 8, 4, 2, 1, 4]
9^       ^
10[4, 2, 1, 4]
11^ ^
12[2, 1, 4]
13^       ^
14[]
15from fractions import Fraction
16def find_array_reductions(nums: List[int]) -> List[int]:
17    """Return list of lengths of max average prefix reductions."""
18
19    def max_prefix_avg(arr: List[int]) -> Tuple[float, int]:
20        """Return value and length of max average prefix in arr."""
21        if len(arr) == 0:
22            return (-math.inf, 0)
23
24        best_length = 1
25        best_average = Fraction(0, 1)
26        running_sum = 0
27
28        for i, x in enumerate(arr, 1):
29            running_sum += x
30            new_average = Fraction(running_sum, i)
31            if new_average >= best_average:
32                best_average = new_average
33                best_length = i
34
35        return (float(best_average), best_length)
36
37    removed_lengths = []
38    total_removed = 0
39
40    while total_removed < len(nums):
41        _, new_removal = max_prefix_avg(nums[total_removed:])
42        removed_lengths.append(new_removal)
43        total_removed += new_removal
44
45    return removed_lengths
46# Lengths of the segments in the upper convex hull
47# of the cumulative sum graph
48def upperSumHullLengths(arr):
49    if len(arr) < 2:
50        if len(arr) < 1:
51            return []
52        else:
53            return [1]
54    
55    hull = [(0, 0),(1, arr[0])]
56    for x in range(2, len(arr)+1):
57        # this has x coordinate x-1
58        prevPoint = hull[len(hull) - 1]
59        # next point in cumulative sum
60        point = (x, prevPoint[1] + arr[x-1])
61        # remove points not on the convex hull
62        while len(hull) >= 2:
63            p0 = hull[len(hull)-2]
64            dx0 = prevPoint[0] - p0[0]
65            dy0 = prevPoint[1] - p0[1]
66            dx1 = x - prevPoint[0]
67            dy1 = point[1] - prevPoint[1]
68            if dy1*dx0 < dy0*dx1:
69                break
70            hull.pop()
71            prevPoint = p0
72        hull.append(point)
73    
74    return [hull[i+1][0] - hull[i][0] for i in range(0, len(hull)-1)]
75
76
77print(upperSumHullLengths([  1,   7,   8,   4,   2,   1,   4]))
78[3, 1, 3]
79

1    module.exports = {
2        name: 'username',
3        description: "this is the username command",
4        async execute(message, args) {
5
6            const fetch = require('node-fetch');
7
8            if (args.length !== 1) {
9                return message.channel.send("invalid username wtf")
10            }
11
12            const ign = args[0]
13
14            if (ign.length > 16 || ign.length < 3) {
15                return message.channel.send("invalid username wtf")
16            }
17
18            const uuid = await fetch(`https://api.mojang.com/users/profiles/minecraft/${ign}`).then(data => data.json()).then(data => data.id).catch(err => message.channel.send("error wtf"));
19            const onlineInfo = await fetch(`https://api.hypixel.net/status?key=${john}&uuid=${uuid}`).then(data => data.json());
20
21            if (uuid.length !== 32) {
22                return;
23            }
24
25            if (onlineinfo.success) {
26                if (onlineinfo.session.online) {
27                    message.channel.send("they are online")
28                }
29                else {
30                    message.channel.send("they are offline")
31                }
32            }
33            else {
34                message.channel.send("hypixel api bad wtf")
35            }
36        }
37    }
38{
39    "name": "discordbot",
40    "version": "1.0.0",
41    "main": "main.js",
42    "scripts": {
43        "test": "echo \"Error: no test specified\" && exit 1",
44        "start": "node main.js"
45    },
46    "author": "",
47    "license": "ISC",
48    "description": "",
49    "dependencies": {
50        "discord.js": "^13.0.1",
51        "node-fetch": "^3.0.0"
52    }
53}
54import fetch from "node-fetch";
55

1time ./sort 30000
2
3./sort 30000  1.82s user 0.00s system 99% cpu 1.816 total
4time ./sort 30000
5
6./sort 30000  1.00s user 0.00s system 99% cpu 1.005 total
7time ./sort 30000
8
9./sort 30000  2.01s user 0.00s system 99% cpu 2.007 total
10#include <stdio.h>
11#include <stdlib.h>
12#include <stdbool.h>
13#include <time.h>
14
15int n;
16
17void bubblesort(int *buf)
18{
19    bool changed = true;
20    for (int i = n; changed == true; i--) { /* will always move at least one element to its rightful place at the end, so can shorten the search by 1 each iteration */
21        changed = false;
22
23        for (int x = 0; x < i-1; x++) {
24            if (buf[x] > buf[x+1]) {
25                /* swap */
26                int tmp = buf[x+1];
27                buf[x+1] = buf[x];
28                buf[x] = tmp;
29
30                changed = true;
31            }
32        }
33    }
34}
35
36int main(int argc, char *argv[])
37{
38    if (argc != 2) {
39        fprintf(stderr, "Usage: %s <arraysize>\n", argv[0]);
40        return EXIT_FAILURE;
41    }
42
43    n = atoi(argv[1]);
44    if (n < 1) {
45        fprintf(stderr, "Invalid array size.\n");
46        return EXIT_FAILURE;
47    }
48
49    int *buf = malloc(sizeof(int) * n);
50
51    /* init buffer with random values */
52    srand(time(NULL));
53    for (int i = 0; i < n; i++)
54        buf[i] = rand() % n + 1;
55
56    bubblesort(buf);
57
58    return EXIT_SUCCESS;
59}
60bubblesort:
61        mov     r9d, DWORD PTR n[rip]
62        xor     edx, edx
63        xor     r10d, r10d
64.L2:
65        lea     r8d, [r9-1]
66        cmp     r8d, edx
67        jle     .L13
68.L5:
69        movsx   rax, edx
70        lea     rax, [rdi+rax*4]
71.L4:
72        mov     esi, DWORD PTR [rax]
73        mov     ecx, DWORD PTR [rax+4]
74        add     edx, 1
75        cmp     esi, ecx
76        jle     .L2
77        mov     DWORD PTR [rax+4], esi
78        mov     r10d, 1
79        add     rax, 4
80        mov     DWORD PTR [rax-4], ecx
81        cmp     r8d, edx
82        jg      .L4
83        mov     r9d, r8d
84        xor     edx, edx
85        xor     r10d, r10d
86        lea     r8d, [r9-1]
87        cmp     r8d, edx
88        jg      .L5
89.L13:
90        test    r10b, r10b
91        jne     .L14
92.L1:
93        ret
94.L14:
95        lea     eax, [r9-2]
96        cmp     r9d, 2
97        jle     .L1
98        mov     r9d, r8d
99        xor     edx, edx
100        mov     r8d, eax
101        xor     r10d, r10d
102        jmp     .L5
103bubblesort:
104        mov     r9d, DWORD PTR n[rip]
105        xor     edx, edx
106        xor     r10d, r10d
107.L2:
108        lea     r8d, [r9-1]
109        cmp     r8d, edx
110        jle     .L13
111.L5:
112        movsx   rax, edx
113        lea     rcx, [rdi+rax*4]
114.L4:
115        movq    xmm0, QWORD PTR [rcx]
116        add     edx, 1
117        pshufd  xmm2, xmm0, 0xe5
118        movd    esi, xmm0
119        movd    eax, xmm2
120        pshufd  xmm1, xmm0, 225
121        cmp     esi, eax
122        jle     .L2
123        movq    QWORD PTR [rcx], xmm1
124        mov     r10d, 1
125        add     rcx, 4
126        cmp     r8d, edx
127        jg      .L4
128        mov     r9d, r8d
129        xor     edx, edx
130        xor     r10d, r10d
131        lea     r8d, [r9-1]
132        cmp     r8d, edx
133        jg      .L5
134.L13:
135        test    r10b, r10b
136        jne     .L14
137.L1:
138        ret
139.L14:
140        lea     eax, [r9-2]
141        cmp     r9d, 2
142        jle     .L1
143        mov     r9d, r8d
144        xor     edx, edx
145        mov     r8d, eax
146        xor     r10d, r10d
147        jmp     .L5
148## What GCC should have done,
149## if it was going to use this 64-bit load strategy at all
150
151        movsx   rax, edx           # apparently it wasn't able to optimize away your half-width signed loop counter into pointer math
152        lea     rcx, [rdi+rax*4]   # Usually not worth an extra instruction just to avoid an indexed load and indexed store, but let's keep it for easy comparison.
153.L4:
154        mov     rax, [rcx]       # into RAX instead of XMM0
155        add     edx, 1
156            #  pshufd  xmm2, xmm0, 0xe5
157            #  movd    esi, xmm0
158            #  movd    eax, xmm2
159            #  pshufd  xmm1, xmm0, 225
160        mov     rsi, rax
161        rol     rax, 32   # swap halves, just like the pshufd
162        cmp     esi, eax  # or eax, esi?  I didn't check which is which
163        jle     .L2
164        movq    QWORD PTR [rcx], rax   # conditionally store the swapped qword
165

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36start=time.time()
37for i in range(100):
38    result1 = summation(0, n, mysum)
39print('Slow method:', time.time()-start)
40
41# method #2
42start=time.time()
43for i in range(100):
44    w=np.arange(0, n+1, dtype=np.object)
45    result2 = (w**2*np.cumsum(w)).sum()
46print('Fast method:', time.time()-start)
47

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36start=time.time()
37for i in range(100):
38    result1 = summation(0, n, mysum)
39print('Slow method:', time.time()-start)
40
41# method #2
42start=time.time()
43for i in range(100):
44    w=np.arange(0, n+1, dtype=np.object)
45    result2 = (w**2*np.cumsum(w)).sum()
46print('Fast method:', time.time()-start)
47Slow method: 0.06906533241271973
48Fast method: 0.008007287979125977
49

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36start=time.time()
37for i in range(100):
38    result1 = summation(0, n, mysum)
39print('Slow method:', time.time()-start)
40
41# method #2
42start=time.time()
43for i in range(100):
44    w=np.arange(0, n+1, dtype=np.object)
45    result2 = (w**2*np.cumsum(w)).sum()
46print('Fast method:', time.time()-start)
47Slow method: 0.06906533241271973
48Fast method: 0.008007287979125977
49# method #3
50import itertools
51start=time.time()
52for i in range(100):
53    result3 = sum(x*x * ysum for x, ysum in enumerate(itertools.accumulate(range(n+1))))
54print('Faster, pure python:', (time.time()-start))
55

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36start=time.time()
37for i in range(100):
38    result1 = summation(0, n, mysum)
39print('Slow method:', time.time()-start)
40
41# method #2
42start=time.time()
43for i in range(100):
44    w=np.arange(0, n+1, dtype=np.object)
45    result2 = (w**2*np.cumsum(w)).sum()
46print('Fast method:', time.time()-start)
47Slow method: 0.06906533241271973
48Fast method: 0.008007287979125977
49# method #3
50import itertools
51start=time.time()
52for i in range(100):
53    result3 = sum(x*x * ysum for x, ysum in enumerate(itertools.accumulate(range(n+1))))
54print('Faster, pure python:', (time.time()-start))
55Faster, pure python: 0.0009944438934326172
56

1import numpy as np
2import time
3
4def summation(start,end,func):
5    sum=0
6    for i in range(start,end+1):
7        sum+=func(i)
8    return sum
9
10def x(y):
11    return y
12
13def x2(y):
14    return y**2
15
16def mysum(y):
17    return x2(y)*summation(0, y, x)
18
19n=100
20
21# method #1
22start=time.time()
23summation(0,n,mysum)
24print('Slow method:',time.time()-start)
25
26# method #2
27start=time.time()
28w=np.arange(0,n+1)
29(w**2*np.cumsum(w)).sum()
30print('Fast method:',time.time()-start)
31# method #2
32start=time.time()
33w=np.arange(0, n+1, dtype=np.object)
34result2 = (w**2*np.cumsum(w)).sum()
35print('Fast method:', time.time()-start)
36start=time.time()
37for i in range(100):
38    result1 = summation(0, n, mysum)
39print('Slow method:', time.time()-start)
40
41# method #2
42start=time.time()
43for i in range(100):
44    w=np.arange(0, n+1, dtype=np.object)
45    result2 = (w**2*np.cumsum(w)).sum()
46print('Fast method:', time.time()-start)
47Slow method: 0.06906533241271973
48Fast method: 0.008007287979125977
49# method #3
50import itertools
51start=time.time()
52for i in range(100):
53    result3 = sum(x*x * ysum for x, ysum in enumerate(itertools.accumulate(range(n+1))))
54print('Faster, pure python:', (time.time()-start))
55Faster, pure python: 0.0009944438934326172
56# method #4
57start=time.time()
58for i in range(100):
59    w = np.arange(0, n+1, dtype=np.object)
60    result2 = (w*w*np.cumsum(w)).sum()
61print('Fast method x*x:', time.time()-start)
62