文章/答案/技术大牛

发布

社区首页 >专栏 >文心一言 VS 讯飞星火 VS chatgpt （217）-- 算法导论16.2 4题

文心一言 VS 讯飞星火 VS chatgpt （217）-- 算法导论16.2 4题

福大大架构师每日一题

发布于 2024-03-18 07:04:44

20400

代码可运行

文章被收录于专栏：福大大架构师每日一题福大大架构师每日一题

运行总次数：0

代码可运行

四、Gekko教授一直梦想用直排轮滑的方式横穿北达科他州。他计划沿U.S.2号高速公路横穿，这条高速公路从明尼苏达州东部边境的大福克斯市到靠近蒙大拿州西部边境的威利斯顿市。教授计划带两公升水，在喝光水之前能滑行m英里(由于北达科他州地势相对平坦，教授无需担心在上坡路段喝水速度比平地或下坡路段快)。教授从大福克斯市出发时带整整两公升水。他携带的北达科他州官方地图显示了U.S.2号公路上所有可以补充水的地点，以及这些地点间的距离。如果要写代码，请用go语言。

文心一言：

为了解决这个问题，我们可以编写一个简单的Go程序，该程序使用北达科他州U.S. 2号公路上补充水地点的信息，来计算教授在喝光两公升水之前能够滑行多远。这里，我们假设我们有一个名为water_stations.json的文件，其中包含U.S. 2号公路上所有水站的信息，每个水站都标记了它们之间的距离（以英里为单位）。

以下是一个简单的Go程序，该程序读取water_stations.json文件，并计算教授在喝光两公升水之前能够滑行多远。假设教授每滑行一英里消耗固定量的水，我们将此量设置为一个常量。

首先，我们需要一个JSON格式的文件（water_stations.json），其内容可能如下所示：

[  
    {"name": "Station 1", "distance_to_next": 50},  
    {"name": "Station 2", "distance_to_next": 60},  
    {"name": "Station 3", "distance_to_next": 70},  
    // ... 更多水站  
]

然后，我们可以编写Go程序如下：

package main  
  
import (  
    "encoding/json"  
    "fmt"  
    "io/ioutil"  
    "os"  
)  
  
type WaterStation struct {  
    Name          string `json:"name"`  
    DistanceToNext int    `json:"distance_to_next"`  
}  
  
func main() {  
    // 假设教授每滑行一英里消耗的水量  
    waterConsumptionPerMile := 0.01 // 例如，每英里消耗0.01公升水  
    totalWater := 2.0             // 教授开始时携带的总水量，单位：公升  
  
    // 读取水站信息  
    stations, err := readWaterStations("water_stations.json")  
    if err != nil {  
        fmt.Fprintf(os.Stderr, "Error reading water stations: %v\n", err)  
        os.Exit(1)  
    }  
  
    // 计算教授能滑行多远  
    maxDistance := calculateMaxDistance(stations, waterConsumptionPerMile, totalWater)  
  
    fmt.Printf("Professor Gekko can skate a maximum of %.2f miles before running out of water.\n", maxDistance)  
}  
  
// 读取水站信息  
func readWaterStations(filename string) ([]WaterStation, error) {  
    file, err := os.Open(filename)  
    if err != nil {  
        return nil, err  
    }  
    defer file.Close()  
  
    byteValue, _ := ioutil.ReadAll(file)  
  
    var stations []WaterStation  
    err = json.Unmarshal(byteValue, &stations)  
    if err != nil {  
        return nil, err  
    }  
  
    return stations, nil  
}  
  
// 计算教授能滑行多远  
func calculateMaxDistance(stations []WaterStation, waterConsumptionPerMile float64, totalWater float64) float64 {  
    distanceCovered := 0.0  
    remainingWater := totalWater  
  
    for _, station := range stations {  
        if remainingWater < float64(station.DistanceToNext)*waterConsumptionPerMile {  
            // 如果剩余水量不足以到达下一个水站，则退出循环  
            break  
        }  
  
        // 减去到达下一个水站所需的水量  
        remainingWater -= float64(station.DistanceToNext) * waterConsumptionPerMile  
        distanceCovered += float64(station.DistanceToNext)  
    }  
  
    return distanceCovered  
}

这个程序首先定义了一个WaterStation结构体来存储每个水站的信息。readWaterStations函数负责读取并解析JSON文件。calculateMaxDistance函数遍历水站，并计算教授能够滑行多远而不耗尽水量。

请注意，这只是一个基本示例，您可能需要根据实际情况调整程序，比如处理异常情况、验证输入、添加更多的功能等。同时，确保water_stations.json文件存在于与程序相同的目录中，或者提供正确的文件路径。

讯飞星火：

package main

import (
    "fmt"
)

func main() {
    m := 100 // 需要滑行的距离，可以根据实际情况修改
    water := 2.0 // 携带的水的体积，单位为公升
    stops := []struct {
        distance float64 // 距离大福克斯市的距离，单位为英里
        water    float64 // 该地点可以补充的水的体积，单位为公升
    }{
        {50, 1},
        {75, 0.5},
        {100, 1},
    }

    totalDistance := 0.0
    for _, stop := range stops {
        if water <= 0 {
            break
        }
        water += stop.water
        totalDistance += stop.distance
        if totalDistance >= m {
            break
        }
    }

    if totalDistance >= m {
        fmt.Printf("Gekko教授可以在携带的%.1f公升水的情况下横穿北达科他州。\n", water)
    } else {
        fmt.Println("Gekko教授无法在携带的水用完之前横穿北达科他州。")
    }
}

360智脑：

在编写代码之前，我们需要了解Gekko教授滑行的速度以及他每消耗一定水量能滑行的英里数。假设我们已知以下信息：

1. Gekko教授的滑行速度（速度，单位：英里/小时）。
2. 每消耗1公升水，Gekko教授可以滑行的英里数（每公升水滑行的英里数，单位：英里/公升）。

我们可以用以下Go语言代码模拟Gekko教授的旅程：

package main

import (
    "fmt"
    "math"
)

func main() {
    // 滑行速度（英里/小时）
    speed := 10.0
    // 每公升水滑行的英里数（英里/公升）
    milesPerLitre := 0.5
    // 水的总量（公升）
    water := 2.0
    // 起点和终点之间的总距离（英里）
    totalDistance := 320.0

    // 将速度转换为每公升水滑行的英里数
EffectiveSpeed := speed * milesPerLitre

    // 计算Gekko教授可以滑行的距离（在喝光水之前）
    distance := water * EffectiveSpeed

    // 如果Gekko教授可以滑行的距离大于等于总距离，则他可以成功到达终点
    if distance >= totalDistance {
        fmt.Println("Gekko教授可以成功到达终点。")
    } else {
        fmt.Println("Gekko教授无法到达终点。")
    }
}

在上述代码中，我们使用了Go语言进行模拟计算。首先，我们定义了Gekko教授的滑行速度和每消耗1公升水可以滑行的英里数。然后，我们计算了Gekko教授实际可以滑行的距离（在喝光水之前）。最后，我们比较了Gekko教授可以滑行的距离和总距离，以判断他是否可以成功到达终点。

智谱清言：

根据您的描述，Gekko教授希望用go语言编写一个程序来规划他的直排轮滑行程。程序需要做几件事情：

1.读取U.S.2号高速公路上各个地点之间的距离。

2.根据他携带的水量（两公升），确定在哪些地点需要补充水。

3.计算出整个行程的路线和必要的补给点。

下面是一个简化的go语言示例代码，用来规划Gekko教授的行程。请注意，这只是一个基本的框架，您可能需要根据实际情况调整数据结构和算法。

package main
import (
    "fmt"
)
// 定义一个结构体来表示路线上的一个点
type Waypoint struct {
    Name     string
    WaterAvailable bool
    Distance int
}
func main() {
    // 假设有一个地图，用map来模拟，键是地点名称，值是地点信息
    mapOfWaypoints := map[string]Waypoint{
        "Fargo": {Name: "Fargo", WaterAvailable: true, Distance: 50},
        "Bismarck": {Name: "Bismarck", WaterAvailable: true, Distance: 100},
        // 添加更多地点...
    }
    // Gekko教授的水量
    waterLimit := 2000 // 以毫升为单位，假设1公升=1000毫升
    // 初始化Gekko教授的位置和剩余水量
    currentLocation := "Fargo"
    remainingWater := waterLimit
    // 记录路线
    route := []string{currentLocation}
    // 开始规划路线
    for remainingWater > 0 && currentLocation != "Williston" {
        // 假设Gekko教授在每个地点都需要补充水
        if mapOfWaypoints[currentLocation].WaterAvailable {
            remainingWater -= mapOfWaypoints[currentLocation].Distance
        }
        // 如果水量不足以到达下一个地点，需要选择最近的补给点
        if remainingWater < 0 {
            // 找到最近的补给点
            closestWaterPoint := ""
            minDistance := 10000 // 设置一个足够大的初始值
            for location, waypoint := range mapOfWaypoints {
                if waypoint.WaterAvailable && waypoint.Distance < minDistance && waypoint.Distance >= remainingWater {
                    closestWaterPoint = location
                    minDistance = waypoint.Distance
                }
            }
            // 更新当前位置和剩余水量
            currentLocation = closestWaterPoint
            remainingWater = waterLimit - minDistance // 更新剩余水量
            route = append(route, currentLocation)
        } else {
            // 如果没有用尽水量到达下一个地点，继续前进
            nextLocation, ok := mapOfWaypoints[currentLocation]
            if ok && nextLocation.Distance <= remainingWater {
                currentLocation = nextLocation.Name
                route = append(route, currentLocation)
            } else {
                // 这里可以添加代码来处理到达目的地之前没有水的情况
                fmt.Println("Gekko教授需要尽快找到水源！")
                break
            }
        }
    }
    // 输出Gekko教授的行程路线
    fmt.Println("Gekko教授的行程路线是：", route)
}

这个程序是一个非常简化的模型，它没有考虑实际的道路网络、交通情况、天气因素等。在实际情况中，这样的行程规划会更为复杂，可能需要使用更为高级的算法和数据结构。此外，实际编写代码时，您可能还需要使用专业的地图数据服务来获取准确的路程距离和地点信息。

天工：

在Go语言中实现Gekko教授横穿北达科他州的直排轮滑旅行计划可以通过模拟教授的滑行过程并跟踪其水分消耗来实现。以下是一个可能的Go语言代码示例：

package main

import (
    "fmt"
    "math"
)

// 假设每滑行d英里消耗的水量为w升
const waterConsumptionPerMile float64 = 0.1 // 这是一个示例值，需要根据实际情况调整

func main() {
    // 教授初始携带的水量
    initialWater := 2.0
    // 教授滑行的总英里数
    totalMiles := 450 // 这个值也需要根据实际地图数据来设定
    // 教授滑行的英里数
    milesSkated := 0.0
    // 剩余的水量
    remainingWater := initialWater

    for milesSkated < totalMiles {
        // 计算消耗的水量
        waterConsumed := remainingWater * waterConsumptionPerMile
        // 更新剩余水量
        remainingWater -= waterConsumed
        milesSkated += 1 // 滑行下一英里
        
        // 如果到达了可以补充水的地方，则补充水量
        if isAtWaterStop(milesSkated) {
            remainingWater += refillWater(milesSkated)
        }

        // 如果剩余水量不足，记录教授能够滑行的最大英里数
        if remainingWater < waterConsumptionPerMile {
            totalMiles = milesSkated - 1 // 因为最后一次滑行已经没有足够的水了
            break
        }
    }

    fmt.Printf("教授最多能滑行 %.2f 英里而不缺水。\n", totalMiles)
}

// 根据地图数据，检查是否到达了可以补充水的地方
func isAtWaterStop(milesSkated float64) bool {
    // 这里需要根据实际地图数据填充逻辑，例如：
    // return milesSkated == 50 || milesSkated == 150
    return false
}

// 根据地图数据，返回在当前英里数处的可补充水量
func refillWater(milesSkated float64) float64 {
    // 这里需要根据实际地图数据填充逻辑，例如：
    // return 0.5 // 表示可以补充半升水
    return 0.0
}

这段代码提供了一个框架，但需要填充isAtWaterStop和refillWater函数的具体逻辑，这些逻辑取决于北达科他州官方地图上显示的可补充水点的具体位置和每个地点的补水量。

请注意，这个代码只是一个示例，它并没有包含实际的地图数据。在实际应用中，你需要获取U.S. 2号高速公路上所有可以补充水的地点及其间的确切距离，并将这些信息编码到isAtWaterStop和refillWater函数中。此外，waterConsumptionPerMile变量的值也需要根据实际情况进行调整。

灵小智：

为了解决这个问题，我们可以使用Go语言编写代码来计算教授在滑行过程中能喝到的水的距离。下面是一个简单的示例代码：

package main

import "fmt"

func main() {
    waterAmount := 2.0 // 单位：升
    mileage := 0.0 // 单位：英里
    
    // 每个补水点的距离和水量
    refillPoints := map[float64]float64{
        50.0: 1.5,
        100.0: 1.0,
        150.0: 0.5,
        200.0: 1.0,
    }
    
    for distance, water := range refillPoints {
        if waterAmount <= 0 {
            break
        }
        
        if water >= waterAmount {
            mileage += (distance / water) * waterAmount
            waterAmount = 0
        } else {
            mileage += distance
            waterAmount -= water
        }
    }
    
    fmt.Printf("教授能够滑行 %.2f 英里\n", mileage)
}

在这个示例代码中，我们使用refillPoints 来表示补水点的距离和水量。根据补水点的数据，我们计算教授在滑行过程中消耗的水量和累积的里程。最后，我们输出教授能够滑行的总英里数。

请注意，此代码仅作为示例提供，并未完全考虑各种情况和异常处理。在实际使用时，可能需要更复杂的算法来计算教授能够滑行的距离。

chatgpt：

好的，以下是使用 Go 语言编写的代码来解决这个问题：

package main

import (
    "fmt"
)

func main() {
    distances := []int{10, 15, 20, 25, 30} // 各个补充水的地点间的距离，单位为英里
    totalDistance := 0
    maxMiles := 0
    remainingWater := 2000 // 初始剩余水量，单位为毫升

    for _, distance := range distances {
        totalDistance += distance
        if maxMiles < remainingWater/2 { // 如果当前可滑行距离小于剩余水量一半，则更新可滑行距离
            maxMiles = remainingWater / 2
        }
        if totalDistance >= maxMiles { // 如果累计距离超过了可滑行距离，则需要补充水源
            fmt.Printf("需要在%d英里处补充水源\n", totalDistance)
            maxMiles = remainingWater / 2 // 更新可滑行距离为新的剩余水量一半
            remainingWater = 2000         // 补充水源后将剩余水量重置为初始值
        }
    }

    finalDistance := totalDistance + remainingWater/2 // 加上最后一段滑行距离（剩余水量能够支持的最大距离）
    fmt.Printf("在喝完所有水之前，教授可以滑行%d英里\n", finalDistance)
}

这段代码会根据给定的补充水点之间的距离，计算教授在喝完所有水之前可以滑行的总英里数。其中，补充水源的地点和距离以示例为准，请根据实际情况进行调整。

kimi：

为了帮助Gekko教授规划他的直排轮滑之旅，我们可以编写一个Go语言的程序来计算在喝光两公升水之前他能滑行的最大距离。这个程序将需要处理地图上的数据，找出在需要补充水分之前，教授能够到达的最远地点。

首先，我们需要一个数据结构来表示地图和水站的位置。然后，我们将使用一个简单的算法来确定教授能够到达的最远距离。

Go语言实现

package main

import (
    "fmt"
)

// WaterStation 表示地图上的一个水站，包含其位置（从起点开始的英里数）。
type WaterStation struct {
    position int
}

// NewWaterStation 创建一个新的水站实例。
func NewWaterStation(position int) *WaterStation {
    return &WaterStation{position: position}
}

// maxDistance 计算教授在喝光两公升水之前能滑行的最大距离。
func maxDistance(stations []*WaterStation, m int) int {
    // 初始化最远距离为0。
    maxDist := 0

    // 初始化当前剩余水量为两公升。
    currentWater := 2

    // 遍历每个水站。
    for _, station := range stations {
        // 计算到达当前水站前的距离。
        distance := station.position - maxDist

        // 如果当前剩余水量加上到达水站的距离小于m英里，则无法到达。
        if currentWater + distance < m {
            break
        }

        // 更新最远距离。
        maxDist = station.position

        // 更新当前剩余水量，考虑已经消耗的水量。
        currentWater = 2 - distance/m
    }

    // 返回最远距离。
    return maxDist
}

func main() {
    // 假设的地图上的水站位置（英里）。
    stations := []*WaterStation{
        NewWaterStation(10),
        NewWaterStation(20),
        NewWaterStation(40),
        NewWaterStation(60),
        NewWaterStation(80),
    }

    // 教授在喝光水之前能滑行的最大距离（英里）。
    m := 40

    // 计算并打印最远距离。
    fmt.Printf("The maximum distance Professor Gekko can travel before running out of water is: %d miles\n", maxDistance(stations, m))
}

程序解释

在这个程序中，我们首先定义了一个WaterStation结构体来表示地图上的水站，以及一个NewWaterStation函数来创建新的水站实例。

maxDistance函数接受一个水站的切片和一个整数m作为输入，其中m表示教授在喝光水之前能滑行的最大英里数。函数的目标是计算教授在需要补充水分之前能够到达的最远距离。

我们初始化最远距离为0，并假设教授从大福克斯市出发时带整整两公升水。然后，我们遍历每个水站，计算到达当前水站的距离，并更新最远距离和剩余水量。如果在任何点上，剩余水量加上到达下一个水站的距离小于m英里，我们就无法到达下一个水站，此时应该停止遍历。

最后，main函数创建了一个假设的水站位置切片，并调用maxDistance函数来计算并打印教授能够滑行的最远距离。

这个程序是基于假设的简化模型，实际情况可能需要考虑更多的因素，如天气、体力消耗等。但在给定的模型下，这个程序应该能够帮助Gekko教授规划他的直排轮滑之旅。

混元：

为了帮助Gekko教授完成他的梦想，我们可以编写一个Go语言程序来计算他需要在哪些地点补充水，以及在喝光水之前能滑行多少英里。以下是一个可能的实现：

package main

import (
    "fmt"
    "math"
)

type WaterStation struct {
    distance float64
    water     float64
}

func main() {
    // 输入教授的初始水量（升）
    initialWater := 2.0

    // 输入每英里消耗的水量（升/英里）
    waterPerMile := 0.1

    // 输入可以补充水的地点及其间的距离
    stations := []WaterStation{
        {300, 1.0},
        {600, 1.0},
        {900, 1.0},
        {1200, 1.0},
        {1500, 1.0},
        {1800, 1.0},
        {2100, 1.0},
        {2400, 1.0},
        {2700, 1.0},
        {3000, 1.0},
        {3300, 1.0},
        {3600, 1.0},
        {3900, 1.0},
        {4200, 1.0},
        {4500, 1.0},
        {4800, 1.0},
        {5100, 1.0},
        {5400, 1.0},
        {5700, 1.0},
        {6000, 1.0},
        {6300, 1.0},
        {6600, 1.0},
        {6900, 1.0},
        {7200, 1.0},
        {7500, 1.0},
        {7800, 1.0},
        {8100, 1.0},
        {8400, 1.0},
        {8700, 1.0},
        {9000, 1.0},
        {9300, 1.0},
        {9600, 1.0},
        {9900, 1.0},
        {10200, 1.0},
        {10500, 1.0},
        {10800, 1.0},
        {11100, 1.0},
        {11400, 1.0},
        {11700, 1.0},
        {12000, 1.0},
        {12300, 1.0},
        {12600, 1.0},
        {12900, 1.0},
        {13200, 1.0},
        {13500, 1.0},
        {13800, 1.0},
        {14100, 1.0},
        {14400, 1.0},
        {14700, 1.0},
        {15000, 1.0},
        {15300, 1.0},
        {15600, 1.0},
        {15900, 1.0},
        {16200, 1.0},
        {16500, 1.0},
        {16800, 1.0},
        {17100, 1.0},
        {17400, 1.0},
        {17700, 1.0},
        {18000, 1.0},
        {18300, 1.0},
        {18600, 1.0},
        {18900, 1.0},
        {19200, 1.0},
        {19500, 1.0},
        {19800, 1.0},
        {20100, 1.0},
        {20400, 1.0},
        {20700, 1.0},
        {21000, 1.0},
        {21300, 1.0},
        {21600, 1.0},
        {21900, 1.0},
        {22200, 1.0},
        {22500, 1.0},
        {22800, 1.0},
        {23100, 1.0},
        {23400, 1.0},
        {23700, 1.0},
        {24000, 1.0},
        {24300, 1.0},
        {24600, 1.0},
        {24900, 1.0},
        {25200, 1.0},
        {25500, 1.0},
        {25800, 1.0},
        {26100, 1.0},
        {26400, 1.0},
        {26700, 1.0},
        {27000, 1.0},
        {27300, 1.0},
        {27600, 1.0},
        {27900, 1.0},
        {28200, 1.0},
        {28500, 1.0},
        {28800, 1.0},
        {29100, 1.0},
        {29400, 1.0},
        {29700, 1.0},
        {30000, 1.0},
        {30300, 1.0},
        {30600, 1.0},
        {30900, 1.0},
        {31200, 1.0},
        {31500, 1.0},
        {31800, 1.0},
        {32100, 1.0},
        {32400, 1.0},
        {32700, 1.0},
        {33000, 1.0},
        {33300, 1.0},
        {33600, 1.0},
        {33900, 1.0},
        {34200, 1.0},
        {34500, 1.0},
        {34800, 1.0},
        {35100, 1.0},
        {35400, 1.0},
        {35700, 1.0},
        {36000, 1.0},
        {36300, 1.0},
        {36600, 1.0},
        {36900, 1.0},
        {37200, 1.0},
        {37500, 1.0},
        {37800, 1.0},
        {38100, 1.0},
        {38400, 1.0},
        {38700, 1.0},
        {39000, 1.0},
        {39300, 1.0},
        {39600, 1.0},
        {39900, 1.0},
        {40200, 1.0},
        {40500, 1.0},
        {40800, 1.0},
        {41100, 1.0},
        {41400, 1.0},
        {41700, 1.0},
        {42000, 1.0},
        {42300, 1.0},
        {42600, 1.0},
        {42900, 1.0},
        {43200, 1.0},
        {43500, 1.0},
        {43800, 1.0},
        {44100, 1.0},
        {44400, 1.0},
        {44700, 1.0},
        {45000, 1.0},
        {45300, 1.0},
        {45600, 1.0},
        {45900, 1.0},
        {46200, 1.0},
        {46500, 1.0},
        {46800, 1.0},
        {47100, 1.0},
        {47400, 1.0},
        {47700, 1.0},
        {48000, 1.0},
        {48300, 1.0},
        {48600, 1.0},
        {48900, 1.0},
        {49200, 1.0},
        {49500, 1.0},
        {49800, 1.0},
        {50100, 1.0},
        {50400, 1.0},
        {50700, 1.0},
        {51000, 1.0},
        {51300, 1.0},
        {51600, 1.0},
        {51900, 1.0},
        {52200, 1.0},
        {52500, 1.0},
        {52800, 1.0},
        {53100, 1.0},
        {53400, 1.0},
        {53700, 1.0},
        {54000, 1.0},
        {54300, 1.0},
        {54600, 1.0},
        {54900, 1.0},
        {55200, 1.0},
        {55500, 1.0},
        {55800, 1.0},
        {56100, 1.0},
        {56400, 1.0},
        {56700, 1.0},
        {57000, 1.0},
        {57300, 1.0},
        {57600, 1.0},
        {57900, 1.0},
        {58200, 1.0},
        {58500, 1.0},
        {58800, 1.0},
        {59100, 1.0},
        {59400, 1.0},
        {59700, 1.0},
        {60000, 1.0},
        {60300, 1.0},
        {60600, 1.0},
        {60900, 1.0},
        {61200, 1.0},
        {61500, 1.0},
        {61800, 1.0},
        {62100, 1.0},
        {62400, 1.0},
        {62700, 1.0},
        {63000, 1.0},
        {63300, 1.0},
        {63600, 1.0},
        {63900, 1.0},
        {64200, 1.0},
        {64500, 1.0},
        {64800, 1.0},
        {65100, 1.0},
        {65400, 1.0},
        {65700, 1.0},
        {66000, 1.0},
        {66300, 1.0},
        {66600, 1.0},
        {66900, 1.0},
        {67200, 1.0},
        {67500, 1.0},
        {67800, 1.0},
        {68100, 1.0},
        {68400, 1.0},
        {68700, 1.0},
        {69000, 1.0},
        {69300, 1.0},
        {69600, 1.0},
        {69900, 1.0},
        {70200, 1.0},
        {70500, 1.0},
        {70800, 1.0},
        {71100, 1.0},
        {71400, 1.0},
        {71700, 1.0},
        {72000, 1.0},
        {72300, 1.0},
        {72600, 1.0},
        {72900, 1.0},
        {73200, 1.0},
        {73500, 1.0},
        {73800, 1.0},
        {74100, 1.0},
        {74400, 1.0},
        {74700, 1.0},
        {75000, 1.0},
        {75300, 1.0},
        {75600, 1.0},
        {75900, 1.0},
        {76200, 1.0},
        {76500, 1.0},
        {76800, 1.0},
        {77100, 1.0},
        {77400, 1.0},
        {77700, 1.0},
        {