9-Loch-Minigolf: Beschreibung

• 9 (meist recht einfache) Code-Golf-Herausforderungen mit unterschiedlichen Schwierigkeitsgraden
• Strafen für die mehrmalige Verwendung derselben Sprache
• Alle Herausforderungen zu einem bestimmten Thema (dieses Thema: Textmanipulation)
• Die Ein- und Ausgabe kann überall sinnvoll sein (z. B. STDIN und STDOUT, Lesen aus / Schreiben in eine Datei, Funktionsargument und Rückgabewert usw.), darf jedoch NICHT fest im Programm codiert sein
• Stark inspiriert von 9 Hole Challenge und Text Mechanic

Löcher

1. Code-Golftasche

   Nehmen Sie zwei Zeichenfolgen als Eingabe.
   Gibt die Anzahl der Zeichen der ersten Zeichenfolge aus und ignoriert dabei jedes Vorkommen eines Zeichens in der zweiten Zeichenfolge.
   Beispiel: f("foobarbaz", "ao")=>5

2. Ein Pre-Text zum Golfen

   Nehmen Sie zwei Zeichenfolgen als Eingabe.
   Geben Sie den ersten String aus, wobei jeder Zeile der zweite vorangestellt ist.
   Beispiel: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. Krieg der Tabs gegen Leerzeichen

   Nehmen Sie eine Zeichenfolge s, eine Zahl nund einen Booleschen Wert b(angegeben, wie Sie möchten) als Eingabe.
   Wenn dies bzutrifft, wird sjede Registerkarte in nLeerzeichen umgewandelt.
   Anderenfalls geben Sie die smit jedem nLeerzeichen konvertierten Tabulatoren aus.
   Beispiel: f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"( [sp]bedeutet Leerzeichen)

4. Säulen des Golfs

   Nehmen Sie eine Zeichenfolge s, eine Zahl nund eine andere Zahl mals Eingabe.
   Ausgabe sin Spalten mit nZeilen und mZeichen pro Spalte.
   Lassen Sie außerdem einen Abstand zwischen den Spalten frei.
   Beispiel: f("this is some placeholder text, foo bar baz...", 3, 5)=>

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

5. Freundliche Briefe

   Nehmen Sie eine Zeichenfolge sund eine Zahl nals Eingabe.
   Geben Sie die häufigste nBuchstabengruppe in aus s.
   Wenn es einen Gleichstand gibt, geben Sie einen oder alle davon aus.
   Beispiel: f("abcdeabcfghiabc", 3)=>"abc"

6. Scrambled eggs Buchstaben zum Frühstück

   Nehmen Sie eine Zeichenfolge als Eingabe.
   Geben Sie die Zeichenfolge mit allen Wörtern außer dem ersten und dem letzten Buchstaben in zufälliger Reihenfolge aus.
   Zur Vereinfachung wird angenommen , dass die Eingabe eine Liste von „Wort“ s sein, Leerzeichen getrennt (dh in @$&_():;" foo bar, @$&_():;"wird ein als „Wort“) .
   Beispiel: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   Nehmen Sie eine Zeichenfolge als Eingabe.
   Wenn die Zeichenfolge nur Zahlen und Leerzeichen enthält, ersetzen Sie die Zahlen durch die entsprechenden ASCII-Zeichen (entfernen Sie die Leerzeichen).
   Andernfalls machen Sie das Gegenteil (Zeichen zu Zahlen).
   Beispiel: f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   Beispiel 2: f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. Mini-Mini-Markdown-Transformation

   Nehmen Sie eine Zeichenfolge als Eingabe.
   Geben Sie den mit Mini-Markdown konvertierten String aus, wie er in Kommentaren zu Stack Exchange verwendet wird.
   Dies ist ein noch Mini-er Version: Sie behandeln müssen **bold**, *italics*und `code`.
   Sie müssen nicht mit ungültigen Verschachtelungen umgehen, wie z **foo *bar** baz*. Nehmen Sie außerdem an, dass ein Begrenzer ( *oder `) immer formatiert werden muss (dh te**st**ing=> te<b>st</b>ingund foo* bar *baz=> foo<i> bar </i>baz).
   Beispiel: f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. Nur die besten Charaktere

   Nehmen Sie eine Zeichenfolge s, eine Zahl nund eine Zeichenfolge rals Eingabe.
   Geben Sie das nth Zeichen jedes Wortes in aus s. (0-indiziert, Wörter sind durch Leerzeichen getrennt).
   Wenn die Länge des Wortes kürzer als ist n, verwenden Sie rstattdessen für dieses Wort.
   Beispiel: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

Wertung

Ihre Punktzahl ist die Summe der Zeichenanzahl Ihrer Programme. Multiplizieren Sie für jede wiederholte Sprache mit 110%. Wenn Sie beispielsweise drei Ruby-Lösungen haben und die Gesamtanzahl der Zeichen aller Ihrer Lösungen 1000 beträgt, beträgt Ihre Punktzahl 1000 * 1,1 * 1,1 = 1210. Runden Sie ab, wenn Sie eine nicht ganzzahlige Punktzahl haben.

Viel Glück!

Ergebnis: 382 * 1,1 ² = 462

Sprachen, die sich ändern können.

1. APL, 8 4

Vielen Dank an @marinus für das Abschneiden von 4 Zeichen.

f←⍴~

Wird mit den Zeichenfolgen als linkes und rechtes Argument aufgerufen, z.

      'foobarbaz' f 'ao'
5

2. Rubin, 35 31

Vielen Dank an @DoorknobofSnow für das Abschneiden von 4 Zeichen.

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;

Angenommen, die Argumente befinden sich auf dem Stapel. Online testen

5. J, 50

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

Wird mit der Zeichenfolge als linkem Argument und der Zahl als rechtem Argument aufgerufen, z.

   'abcdeabcfghiabc' f 3
abc

6. Ruby, 61

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

7. GolfScript, 39 35 34

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

Auch hier wird davon ausgegangen, dass sich das Argument auf dem Stapel befindet. Online testen

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

Ich liebe Lambdas.

Anmerkung : 3 und 5 wurden schamlos aus Volatilitäts Antwort übernommen , da ich keine bessere Alternative finden konnte. Auch dies wurde nur zum Spaß gemacht .

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

EDIT : Danke an Volatility für die Tipps.

Punktzahl 513 * 1,1 ⁵ = 826 

Hat durch den Elfmeter in der gleichen Sprache eine ziemliche Niederlage davongetragen. Die meisten davon wurden in Ruby gelöst, um sie so schnell wie möglich zu beenden. Könnte später einige Sprachen ändern. Fügte eine kleine Zusammenfassung / Erklärung zu jeder Antwort hinzu.

1: Python (46)

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

Erste, kürzere Antwort in Ruby 2.0 (30) , die mehr Strafe und höhere Gesamtpunktzahl gibt:

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

2: Ruby 1.9+ (37)

Gibt jede Zeile mit dem sPräfix zurück t:

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

3: Ruby 1.9+ (48)

Gibt smit Tabulatoren zurück, die durch nLeerzeichen ersetzt werden , oder umgekehrt, abhängig von b:

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

4: Ruby 1.9+ (95)

Jemand erschießt mich.

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)

Gibt die häufigste nZeichenfolge zurück in s:

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

6: J (47)

Verwirrt den Text irgendwie; Schamlos wörtlich von Marinus gestohlen :

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

7: Rubin (57 + 1)

Druckt die ASCII-Eingabe oder die ASCII-Freigabe. Laufen Sie mit dem -pSchalter.

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

8: Sed (87)

Druckt die Eingabe konvertiert von (Mini) Markdown nach HTML:

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

9 Ruby 1.9+ (37)

Gibt eine Zeichenfolge der nth Zeichen jedes ersten Wortes in zurück s, oder r:

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

In Arbeit

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.