// 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
}
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("")
}
}
}
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)
}
}
func (this *Sum) Init(newElements vector.IntVector) {
this.elements = newElements.Copy()
this.accumulated = 0
for _, v := range this.elements {
this.accumulated += v
}
}
func removeZeros(c []int) []int {
var ret vector.IntVector
for _, v := range c {
if v != 0 {
ret.Push(v)
}
}
return ret
}
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++
}
}
}
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
}
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)
}
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
}
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
}
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
}
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)
}
}
}
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
}
// 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
}
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)
}
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
}
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
}
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)
}
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)
}
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
}
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
}
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
}
// 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
}
// 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
}
}
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)
}
}
}
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)
}
}
// 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)
}
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
}
