Arrays 列表理解的方法，以设置的间隔使用不同的字符串连接列表。（语言不可知论）

我感兴趣的是不同语言可以连接一个数组的可能方式，而不是使用单个连接字符串，而是在给定的时间间隔使用不同的连接字符串

例如（假设语言）：

在参数指定包含模和联接字符的数组或对象时，实现将检查模的哪个顺序优先（最新的一个），并应用联接字符。（要求[mod，char]按mod升序提供）

i、 e

例如，我在Ruby中提出了以下内容，但我怀疑存在更好/更优雅的方法，这正是我希望看到的

#Create test Array 
#9472 - 9727 as HTML Entities (unicode box chars)
range       = (9472..9727).to_a.map{|u| "&##{u};" }  

假设我们有一个mod和join字符的列表，我们必须规定mod的值随着列表的进展而增加

mod_joins   = [{m:1, c:",", m:12, c:"<br/>"]

从这里我们有一个htmlEntities列表，用

，

分隔，除非它的索引是第12个模，在这种情况下它是

---

因此，我感兴趣的是如何更优雅地实现这一点，主要是在Haskell、F#、Common Lisp（Scheme、Clojure）等函数式语言中。但在具有列表理解扩展的通用语言中，也有一些很酷的方法来实现这一点，如C#with Linq，Ruby和Python甚至Perl。

这是一个用Python编写的纯函数版本。我相信它可以很容易地适应其他语言

import itertools

def calcsep(num, sepspecs):
  '''
    num: current character position
    sepspecs: dict containing modulus:separator entries
  '''
  mods = reversed(sorted(sepspecs))
  return sepspecs[next(x for x in mods if num % x == 0)]

vector = [str(x) for x in range(12)]

result = [y for ix, el in enumerate(vector)
            for y in (calcsep(ix, {1:'.', 3:',', 5:';'}), el)]

print ''.join(itertools.islice(result, 1, None))

---

这里有一个更简单、更可读的Ruby解决方案

array = (9472..9727).map{|u|"&##{u};"}
array.each_slice(12).collect{|each|each.join(",")}.join("<br/>")

array=（9472..9727）.map{u|“&{u}；”
array.each_slice（12）。收集{each | each.join（“，”）}.join（
）

还是一般情况

module Enumerable   
  def fancy_join(instructions)
    return self.join if instructions.empty?
    separator = instructions.delete(mod = instructions.keys.max)
    self.each_slice(mod).collect{|each|each.fancy_join(instructions.dup)}.join(separator)
  end
end

range = (9472..9727).map{|u|"&##{u};"}
instructions = {1=>",",12=>"<br/>"}

puts array.fancy_join(instructions)    

模块可枚举
def fancy_join（说明）
如果指令为空，返回self.join？
分隔符=指令.delete（mod=instructions.keys.max）
self.each_slice（mod）.collect{each | each.fancy_join（instructions.dup）}.join（分隔符）
结束
结束
range=（9472..9727）.map{u|“&{u}；”
指令={1=>“，”，12=>“
”}
puts数组。花式连接（说明）

我要冒险说，Ruby似乎可以做得更简洁一点，而且我并不是真的想把我的实现移植到另一种语言上，我的意思是使用该语言的新颖功能来提高例程的可读性。它可以做得更简洁。“清洁剂”通常是一个品味问题。当然，这肯定是一个品味问题，例如，我的<代码>如果条件<代码>有点偏执，就做些什么。我的意思是更干净，不必显式地反转mods，然后处理它们。我想如果不直接在下面使用，它看起来会更好（我最初的反应是一眼）。对不起，顺便说一下，它不是一个分隔符，它是一个连接符。因此，名称

joinspecs

和

concatentator

（或类似名称）非常好，我不知道

每个片段都存在。这看起来像是绿色的蜱虫，我会等到明天，看看有没有更好的。但我认为这不太可能。这就自动解决了索引0的问题。@slomojo
每个片及其同级
每个子片都非常强大。我已经添加了代码来涵盖一般情况。谢谢，我正要回来询问多参数情况。如果要添加
instruction.empty？
您应该抛出一个错误，而不是执行常规联接。是和是。您需要锚定递归，或者通过测试是否位于指令的末尾，或者使用
return self if self.size==1
测试长度为1的片段（尽管在这种情况下，指令必须为mod 1提供分隔符，例如
array.fancy_join（4=>，“，12=>”）
在使用上述代码时不起作用）。
import itertools

def calcsep(num, sepspecs):
  '''
    num: current character position
    sepspecs: dict containing modulus:separator entries
  '''
  mods = reversed(sorted(sepspecs))
  return sepspecs[next(x for x in mods if num % x == 0)]

vector = [str(x) for x in range(12)]

result = [y for ix, el in enumerate(vector)
            for y in (calcsep(ix, {1:'.', 3:',', 5:';'}), el)]

print ''.join(itertools.islice(result, 1, None))

array = (9472..9727).map{|u|"&##{u};"}
array.each_slice(12).collect{|each|each.join(",")}.join("<br/>")

module Enumerable   
  def fancy_join(instructions)
    return self.join if instructions.empty?
    separator = instructions.delete(mod = instructions.keys.max)
    self.each_slice(mod).collect{|each|each.fancy_join(instructions.dup)}.join(separator)
  end
end

range = (9472..9727).map{|u|"&##{u};"}
instructions = {1=>",",12=>"<br/>"}

puts array.fancy_join(instructions)