/tech/ - Technology★

I think there should be a week waiting time before anyone is allowed to reply so OP has to do his homework himself first.

1. sort list

2. begin looping through items starting at beginning of list

3. if the current element's value is equal to the value at the current index + L/2, return that element

4. keep going until that value is found, or reached L/2

>>808652

Not my homework, nice try.

>>808653

No pesudocode allowed.

>>808655

>>808655

op copied the problem from https://www.codeeval.com/browse/132/

he wants us to come up with an original answer for him to put on his profile

Done. It could be neater, and I've taken some liberties with the output so that you can't use it as homework, but it works.

Save as homework.perl and use it like so:

perl homework.perl "92,19,19,76,19,21,19,85,19,19,19,94,19,19,22,67,83,19,19,54,59,1,19,19"
>19

perl homework.perl "92,11,30,92,1,11,92,38,92,92,43,92,92,51,92,36,97,92,92,92,43,22,84,92,92"
>92

perl homework.perl "4,79,89,98,48,42,39,79,55,70,21,39,98,16,96,2,10,24,14,47,0,50,95,20,95,48,50,12,42"
>None

perl homework.perl
>Crashes because I'm too lazy to add an alternative.

https://hastebin.com/ribenivili.pl

>>808712

>perl

>>808650 (OP)

>women and rust get a 10% bonus

Your 'challenge' gets a 110% penalty for this cancer, OP. Hang your head in shame.

>>808715

OP gets the code he deserves in the language he deserves.

At least he would, but I don't know Rust.

I'm a black Jewish trans M2F otherkin who identifies as lesbian. I felt unsafe coding in Rust which is a toxic masculine name. Coded in Mathematica because it's proprietary.

majorElement[lst_] :=
 SelectFirst[
   Tally[lst], #[[2]] > Length[lst]/2 &] /.
  {Missing[_] -> "None",
   {x_, c_} -> x}

Use a dictionary

O(n), can't do it faster I believe.

>>808728

It can be done in O(1) time you dumb nigger.

>>808731

How? **You dumb nigger*

>>808732

O(k) is asymptotically equivalent to O(1) for any constant k you double nigger.

>>808734

O(L) then. Happy faggot? Learn standard notation, n is the length of the sequence

>>808735

Please give me a value of n where O(n) wouldn't be a constant.

>>808749

n=a variable=the length of the sequence

You're insane. Now show me how to do it in constant time rather than linear, faggot

>>808753

no you double faggot

>>808753

Impossible. Only alternative to O(n) would be probabilistic (Monte Carlo) methods up to some desired confidence interval.

>>808753

>n=a variable=the length of the sequence

No, nigger, that's L.

>show me how to do it in constant time

It's trivial. Do you even know what constant time means?

jesus christ stop taking such obvious bait

>>808650 (OP)

>N is in range [0, 100]

this is retarded just create an array of 100 counters and record the largest one.

That's it, now do your fucking homework.

>>808788

> 0 to 100

> create 100 counters

You don’t deserve those dubs.

I can do it in O(\alpha n):

Get a hash table where putting shit in each bin is O(\alpha)

Put every item there.

I assume the hash table has a "majorest element" and "amount of times it appears" that gets updated when you put the element in each bin (which stores how many times the element appeared).

Then take the majorest element of the hash table.

My solution is "faster" than >>808653 because I don't do the nlog(n) bit. All you have to do is control \alpha and you're golden (most times \alpha won't go over a constant). Just have a good hash function that doesn't put everything in the same bin.

>>808788

Right. That there is the hash function. Then my answer is O(L).

>>808795

It's O(n) you dumb nigger.

>>808801

>can't do it in constant time

>calls others dumb niggers

function major(L) 
  local M = {}
  local max_n = nil
  local max_count = 0
  local length = 0
  for n in L do
    M[n] = (M[n] or 0) + 1
    length = length + 1
  end
  for n,count in pairs(M) do
    if count > max_count then
      max_n = n
      max_count = count
    end
  end
  if max_count > length/2 then
    return max_n
  end
end

for line in io.lines(arg[1]) do
  print(major(string.gmatch(line, "%d+")) or "None")
end

Usage:

$ cat data
92,19,19,76,19,21,19,85,19,19,19,94,19,19,22,67,83,19,19,54,59,1,19,19
92,11,30,92,1,11,92,38,92,92,43,92,92,51,92,36,97,92,92,92,43,22,84,92,92
4,79,89,98,48,42,39,79,55,70,21,39,98,16,96,2,10,24,14,47,0,50,95,20,95,48,50,12,42
$ luajit shit.lua data 
19
92
None

Gotta go fast, faggots. Also, I identify as I woman.

#include <unistd.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define MAX_L 30000
#define SEPARATOR_LENGTH 1
#define EOL_LENGTH 1
#define MAX_N_LENGTH 1
#define MAX_CASES 40
#define MAX_LINE_LENGTH ((SEPARATOR_LENGTH * (MAX_L - 1)) + (MAX_N_LENGTH * MAX_L) + EOL_LENGTH)
#define MAX_FILE_LENGTH MAX_LINE_LENGTH * MAX_CASES

char buffer[MAX_FILE_LENGTH + 1];
uint_fast64_t counts[100];
uint_fast64_t const tens[] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};

inline uint_fast64_t parse_n(char * restrict * restrict c) {
  uint_fast64_t retval = 0;

  char *begin = *c;
  while(**c >= '0' && **c <= '9') {
    ++*c;
  }

  int len = *c - begin;

  switch(len) {
    case 3: retval = 100; break;
    case 2: retval = tens[begin[len - 2] - '0'];
    case 1: retval += begin[len - 1] - '0';
  }

  return retval;
}

int main(int argc, char *argv[]) {
  uint_fast64_t n;
  uint_fast16_t l;
  int i;

  int fd = open(argv[1], O_RDONLY);
  (void) read(fd, buffer, MAX_FILE_LENGTH);

  char *c = buffer;
  goto start;
  for(; *c; ++c) {
    (void) memset(counts, 0, sizeof(counts));
start:
    for(l = 1; ; ++l, ++c) {
      n = parse_n(&c);
      ++counts[n];
      if(*c == '\n') break;
    }
    uint_fast16_t half = l >> 1;
    for(i = 0; i < 100; ++i) {
      if(counts[i] > half) {
        printf("%d\n", i);
        break;
      }
    }
    if(i == 100) printf("None\n");
  }
}

It could go faster with pthreads but it's just extra bulk for what would be a pretty boring split of a buffer across threads.

>>808872

You need 101 bins, faggot.

>>808894

No, I identify as a woman, I can get away with it.

>>808911

I am so sorry. Will educate myself to be aware of my own privilege. I will learn from this teaching experience.

>>808715

Perl beautiful language

perl -nE 'chomp;@a=split/,/;%c;$c{$_}++for@a;say((grep{$c{$_}>=~~@a/2}@a)[0]||None)' cocks

I'm not gay

>>809087

Post the source not the binary, dumbass.

>>808872

[code]

> goto start;

> for(; *c; ++c) {

> (void) memset(counts, 0, sizeof(counts));

>start:

What is going on here?

>>809100

I'm skipping the first initialization since it's guaranteed to start zeroed. Jumping midway into a loop on the first iteration is generally a cleaner way to deal with that.

>>809107

Argh, I need to sleep, I swear that { wasn't there when I first looked.

Bump. Do something for once, /tech/.

>>809140

Even 4/g/ is better at programming than /tech/ lmao

>>808872

g++ challenge.c -o a.out

challenge.c:21:46: error: expected ‘,’ or ‘...’ before ‘*’ token
 inline uint_fast64_t parse_n(char * restrict * restrict c) {
                                              ^
challenge.c: In function ‘uint_fast64_t parse_n(char*)’:
challenge.c:24:18: error: ‘c’ was not declared in this scope
   char *begin = *c;
                  ^
challenge.c: In function ‘int main(int, char**)’:
challenge.c:54:21: error: cannot convert ‘char**’ to ‘char*’ for argument ‘1’ to ‘uint_fast64_t parse_n(char*)’
       n = parse_n(&c);

>>809238

>g++

>c

kys

>>809245

gcc challenge.c
In function `main':
challenge.c:(.text+0x87): undefined reference to `parse_n'
collect2: error: ld returned 1 exit status

>>809251

remove the 'inline' from the start of parse_n's definition.

>>809251

Why are you even on this board if you don't know shit about technology?

>$ gcc anon.c -std=c99 -O2

>>809252

No retard.

>>809253

>he doesn't use C89

hipster.

[[$]] major_search.

$<[[containers]]::*.
$<[[iterators]]::while,break.
$<[[stdio]]::[File printf].
$<[[string]]::String.

$::main<%({argc: i32 argv: u8*[]} i32 ->
  argc!=2? $::printf{"Usage: %s [file]" argv[0]}.

  list_count := 0.
  new counts: $::HashMap(i32 i32).
  f := $::File::open argv[1].
  f::seek 0.
  str := $::String::new{f::read f::tell}.
  f::close!.

  $::while %(bool -> !str::empty!) %(->
    pos := str::find','.
    !pos? $::break!.

    num: i32 = str::substr{0, pos}::to_i32!.
    !counts::contains{num}?
      counts::set{num 1} :
      counts::set{num counts::get{num}+1}.
    str::shift pos+1.
    list_count++.
  ).

  counts::map %({key: i32 val: i32} ->
    val >= list_count/2? (
      $::printf{"%d\n" key}. $=0.
    ).
  ).

  $::printf"None\n".
  0.
).

>retards actually doing this faggots homework

lmao

>>809279

I encourage retards to get by through stealing homework, they'll inevitably fail their exams.

>>809276

gib terminal configuration

#!/bin/python2.7
import argparse
import sqlite3
from multiprocessing import Pool

def dowork(sequence):
	conn=sqlite3.connect(':memory:')
	cursor=conn.cursor()

	seq_list=sequence.split(',')
	target_length=(len(seq_list)/2)

	cursor.execute ('CREATE TABLE IF NOT EXISTS challenge (integers integer)')
	for integer in seq_list:
		cursor.execute('INSERT INTO challenge VALUES (?)',(int(integer),) )
		conn.commit()
	cursor.execute('SELECT integers, COUNT(*) FROM challenge GROUP BY integers HAVING COUNT(*) > (?)',(target_length,))
		
	fetch=cursor.fetchone()
	if fetch!=None:
		return fetch[0]
	else:
		return 'None'

	cursor.execute('DROP TABLE challenge')
	conn.commit()
	conn.close()
	
def main():
	parser=argparse.ArgumentParser()
	parser.add_argument('filename',type=str)
	args=parser.parse_args()
	try:
		sequences=open(args.filename,'r').read().rstrip().split('\n')
	except:
		print 'None'

	p=Pool(8)
	majors=p.map(dowork,sequences)
	for major in majors:
		print major

if __name__=="__main__":
	main()

>>809307

Which is why you'll be able to use ANY language when you graduate.

Wow, you're making me realize just how much I suck a programming OP.

I tried doing this in C and I'm struggling to parse the fucking input.

I guess this is what happens when you only do algorithms (which is what you should be learning in school).

Also here's a hint to the people in this thread.

If you're using a hash table or any kind of bucket you're probably doing it wrong.

>>809307

Nope, "computer science" was considered a branch of mathematics when I went to school.

>>809307

Europoor here, we did Java in the first year and Assembly, Haskell and Prolog in the second. Half of each year and the whole of year 3 got delegated to theory, and we picked our own programming languages to fuck around with. The problem is that we all picked different languages to use primarily, and there were a lot of arguments on Python2 vs 3, PHP vs Perl and Java vs C#.

Theory is great, but you have to get your hands dirty with code too.

use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() {
    let mut args = std::env::args_os().skip(1);
    assert_eq!(args.len(), 1, "exactly 1 arg you stupid nigger");

    let file = File::open(args.next().unwrap()).expect("i can't open this file you retarded fag");
    let reader = BufReader::new(file);
    let mut map = HashMap::new();

    for line in reader
        .lines()
        .map(|r| r.expect("your fucking shit isnt utf8")) {
        let mut count = 0;

        for i in line.split(',')
            .map(|s| s.parse::<u32>().expect("hitler dindu nuffin")) {
            *map.entry(i).or_insert(0) += 1;
            count += 1;
        }

        if let Some((k, _)) = map.drain()
            .filter(|&(_, v)| v >= count / 2)
            .max_by_key(|&(_, v)| v) {
            println!("{}", k);
        } else {
            println!("None");
        }
    }
}

>>809307

>We barely see code, here, we mostly focus on the logical/mathematical aspect of things.

That's because Euro CS is dead. In the '90s, you used to be all code and would do class projects as an entire class led by the professor. It's why Euro CS grads were so good back then. Today, you have the standard post-modern Jewish CS education where you learn no CS and produce CS Grads.

#include <stdio.h>
#include <stdlib.h>

#define L_MAX 30000

struct element {
	int value;
	int n;
};

struct element_list {
	struct element elements[L_MAX];
	size_t index;
	size_t max_index;
};

void
initElementList(struct element_list *elist)
{
	elist->index = 0;
	elist->max_index = 0;
}

int
findElementByValue(int value, struct element_list *elist)
{
	int i;

	for (i = 0; i < elist->max_index; i++) {
		if (elist->elements[i].value == value)
			return i;
	}

	return -1;
}

void
addValueToList(int value, struct element_list *elist) {
	int idx;

	if ((idx = findElementByValue(value, elist)) == -1) {
		elist->elements[elist->max_index].value = value;
		elist->elements[elist->max_index].n = 1;
		elist->max_index++;
	} else {
		elist->elements[idx].n++;
	}
}

int
findMajorElement(struct element_list *elist)
{
	int i;
	int max = 0;
	int max_index = 0;

	if (elist->max_index == 0) return -1;

	for (i = 0; i < elist->max_index; i++) {
		if (elist->elements[i].n > max) {
			max = elist->elements[i].n;
			max_index = i;
		}
	}

	if (max > (elist->max_index / 2)) {
		return elist->elements[max_index].value;
	}

	return -1;
}

int
main (int argc, char *argv[])
{
	FILE *fp;
	char c;
	char buf[3];
	size_t buf_idx = 0;
	struct element_list elist;
	int major;

	initElementList(&elist);

	if (argc == 1) {
		printf("No input file.\n");
	} else {
		while (--argc > 0) {
			if (!(fp = fopen(*++argv, "r"))) {
				printf("Can not open file.");
				exit(1);
			} else {
				while ((c = getc(fp)) != EOF) {
					if ((c >= '0') && (c <= '9')) {
						buf[buf_idx] = c;
						buf_idx++;
					} else if ((c == ',') || (c == '\n')) {
						if (buf_idx <= 2) buf[buf_idx] = '\0';
						buf_idx = 0;

						addValueToList(atoi(buf), &elist);

						if (c == '\n') {
							if ((major = findMajorElement(&elist)) != -1) {
								printf("%d\n", major);
							} else {
								printf("None\n");
							}

							initElementList(&elist);
						}
					} else if (c == ' ') {
						/* Ignore spaces. */
					} else {
						printf("Unexpected character %c.\n", c);
					}
				}

				fclose(fp);
			}
		}
	}

	return 0;
}

From 0 to pajeet how bad is my code?

>>809352

>calling an array a list

>O(N) insertion to array when the problem requires an int n->int m map and n can only have 101 possible values

>mixed bracing

>function types on the previous line

>using a 3-char buf instead of replacing ',' and '\0' and reusing parts of the input string smh

>getc()'s return assigned to a char

>trying to printf("%c") the -1 you'll get on from getc() on EOF

0.2pajeet

I hate you

>>809288

Xresources

URxvt.perl-ext:
URxvt.perl-ext-common: selection-to-clipboard

#define termfont      xft:tewi:pixelsize=13:antialias=false

URxvt.font: termfont
URxvt.boldFont: termfont

URxvt.intensityStyles: false
URxvt.boldMode: false
URxvt.skipBuiltinGlyphs: true
URxvt.loginShell: true
URxvt*title: urxvt
URxvt*termName: rxvt-unicode
URxvt*urgentOnBell: true
URxvt.letterSpacing: 1

URxvt.borderless: true
URxvt.internalBorder: 20

URxvt.scrollBar: false
URxvt.scrollBar_right: false
URxvt.scrollstyle: plain
URxvt.jumpScroll: false

URxvt.scrollWithBuffer: true
URxvt.scrollTtyKeypress: true
URxvt.scrollTtyOutput: false

URxvt.buffered: true
URxvt.pointerBlank: true
URxvt.underlineURLs: true
URxvt.saveLines: 2048

URxvt.url-select.launcher: /opt/waterfox/waterfox-bin
URxvt.url-select.underline: true
URxvt.iso14755: false
URxvt.iso14755_52: false

Xft.antialias: true
Xft.autohint: false
Xft.dpi: 96
Xft.hinting: true
Xft.hitstyle: hintslight
Xft.lcdfilter: lcddefault
Xft.rgba: rgb

Xcursor.size: 15

URxvt.utf8: true
URxvt.locale: true

! X colors.
! Generated by 'wal'
emacs*foreground:   #BDBBD2
emacs*background:   #1D1C22
URxvt*foreground:   #BDBBD2
XTerm*foreground:   #BDBBD2
UXTerm*foreground:  #BDBBD2
URxvt*background:   [100]#1D1C22
XTerm*background:   #1D1C22
UXTerm*background:  #1D1C22
URxvt*cursorColor:  #BDBBD2
XTerm*cursorColor:  #BDBBD2
UXTerm*cursorColor: #BDBBD2
URxvt*borderColor:  [100]#1D1C22

! Colors 0-15.
*.color0: #1D1C22
*color0:  #1D1C22
*.color1: #588877
*color1:  #588877
*.color2: #606F8B
*color2:  #606F8B
*.color3: #D060AE
*color3:  #D060AE
*.color4: #19A494
*color4:  #19A494
*.color5: #609E9B
*color5:  #609E9B
*.color6: #43DBD4
*color6:  #43DBD4
*.color7: #BDBBD2
*color7:  #BDBBD2
*.color8: #77767a
*color8:  #77767a
*.color9: #588877
*color9:  #588877
*.color10: #606F8B
*color10:  #606F8B
*.color11: #D060AE
*color11:  #D060AE
*.color12: #19A494
*color12:  #19A494
*.color13: #609E9B
*color13:  #609E9B
*.color14: #43DBD4
*color14:  #43DBD4
*.color15: #BDBBD2
*color15:  #BDBBD2

! Black color that will not be affected by bold highlighting.
*.color66: #1D1C22
*color66:  #1D1C22

! Rofi colors.
rofi.color-window: #1D1C22, #1D1C22, #606F8B
rofi.color-normal: #1D1C22, #BDBBD2, #1D1C22, #606F8B, #1D1C22
rofi.color-active: #1D1C22, #BDBBD2, #1D1C22, #606F8B, #1D1C22
rofi.color-urgent: #1D1C22, #588877, #1D1C22, #588877, #BDBBD2

! Xclock colors.
XClock*foreground: #BDBBD2
XClock*background: #1D1C22
XClock*majorColor:  rgba:bd/bb/d2/ff
XClock*minorColor:  rgba:bd/bb/d2/ff
XClock*hourColor:   rgba:bd/bb/d2/ff
XClock*minuteColor: rgba:bd/bb/d2/ff
XClock*secondColor: rgba:bd/bb/d2/ff

! Set depth to make transparency work.
URxvt*depth: 32

font: https://github.com/Lucy/tewi-font

>>809324

The same thing without the hashmap

use std::fs::File;
use std::io::{BufRead, BufReader};
use std::env::args_os;

fn main() {
    let filename = args_os().skip(1).next().expect(
        "exactly 1 arg you stupid nigger",
    );

    let reader = BufReader::new(File::open(filename).expect(
        "i can't open this file you retarded fag",
    ));

    for line in reader.lines().map(
        |r| r.expect("your fucking shit isnt utf8"),
    )
    {
        let mut buf: [u32; 101] = [0; 101];
        let mut cnt = 0;

        for n in line.split(',') {
            buf[n.parse::<usize>().expect("hitler dindu nuffin")] += 1;
            cnt += 1;
        }

        match buf.into_iter().position(|x| *x > cnt / 2) {
            Some(n) => println!("{}", n),
            _ => println!("None"),
        }
    }
}

>>809324

Now we need the Ada version.

>>809390

>expect("error message")

expect

the English word "expect"

used for that

<triggered

>>808791

Alright, you win. 99 then.

>>809453

101 my black friend.

>>809482

Thank me for bothering to correct you.

>>809390

So how does it perform?

>>809494

explain

>>809298

i wonder why this isn't faster than it is. it's not much faster than my straight python solution, isn't the sqlite3 module for python C? All the work here should be done by sqlite3 but it's still slow.

>>809569

Databases are ridiculously fucking slow, anon. And sqlite3 is slow for a database.

>>809298

There's up to 30,000 numbers in each test right? You're probably spending a lot of time inserting each row individually. Look into doing a bulk insert, or possibly grouping those inserts into a single transaction. Of course this is just conjecture, and you should profile to see where time is being spent.

>>809578

A script to create test data if anyone wants it.

#!/usr/bin/python
from random import random

for t in xrange(40):
    l = 10000 + int((30000 - 10000 + 1) * random())
    bias = 10 * random()
    result = []
    for i in xrange(l):
        n = int(random()**bias * (100 + 1))
        result.append(n)
    print ",".join([str(x) for x in result])

>>809582

i was _just_ about to write one myself. thx

>>809582

>>809587

same, already did too

import random

string=''
row_count=40
integer_count=50000

row_counter=0
while(row_counter<row_count):
	integer_counter=0
	while(integer_counter<integer_count):
		string+=str(random.randint(0,100))+','
		integer_counter+=1
	string=string[:-1]+'\n'
	row_counter+=1
string=string[:-1]

f=open('testdata','w')
f.write(string)
f.close()

>>809578

doing a batch insert with executemany instead of one by one improved performance by 500%.

testing on 40 rows with 50k integers each:

10-11s with

>>809298

2-2.4s with

#!/bin/python2.7
import argparse
import sqlite3
from multiprocessing import Pool

def dowork(sequence):
	conn=sqlite3.connect(':memory:')
	cursor=conn.cursor()

	seq_list=sequence.split(',')
	target_length=(len(seq_list)/2)

	seq_list_int=[]
	for integer_str in seq_list:
		seq_list_int.append( ( int(integer_str),) )

	cursor.execute ('CREATE TABLE challenge (integers integer)')
	cursor.executemany('INSERT INTO challenge VALUES (?)',seq_list_int)
	conn.commit()

	cursor.execute('''SELECT integers,max(rowid) FROM challenge 
		GROUP BY integers HAVING COUNT(1) > (?) LIMIT 1''',(target_length,))
		
	fetch=cursor.fetchone()
	if fetch!=None:
		return fetch[0]
	else:
		return 'None'

	cursor.execute('DROP TABLE challenge')
	conn.commit()
	conn.close()
	
def main():
	parser=argparse.ArgumentParser()
	parser.add_argument('filename',type=str)
	args=parser.parse_args()
	try:
		sequences=open(args.filename,'r').read().rstrip().split('\n')
	except:
		print 'None'

	p=Pool(8)
	majors=p.map(dowork,sequences)
	for major in majors:
		print major

if __name__=="__main__":
	main()

>>809591

>integer_count=50000

>L is in range [10000, 30000]

wat

>>808650 (OP)

IMPORTANT: OP PLEASE SPECIFY

are you saying that there is only one element which appears more than L/2 times?

>>809592

using list comprehensions to generate the tuple list being fed into the table is another 20% performance boost, now 1.8-2.0s instead of 2-2.4

def dowork(sequence):
	conn=sqlite3.connect(':memory:')
	cursor=conn.cursor()

	seq_list=sequence.split(',')
	seq_list=[(x,) for x in seq_list ]
	target_length=(len(seq_list)/2)

	cursor.execute ('CREATE TABLE challenge (integers integer)')
	cursor.executemany('INSERT INTO challenge VALUES (?)',seq_list)
	conn.commit()

	cursor.execute('''SELECT integers,max(rowid) FROM challenge 
		GROUP BY integers HAVING COUNT(1) > (?) LIMIT 1''',(target_length,))
		
	fetch=cursor.fetchone()
	if fetch!=None:
		return fetch[0]
	else:
		return 'None'

	cursor.execute('DROP TABLE challenge')
	conn.commit()
	conn.close()

>>809602

I thought i screwed up here

seq_list=[(x,) for x in seq_list ]

should have been

seq_list=[(int(x),) for x in seq_list ]

but apparently it doesn't matter, sqlite will do the conversion if it can, which is probably part of the 20% performance increase.

>>809600

How can there be more than one, Pajeet?

>>809602

	cursor.execute('DROP TABLE challenge')
	conn.commit()
	conn.close()

Those lines are unreachable, aren't they?

>>809611

ya that's another fuckup, that should go above

if fetch!=None:

i don't know how necessary it even is, python probably closes it and garbage collects it anyway, in theory.

i made the fastest version:

extern crate memchr;
extern crate memmap;
extern crate rayon;

use std::cmp::{min};
use memchr::{memchr};
use memmap::{Mmap};
use rayon::prelude::*;

const MAX_TEST_CASES: usize = 40;
const MAX_N: usize = 100;
const MIN_L: usize = 10000;
const MAX_L: usize = 30000;
const MIN_LINE_LEN: usize = MIN_L + MIN_L - 1;
const MAX_LINE_LEN: usize = MAX_L * 3 + MAX_L - 1;
const MAX_TESTS_LEN: usize = MAX_LINE_LEN * MAX_TEST_CASES + MAX_TEST_CASES;

fn main() {
	let mut args = std::env::args_os().skip(1);
	assert_eq!(args.len(), 1);

	let mmap = Mmap::open_path(args.next().unwrap(), memmap::Protection::Read).unwrap();
	let slice = unsafe { mmap.as_slice() };

	for &r in do_it(slice).iter().filter(|&r| r.is_some()) {
		match r.unwrap() {
			Some(v) => { println!("{}", v); }
			None => { println!("None"); }
		}
	}
}

fn do_it(slice: &[u8]) -> [Option<Option<usize>>; MAX_TEST_CASES] {
	debug_assert!(slice.len() <= MAX_TESTS_LEN);

	let mut results = [None; MAX_TEST_CASES];
	split_line(slice, &mut results);
	results
}

fn split_line(slice: &[u8], results: &mut [Option<Option<usize>>]) {
	if slice.is_empty() {
		return;
	}

	debug_assert!(slice.len() >= MIN_LINE_LEN);

	let (r, rs) = results.split_first_mut().unwrap();

	match memchr(b'\n', &slice[MIN_LINE_LEN..min(slice.len(), MAX_LINE_LEN + 1)]) {
		Some(i) => {
			let (sl, sr) = slice.split_at(MIN_LINE_LEN + i);
			rayon::join(|| process_line(sl, r), || split_line(&sr[1..], rs));
		}
		None => { rayon::join(|| process_line(slice, r), || {}); }
	}
}

fn process_line(slice: &[u8], result: &mut Option<Option<usize>>) {
	debug_assert!(slice.len() >= MIN_LINE_LEN);
	debug_assert!(slice.len() <= MAX_LINE_LEN);

	let (c, m) = slice.par_split(|&b| b == b',')
		.map(|b| parse(b))
		.fold(|| (0, [0; MAX_N + 1]), |(c, mut m), i| { m[i] += 1; (c + 1, m) })
		.reduce(|| (0, [0; MAX_N + 1]), |(c1, mut m1), (c2, m2)| { for i in 0..MAX_N + 1 { m1[i] += m2[i]; } (c1 + c2, m1) });

	match m.par_iter().cloned().enumerate().find_any(|&(_, v)| v >= c / 2) {
		Some((i, c)) => {
			debug_assert!(c >= MIN_L);
			debug_assert!(c <= MAX_L);
			*result = Some(Some(i));
		}
		None => { *result = Some(None); }
	}
}

fn parse(b: &[u8]) -> usize {
	debug_assert!(b.iter().all(|&b| b >= b'0' && b <= b'9'));
	debug_assert!(std::str::from_utf8(b).unwrap().parse::<usize>().unwrap() <= MAX_L);

	(match b.len() {
		1 => { b[0] - b'0' }
		2 => { (b[0] - b'0') * 10 + (b[1] - b'0') }
		3 => { 100 }
		_ => { unreachable!() }
	}) as usize
}