Downloads

• Executable JAR of the visualizer
• Source code of the visualizer
• Training data
• (trainlist.csv) Ground truth file for training data

In order to use the offline tester / visualizer tool for testing your solution locally, you'll have to modify your solution by adding the main method that interacts with the tester / visualizer via reading data from standard input and writing data to standard output. As long as you do not change the implementation of method init and forecast, this doesn't affect the way your solution works when being submitted to our server.

To simulate a single test case, your program should implement the following protocol (each integer or double is to be read from / printed in a separate line):

• Read integer sampleRate, the number of samples in a second.
• Call init(sampleRate). Let ret be the return integer value.
• Print the ret value on a separate line.
• Read integer doTraining, a flag used for local training.
• If doTraining=1, do the following:
•     Read integer gtf_Hour, the hour when the quake will occur.
•     Read integer gtf_QuakeOccured, zero if no quake occured, one otherwise.
•     Call answer(gtf_Hour, gtf_QuakeOccured).
• Repeat the following for every hour:
•     Read integer hour, the hour that the following data belongs to.
•     If hour=-1, break out of the loop, the quake happened.
•     Read integer DLEN, the size of the data array.
•     Read DLEN integers data[0], data[1], ..., data[DLEN-1].
•     Read double K, the planetary magnetic activity index.
•     Call forecast(hour, data, K). Let retM[] be the return array.
•     Print the length of retM[] on a separate line.
•     Print the doubles in retM[] each on a separate line. Flush standard output stream.

In other words, you should implement the following pseudocode in the main method of your solution:

    
    sampleRate = parseInt(readLine())
    ret = init(sampleRate)
    printLine(ret)

    doTraining = parseInt(readLine())
    if (doTraining=1)
    {
        gtf_Hour = parseInt(readLine())
        gtf_QuakeOccured = parseInt(readLine())
        answer(gtf_Hour, gtf_QuakeOccured);
    }
    repeat until break
    {
        hour = parseInt(readLine())
        if (hour=-1) break
        DLEN = parseInt(readLine())
        for (i=0; i < DLEN; i++)
            data[i] = parseInt(readLine())
        K = parseDouble(readLine())
        retM[] = forecast(hour, data, K)
        printLine(retM.length)
        for (i=0; i < retM.length; i++)
            printLine(retM[i])
        flush(stdout)
    }

Make sure to put the trainlist.csv file in the same folder as the visualizer. In order to run the tester / visualizer, you should use the following command:

java -jar tester.jar -exec "<command>"

<command> is the command you would use to execute your solution. If your compiled solution is an executable file, the command will just be the full path to it, for example, "C:\TopCoder\solution.exe" or "~/topcoder/solution". In case your compiled solution is to be run with the help of an interpreter, for example, if you program in Java, the command will be something like "java -cp C:\TopCoder Solution".

Additionally you can use the following parameters (all are optional):

• -seed <seed>. Sets the seed used for test case generation. Default value is 1.
• -folder <data folder>. Name of the folder where the data is stored. ex: data/
• -train. The ground truth data will be passed to your algorithm. doTraining will be set to 1.
• -silent. Debug messages from the tester will not be displayed.

You can print any debug information of your solution to the standard error stream and it will be forwarded to the standard output of the tester. Place the gtf.csv file in the same folder as the tester.jar.

For more information on using visualizers, please check the following recipe draft from TopCoder Cookbook. Note that this is not a troubleshooting thread, please use the match forum for questions instead.