组合数函数python,复合函数和组合函数

Python实现,输入一个正整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接

你的例子第一列全是 3，我给个例子吧：[321, 32, 3, 4]，输出该是 321,32,3,4。

创新互联是一家集网站建设,香河企业网站建设,香河品牌网站建设,网站定制,香河网站建设报价,网络营销,网络优化,香河网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

第一个数越大，则应该排在后面，毕竟 4XXX 是比 3XXX 大的。

setp 1: [0][1][2]

3  2  1

3  2

3

4

排序第 0 列，越大的排越后。

ret = [?, ?, ?, 4]

setp 2: [0][1][2]

3  2  1

3  2

3 3     - 补位 3，因为 3 是同 3 组第一个元素。

排序第 1 列，越大的排越后。

ret = [?, ?, 3, 4]

setp 3: [0][1][2]

3  2  1

3  2 3  - 补位 3，因为 3 是同 3 组第一个元素。

排序第 2 列，越大的排越后。323 比 321 大，所以……

ret = [?, 32, 3, 4]

只剩一个，那个排第一：

ret = [321, 32, 3, 4]

以上就是基本思路了。综上可得：

1. 先按 [0] 列分组：

2. 组中每个数都补位到同样长度，然后再排序。

完整代码：

def joinmin(ls):

groups = {}

for item in ls:

prefix = item

n = 0

while prefix  10:

prefix //= 10

n += 1

groups.setdefault(prefix, []).append([item, n])

sorted_keys = list(sorted(groups))

ret = 0

for prefix in sorted_keys:

items = groups[prefix]

max_n = max([t[1] for t in items])

presort_items = []

for item, item_n in items:

padding = item

n = item_n

while max_n  n:

padding *= 10

padding += prefix

n += 1

presort_items.append((padding, item, item_n))

for _, item, n in sorted(presort_items):

while n  -1:

ret *= 10

n -= 1

ret += item

return ret

不是看在你的分上答的，不过这种小题目蛮有趣的。

python的几个简单问题关于幂运算和阶乘

前两个都封装成了函数。最后一个直接运行的。没有定义函数。

中间那个问题，是因为你忘记做类型转换，你试着运行这个number=int(number)。应该 就对了。

.编写一个计算组合数的函数combinNum(int m,int n).计算结果由函数返回. 计算组

#include stdio.h

unsigned long combinNum(int m,int n)

{

int i;

unsigned long x=1;

if(n0||nm)return 0;

for(i=m;im-n;i--)

x=x*i/(m+1-i);

return x;

}

void main()

{

int m,n;

scanf("%d%d",m,n);

printf("%ld\n",combinNum(m,n));

}

python第六讲：组合数类型

定义：集合是多个元素的无序组合

特点：集合类型与数学中的集合概念一致，几何元素之间无序、每个元素唯一、不存在相同元素，几何元素不可更待、不能存在可变数据类型。

非可变数据类型：整数、浮点数、复数、字符串类型、元组类型等

表示：{},元素间用，分隔

建立：{} 或者set{}，建立空集合必须使用set{}

举例：

基本操作符：

增强操作符：

实例：

A-B

{123}

B-A

{'3','1','2'}

AB

{'p','y'}

A|B

{'1','p','2','y','3',123}

A^B

{'2',123,'3','1'}

p123y

A

set()

1.包含关系比较：

True

False

2.数据去重

{'p','y',123}

['p','y',123]

定义：序列是具有先后关系的一组元素

特点：序列是一维元素向量，元素类型可以不同，元素可以相同：类似数学元素序列：元素间有序列引导，通过下标访问序列的特定元素

序列是一个基类类型，衍生为：字符串类型、元组类型、列表类型

序号的定义：正向递增序号、反向递减序号，与字符串中相似。

['.io',123,'python']

'oi.321nohtyp'

序列类型的通用函数和方法：

3

'y'

定义：元组类型是序列类型的一种扩展，一旦创建就不能修改

形式：元组使用（）或者tuple（）创建，元素之间用逗号分隔：小括号使不使用都可以。

举例：

('cat','dog','tiger','human')

(4352,'bule',('cat','dog','tiger','human'))

元组类型继承序列类型全部通用操作：操作符、处理函数、处理方法

元组类型创建后不能修改，因此没有特殊操作

('human','tiger',dog','cat')

'tiger'

定义：列表是序列类型的一种扩展，创建后其中的元素可以被随意修改

使用：[]或者list()创建，元素间可以用逗号隔开，列表中各元素类型可不同，无长度限制

['cat','dog','tiger',1024]

['cat','dog','tiger',1024]

列表类型操作函数及其方法：

['cat',1,2,3,4,'tiger',1024]

修改列表：

练习：

序列：元组和列表两种重要类型

应用场景：元组用于元素不改变的场景，更多用于固定搭配场景：列表更加灵活，它是最常用的序列类型

作用：表达一组有序数据并且处理问题；数据保护

元素遍历：

元组类型：

数据保护：不希望数据被程序所改变，转换成元组类型

('cat',1,2,3,4,'tiger',1024)

基本统计值需求：给出一组数并且理解

定义：总个数、求和、平均值、方差、中位数...

总个数：len()

求和：for...in

平均值：求和/总个数

方差：各数据与平均数差的平方的和的平均数

中位数：排序，然后... 奇数找中间一个，偶数中间两个的平均

映射：是一种索引和数据的对应关系，也是键和值的对应关系。

映射类型：由用户数据为定义索引

字典类型：数据的组织与表达的一种新的形态，是映射的体现。

键值对：键是数据索引的扩展，字典是键值对的集合，键值对间无序。

生成：{}和dict()创建，键值对之间用冒号：表示

举例：{键1:值1,键2:值2,...,键n:值n}

在字典变量中，通过键获得值：

字典变量={键1:值1,...,键n:值n}

值=字典变量[键]

字典变量[键]=值

用[]来向字典中增加或者索引键值对

举例：

'北京'

生成空字典：

de={};type(de)

class 'dict'

type(x) 返回变量x的类型

举例：

True

dict_keys(['中国','美国','法国])

dict_values(['北京','华盛顿','巴黎'])

实例：

'北京'

'伊斯兰堡'

('中国','北京')

练习：

1.映射的表达：映射无处不在，键值对也无处不在，统计数据出现的次数，数据是键，次数是值。

字典的主要作用：表达键值对的数据进而操作他们

2.元素遍历：

for k in d:

语句块

定义：jieba库是优秀的第三方中文分词库，需要额外安装

安装方法：（cmd命令下）pip install jieba

作用：利用中文词库确定汉字间的关联概率，字间概率大的组成词组，形成分词效果，用户还可以向其中自定义的添加词组。

分类：精确模式、全模式、搜索引擎模式

精确模式：将词组精确的分开，不存在冗余单词

全模式：将所有可能的词组都扫描出来，有冗余

搜索引擎模式：在精确模式的基础上，将长词再次切分

举例：

['中国','是','一个','伟大','的','国家']

['中国','国是','一个','伟大','的','国家']

['中华','华人','人民','共和','共和国','中华人民共和国','是','伟大','的']

需求：一篇文章中出现的词的频率统计

分类：英文文本，中文文本

举例：

英文：哈姆雷特（hamlet）

中文：三国演义（threekingdoms）

关于杨辉三角python代码的问题

杨辉三角，是二项式系数在三角形中的一种几何排列。

前提：每行端点与结尾的数为1.

每个数等于它上方两数之和。

每行数字左右对称，由1开始逐渐变大。

第n行的数字有n项。

第n行数字和为2n-1。

第n行的m个数可表示为

C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。

第n行的第m个数和第n-m+1个数相等

，为组合数性质之一。

每个数字等于上一行的左右两个数字之和。可用此性质写出整个杨辉三角。即第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，这也是组合数的性质之一。即

C(n+1,i)=C(n,i)+C(n,i-1)。

(a+b)n的展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

将第2n+1行第1个数，跟第2n+2行第3个数、第2n+3行第5个数……连成一线，这些数的和是第4n+1个斐波那契数；将第2n行第2个数(n1)，跟第2n-1行第4个数、第2n-2行第6个数……这些数之和是第4n-2个斐波那契数。

将各行数字相排列，可得11的n-1（n为行数）次方：1=11^0;

11=11^1;

121=11^2……当n5时会不符合这一条性质，此时应把第n行的最右面的数字”1”放在个位，然后把左面的一个数字的个位对齐到十位…

…，以此类推，把空位用“0”补齐，然后把所有的数加起来，得到的数正好是11的n-1次方。以n=11为例，第十一行的数为：1,10,45,120,210,252,210,120,45,10,1，结果为

25937424601=1110。

完整代码：

#!/usr/bin/python

#coding=utf-8

#

__author__

=

'cy'

#输出杨辉三角数值表

def

triangle(num):

#初始表值为[1]

triangle=[[1]]

#添加i个值([1])至triangle表,eg:[1]*3,triangle=[[1],

[1],

[1]]

for

i

in

range(2,

num+1):

triangle.append([1]*i)

#改变triangle表的值,eg:

#当num=5时，i取5，j取3

#triangle[4][1]

=

triangle[3][1]+triangle[3][0]

#triangle[4][2]

=

triangle[3][2]+triangle[3][1]

#triangle[4][3]

=

triangle[3][3]+triangle[3][2]

#相当于triangle表的第4位的值(这里的值为一个表)的第1,2,3位值等于第3位的值(这里的值也是一个表)的第1,2,3位值和0,1,2的值分别相加(即错位相加)。

for

j

in

range(1,

i-1):

triangle[i-1][j]

=

triangle[i-2][j]+triangle[i-2][j-1]

return

triangle

#格式化输出(输出的是一个表)

def

printtriangle(triangle,

width):

#列宽

column

=

len(triangle[-1])*width

for

sublist

in

triangle:

result

=

[]

for

contents

in

sublist:

#控制间距

result.append('{0:^{1}}'.format(str(contents),

width))

#控制缩进，{0:^{1}}：空格在两边补齐空位‘^’居中对齐，‘:’号后面带填充的字符

print('{0:^{1}}'.format(''.join(result),

column))

#启动函数

if

__name__

==

'__main__':

#输入整数

num

=

int(input('How

many

rows

do

you

want:'))

#打印信息

print

"The

triangle

rows

as

follows:"

triangle

=

triangle(num)

#列宽

width

=

len(str(triangle[-1][len(triangle[-1])//2]))+3

printtriangle(triangle,

width)

用python 写 组合数C(m,n)=m!/n!/(m-n)!。试编写阶乘的函数及组合数的函数？

import math

m = int(input("请输入第一个数字："))

n = int(input("请输入第二个数字："))

if m 0 or n 0 or m - n 0:

print("负数是没有阶乘,请重新输入！")

else:

result = math.factorial(m) / math.factorial(n) / math.factorial(m - n)

print("按照公式C(m, n) = m!/n! /(m - n)!，C({0},{1})的答案为 {2}".format(m, n, result))