Mini-golfe de 9 buracos: Descrição

• 9 (na maior parte razoavelmente fácil) desafios de código de golfe de dificuldade variável
• Sanções por usar o mesmo idioma mais de uma vez
• Todos os desafios sobre um tema específico (este tema: Manipulação de texto)
• Entrada e saída podem ser razoáveis ​​em qualquer lugar (por exemplo, STDIN e STDOUT, leitura / gravação em um arquivo, argumento de função e valor de retorno, etc.), mas NÃO devem ser codificadas no programa
• Fortemente inspirado no desafio de 9 buracos e no mecânico de texto

Buracos

1. Código-saco de golfe

   Pegue duas cordas como entrada.
   Gera a contagem de caracteres da primeira string, ignorando qualquer ocorrência de qualquer caractere na segunda string.
   Exemplo: f("foobarbaz", "ao")=>5

2. Um pré-texto para jogar golfe

   Pegue duas cordas como entrada.
   Saída a primeira string, com cada linha prefixada com a segunda.
   Exemplo: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. Guerra de abas vs espaços

   Pegue uma string s, um número ne um booleano b(especificado como desejar) como entrada.
   Se bfor verdade, faça a saída scom todas as guias convertidas em nespaços.
   Senão, faça a saída scom todos os nespaços convertidos em guias.
   Exemplo: f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"( [sp]significa espaço)

4. Pilares de golfe

   Pegue uma string s, um número ne outro número mcomo entrada.
   Saída sem colunas de nlinhas cada e mcaracteres por coluna.
   Também possui preenchimento de um espaço entre as colunas.
   Exemplo: f("this is some placeholder text, foo bar baz...", 3, 5)=>

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

5. Cartas amigáveis

   Pegue uma string se um número ncomo entrada.
   Envie o grupo de nletras mais comum em s.
   Se houver um empate, produza um ou todos eles.
   Exemplo: f("abcdeabcfghiabc", 3)=>"abc"

6. Letras de ovos mexidos no café da manhã

   Pegue uma string como entrada.
   Produza a sequência com todas as suas palavras embaralhadas (ordem das letras aleatoriamente), exceto a primeira e a última letras.
   Por uma questão de simplicidade, suponha que a entrada seja uma lista de "palavras" s, separadas por espaço (ou seja @$&_():;" foo bar, em , @$&_():;"é considerada uma "palavra".)
   Exemplo: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   Pegue uma string como entrada.
   Se a sequência contiver apenas números e espaços, substitua os números pelos respectivos caracteres ASCII (removendo os espaços).
   Senão, faça o inverso (caracteres para números).
   Exemplo: f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   Exemplo 2: f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. Transformação mini-mini-markdown

   Pegue uma string como entrada.
   Produza a sequência convertida com minidistribuição, conforme usado nos comentários no Stack Exchange.
   Esta é uma versão ainda mini-er: você só precisa lidar com **bold**, *italics*e `code`.
   Você não precisa lidar com aninhamentos inválidos, como **foo *bar** baz*. Suponha também que quando você vê um delimitador ( *ou `), isso sempre significa formatar (ou seja, te**st**ing=> te<b>st</b>inge foo* bar *baz=> foo<i> bar </i>baz).
   Exemplo: f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. Apenas os melhores personagens

   Pegue uma sequência s, número ne sequência rcomo entrada.
   Produza o nth caractere de cada palavra ems . (Indexadas em 0, as palavras são separadas por espaço).
   Se o comprimento da palavra for menor que n, use rpara essa palavra.
   Exemplo: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

Pontuação

Sua pontuação é a soma das contagens de caracteres dos seus programas. Para cada idioma repetido, multiplique por 110%. Por exemplo, se você tiver três soluções Ruby e a contagem total de caracteres de todas as suas soluções for 1000, sua pontuação será 1000 * 1,1 * 1,1 = 1210. Arredonde para baixo se você tiver uma pontuação não inteira.

Boa sorte!

Pontuação: 382 * 1,1 ² = 462

Idiomas propensos a mudar.

1. APL, 8 4

Obrigado @marinus por cortar 4 caracteres.

f←⍴~

Chamado com as strings como argumentos esquerdo e direito, por exemplo.

      'foobarbaz' f 'ao'
5

2. Ruby, 35 31

Obrigado @DoorknobofSnow por cortar 4 caracteres.

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;

Assume que os argumentos estão na pilha. Teste on-line

5. J, 50

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

Chamado com a string como argumento à esquerda e o número como à direita, por exemplo.

   'abcdeabcfghiabc' f 3
abc

6. Ruby, 61

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

7. GolfScript, 39 35 34

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

Novamente, assume que o argumento está na pilha. Teste on-line

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

Caramba, eu com certeza amo lambdas.

Nota : 3 e 5 foram copiados descaradamente da resposta da Volatility , pois não consegui encontrar uma alternativa melhor. Além disso, isso foi feito apenas por diversão .

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 : Obrigado ao Volatility pelas dicas.

Pontuação 513 * 1,1 ⁵ = 826 

Levou uma surra pela penalidade no mesmo idioma. Resolvi a maioria delas em Ruby apenas para finalizá-las o mais rápido possível. Pode mudar alguns idiomas mais tarde. Adicionada uma pequena recapitulação / explicação em cada resposta.

1: Python (46)

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

Primeiro, resposta mais curta no Ruby 2.0 (30) que oferece mais penalidade e maior pontuação geral:

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

2: Ruby 1.9+ (37)

Retorna cada linha de sprefixo com t:

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

3: Ruby 1.9+ (48)

Retorna scom guias substituídas por nespaços ou vice-versa, dependendo de b:

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

4: Ruby 1.9+ (95)

Alguém atira em mim.

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)

Retorna a execução de ncaracteres mais comum em s:

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

6: J (47)

Embaralha o texto de alguma forma; Vergonhosamente roubados descaradamente de marinus :

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

7: Ruby (57 + 1)

Imprime a entrada ASCIIfied ou de-ASCIIfied. Corra com o -pinterruptor.

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

8: Sed (87)

Imprime a entrada convertida de (mini) remarcação para HTML:

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

9 Ruby 1.9+ (37)

Retorna uma sequência dos ncaracteres th de cada primeira palavra em s, ou r:

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

Trabalho em progresso

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