มินิกอล์ฟ 9 หลุม: คำอธิบาย

• 9 (ส่วนใหญ่ค่อนข้างง่าย) การท้าทายการเล่นกอล์ฟรหัสของความยากลำบากที่แตกต่างกัน
• บทลงโทษสำหรับการใช้ภาษาเดียวกันมากกว่าหนึ่งครั้ง
• ความท้าทายทั้งหมดเกี่ยวกับชุดรูปแบบเฉพาะ (ชุดรูปแบบนี้: การจัดการข้อความ)
• อินพุตและเอาต์พุตสามารถทำได้ทุกที่ที่เหมาะสม (เช่น STDIN และ STDOUT การอ่าน / เขียนไปยังไฟล์อาร์กิวเมนต์ของฟังก์ชันและค่าส่งคืนเป็นต้น) แต่ต้องไม่ฮาร์ดโค้ดในโปรแกรม
• แรงบันดาลใจอย่างมากจาก9 Hole ChallengeและText Mechanic

หลุม

1. รหัสกระเป๋ากอล์ฟ

   รับสองสายเป็นอินพุต
   เอาต์พุตจำนวนอักขระของสตริงแรกขณะที่ละเว้นอักขระใด ๆ ในสตริงที่สอง
   ตัวอย่าง: f("foobarbaz", "ao")=>5

2. ข้อความล่วงหน้าสำหรับการเล่นกอล์ฟ

   รับสองสายเป็นอินพุต
   เอาต์พุตสตริงแรกโดยทุกบรรทัดนำหน้าด้วยสตริงที่สอง
   ตัวอย่าง: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. สงครามของแท็บ vs ช่องว่าง

   รับสตริงsตัวเลขnและบูลีนb(ระบุตามที่คุณต้องการ) เป็นอินพุต
   ถ้าbเป็นจริงเอาท์พุทที่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. ตัวอักษรไข่กวนสำหรับอาหารเช้า

   ใช้สตริงเป็นอินพุต
   เอาต์พุตสตริงที่มีคำทั้งหมดที่มีสัญญาณรบกวน (สุ่มเรียงลำดับตัวอักษร) ยกเว้นตัวอักษรตัวแรกและตัวสุดท้าย
   สำหรับความเรียบง่ายคิดว่าการป้อนข้อมูลจะมีรายการของ "คำว่า" s และพื้นที่แยกออกจากกัน (เช่นใน@$&_():;" foo bar, @$&_():;"ถือว่าเป็น "คำว่า.")
   ตัวอย่าง: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   ใช้สตริงเป็นอินพุต
   หากสตริงมีตัวเลขและช่องว่างเท่านั้นให้แทนที่ตัวเลขด้วยอักขระ 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
   นี่คือแม้กระทั่งรุ่นมินิเอ้อ: คุณต้องการเพียงที่จะจัดการ**bold**, และ*italics* คุณไม่จำเป็นต้องจัดการกับการทำรังที่ไม่ถูกต้องเช่น นอกจากนี้ยังคิดว่าเมื่อคุณเห็นตัวคั่น ( หรือ) ก็จะมักจะหมายถึงรูปแบบ (เช่น=> และ=> ) ตัวอย่าง: =>`code`
**foo *bar** baz**`te**st**ingte<b>st</b>ingfoo* bar *bazfoo<i> bar </i>baz
f("**foo** *bar **baz*** `qux`")"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. เฉพาะตัวละครที่ดีที่สุด

   รับสตริงsตัวเลขnและสตริงrเป็นอินพุต
   เอาท์พุทnตัวอักษร TH sของแต่ละคำใน (มีการจัดทำดัชนี 0 คำจะถูกคั่นด้วยช่องว่าง)
   หากความยาวของคำน้อยกว่าnใช้rสำหรับคำนั้นแทน
   ตัวอย่าง: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

เกณฑ์การให้คะแนน

คะแนนของคุณคือผลรวมของจำนวนตัวละครในโปรแกรมของคุณ สำหรับทุกภาษาที่มีการทำซ้ำให้คูณ 110% ตัวอย่างเช่นหากคุณมีโซลูชันทับทิมสามตัวและจำนวนอักขระทั้งหมดของโซลูชันทั้งหมดคือ 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. ทับทิม, 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. Haskell, 36

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

Python - 697 × 1.1 ⁹ ≈ 1644

ฉันแน่ใจว่ารักลูกแกะ

หมายเหตุ : 3 และ 5 ถูกคัดลอกมาจากคำตอบของความผันผวนอย่างไร้ยางอายเพราะฉันไม่สามารถหาทางเลือกที่ดีกว่าได้ นอกจากนี้ยังทำเพื่อความสนุกเท่านั้น

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: Ruby 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: ทับทิม 1.9+ (58)

ส่งคืนnตัวอักษรที่ใช้บ่อยที่สุดในs:

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

6: J (47)

Scrambles ข้อความอย่างใด; คำต่อคำที่ขโมยมาจากMarinus อย่างไร้ยางอาย:

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

7: ทับทิม (57 + 1)

พิมพ์อินพุต ASCIIfied หรือ de-ASCIIfied ทำงานด้วย-pสวิตช์

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

8: Sed (87)

พิมพ์อินพุตที่แปลงจาก (มินิ) markdown เป็น HTML:

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

9 Ruby 1.9+ (37)

ส่งคืนสตริงของnอักขระ th ของแต่ละคำแรกใน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