精华内容
下载资源
问答
  • pandas按照多列排序-ascending

    千次阅读 2021-01-22 10:43:46
    .str.replace('℃','').astype('int32') #排序并获取最高温度前5名 print(df.sort_values(by='最高温度',ascending=False).head()) ''' 打印: 日期 最高温度 最低温度 天气 风向 风级 空气质量 184 2019/7/4 38 25 ...

    代码示例:

    import pandas as pd
    
    #读取文件
    df = pd.read_csv('./TianQi.csv')
    #字符串替换和类型转换
    df['最高温度'] = df['最高温度'].str.replace('℃','').astype('int32')
    df.loc[:,'最低温度'] = df['最低温度'].str.replace('℃','').astype('int32')
    #排序并获取最高温度前5名
    print(df.sort_values(by='最高温度',ascending=False).head())
    '''
    打印:
                日期  最高温度  最低温度      天气   风向  风级 空气质量
    184   2019/7/4    38    25    晴~多云  西南风  2级    良
    206  2019/7/26    37    27       晴  西南风  2级    良
    142  2019/5/23    37    21       晴  东南风  2级    良
    183   2019/7/3    36    24       晴  东南风  1级    良
    204  2019/7/24    36    27  多云~雷阵雨  西南风  2级    良
    '''
    
    #按照多列排序
    print(df.sort_values(by=['最高温度','最低温度'],ascending= True).head(10))
    '''
    打印:
                 日期  最高温度  最低温度     天气   风向  风级 空气质量
    363  2019/12/30    -5   -12      晴  西北风  4级    优
    364  2019/12/31    -3   -10      晴  西北风  1级    优
    42    2019/2/12    -3    -8  小雪~多云  东北风  2级    优
    44    2019/2/14    -3    -6  小雪~多云  东南风  2级    良
    14    2019/1/15    -2   -10      晴  西北风  3级    良
    37     2019/2/7    -2    -7     多云  东北风  3级    优
    38     2019/2/8    -1    -7     多云  西南风  2级    优
    4      2019/1/5     0    -8     多云  东北风  2级    优
    39     2019/2/9     0    -8     多云  东北风  2级    优
    40    2019/2/10     0    -8     多云  东南风  1级    优
    '''
    print(df.sort_values(by=['最高温度','最低温度'],ascending= False).head(10))
    '''
    打印:
               日期  最高温度  最低温度      天气   风向  风级  空气质量
    184   2019/7/4    38    25    晴~多云  西南风  2级     良
    206  2019/7/26    37    27       晴  西南风  2级     良
    142  2019/5/23    37    21       晴  东南风  2级     良
    201  2019/7/21    36    27    晴~多云  西南风  2级  轻度污染
    204  2019/7/24    36    27  多云~雷阵雨  西南风  2级     良
    207  2019/7/27    36    27      多云  东南风  2级  轻度污染
    174  2019/6/24    36    24      多云  东南风  2级     良
    175  2019/6/25    36    24      多云  东南风  2级     良
    183   2019/7/3    36    24       晴  东南风  1级     良
    170  2019/6/20    36    23    多云~晴  东南风  2级  轻度污染
    '''
    print(df.sort_values(by=['最高温度','最低温度'],ascending= [True,False]).head(10))
    '''
    打印:
                 日期  最高温度  最低温度     天气   风向  风级 空气质量
    363  2019/12/30    -5   -12      晴  西北风  4级    优
    44    2019/2/14    -3    -6  小雪~多云  东南风  2级    良
    42    2019/2/12    -3    -8  小雪~多云  东北风  2级    优
    364  2019/12/31    -3   -10      晴  西北风  1级    优
    37     2019/2/7    -2    -7     多云  东北风  3级    优
    14    2019/1/15    -2   -10      晴  西北风  3级    良
    38     2019/2/8    -1    -7     多云  西南风  2级    优
    4      2019/1/5     0    -8     多云  东北风  2级    优
    39     2019/2/9     0    -8     多云  东北风  2级    优
    40    2019/2/10     0    -8     多云  东南风  1级    优
    '''

     

    展开全文
  • 实现升序优先队列Ascending priority queuenode结构体升序优先队列Ascending priority queue完整源码(定义,实现,main函数测试) node结构体 struct node { int data; struct node *next; }; 升序优先队列...

    node结构体

    
    struct node
    {
       
        int data;
        struct node *next;
    };
    

    升序优先队列Ascending priority queue完整源码(定义,实现,main函数测试)

    #in
    展开全文
  • jupyter_ascending 从任何编辑器同步Jupyter Notebook 安装 $ pip install jupyter_ascending $ # It is possible you won't need to run the following commands on newer version of jupyter notebook, $ # but ...
  • VJupiter.Ascending.2015.720p&1080p.BluRay.rar
  • <p>2D cartography跑了好几个包都报这个错误</p>
  • ```python rs = pd.Series(cs[0]).sort_values(ascending=0) top5 = rs.iloc[0:5] top5 ```出现错误 ValueError Traceback (most recent call last) in ----> 1 rs = pd.Series(cs[0]).sort_values(ascending=0) 2 3...
  • Ascending Rating Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 524288/524288 K (Java/Others) Total Submission(s): 587 Accepted Submission(s): 150   Problem Description Befo...

    Problem A. Ascending Rating

    Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 524288/524288 K (Java/Others)
    Total Submission(s): 587    Accepted Submission(s): 150


     

    Problem Description

    Before the start of contest, there are n ICPC contestants waiting in a long queue. They are labeled by 1 to n from left to right. It can be easily found that the i-th contestant's QodeForces rating is ai.
    Little Q, the coach of Quailty Normal University, is bored to just watch them waiting in the queue. He starts to compare the rating of the contestants. He will pick a continous interval with length m, say [l,l+m−1], and then inspect each contestant from left to right. Initially, he will write down two numbers maxrating=0 and count=0. Everytime he meets a contestant k with strictly higher rating than maxrating, he will change maxrating to ak and count to count+1.
    Little T is also a coach waiting for the contest. He knows Little Q is not good at counting, so he is wondering what are the correct final value of maxrating and count. Please write a program to figure out the answer.

     

     

    Input

    The first line of the input contains an integer T(1≤T≤2000), denoting the number of test cases.
    In each test case, there are 7 integers n,m,k,p,q,r,MOD(1≤m,k≤n≤107,5≤p,q,r,MOD≤109) in the first line, denoting the number of contestants, the length of interval, and the parameters k,p,q,r,MOD.
    In the next line, there are k integers a1,a2,...,ak(0≤ai≤109), denoting the rating of the first k contestants.
    To reduce the large input, we will use the following generator. The numbers p,q,r and MOD are given initially. The values ai(k<i≤n) are then produced as follows :

    ai=(p×ai−1+q×i+r)modMOD


    It is guaranteed that ∑n≤7×107 and ∑k≤2×106.

     

     

    Output

    Since the output file may be very large, let's denote maxratingi and counti as the result of interval [i,i+m−1].
    For each test case, you need to print a single line containing two integers A and B, where :

    AB==∑i=1n−m+1(maxratingi⊕i)∑i=1n−m+1(counti⊕i)


    Note that ``⊕'' denotes binary XOR operation.

     

     

    Sample Input

     

    1 10 6 10 5 5 5 5 3 2 2 1 5 7 6 8 2 9

     

     

    Sample Output

     

    46 11

     

     

    Source

    2018 Multi-University Training Contest 3

     题意:生成N个数,对于每个M长度的区间,设为[L, L+M-1],贡献1为区间最大值异或x,贡献2为以以L为起点的最长上升子序列异或X,输出所有M长度区间的贡献之和。

    思路:首先按照公式生成N个数,正着做很难维护,考虑反着做维护一个单调递减的序列,任意时刻队列的大小就是上升子序列的长度,注意边界条件就行,然后得用数组模拟双端队列。

    # include <bits/stdc++.h>
    using namespace std;
    typedef long long LL;
    const LL mod = 1e9+7;
    const int maxn = 1e7+30;
    int a[maxn], d[maxn];
    int T, n, m, k, p, q, r, MOD;
    void scan(int &ret)
    {
        char c; ret = 0;
        while((c=getchar()) < '0' || c > '9');
        while(c>='0' && c<='9') ret = ret*10 + (c-'0'), c = getchar();
    }
    int main()
    {
        for(scan(T);T;--T)
        {
            LL ans = 0, ans2=0;
            scan(n);scan(m);scan(k);scan(p);scan(q);scan(r);scan(MOD);
            p %= MOD;q %= MOD;r %= MOD;
            for(int i=1; i<=k; ++i) scan(a[i]);
            for(int i=k+1; i<=n; ++i)
            {
                a[i] = 1LL*p*a[i-1]%MOD+(1LL*q*i%MOD+r)%MOD;
                if(a[i] >= MOD) a[i] -= MOD;
            }
            int tail = 10000001, head = tail+1;
            for(int i=n; i>=n-m+1; --i)
            {
                while(tail+1 != head && a[i] >= a[d[head]]) ++head;
                d[--head] = i;
            }
            ans = (tail-head+1)^(n-m+1);
            ans2 = (a[d[tail]])^(n-m+1);
            for(int i=n-m; i>0; --i)
            {
                if(d[tail] == i+m) --tail;;
                while(tail+1!= head && a[i] >= a[d[head]]) ++head;
                d[--head] = i;
                ans += (tail-head+1)^i;
                ans2 += a[d[tail]]^i;
            }
            printf("%lld %lld\n",ans2,ans);
        }
        return 0;
    }
    

     

    展开全文
  • import ascending from "./ascending.js"; // Based on https://github.com/mourner/quickselect // ISC license, Copyright 2018 Vladimir Agafonkin. export default function quickselect(array, k, left = 0, ...

    本着学习d3js的原则,对函数用法做出解释,对源码写出自己的理解,文章最后补充一些源码中用到的JS语法,欢迎各位批评指正,学习交流!多多评论共同进步!

    d3.min(iterable[,accessor])

    根据顺序返回可迭代对象中的最小值,如果没有可以比较的值,返回undefined. 可选访问函数等价于调用Array.from(Array.from用法,将类似于数组的对象转化为数组,要求该对象有length属性)。

    和Math.min不同,该方法会会忽略undefined,null,NaN值,这对处理missing data有用, 此外,元素比较顺序依赖字符串顺序而不是数字顺序,比如,["20","3"]按照字符串顺序最小值为“20”,[20,3]按照数字顺序最小值为3。

    export default function min(values, valueof) {
      let min;
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null
              && value >= value
              && (min === undefined || min > value)) {
            min = value;
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null
              && value >= value
              && (min === undefined || min > value)) {
            min = value;
          }
        }
      }
      return min;
    }

    采用ES6 module标准导出接口,这里value >= value 操作有点不解?

    d3.max(iterable[, accessor]) 

    该方法返回最大值,其他特性与d3.min类似。

    export default function max(values, valueof) {
      let max;
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null
              && value >= value
              && (max === undefined || max < value)) {
            max = value;
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null
              && value >= value
              && (max === undefined || max < value)) {
            max = value;
          }
        }
      }
      return max;
    }

    d3.extent(iterable[, accessor])

    该方法返回[最小值,最大值],没有可比较元素返回[undefined,undefined]。

    export default function(values, valueof) {
      let min;
      let max;
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null && value >= value) {
            if (min === undefined) {
              min = max = value;
            } else {
              if (min > value) min = value;
              if (max < value) max = value;
            }
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null && value >= value) {
            if (min === undefined) {
              min = max = value;
            } else {
              if (min > value) min = value;
              if (max < value) max = value;
            }
          }
        }
      }
      return [min, max];
    }

    实现原理没有什么特别的,第一次循环将value赋值min,max,后面循环求出最大值最小值。

     d3.sum(iterable[, accessor]) 

    返回可迭代元素和,如果没有元素返回0。该方法忽略undefine,NaN。

    export default function sum(values, valueof) {
      let sum = 0;
      if (valueof === undefined) {
        for (let value of values) {
          if (value = +value) {
            sum += value;
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if (value = +valueof(value, ++index, values)) {
            sum += value;
          }
        }
      }
      return sum;
    }

    这里value前的+号,作用是什么?

    d3.mean(iterable[, accessor])

    返回平均值,忽略undefine,NaN。

    export default function mean(values, valueof) {
      let count = 0;
      let sum = 0;
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null && (value = +value) >= value) {
            ++count, sum += value;
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
            ++count, sum += value;
          }
        }
      }
      if (count) return sum / count;
    }

    d3.median(iterable[, accessor])

    使用r-7method返回中位数

    import quantile from "./quantile.js";
    import quickselect from "./quickselect.js";
    
    function* numbers(values, valueof) {
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null && (value = +value) >= value) {
            yield value;
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
            yield value;
          }
        }
      }
    }
    
    export default function(values, valueof) {
      values = Float64Array.from(numbers(values, valueof));
      if (!values.length) return;
      const n = values.length;
      const i = n >> 1;
      quickselect(values, i - 1, 0);
      if ((n & 1) === 0) quickselect(values, i, i);
      return quantile(values, 0.5);
    }

    首先通过迭代器函数生成float64数组,通过quickselect给中值排好序。

    d3.quickselect(arraykleft = 0, right = array.length - 1, compare = ascending)

    该方法为Floyd–Rivest algorithm,快速选择算法。

    详情:https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm

    import ascending from "./ascending.js";
    
    // Based on https://github.com/mourner/quickselect
    // ISC license, Copyright 2018 Vladimir Agafonkin.
    export default function quickselect(array, k, left = 0, right = array.length - 1, compare = ascending) {
      while (right > left) {
        if (right - left > 600) {
          const n = right - left + 1;
          const m = k - left + 1;
          const z = Math.log(n);
          const s = 0.5 * Math.exp(2 * z / 3);
          const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
          const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
          const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
          quickselect(array, k, newLeft, newRight, compare);
        }
    
        const t = array[k];
        let i = left;
        let j = right;
    
        swap(array, left, k);
        if (compare(array[right], t) > 0) swap(array, left, right);
    
        while (i < j) {
          swap(array, i, j), ++i, --j;
          while (compare(array[i], t) < 0) ++i;
          while (compare(array[j], t) > 0) --j;
        }
    
        if (compare(array[left], t) === 0) swap(array, left, j);
        else ++j, swap(array, j, right);
    
        if (j <= k) left = j + 1;
        if (k <= j) right = j - 1;
      }
      return array;
    }
    
    function swap(array, i, j) {
      const t = array[i];
      array[i] = array[j];
      array[j] = t;
    }

    这个算法有点复杂,功能为快速选择k值的算法。如果数据量过大,会先选择一个样本进行就行搜索。首先对第在k的位置上的值放置到该值应该呆的位置,之后根据k位置的值所在的下标进行更新,取前部或着取后部,循环迭代直到找到了第k值。

    number.js

    x为null返回NaN,否则返回x,该函数的功能就是可以把字符串变成数字,+“123”=123。

    export default function(x) {
      return x === null ? NaN : +x;
    }

    d3.quantile(arrayp[, accessor])

        
    import number from "./number.js";
    
    export default function quantile(values, p, valueof = number) {
      if (!(n = values.length)) return;
      if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
      if (p >= 1) return +valueof(values[n - 1], n - 1, values);
      var n,
          i = (n - 1) * p,
          i0 = Math.floor(i),
          value0 = +valueof(values[i0], i0, values),
          value1 = +valueof(values[i0 + 1], i0 + 1, values);
      return value0 + (value1 - value0) * (i - i0);
    }

    用法如下,当然要求传入的数组为排好序的数组

    var a = [0, 10, 30];
    d3.quantile(a, 0); // 0
    d3.quantile(a, 0.5); // 10
    d3.quantile(a, 1); // 30
    d3.quantile(a, 0.25); // 5
    d3.quantile(a, 0.75); // 20
    d3.quantile(a, 0.1); // 2

    d3.variance(iterable[, accessor]) 

    export default function variance(values, valueof) {
      let count = 0;
      let delta;
      let mean = 0;
      let sum = 0;
      if (valueof === undefined) {
        for (let value of values) {
          if (value != null && (value = +value) >= value) {
            delta = value - mean;
            mean += delta / ++count;
            sum += delta * (value - mean);
          }
        }
      } else {
        let index = -1;
        for (let value of values) {
          if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
            delta = value - mean;
            mean += delta / ++count;
            sum += delta * (value - mean);
          }
        }
      }
      if (count > 1) return sum / (count - 1);
    }

    使用增量算法计算方差:https://www.cnblogs.com/yoyaprogrammer/p/delta_variance.html

    d3.deviation(iterable[, accessor])

    import variance from "./variance.js";
    
    export default function deviation(values, valueof) {
      const v = variance(values, valueof);
      return v ? Math.sqrt(v) : v;
    }

    标准差即对方差开根号

    d3.scan(iterable[,comparator])

    对可迭代对象执行线性迭代,根据可选比较函数comparator返回最小元素的索引,(如果比较函数返回NaN,即给定的对象没有可以比较的元素,该函数返回undefined,比较函数没有指定,默认为ascending).例如:

    const array = [{foo: 42}, {foo: 91}];
    d3.scan(array, (a, b) => a.foo - b.foo); // 0
    d3.scan(array, (a, b) => b.foo - a.foo); // 1

    该方法和min非常类似,区别就是该方法接受一个比较函数而不是访问函数,返回元素为下标。

    import ascending from "./ascending.js";
    
    export default function scan(values, compare = ascending) {
      let min;
      let minIndex;
      let index = -1;
      for (const value of values) {
        ++index;
        if (minIndex === undefined
            ? compare(value, value) === 0
            : compare(value, min) < 0) {
          min = value;
          minIndex = index;
        }
      }
      return minIndex;
    }

    d3.ascending(ab)

    该比较函数为natural order,递增顺序。可以与内置的array.sort方法一起使用,以按升序排列元素。

    export default function(a, b) {
      return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
    }

    这里要注意array.sort在没有指定比较函数的情况下,默认排序为字典顺序(lexicographic),而不是natural。

    JS语法补充:

    js中的iterable

    ES6标准引入iterable类型,Array、Map、Set都属于iterable类型,可以使用for...of循环来遍历。

    了解更多:https://www.cnblogs.com/yuanxinru321/p/7551660.html

    关于Set:https://www.cnblogs.com/diligenceday/p/5479076.html

    Array.from方法:https://www.jianshu.com/p/f4554f74de95

    function* 生成器函数

    通过next()方法调用yield,返回两个值,value和done,分别为本次的返回值和后续是否还有yield语句布尔值。yield*可以移交执行权。

    了解更多:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/function*

    展开全文
  • MLUtils.loadLibSVMFile数据集标记的index是从1开始,如下: 此时可以正确执行,输出: 当index从0开始时: 便会报错:
  • checkio Ascending List

    2020-07-07 13:37:27
    题目: list无重复数字,都是从小到大排列为True 链接: ...代码 ...def is_ascending(items: Iterable[int]) -> bool: a = items aa = list(set(a)) b = sorted(a) if len(aa) != len(a): r =
  • 【题目链接】 ... 题目意思 给定一个长度为n的序列,给出前k个值,后面根据公式自己算。现在问你每个区间长度为m的子序列最大值异或上i和最大值变化次数异或上i的求和。 ...用单调队列来维护,只要把序列倒过来维护...
  • Create and return a new iterable that contains the same elements as the argument iterable items, but with the reversed order of the elements inside every maximal strictly ascending sublist. This ...
  • #as_index=False结果的列名与之前一致 aa=chipo.groupby(['item_name'],...daleijine=df.groupby(['大类名称'],as_index=False)['销售金额'].sum().sort_values(['销售金额'],ascending=False).reset_index(drop=True)
  • 高分辨目标方位估计算法──递增阶数多参数估计的理论与实验研究
  • 这道题自己思路也对了,就是数组使用出了点问题,然后就是看了别人的代码才改过来,用到匿名数组。 不多说,看代码,   class Solution {  public int[] twoSum(int[] numbers, int target) { ...
  • 题目大意: 给你n个数,对于第i个数求区间(i , i+m-1)的最大值以及严格递增序列的长度。   解题思路: ...n是1e7,所以肯定是单调队列,但是单调队列注意要倒着维护,倒着维护感觉会比较的简单。...
  • import java.util.Arrays;import java.util....public class Ascending{ public static void main(String[] args){ Scanner in=new Scanner(System.in); int[] arr=new int[10]; for(int i=0;i<arr.lengt...
  • Unique Ascending Array Time Limit: 2000MS   Memory Limit: 65536KB   64bit IO Format: %lld & %llu Submit Status Description Given an array of integers A[N], you are ...
  • vlan internal allocation policy ----- "ascending" 或者 "descending". 它的内部VLAN的分配政策。可以选择 "ascending" 或者 "descending". "ascending" ,内部VLAN分配从1006开向依次向上建立内部VLAN。 ...
  • zoj Unique Ascending Array

    2013-11-24 22:58:01
    Unique Ascending Array Time Limit:2000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu Submit Status Description Given an array of integers A[N], you are asked to decide the
  • Q:Write a program to sort a stack in ascending order. You should not make any assumptions about how the stack is implemented. The following are the only functions that should be used to write this p
  • Given an array of positive integers nums, return the maximum possible sum of an ascending subarray in nums. A subarray is defined as a contiguous sequence of numbers in an array. A subarray [nums[l], ...
  • 题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1481   //C++代码 #include #include using namespace std; int main(){ int n,a; while(cin>>n,n){ set s;... s.
  • UCOS-II 中的下面写法, 可以无论cpu stack是full-ascending, full-descending, empty-ascending, empty-descending. stack都是没有问题的。os的代码跟平台无关 #if OS_STK_GROWTH == 1u  (void)...
  • #include #include #include int cmp(const void *a,const void *b) { return *(int *)a-*(int *)b; } int main() { int a[101],n,i,x,k,flag,count; while(scanf("%d",&n)!=EOF&&n) { ...
  • Sorting ArrayList in Java is not difficult, by using Collections.sort() method you can ...sort ArrayList in ascending and descending order in Java. Collections.sort() method optionally accept a Compar
  • Question: Write a program to sort a stack in ascending order. You should not make any assumptions about how the stack is implemented. The following are the only functions that should be used to w...
  • HDU 6319 Ascending Rating(单调队列)

    千次阅读 2018-07-30 19:06:22
    Ascending Rating(单调队列) 题意   先给出一个长度为k(k&amp;amp;amp;lt;=n)的序列,和一个递推式,让你先求出整个长度为n的序列,然后对于每个区间都求题目给的式子,其中maxratingi为区间最大值...
  • Sorted Set Ascending order By TreeMap Example package com.sheting.basic.collection.sorted; import java.util.HashSet; import java.util.Set; import java.util.TreeSet; public class SetSimpleSorting ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,352
精华内容 28,940
关键字:

ascending