9洞迷你高尔夫球：说明

• 难度各不相同的9个（大多数情况下非常容易）代码高尔夫挑战
• 多次使用同一语言的处罚
• 有关特定主题的所有挑战（此主题：文本操作）
• 输入和输出可以是任何合理的位置（例如，STDIN和STDOUT，从文件中读取/写入文件，函数自变量和返回值等），但不得将其硬编码到程序中
• 受9孔挑战和文本机制的启发

孔洞

1. 高尔夫球码袋

   以两个字符串作为输入。
   输出第一个字符串的字符数，而忽略第二个字符串中任何字符的出现。
   示例：f("foobarbaz", "ao")=>5

2. 打高尔夫球的前言

   以两个字符串作为输入。
   输出第一个字符串，每行以第二行为前缀。
   示例：f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. 标签与空间之战

   将一个字符串s，一个数字n和一个布尔值b（根据需要指定）作为输入。
   如果b为true，则输出s，每个制表符都转换为n空格。
   否则，输出，s并将每个n空格都转换为制表符。
   示例：f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"（[sp]表示空格）

4. 高尔夫支柱

   以字符串s，数字n和另一个数字m作为输入。每行
   输出s一列，每列输出n一个m字符。
   列之间也要有一个空格的填充。
   示例：f("this is some placeholder text, foo bar baz...", 3, 5)=>

   this  aceho  foo 
   is so lder  bar b
   me pl text, az...
   

5. 友好的信件

   以字符串s和数字n作为输入。
   输出中最常见的n字母组s。
   如果有平局，则输出其中的一个或全部。
   示例：f("abcdeabcfghiabc", 3)=>"abc"

6. 炒鸡蛋字母早餐

   以字符串作为输入。
   输出字符串，其所有单词都乱码（字母顺序随机），但首字母和尾字母除外。
   为简单起见，假设输入将是一个由空格隔开的“单词”列表（即，在中@$&_():;" foo bar，@$&_():;"被视为“单词”。）
   示例：f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCII码

   以字符串作为输入。
   如果字符串仅包含数字和空格，则将数字替换为其各自的ASCII字符（删除空格）。
   否则，做相反的操作（数字字符）。
   示例：f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   示例2：f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. 迷你-迷你降价转换

   以字符串作为输入。
   输出使用mini-markdown转换的字符串，如Stack Exchange上的注释中所使用。
   这是一个更小-ER版：你只需要处理**bold**，*italics*和`code`。
   您无需处理无效的嵌套，例如**foo *bar** baz*。还假定当您看到定界符（*或`）时，它将始终意味着格式化（即te**st**ing=> te<b>st</b>ing和foo* bar *baz=> foo<i> bar </i>baz）。
   示例：f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. 只有最好的角色

   将string s，number n和string r作为输入。
   输出n中每个单词的th个字符s。（0索引，单词之间用空格分隔）。
   如果单词的长度小于n，请改用r该单词。
   示例：f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

计分

您的分数是程序中字符数的总和。对于每种重复的语言，请乘以110％。例如，如果您有三个Ruby解决方案，并且所有解决方案的字符总数为1000，则得分为1000 * 1.1 * 1.1 =1210。如果您的得分为非整数，则四舍五入。

祝好运！

得分：382 * 1.1 ² = 462

语言容易改变。

1. APL，8 4

感谢@marinus削减了4个字符。

f←⍴~

以字符串作为左右参数调用，例如。

      'foobarbaz' f 'ao'
5

2.红宝石，35 31

感谢@DoorknobofSnow削减了4个字符。

f=->s,r{s.gsub(/(?<=^)/,r+' ')}

3. Python，48岁

f=lambda s,n,b:s.replace(*['\t',' '*n][::2*b-1])

4. GolfScript，20岁

{@//zip{' '*}%n*}:f;

假设参数在堆栈上。在线测试

5. J，50岁

f=:({~[:(i.>./)+/"1@=@(}.~0-1{$))@|:@([$~],1+[:$[)

以字符串作为左参数，数字作为右，例如。

   'abcdeabcfghiabc' f 3
abc

6. Ruby，61岁

f=->s{s.gsub(/(?<!^| )[^ ]+(?!$| )/){[*$&.chars].shuffle*''}}

7. GolfScript，39 35 34

{[.10,' '*-{{}/]' '*}{~]''+}if}:f;

同样，假设参数在堆栈上。在线测试

8. Perl，98岁

sub f{$_=@_[0];s!\*\*(.+?)\*\*!<b>$1</b>!g;s!\*(.+?)\*!<i>$1</i>!g;s!`(.+?)`!<code>$1</code>!g;$_}

9.哈斯克尔，36岁

f s n r=[(x++cycle r)!!n|x<-words s]

蟒- 697×1.1 ⁹ ≈1644

e，我肯定喜欢lambdas。

注意：3和5是从Volatility的答案中无耻复制的，因为我找不到更好的选择。另外，这样做只是为了好玩。

f=lambda a,b:sum([x not in b for x in a])        # 1, 41 chars
f=lambda a,b:b+' '+a.replace('\n','\n'+b+' ')    # 2, 43 chars
f=lambda s,n,b:s.replace(*['\t',' '*n][::b*2-1]) # 3, 47 chars
f=lambda s,n,m:'\n'.join([' '.join([s[x:x+m]for x in range(y*m,len(s),m*n)])for y in range(n)])
                                                 # 4, 94 chars
f=lambda s,n:max([s[x:x+n]for x in range(len(s)+1-n)],key=s.count)
                                                 # 5, 66 chars
import random;f=lambda s:' '.join([''.join(sorted(y,key=lambda*x:random.random()))for y in s.split()])
                                                 # 6, 102 chars
f=lambda s:s.replace(' ','').isdigit()and ''.join(map(chr,map(int,s.split())))or ' '.join(map(str,map(ord,s)))
                                                 # 7, 110 chars
import re;f=lambda s:re.sub('`(.*?)`','<code>\\1</code>',re.sub(r'\*(.*?)\*','<i>\\1</i>',re.sub(r'\*\*(.*?)\*\*','<b>\\1</b>',s)))
                                                 # 8, 128 chars
f=lambda s,n,r:''.join([len(x)>n and x[n]or r for x in s.split()])
                                                 # 9, 66 chars

编辑：感谢波动性的提示。

得分513 * 1.1 ⁵ = 826 

用同一种语言的惩罚相当可观。在Ruby中解决了其中大多数问题，只是为了尽可能快地完成它们。稍后可能会更改某些语言。在每个答案上添加了一个简短的摘要/说明。

1：Python（46）

f=lambda a,b:len([x for x in a if not x in b])

首先，Ruby 2.0（30）中的答案较短，会带来更多的惩罚和更高的总体评分：

p (gets.chars-gets.chars).size

2：红宝石1.9+（37）

返回s以开头的每行t：

f=->s,t{s.split(?\n).map{|x|t+x}*?\n}

3：红宝石1.9+（48）

返回，s其中制表符由n空格代替，反之亦然，具体取决于b：

f=->s,n,b{r=[" "*n,?\t];b||r.reverse!;s.gsub *r}

4：Ruby 1.9+（95）

有人开枪打我

f=->s,n,m{[*s.chars.each_slice(m).map{|w|w*''}.each_slice(s.size/m/n)].transpose.map{|w|w*' '}}

5：Ruby 1.9+（58）

返回以下最常见的n字符s：

f=->s,n{(a=s.chars.each_slice(n)).max_by{|v|a.count v}*''}

6：J（47）

以某种方式对文本进行打乱；从马里纳斯偷来的无耻逐字记录：

''[1!:2&4('\w(\w+)\w';,1)({~?~@#)rxapply 1!:1[3

7：红宝石（57 + 1）

打印输入为ASCII或反ASCII的。用-p开关运行。

~/\d/?gsub(/\d+\s*/){$&.to_i.chr}:gsub(/./){"#{$&.ord} "}

8：塞德（87）

打印从（mini）markdown转换为HTML的输入：

s:\*\*([^*]+)\*\*:<b>\1</b>:g;
s:\*([^*]+)\*:<i>\1</i>:g;
s:`([^`]+)`:<code>\1</code>:g

9红宝石1.9+（37）

返回的字符串n中的每个第一个字的日字s，或r：

f=->s,n,r{s.split.map{|w|w[n]||r}*''}

工作正在进行中

1. Java-66

int f(String s,String b){for(char c:b)s=s.replace(b,"");return s;}

2. Java-64

String f(String i,String r){return i.replaceAll("(?m)^",r+" ");}

3. Python-58

def f(s,n,b):t=" "*n;a=t,'\t';print s.replace(a[b],a[b^1])

4. Python-84

def f(s,n,m):
 a=['']*n;c=0
 while s:a[c%n]+=s[:m]+" ";s=s[m:];c+=1
 for i in a:print i

5，

6。

7. Befunge 98-9

&,5j3.~@#

8。

9。