=MID(RC[-1],FIND(""_"",RC[-1])+3,FIND(""_"",RC[-1],FIND(""_"",RC[-1])+3)-FIND(""_"",RC[-1])-3)

这是一个Excel的公式，作用是截取一个下划线"_"之后到下一个下划线"_"之间的字符串。

RC[-1]表示当前单元格左侧单元格的值。

具体解释如下：

1. FIND(""_"",RC[-1])表示在当前单元格左侧单元格的值中查找第一个下划线"_"的位置。

2. FIND(""_"",RC[-1])+3表示第一个下划线"_"之后的第三个字符的位置。

3. FIND(""_"",RC[-1],FIND(""_"",RC[-1])+3)表示在第一个下划线"_"之后的第三个字符之后查找下一个下划线"_"的位置。

4. FIND(""_"",RC[-1],FIND(""_"",RC[-1])+3)-FIND(""_"",RC[-1])-3表示第二个下划线"_"之前的字符个数。

5. 最终，MID函数截取出第一个下划线"_"之后到第二个下划线"_"之间的字符串。

例如，如果当前单元格左侧单元格的值为"ABC_DEF_GHI"，则该公式的结果为"GHI"。

相关问题

def merge(arr, left, mid, right): n1 = mid - left + 1 n2 = right- mid # 创建临时数组 L = arr[left:mid+1] R = arr[mid+1:right+1] # 归并临时数组到 arr[l..r] i = 0 # 初始化第一个子数组的索引 j = 0 # 初始化第二个子数组的索引 k = left # 初始归并子数组的索引 while i < n1 and j < n2 : if L[i] <= R[j]: arr[k] = L[i] i += 1 else: arr[k] = R[j] j += 1 k += 1 # 拷贝 L[] 的保留元素 while i < n1: arr[k] = L[i] i += 1 k += 1 # 拷贝 R[] 的保留元素 while j < n2: arr[k] = R[j] j += 1 k += 1 def mergeSort(arr,left,right): if left < right: mid = (left+right)//2 mergeSort(arr, left, mid) mergeSort(arr, mid+1, right) merge(arr, left, mid, right) if __name__ =="__main__": 补充代码

如果您需要补充代码，可以参考以下完整的Python代码实现：

def merge(arr, left, mid, right):
    n1 = mid - left + 1
    n2 = right- mid
    # 创建临时数组
    L = arr[left:mid+1]
    R = arr[mid+1:right+1]
    # 归并临时数组到 arr[l..r]
    i = 0     # 初始化第一个子数组的索引
    j = 0     # 初始化第二个子数组的索引
    k = left     # 初始归并子数组的索引
    while i < n1 and j < n2 :
        if L[i] <= R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1
    # 拷贝 L[] 的保留元素
    while i < n1:
        arr[k] = L[i]
        i += 1
        k += 1
    # 拷贝 R[] 的保留元素
    while j < n2:
        arr[k] = R[j]
        j += 1
        k += 1

def mergeSort(arr,left,right):
    if left < right:
        mid = (left+right)//2
        mergeSort(arr, left, mid)
        mergeSort(arr, mid+1, right)
        merge(arr, left, mid, right)

if __name__ =="__main__":
    arr = [38,27,43,3,9,82,10]
    n = len(arr)
    mergeSort(arr,0,n-1)
    print ("排序后的数组:")
    for i in range(n):
        print ("%d" %arr[i],end=" ")

这段代码实现了归并排序算法，其中merge函数用来合并两个有序数组，mergeSort函数用来递归调用归并排序，最后在主函数中对一个未排序的数组进行排序并输出结果。

帮我把下面一段C++代码改写成python代码：#include "Trade.h" #include "WPrice.h" #include <algorithm> double normalCDF(double x) // Phi(-∞, x) aka N(x) { return std::erfc(-x / std::sqrt(2)) / 2; //erfc()是互补误差函数，该返回值表示标准正态分布下var小于x的概率，即N(x) } CTrade::CTrade(double tick) : wp_bid(0.01), wp_ask(0.01), m_tick(tick), m_TimeRound(50) { newday(NULL); } CTrade::~CTrade() { } void CTrade::OnBook(const BTRec& btRec) { wp.setGamma(0.1); wp_bid = wp.getWP(&btRec.Bids); wp_ask = wp.getWP(&btRec.Asks); if (wp_mid > 0){ //wp_mid初始化为-1，仅遇到第一条BTRec记录时条件为false double wp_now = (wp_bid + wp_ask) / 2; //updated wp_mid int volume = btRec.volume; //volume between two orderbook records double ratio = normalCDF((wp_now - wp_mid) / (2 * m_tick)); //m_tick = tick = 0.2 double buyvolume = ratio*volume, sellvolume = (1 - ratio)*volume; m_TimeRound.update(buyvolume, sellvolume, btRec.rec_time.timestamp); //volume moving average if (mv_volume < 0) { mv_volume = volume; mv_buyvolume = buyvolume; } else{ mv_volume += 0.002*(volume - mv_volume); mv_buyvolume += 0.002*(buyvolume - mv_buyvolume); } // round trip volatility if (time_ini < 0 || btRec.rec_time.timestamp - time_ini >= time_scale){ if (time_ini>0){ double dp = wp_now - wp_ini; volatility += 0.05*(dp*dp - volatility); } time_scale = m_TimeRound.getTime() * 1000; //in milliseconds time_ini = btRec.rec_time.timestamp; wp_ini = wp_now; } } wp_mid = (wp_bid + wp_ask) / 2; } void CTrade::newday(const char* p) { wp_mid = -1; m_TimeRound.newday(p); volatility = 16 * m_tick*m_tick; time_slapse = -1, time_scale = -1, wp_ini = -1, time_ini = -1; mv_buyvolume = mv_volume = -1; }

import math

class CTrade:
    def __init__(self, tick):
        self.wp_bid = 0.01
        self.wp_ask = 0.01
        self.m_tick = tick
        self.m_TimeRound = TimeRound()
        self.newday(None)

    def OnBook(self, btRec):
        self.wp.setGamma(0.1)
        self.wp_bid = self.wp.getWP(btRec.Bids)
        self.wp_ask = self.wp.getWP(btRec.Asks)
        if self.wp_mid > 0:
            wp_now = (self.wp_bid + self.wp_ask) / 2
            volume = btRec.volume
            ratio = normalCDF((wp_now - self.wp_mid) / (2 * self.m_tick))
            buyvolume = ratio * volume
            sellvolume = (1 - ratio) * volume
            self.m_TimeRound.update(buyvolume, sellvolume, btRec.rec_time.timestamp)
            if self.mv_volume < 0:
                self.mv_volume = volume
                self.mv_buyvolume = buyvolume
            else:
                self.mv_volume += 0.002 * (volume - self.mv_volume)
                self.mv_buyvolume += 0.002 * (buyvolume - self.mv_buyvolume)
            if self.time_ini < 0 or btRec.rec_time.timestamp - self.time_ini >= self.time_scale:
                if self.time_ini > 0:
                    dp = wp_now - self.wp_ini
                    self.volatility += 0.05 * (dp * dp - self.volatility)
                self.time_scale = self.m_TimeRound.getTime() * 1000
                self.time_ini = btRec.rec_time.timestamp
                self.wp_ini = wp_now
        self.wp_mid = (self.wp_bid + self.wp_ask) / 2

    def newday(self, p):
        self.wp_mid = -1
        self.m_TimeRound.newday(p)
        self.volatility = 16 * self.m_tick * self.m_tick
        self.time_slapse = -1
        self.time_scale = -1
        self.wp_ini = -1
        self.time_ini = -1
        self.mv_buyvolume = -1
        self.mv_volume = -1

def normalCDF(x):
    return math.erfc(-x / math.sqrt(2)) / 2

class TimeRound:
    def __init__(self):
        self.buy_volume = 0
        self.sell_volume = 0
        self.time = 0

    def update(self, buyvolume, sellvolume, timestamp):
        if timestamp > self.time:
            self.buy_volume = 0
            self.sell_volume = 0
            self.time = timestamp
        self.buy_volume += buyvolume
        self.sell_volume += sellvolume

    def getTime(self):
        return self.buy_volume + self.sell_volume