How many of a particular item of clothing do I need?
For a beginner to go your program is good. You have obviously read up on flag handling, and you've got a grasp on the pointers. I have come to like the flag processing in go (though having previously learned/understood getopt and written my own library in Java, I feel like go should allow more powerful commandline handling).

Flags

So, having said you have a good grasp on those concepts, I am going to recommend that you change the flag handling (and as a consequence, you remove the pointers).

In addition, you should be putting in the number of days to simulate, and perhaps the starting date, as flags too.

So, flag functions include both ...Ptr and ...Var variants. I recommend using the ...Var variants where you can. Your code:


numberOftshirtsPtr := flag.Int("shirts", 9, "a int number of tshirts")
thursdayPtr := flag.Bool("thursday", true, "a bool use Thursday")
dryingPtr := flag.Bool("drying", true, "a bool use drying")
flag.Parse()



I would write like:

numberOftshirts := 9
doThursdays := true
doDrying := true

flag.IntVar(&amp;numberOftshirts, "shirts", numberOftshirts, "the number of tshirts")
flag.BoolVar(&amp;doThursdays, "thursday", doThursdays, "use Thursday")
flag.BoolVar(&amp;doDrying, "drying", doDrying, "use drying")
flag.Parse()


By taking the address of the var and giving it to flag, we can then use the variables as-is later without having to keep the pointer handling at all, so code like:


var clean, minClean = *numberOftshirtsPtr, *numberOftshirtsPtr



becomes:

var clean, minClean = numberOftshirts, numberOftshirts


Note that, by convention, using hungarian notation in go is not good code-style. You should not suffix pointer variables with Ptr. A pointer to an int containing the number of T-Shirts is still numberOftshirts and not numberOftshirtsPtr

OK, so the above code changes the flag handling to be Var-based, and it reads easier, and removes all pointer references later.

I would also add flags for the starting date, and number of days to simulate.

Washing Day

Your washingday function is a good idea, but you are doing string processing in places where the time library has better options to offer. Note that time has constantes for the days-of-week, and those constants are declared as a Weekday type, and that type has a String() function available: https://golang.org/pkg/time/#Weekday - what this means is that you can avoid the string-conversions in the function. I personally would probably use the String() option too to print the days. Actually, I would remove the println from the function because it is making the function do too much - (computation and presentation). I would have your function as:

func isWashingDay(today time.Time, doThursday bool) bool {

    if today.Weekday() == time.Monday {
        //fmt.Printf("%v!\n", time.Monday)
        return true
    }

    if doThursday &amp;&amp; today.Weekday() == time.Thursday {
        _, week := today.ISOWeek()
        if even(week) {
            //fmt.Printf("%v!\n", time.Thursday)
            return true
        }
    }

    return false
}


Note that I no longer have any raw text in there (it's all time variables, etc), and also note that I no longer have if ... else ... statements. When the if part of a condition always has a return in it, there's no need for the else at all.

Main

Your program is essentially contained inside the main-method. This makes the main method bulky, and the code is not reusable. Even in example progams and learning exercises, you should try to break your code in to functions that can be run, and tested independently. Go has a strong toolset related to unit-tests and benchmarks, and you should get in the habit of creating small, independent functions that are easy to process in the testing systems too.

One way to improve the bulkiness of the main method is to declare a struct to contain the state of a given day. You can get clever with some function processing too. I would create a state struct, and use it for a bunch of the logic....

type ClothesState struct {
    day     time.Time
    clean   int
    dirty   int
    washing int
    drying  int
}


In addition, to separate out your printing of the state, I would create a bit of a string helper function... I'll explain it later, but show you here, now:

func format(day, clean, dirty, washing, drying interface{}) string {
    return fmt.Sprintf("%-11v| %-2v| %-2v| %-2v| %2-v", day, clean, dirty, washing, drying)
}


With this function, we can add a String() method to our state too that uses it:

func (cs ClothesState) String() string {
    return format(cs.day.Format("2006-01-02"), cs.clean, cs.dirty, cs.washing, cs.drying)
}


Now we can use the %v (or %s) style fmt to print the state:

fmt.Printf("%v\n", state)


Further, I would take the state-tansition logic and make it a method on the struct too:

func (cs ClothesState) Advance(doDrying, doThursdays bool) ClothesState {
    tomorrow := cs.day.AddDate(0, 0, 1)

    clean := cs.clean
    clean += cs.drying

    drying := cs.washing
    if !doDrying {
        // take all the drying directly in to clean
        clean += drying
        drying = 0
    }

    washing := 0
    dirty := cs.dirty
    if isWashingDay(tomorrow, doThursdays) {
        washing = dirty
        dirty = 0
    }

    clean--
    dirty++

    return ClothesState{
        day:     tomorrow,
        clean:   clean,
        dirty:   dirty,
        washing: washing,
        drying:  drying,
    }

}


Now you have an immutable state struct that you can then advance through the daily logic. Each advance returns a new state.

Conclusion

You've made a great start in to Go. I encourage the use of structs to localize logic, the use of smaller, single-purpose functions, and separating the presentation code (printlns) from the calculation code.

I have taken your code and re-worked it in a way I would consider an improvement, and I have tweaked the starting state to match your logic (and also kept the println statements in the isWashingDay so that it matches the output of your program.

Have a look, and see how the logic is separated, how the flags are used, and so on: https://play.golang.org/p/B62HmIoxNc

package main

import (
    "flag"
    "fmt"
    "time"
)

func even(number int) bool {
    return number%2 == 0
}

func isWashingDay(today time.Time, doThursday bool) bool {

    if today.Weekday() == time.Monday {
        fmt.Printf("%v!\n", time.Monday)
        return true
    }

    if doThursday &amp;&amp; today.Weekday() == time.Thursday {
        _, week := today.ISOWeek()
        if even(week) {
            fmt.Printf("%v!\n", time.Thursday)
            return true
        }
    }

    return false
}

func format(day, clean, dirty, washing, drying interface{}) string {
    return fmt.Sprintf("%-11v| %-2v| %-2v| %-2v| %-2v", day, clean, dirty, washing, drying)
}

type ClothesState struct {
    day     time.Time
    clean   int
    dirty   int
    washing int
    drying  int
}

func (cs ClothesState) String() string {
    return format(cs.day.Format("2006-01-02"), cs.clean, cs.dirty, cs.washing, cs.drying)
}

func (cs ClothesState) Advance(doDrying, doThursdays bool) ClothesState {
    tomorrow := cs.day.AddDate(0, 0, 1)

    clean := cs.clean
    clean += cs.drying

    drying := cs.washing
    if !doDrying {
        // take all the drying directly in to clean
        clean += drying
        drying = 0
    }

    washing := 0
    dirty := cs.dirty
    if isWashingDay(tomorrow, doThursdays) {
        washing = dirty
        dirty = 0
    }

    clean--
    dirty++

    return ClothesState{
        day:     tomorrow,
        clean:   clean,
        dirty:   dirty,
        washing: washing,
        drying:  drying,
    }

}

func main() {
    numberOftshirts := 9
    doThursdays := true
    doDrying := true

    flag.IntVar(&amp;numberOftshirts, "shirts", numberOftshirts, "the number of tshirts")
    flag.BoolVar(&amp;doThursdays, "thursday", doThursdays, "use Thursday")
    flag.BoolVar(&amp;doDrying, "drying", doDrying, "use drying")
    flag.Parse()

    today, _ := time.Parse(time.RFC3339, "2017-02-06T00:00:00+00:00")

    // Set the state with 1 dirty shirt to match OP logic
    state := ClothesState{
        day:   today,
        clean: numberOftshirts - 1,
        dirty: 1,
    }

    minClean := state.clean

    fmt.Println(format("Date", "C", "D", "W", "Y"))
    fmt.Printf("%v\n", state)

    testDays := 365
    for i := 0; i &lt; testDays; i++ {
        state = state.Advance(doDrying, doThursdays)
        fmt.Printf("%v\n", state)

        if state.clean &lt; minClean {
            minClean = state.clean
        }

    }

    fmt.Println("Total days:", testDays)
    fmt.Println("Minimum clean shirts:", minClean)
}