Mini-golf a 9 buche: descrizione

• 9 sfide (per lo più abbastanza facili) di golf con codice di varia difficoltà
• Sanzioni per l'utilizzo della stessa lingua più di una volta
• Tutte le sfide su un tema specifico (questo tema: manipolazione del testo)
• L'input e l'output possono essere ragionevoli (es. STDIN e STDOUT, lettura / scrittura in un file, argomento della funzione e valore di ritorno, ecc.) Ma NON devono essere codificati nel programma
• Fortemente ispirato a 9 Hole Challenge e Text Mechanic

fori

1. Sacca da golf

   Prendi due stringhe come input.
   Emette il conteggio dei caratteri della prima stringa, ignorando ogni occorrenza di qualsiasi carattere nella seconda stringa.
   Esempio: f("foobarbaz", "ao")=>5

2. Un pre-testo per il golf

   Prendi due stringhe come input.
   Emette la prima stringa, con ogni riga preceduta dal secondo.
   Esempio: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. Guerra di schede vs spazi

   Prendi come input una stringa s, un numero ne un valore booleano b(specificato come preferisci).
   Se bè vero, output scon ogni scheda convertita in nspazi.
   Altrimenti, output scon ogni nspazio convertito in schede.
   Esempio: f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"( [sp]significa spazio)

4. Pilastri del golf

   Prendi una stringa s, un numero ne un altro numero mcome input.
   Output sin colonne di nrighe ciascuna e mcaratteri per colonna.
   Hanno anche un'imbottitura di uno spazio tra le colonne.
   Esempio: f("this is some placeholder text, foo bar baz...", 3, 5)=>

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

5. Lettere amichevoli

   Prendi una stringa se un numero ncome input.
   Stampa il gruppo di nlettere più comune in s.
   Se è presente un pareggio, emettere uno o tutti.
   Esempio: f("abcdeabcfghiabc", 3)=>"abc"

6. Lettere di uova strapazzate per colazione

   Prendi una stringa come input.
   Stampa la stringa con tutte le sue parole criptate (ordine delle lettere randomizzato) tranne la loro prima e ultima lettera.
   Per semplicità, supponiamo che l'input sia un elenco di "parole", lo spazio separato (ovvero in @$&_():;" foo bar, @$&_():;"è considerato una "parola")
   Esempio: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   Prendi una stringa come input.
   Se la stringa contiene solo numeri e spazi, sostituisci i numeri con i rispettivi caratteri ASCII (rimuovendo gli spazi).
   Altrimenti, fai il contrario (caratteri in numeri).
   Esempio: f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   Esempio 2: f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. Trasformazione mini-mini-markdown

   Prendi una stringa come input.
   Emette la stringa convertita con mini-markdown, come utilizzata nei commenti su Stack Exchange.
   Si tratta di una versione ancora mini-er: avete solo bisogno di gestire **bold**, *italics*e `code`.
   Non è necessario gestire l'annidamento non valido, ad esempio **foo *bar** baz*. Supponi anche che quando vedi un delimitatore ( *o `), significherà sempre formattare (cioè te**st**ing=> te<b>st</b>ing, e foo* bar *baz=> foo<i> bar </i>baz).
   Esempio: f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. Solo i migliori personaggi

   Prendi una stringa s, un numero ne una stringa rcome input.
   Stampa il ncarattere di ogni parola in s. (0-indicizzati, le parole sono separate da spazio).
   Se la lunghezza della parola è inferiore a n, utilizzare invece rper quella parola.
   Esempio: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

punteggio

Il tuo punteggio è la somma dei conteggi dei personaggi dei tuoi programmi. Per ogni lingua ripetuta, moltiplicare per il 110%. Ad esempio, se hai tre soluzioni Ruby e il conteggio totale dei caratteri di tutte le tue soluzioni è 1000, il tuo punteggio è 1000 * 1,1 * 1,1 = 1210. Arrotondare se si dispone di un punteggio non intero.

In bocca al lupo!

Punteggio: 382 * 1,1 ² = 462

Le lingue sono inclini a cambiare.

1. APL, 8 4

Grazie @marinus per aver rasato 4 caratteri.

f←⍴~

Chiamato con le stringhe come argomenti sinistro e destro, ad es.

      'foobarbaz' f 'ao'
5

2. Ruby, 35 31

Grazie @DoorknobofSnow per aver rasato 4 caratteri.

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;

Presuppone che gli argomenti siano nello stack. Test online

5. J, 50

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

Chiamato con la stringa come argomento sinistro e il numero come diritto, ad es.

   'abcdeabcfghiabc' f 3
abc

6. Ruby, 61

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

7. GolfScript, 39 35 34

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

Ancora una volta, presuppone che l'argomento sia nello stack. Test 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

Accidenti, adoro Lambdas.

Nota : 3 e 5 sono stati copiati spudoratamente dalla risposta di Volatility , poiché non sono riuscito a trovare un'alternativa migliore. Inoltre, questo è stato fatto solo per divertimento .

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 : grazie alla volatilità per i suggerimenti.

Punteggio 513 * 1,1 ⁵ = 826 

Ha preso un bel colpo dalla penalità nella stessa lingua. Risolto la maggior parte di questi in Ruby solo per finirli il più velocemente possibile. Potrebbe cambiare alcune lingue in seguito. Aggiunto un piccolo riepilogo / spiegazione su ogni risposta.

1: Python (46)

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

Innanzitutto, la risposta più breve in Ruby 2.0 (30) che fornisce più penalità e un punteggio complessivo più alto:

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

2: Ruby 1.9+ (37)

Restituisce ogni riga di sprefisso con t:

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

3: Ruby 1.9+ (48)

Restituisce scon le schede sostituite da nspazi o viceversa, a seconda di b:

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

4: Ruby 1.9+ (95)

Qualcuno mi spari.

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)

Restituisce la sequenza di ncaratteri più comune ins :

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

6: J (47)

Scrambles il testo in qualche modo; Veramente rubati spudoratamente da Marinus :

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

7: Ruby (57 + 1)

Stampa input ASCIIfied o de-ASCIIfied. Corri con l' -pinterruttore.

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

8: Sed (87)

Stampa input convertito da (mini) markdown in HTML:

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

9 Ruby 1.9+ (37)

Restituisce una stringa di ncaratteri th di ogni prima parola in soppure r:

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

Lavori in corso

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.