Method to check if TicTacToe board has a winner
Just in case you find the for loops inelegant, here is an alternative solution. I don't know Objective C, but the following Go code uses only simple integer arithmetic and decimal formatting, so it should be easy to translate to almost any other language. It was fun to write, so have fun solving this little puzzle.

package main

import (
    &quot;fmt&quot;
    &quot;strings&quot;
)

type Board struct {
    b [3][3]int
}

func (bo *Board) HasWinner() bool {
    b := bo.b
    st := 555555555 +
        b[0][0]*110010010 +
        b[1][0]*101010000 +
        b[2][0]*100110001 +
        b[0][1]*110001000 +
        b[1][1]*101001011 +
        b[2][1]*100101000 +
        b[0][2]*110000101 +
        b[1][2]*101000100 +
        b[2][2]*100100110
    str := fmt.Sprintf(&quot;%d&quot;, st%100000000)
    return strings.Contains(str, &quot;2&quot;) || strings.Contains(str, &quot;8&quot;)
}

func main() {
    b := &amp;Board{[3][3]int{{1, 1, 1}, {0, -1, -1}, {0, -1, -1}}}
    fmt.Println(b.HasWinner())
}

Hints and spoilers:

! The leading 1s in the number block prevent the numbers from being interpreted as octal. The modulo operation later discards these digits. If performance is critical, you can remove each leading 1 and all following 0s, as well as the % operation. Alternatively you can subtract 100000000 from each of the factors, as well as remove the % operation.
! The 555555555 prevents overflow amongst the separate digits. It has to be 9 digits long because of the extra leading 1s in the number block. The st variable could become negative otherwise. If you remove the leading 1s, the leading 5 can be removed as well.
! Each column in the number block represents one winning combination. First horizontally, then vertically, then diagonally. Therefore, each column has exactly three 1s. If your programming language allows underscores in integer literals, each factor should look like 1_hhh_vvv_dd.
! Each digit of st starts at 5 and is incremented or decremented depending on the relevant cells. When there are 3 relevant cells in either direction (+1, -1), it is a winning combination. Since every column has only 3 1s, overflow cannot happen.