9-dołkowe minigolf: opis

• 9 (w większości dość łatwych) wyzwań golfowych o różnym stopniu trudności
• Kary za używanie tego samego języka więcej niż jeden raz
• Wszystkie wyzwania dotyczące określonego tematu (ten temat: manipulacja tekstem)
• Dane wejściowe i wyjściowe mogą być w dowolnym miejscu uzasadnione (tj. STDIN i STDOUT, odczyt z / zapis do pliku, argument funkcji i wartość zwracana itp.), Ale NIE mogą być zakodowane na stałe w programie
• Mocno zainspirowany 9-dołkowym wyzwaniem i mechaniką tekstową

Otwory

1. Torba golfowa

   Weź dwa ciągi jako dane wejściowe.
   Wypisuje liczbę znaków pierwszego łańcucha, ignorując jednocześnie wystąpienie dowolnego znaku w drugim ciągu.
   Przykład: f("foobarbaz", "ao")=>5

2. Pretekst do gry w golfa

   Weź dwa ciągi jako dane wejściowe.
   Wyprowadza pierwszy ciąg, z każdym wierszem poprzedzonym drugim.
   Przykład: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. Wojna między kartami a spacjami

   Weź jako dane wejściowe ciąg s, liczbę ni wartość logiczną b(określaną dowolnie).
   Jeśli bjest to prawda, dane wyjściowe ssą przekształcane przy każdej tabulacji na nspacje.
   W przeciwnym razie wypisz sz każdą nspacją przekonwertowaną na tabulatory.
   Przykład: f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"( [sp]oznacza spację)

4. Filary golfa

   Weź ciąg s, liczbę ni inną liczbę mjako dane wejściowe.
   Dane wyjściowe sw kolumnach nwierszy każdy i mznaki w kolumnie.
   Wypełnij również jedną spację między kolumnami.
   Przykład: f("this is some placeholder text, foo bar baz...", 3, 5)=>

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

5. Przyjazne litery

   Weź ciąg si liczbę njako dane wejściowe.
   Wypisuj najczęstszą grupę nliter w s.
   Jeśli jest remis, wypisz jeden lub wszystkie z nich.
   Przykład: f("abcdeabcfghiabc", 3)=>"abc"

6. Jajecznica jajka litery na śniadanie

   Weź ciąg jako dane wejściowe.
   Wypisuje ciąg ze wszystkimi słowami zaszyfrowanymi (kolejność liter losowo), z wyjątkiem pierwszych i ostatnich liter.
   Dla uproszczenia załóżmy, że wejście będzie listą „słowa”, oddzielone spacjami (tzn. In @$&_():;" foo bar, @$&_():;"jest uważane za „słowo”).
   Przykład: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   Weź ciąg jako dane wejściowe.
   Jeśli ciąg zawiera tylko cyfry i spacje, zastąp je odpowiednimi znakami ASCII (usuwając spacje).
   W przeciwnym razie wykonaj odwrotność (od znaków do cyfr).
   Przykład: f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   Przykład 2: f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. Transformacja mini-mini-markdown

   Weź ciąg jako dane wejściowe.
   Wyprowadza ciąg znaków przekonwertowany za pomocą mini-markdown, jak zastosowano w komentarzach na Stack Exchange.
   Jest to jeszcze wersja mini-er: trzeba tylko poradzić **bold**, *italics*i `code`.
   Nie musisz obsługiwać nieprawidłowego zagnieżdżania, np **foo *bar** baz*. Załóż również, że gdy zobaczysz ogranicznik ( *lub `), zawsze będzie oznaczać formatowanie (tj. te**st**ing=> te<b>st</b>ingI foo* bar *baz=> foo<i> bar </i>baz).
   Przykład: f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. Tylko najlepsze postacie

   Weź ciąg s, liczbę ni ciąg rjako dane wejściowe.
   Wypisz nth znak każdego słowa w s. (Indeksowane 0, słowa są rozdzielane spacjami).
   Jeśli długość słowa jest mniejsza niż n, użyj rzamiast niego tego słowa.
   Przykład: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

Punktacja

Twój wynik to suma liczby znaków w twoich programach. Dla każdego powtarzanego języka pomnóż przez 110%. Na przykład, jeśli masz trzy rozwiązania Ruby, a całkowita liczba znaków wszystkich twoich rozwiązań wynosi 1000, twój wynik to 1000 * 1,1 * 1,1 = 1210. Zaokrąglij w dół, jeśli masz wynik nie będący liczbą całkowitą.

Powodzenia!

Wynik: 382 * 1,1 ² = 462

Języki podatne na zmiany.

1. APL, 8 4

Dzięki @marinus za zgolenie 4 znaków.

f←⍴~

Wywoływany z łańcuchami jako lewy i prawy argument, np.

      'foobarbaz' f 'ao'
5

2. Ruby, 35 31

Dzięki @DoorknobofSnow za golenie 4 znaków.

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;

Zakłada, że ​​argumenty są na stosie. Przetestuj online

5. J, 50

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

Wywoływany z ciągiem jako lewym argumentem i liczbą jako prawym, np.

   'abcdeabcfghiabc' f 3
abc

6. Ruby, 61

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

7. GolfScript, 39 35 34

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

Ponownie zakładamy, że argument znajduje się na stosie. Przetestuj online

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

Rany, na pewno kocham lambdas.

Uwaga : 3 i 5 zostały bezwstydnie skopiowane z odpowiedzi Zmienności , ponieważ nie mogłem znaleźć lepszej alternatywy. Zrobiono to również dla zabawy .

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

EDYCJA : Dzięki zmienności dla wskazówek.

Wynik 513 * 1,1 ⁵ = 826 

Służyło to pokonanie karą w tym samym języku. Rozwiązałem większość z nich w Ruby, aby ukończyć je jak najszybciej. Może później zmienić niektóre języki. Dodano małe podsumowanie / wyjaśnienie dla każdej odpowiedzi.

1: Python (46)

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

Po pierwsze, krótsza odpowiedź w Ruby 2.0 (30), która daje więcej kar i wyższy ogólny wynik:

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

2: Ruby 1.9+ (37)

Zwraca każdą linię z sprefiksem t:

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

3: Ruby 1.9+ (48)

Zwraca sz tabulatorami zastąpionymi nspacjami lub odwrotnie, w zależności od b:

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

4: Ruby 1.9+ (95)

Ktoś mnie zastrzelił.

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

5: Rubinowy 1.9+ (58)

Zwraca najczęstszy ciąg nznaków w s:

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

6: J (47)

Jakoś szyfruje tekst; Bezwstydnie skradziony dosłownie marinus :

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

7: Rubinowy (57 + 1)

Wyświetla wejście ASCIIfied lub de-ASCIIfied. Uruchom z -pprzełącznikiem.

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

8: Sed (87)

Wyświetla dane wejściowe przekonwertowane z (mini) markdown na HTML:

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

9 Rubinowy 1.9+ (37)

Zwraca ciąg nth znaków każdego pierwszego słowa w slub r:

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

Praca w toku

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