Example #1
0
// renvoie la liste des trolls avec qui le troll passé a un partage actif
func (store *MysqlStore) GetPartageurs(db *mysql.Client, trollId int) ([]int, os.Error) {
	st := strconv.Itoa(trollId)
	sql := "select troll_a, troll_b from partage where (troll_a=" + st + " or troll_b=" + st + ") and statut_a='on' and statut_b='on'"
	err := db.Query(sql)
	if err != nil {
		return nil, err
	}
	result, err := db.UseResult()
	if err != nil {
		return nil, err
	}
	defer result.Free()

	amis := new(vector.IntVector)
	for {
		row := result.FetchRow()
		if row == nil {
			break
		}
		r0 := fieldAsInt(row[0])
		r1 := fieldAsInt(row[1])
		if r0 == trollId {
			amis.Push(r1)
		} else {
			amis.Push(r0)
		}
	}

	return *amis, nil

}
Example #2
0
func main() {

	min := 113
	max := int(^uint32(0) >> 1)

	for currentSum := min; currentSum <= max; currentSum++ {
		var a Sum
		var initVector vector.IntVector

		for i := 0; i < currentSum; i += 1 {
			initVector.Push(1)
		}

		a.Init(initVector)

		count := recursiveMerging(a, currentSum, 0)

		fmt.Println(currentSum, count)

		if count%1000000 == 0 {
			panic("")
		}
	}

}
Example #3
0
func (d *debugHistogram) PrintSorted() {
	if !printDebugOutput {
		return
	}
	if len(d.mapping) == 0 {
		return
	}
	var scores vector.IntVector
	inverseMapping := make(map[int]string)
	sum := 0
	for key, value := range d.mapping {
		inverseMapping[value] = key
		scores.Push(value)
		sum += value
	}
	scoresArray := sort.IntArray(scores)
	scoresArray.Sort()

	fmt.Fprintf(os.Stderr, "Debug histogram - sorted:\n")
	length := len(scoresArray)
	for i := 0; i < length; i++ {
		current := scoresArray[length-i-1]
		fmt.Fprintf(os.Stderr, "%s: %d (%2.1f%%)\n", inverseMapping[current], current, float(current)/float(sum)*100)
	}
}
Example #4
0
func (this *Sum) Init(newElements vector.IntVector) {
	this.elements = newElements.Copy()

	this.accumulated = 0
	for _, v := range this.elements {
		this.accumulated += v
	}
}
Example #5
0
func removeZeros(c []int) []int {
	var ret vector.IntVector
	for _, v := range c {
		if v != 0 {
			ret.Push(v)
		}
	}
	return ret
}
Example #6
0
func (t *GoTracker) dead() []int {
	dead := new(vector.IntVector)
	cp := t.Copy().(*GoTracker)
	color := BLACK
	move := 0
	for {
		vertex := cp.weights.Rand(color)
		cp.Play(color, vertex)
		move++
		if move > 3*t.sqsize || cp.Winner() != EMPTY {
			break
		}
		color = Reverse(color)
	}
	for i := 0; i < t.sqsize; i++ {
		if t.board[i] != EMPTY && cp.board[i] != t.board[i] {
			dead.Push(i)
		}
	}
	stones := make([]int, dead.Len())
	for i := 0; i < dead.Len(); i++ {
		stones[i] = dead.At(i)
	}
	return stones
}
func BenchmarkIntVector(b *testing.B) {
	for i := 0; i < b.N; i++ {
		var vec vector.IntVector
		for j := 0; j < vectorLength; j++ {
			vec.Push(j)
		}
		for j := 0; j < vectorLength; j++ {
			val := vec.At(j)
			val++
		}
	}
}
Example #8
0
func generatePrimes(min int, max int) vector.IntVector {

	var ret vector.IntVector

	for n := min; n <= max; n++ {
		if isPrime(n) {
			ret.Push(n)
		}
	}

	return ret
}
Example #9
0
func (self *YesOrNo) Rollup(time int64, key string, samples *vector.IntVector) {
	data := &YesOrNoItem{}
	samples.Do(func(elem interface{}) {
		value := elem.(int)
		if value > 0 {
			data.ok++
		} else {
			data.fail++
		}
	})
	self.save(time, key, data)
}
Example #10
0
func (connection *Connection) SearchPrefix(query string) (*vector.IntVector, os.Error) {
	var count _C_int
	resp := C.tcidbsearch(connection.Dystopia, C.CString(query), C.x_prefix(), &count)
	fmt.Printf("searched for %v, num results = %d, resp = %v\n", query, count, resp)

	var result vector.IntVector
	for i := 0; i < int(count); i++ {
		result.Push(int(C.x_get_result_item(resp, _C_int(i))))
	}

	//        return &result, nil;
	return &result, nil
}
Example #11
0
func AreTwoIntVectorEquals(vector1, vector2 *vector.IntVector) bool {
	if vector1.Len() != vector2.Len() {
		return false
	}

	for i := 0; i < vector1.Len(); i++ {
		if vector1.At(i) != vector2.At(i) {
			return false
		}
	}

	return true
}
// find all occurrences of s in source; report at most n occurences
func find(src, s string, n int) []int {
	var res vector.IntVector
	if s != "" && n != 0 {
		// find at most n occurrences of s in src
		for i := -1; n < 0 || len(res) < n; {
			j := strings.Index(src[i+1:], s)
			if j < 0 {
				break
			}
			i += j + 1
			res.Push(i)
		}
	}
	return res
}
Example #13
0
func readLexeme(state *LexerState,
	rune int,
	size int,
	err os.Error,
	predicate func(rune int) bool,
	reader *bufio.Reader) (string, os.Error) {
	var runes vector.IntVector
	for predicate(rune) && size > 0 && err == nil {
		runes.Push(rune)
		rune, size, err = readRune(state, reader)
	}
	if err != os.EOF {
		unreadRune(state, reader, rune)
	}
	return lexeme(runes), err
}
Example #14
0
func checkValues(trie *Trie, s string, v *vector.IntVector, t *testing.T) {
	value, ok := trie.GetValue(s)
	values := value.(*vector.IntVector)
	if !ok {
		t.Fatalf("No value returned for string '%s'", s)
	}

	if values.Len() != v.Len() {
		t.Fatalf("Length mismatch: Values for '%s' should be %v, but got %v", s, *v, *values)
	}
	for i := 0; i < values.Len(); i++ {
		if values.At(i) != v.At(i) {
			t.Fatalf("Content mismatch: Values for '%s' should be %v, but got %v", s, *v, *values)
		}
	}
}
Example #15
0
func generatePrimes(min int, max int) []int {

	var primes vector.IntVector

	for n := min; n <= max; n++ {
		if isPrime(n) {
			primes.Push(n)
		}
	}

	ret := make([]int, len(primes))
	for k, v := range primes {
		ret[k] = v
	}

	return ret
}
Example #16
0
// Specialized function for TeX-style hyphenation patterns.  Accepts strings of the form '.hy2p'.
// The value it stores is of type vector.IntVector
func (p *Trie) AddPatternString(s string) {
	v := new(vector.IntVector)

	// precompute the Unicode rune for the character '0'
	rune0, _ := utf8.DecodeRune([]byte{'0'})

	strLen := len(s)

	// Using the range keyword will give us each Unicode rune.
	for pos, rune := range s {
		if unicode.IsDigit(rune) {
			if pos == 0 {
				// This is a prefix number
				v.Push(rune - rune0)
			}

			// this is a number referring to the previous character, and has
			// already been handled
			continue
		}

		if pos < strLen-1 {
			// look ahead to see if it's followed by a number
			next := int(s[pos+1])
			if unicode.IsDigit(next) {
				// next char is the hyphenation value for this char
				v.Push(next - rune0)
			} else {
				// hyphenation for this char is an implied zero
				v.Push(0)
			}
		} else {
			// last character gets an implied zero
			v.Push(0)
		}
	}

	pure := strings.Map(func(rune int) int {
		if unicode.IsDigit(rune) {
			return -1
		}
		return rune
	},
		s)
	leaf := p.addRunes(strings.NewReader(pure))
	if leaf == nil {
		return
	}

	leaf.value = v
}
Example #17
0
func main() {

	var a Sum
	var initVector vector.IntVector

	for i := 0; i < 100; i += 1 {
		initVector.Push(1)
	}

	a.Init(initVector)

	var count uint64 = 0

	recursiveMerging(a, 100, 0, &count)

	fmt.Println(count - 1)
}
Example #18
0
func ReadGridFromString(input string) *vector.Vector {
	grid := new(vector.Vector)
	lines := strings.Split(input, "\n")

	for _, line := range lines {
		lineVector := new(vector.IntVector)

		numbers := strings.Split(line, " ")
		for _, number := range numbers {
			number, _ := strconv.Atoi(number)
			lineVector.Push(number)
		}

		grid.Push(lineVector)
	}

	return grid
}
Example #19
0
func continuedFraction(a float64, dSquaredFloorTimesTwo int) vector.IntVector {

	aFloor := int(math.Floor(a))

	var ret vector.IntVector

	if dSquaredFloorTimesTwo == aFloor {
		return ret
	}

	ret.Push(aFloor)

	nextRet := continuedFraction(1/(a-float64(aFloor)), dSquaredFloorTimesTwo)

	ret.AppendVector(&nextRet)

	return ret
}
Example #20
0
func TestGridProductOfTheMainDiagonal(t *testing.T) {
	grid := new(vector.Vector)

	for i := 0; i < 5; i++ {
		line := new(vector.IntVector)
		for j := 0; j < 5; j++ {
			if i == j {
				line.Push(10)
			} else {
				line.Push(1)
			}
		}

		grid.Push(line)
	}

	AssertGridProduct(t, grid, 10000)
}
Example #21
0
func TestGridProductOfVerticalLine(t *testing.T) {
	grid := new(vector.Vector)

	for i := 0; i < 5; i++ {
		line := new(vector.IntVector)
		for j := 0; j < 5; j++ {
			if j == 0 {
				line.Push(10)
			} else {
				line.Push(1)
			}
		}

		grid.Push(line)
	}

	AssertGridProduct(t, grid, 10000)
}
Example #22
0
func TreeSort(data []int) {
	if len(data) <= 1 {
		return
	}
	root := NewTree(nil, data[0]) //root node
	for i := 1; i < len(data); i++ {
		root.NewNode(data[i]) //filling up the tree
	}
	var sorted vector.IntVector
	var sortIntoArray func(*Tree) //declared to use recursively
	sortIntoArray = func(node *Tree) {
		if node == nil {
			return
		}
		sortIntoArray(node.left)
		sorted.Push(node.val)
		sortIntoArray(node.right)
	}
	sortIntoArray(root)
	copy(data, sorted.Data()) //copy the sorted to the source
}
Example #23
0
func GetPrimeFactors(number int) (*vector.IntVector, *vector.IntVector) {
	numbers := new(vector.IntVector)
	counts := new(vector.IntVector)

	primesChannel := GetPrimes()
	result := number
	for {
		prime := <-primesChannel

		if number < prime {
			break
		}

		if result%prime == 0 {
			numbers.Push(prime)
			count := 1

			for result = result / prime; result%prime == 0; result = result / prime {
				count++
			}

			counts.Push(count)
		}
	}

	return numbers, counts
}
Example #24
0
func (g *Game) nexts(index int) []int {
	var r vector.IntVector = make([]int, 0)
	x := index % g.w
	y := index / g.w
	if y < g.h-1 && g.rootBoard[index+g.w] > 0 {
		r.Push(g.w)
	}
	if y > 0 && g.rootBoard[index-g.w] > 0 {
		r.Push(-g.w)
	}
	if x < g.w-1 && g.rootBoard[index+1] > 0 {
		r.Push(1)
	}
	if x > 0 && g.rootBoard[index-1] > 0 {
		r.Push(-1)
	}
	return r
}
Example #25
0
// Lookup returns an unsorted list of at most n indices where the byte string s
// occurs in the indexed data. If n < 0, all occurrences are returned.
// The result is nil if s is empty, s is not found, or n == 0.
// Lookup time is O((log(N) + len(result))*len(s)) where N is the
// size of the indexed data.
//
func (x *Index) Lookup(s []byte, n int) []int {
	var res vector.IntVector

	if len(s) > 0 && n != 0 {
		// find matching suffix index i
		i := x.search(s)
		// x.at(i) <= s < x.at(i+1)

		// ignore the first suffix if it is < s
		if i < len(x.sa) && bytes.Compare(x.at(i), s) < 0 {
			i++
		}

		// collect the following suffixes with matching prefixes
		for (n < 0 || len(res) < n) && i < len(x.sa) && bytes.HasPrefix(x.at(i), s) {
			res.Push(x.sa[i])
			i++
		}
	}

	return res
}
Example #26
0
// Adapted/ported the neat recipe/method by Manuel Ebert at
//   http://portwempreludium.tumblr.com/post/13108758604/instagram-unshredding
func FindShredWidth(img *image.Gray) {
	bounds := img.Bounds()
	width := bounds.Max.X
	height := bounds.Max.Y
	avg := make([]float64, width)
	for x := 0; x < width; x++ {
		tmp := 0
		for y := 0; y < height; y++ {
			tmp += int(img.Pix[x+y*img.Stride])
		}
		avg[x] = float64(tmp) / float64(height)
	}
	diff := make([]float64, width)
	for z := 1; z < width; z++ {
		diff[z] = math.Fabs(avg[z] - avg[z-1])
	}
	diff[0] = 0.0
	shred_width = 0
	for threshold := 1; threshold < 255; threshold++ {
		if shred_width >= 5 {
			break
		}
		var boundaries vector.IntVector
		for i, _ := range diff {
			if diff[i] > float64(threshold) {
				boundaries.Push(i)
			}
		}
		if len(boundaries) == 0 {
			shred_width = 0
			continue
		}
		tmp := boundaries[0]
		for b := 1; b < len(boundaries); b++ {
			tmp = gcd(tmp, boundaries[b])
		}
		shred_width = tmp
	}
}
Example #27
0
func generateFactorizedN(primes vector.IntVector, pos int, max int, currentN int, currentFactors map[int]int, returnChannel chan<- nWithFactors) {

	for ; pos < len(primes); pos++ {

		prime := primes.At(pos)

		pToThePowerOfKTimesN := currentN

		for k := 1; ; k++ {

			if int64(pToThePowerOfKTimesN)*int64(prime) > int64(max) {
				break
			}

			pToThePowerOfKTimesN *= prime

			copiedCurrentFactors := copyMapIntInt(currentFactors)
			copiedCurrentFactors[prime] = k

			returnChannel <- nWithFactors{pToThePowerOfKTimesN, copiedCurrentFactors}
			generateFactorizedN(primes, pos+1, max, pToThePowerOfKTimesN, copiedCurrentFactors, returnChannel)
		}
	}
}
Example #28
0
func recursive(in int64, value *big.Int, v vector.IntVector, primeIndex int, primes []*big.Int, winner *big.Int, winner2 *vector.IntVector) {

	if in > 4000000 {

		if value.Cmp(winner) < 0 || winner.Cmp(big.NewInt(-1)) == 0 {
			winner.Set(value)
			*winner2 = v
			fmt.Println(in, winner, *winner2)
			//fmt.Print(in, winner, *winner2, " (")
			//for k, v := range *winner2 {
			//	fmt.Print(primes[k], "**", v, " * ")
			//}
			//fmt.Println(")")
		}

		return
	}

	for i := int64(15); i >= 1; i -= 1 {

		var factor big.Int

		factor.Exp(primes[primeIndex], big.NewInt(i), nil)

		//fmt.Println(factor, i, primes[primeIndex])

		newV := v.Copy()
		newV.Push(int(i))

		var newValue big.Int
		newValue.Mul(value, &factor)

		recursive(in*(2*i+1)-i, &newValue, newV, primeIndex+1, primes, winner, winner2)

	}
}
Example #29
0
// enter
func main() {
	f := addhold(1)
	fmt.Println(f(1))
	fmt.Println(f(20))
	fmt.Println(f(300))

	list := &StudentList{"class1", []string{"shen", "cai"}}

	list.AppendStudent("yu")
	fmt.Println(list.StudentName)

	list.AppendStudent("wang")
	fmt.Println(list.StudentName)

	list.EraseStudent(list.CountStudent() - 1)
	fmt.Println(list.StudentName)

	list.EraseStudent(list.CountStudent() - 1)
	fmt.Println(list.StudentName)

	list.EraseStudent(list.CountStudent() - 1)
	fmt.Println(list.StudentName)

	list.EraseStudent(0)
	fmt.Println(list.StudentName)

	fmt.Printf("len: %d\n", len(list.StudentName))
	fmt.Printf("cap: %d\n", cap(list.StudentName))

	isAbsList(list)
	isAbsList(FooList{})

	var vec vector.IntVector = []int{1, 2, 3, 4}
	vec.Insert(0, 10)
	fmt.Println(vec)
}
Example #30
0
func distinct(list vector.StringVector) [][2]string {
	if len(list) == 0 {
		return nil
	}
	var keys vector.StringVector
	var vals vector.IntVector
	for _, l := range list {
		index := search(keys, l)
		if index == -1 {
			keys.Push(l)
			vals.Push(1)
		} else {
			vals.Set(index, vals.At(index)+1)
		}
	}
	m := make([][2]string, len(keys))
	for i, k := range keys {
		m[i][0] = k
		m[i][1] = fmt.Sprint(vals.At(i))
	}
	return m
}