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

发布网友 发布时间：2022-04-25 07:12

我来回答

共4个回答

热心网友 时间：2023-11-06 01:41

你的例子第一列全是 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

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

热心网友 时间：2023-11-06 01:41

你的例子第一列全是 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

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

热心网友 时间：2023-11-06 01:41

import itertools

data = {3, 32, 321, 3432, 435, 64, 324}     # 最小组合数结果 321323243343243564
# data = {3, 32, 321}     # 最小组合数结果    321323

# 1、首先 data 是一个 set 集合,需要将其转换为 列表进行排序    sorted(list(data)))
# 2、然后通过python的内置库 itertools.permutations   进行排列组合
x = list(itertools.permutations(sorted(list(data))))

# 3、将排列组合出来的数先转为字符串
# 4、然后通过 join 将其组合成一个字符串
# 5、将组合出的数字字符串加入新的 set 集合中
new_data = set()
for i in x:
    n_str = "".join([str(n) for n in i])
    new_data.add(n_str)

# 6、将新的 set 集合转换成列表进行排序,取第一个就是最小的
min_n = sorted(list(new_data))[0]
print(min_n)    # 7、输出最小排列组合的值

热心网友 时间：2023-11-06 01:42

用int会越界的，所以先转成str

数字拼接满足结合律，所以只需要保证每两个数拼接后更小就行了，即ij?ji。因此，可以使用冒泡排序，但是比较的条件变成'i'+'j' > 'j' + 'i',如果满足就交换。

输出用print(''.join(list))即可，python打印字符串的时候不会带''的。

代码是：

# -*- coding:utf-8 -*-

class Solution:

def PrintMinNumber(self,numbers):

if not numbers:

return ''

n = len(numbers)

for i in range(n):

numbers[i] = str(numbers[i])

print(numbers)

for i in range(n):

for j in range(i+1,n):

if numbers[i] + numbers[j] > numbers[j] + numbers[i]:

numbers[i],numbers[j] = numbers[j],numbers[i]

return ''.join(numbers)

热心网友 时间：2023-11-06 01:42

python中的数组，即使是*数组，貌似都是用的中括号表示吧？ 花括号貌似都是针对字典的。

个人以为，可以先将原先的数组转换成列表，利用列表的内置方法排序并拼接后，再转换回去原来的格式。

原始数据，我不知道是什么格式。只是我以为，按照你的说法，跑不出元组、列表、字典等几种格式。这几种格式的转换相对还是比较简单的。

代码就不写了。个人以为这样的做法，应该比较合适。

热心网友 时间：2023-11-06 01:41

import itertools

data = {3, 32, 321, 3432, 435, 64, 324}     # 最小组合数结果 321323243343243564
# data = {3, 32, 321}     # 最小组合数结果    321323

# 1、首先 data 是一个 set 集合,需要将其转换为 列表进行排序    sorted(list(data)))
# 2、然后通过python的内置库 itertools.permutations   进行排列组合
x = list(itertools.permutations(sorted(list(data))))

# 3、将排列组合出来的数先转为字符串
# 4、然后通过 join 将其组合成一个字符串
# 5、将组合出的数字字符串加入新的 set 集合中
new_data = set()
for i in x:
    n_str = "".join([str(n) for n in i])
    new_data.add(n_str)

# 6、将新的 set 集合转换成列表进行排序,取第一个就是最小的
min_n = sorted(list(new_data))[0]
print(min_n)    # 7、输出最小排列组合的值

热心网友 时间：2023-11-06 01:42

用int会越界的，所以先转成str

数字拼接满足结合律，所以只需要保证每两个数拼接后更小就行了，即ij?ji。因此，可以使用冒泡排序，但是比较的条件变成'i'+'j' > 'j' + 'i',如果满足就交换。

输出用print(''.join(list))即可，python打印字符串的时候不会带''的。

代码是：

# -*- coding:utf-8 -*-

class Solution:

def PrintMinNumber(self,numbers):

if not numbers:

return ''

n = len(numbers)

for i in range(n):

numbers[i] = str(numbers[i])

print(numbers)

for i in range(n):

for j in range(i+1,n):

if numbers[i] + numbers[j] > numbers[j] + numbers[i]:

numbers[i],numbers[j] = numbers[j],numbers[i]

return ''.join(numbers)

热心网友 时间：2023-11-06 01:42

python中的数组，即使是*数组，貌似都是用的中括号表示吧？ 花括号貌似都是针对字典的。

个人以为，可以先将原先的数组转换成列表，利用列表的内置方法排序并拼接后，再转换回去原来的格式。

原始数据，我不知道是什么格式。只是我以为，按照你的说法，跑不出元组、列表、字典等几种格式。这几种格式的转换相对还是比较简单的。

代码就不写了。个人以为这样的做法，应该比较合适。

热心网友 时间：2023-11-06 01:41

你的例子第一列全是 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

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

热心网友 时间：2023-11-06 01:41

import itertools

data = {3, 32, 321, 3432, 435, 64, 324}     # 最小组合数结果 321323243343243564
# data = {3, 32, 321}     # 最小组合数结果    321323

# 1、首先 data 是一个 set 集合,需要将其转换为 列表进行排序    sorted(list(data)))
# 2、然后通过python的内置库 itertools.permutations   进行排列组合
x = list(itertools.permutations(sorted(list(data))))

# 3、将排列组合出来的数先转为字符串
# 4、然后通过 join 将其组合成一个字符串
# 5、将组合出的数字字符串加入新的 set 集合中
new_data = set()
for i in x:
    n_str = "".join([str(n) for n in i])
    new_data.add(n_str)

# 6、将新的 set 集合转换成列表进行排序,取第一个就是最小的
min_n = sorted(list(new_data))[0]
print(min_n)    # 7、输出最小排列组合的值

热心网友 时间：2023-11-06 01:42

用int会越界的，所以先转成str

数字拼接满足结合律，所以只需要保证每两个数拼接后更小就行了，即ij?ji。因此，可以使用冒泡排序，但是比较的条件变成'i'+'j' > 'j' + 'i',如果满足就交换。

输出用print(''.join(list))即可，python打印字符串的时候不会带''的。

代码是：

# -*- coding:utf-8 -*-

class Solution:

def PrintMinNumber(self,numbers):

if not numbers:

return ''

n = len(numbers)

for i in range(n):

numbers[i] = str(numbers[i])

print(numbers)

for i in range(n):

for j in range(i+1,n):

if numbers[i] + numbers[j] > numbers[j] + numbers[i]:

numbers[i],numbers[j] = numbers[j],numbers[i]

return ''.join(numbers)

热心网友 时间：2023-11-06 01:42

python中的数组，即使是*数组，貌似都是用的中括号表示吧？ 花括号貌似都是针对字典的。

个人以为，可以先将原先的数组转换成列表，利用列表的内置方法排序并拼接后，再转换回去原来的格式。

原始数据，我不知道是什么格式。只是我以为，按照你的说法，跑不出元组、列表、字典等几种格式。这几种格式的转换相对还是比较简单的。

代码就不写了。个人以为这样的做法，应该比较合适。

热心网友 时间：2023-11-06 01:41

你的例子第一列全是 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

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

热心网友 时间：2023-11-06 01:41

import itertools

data = {3, 32, 321, 3432, 435, 64, 324}     # 最小组合数结果 321323243343243564
# data = {3, 32, 321}     # 最小组合数结果    321323

# 1、首先 data 是一个 set 集合,需要将其转换为 列表进行排序    sorted(list(data)))
# 2、然后通过python的内置库 itertools.permutations   进行排列组合
x = list(itertools.permutations(sorted(list(data))))

# 3、将排列组合出来的数先转为字符串
# 4、然后通过 join 将其组合成一个字符串
# 5、将组合出的数字字符串加入新的 set 集合中
new_data = set()
for i in x:
    n_str = "".join([str(n) for n in i])
    new_data.add(n_str)

# 6、将新的 set 集合转换成列表进行排序,取第一个就是最小的
min_n = sorted(list(new_data))[0]
print(min_n)    # 7、输出最小排列组合的值

热心网友 时间：2023-11-06 01:42

用int会越界的，所以先转成str

数字拼接满足结合律，所以只需要保证每两个数拼接后更小就行了，即ij?ji。因此，可以使用冒泡排序，但是比较的条件变成'i'+'j' > 'j' + 'i',如果满足就交换。

输出用print(''.join(list))即可，python打印字符串的时候不会带''的。

代码是：

# -*- coding:utf-8 -*-

class Solution:

def PrintMinNumber(self,numbers):

if not numbers:

return ''

n = len(numbers)

for i in range(n):

numbers[i] = str(numbers[i])

print(numbers)

for i in range(n):

for j in range(i+1,n):

if numbers[i] + numbers[j] > numbers[j] + numbers[i]:

numbers[i],numbers[j] = numbers[j],numbers[i]

return ''.join(numbers)

热心网友 时间：2023-11-06 01:42

python中的数组，即使是*数组，貌似都是用的中括号表示吧？ 花括号貌似都是针对字典的。

个人以为，可以先将原先的数组转换成列表，利用列表的内置方法排序并拼接后，再转换回去原来的格式。

原始数据，我不知道是什么格式。只是我以为，按照你的说法，跑不出元组、列表、字典等几种格式。这几种格式的转换相对还是比较简单的。

代码就不写了。个人以为这样的做法，应该比较合适。