Mini-golf 9 trous: description

• 9 défis de golf de code (généralement assez faciles) de difficulté variable
• Pénalités pour avoir utilisé la même langue plusieurs fois
• Tous les défis sur un thème spécifique (ce thème: Manipulation de texte)
• L'entrée et la sortie peuvent être raisonnables (c.-à-d. STDIN et STDOUT, lecture / écriture dans un fichier, argument de fonction et valeur de retour, etc.) mais NE doivent PAS être codées en dur dans le programme
• Fortement inspiré par 9 Hole Challenge et Text Mechanic

des trous

1. Sac de golf code

   Prenez deux chaînes en entrée.
   Affiche le nombre de caractères de la première chaîne, tout en ignorant toute occurrence d'un caractère dans la deuxième chaîne.
   Exemple: f("foobarbaz", "ao")=>5

2. Un pré-texte pour le golf

   Prenez deux chaînes en entrée.
   Sortez la première chaîne, chaque ligne étant préfixée par la seconde.
   Exemple: f("foo\nbar\nbaz", "a")=>"a foo\na bar\na baz"

3. Guerre des onglets vs espaces

   Prenez une chaîne s, un nombre net un booléen b(spécifié comme vous le souhaitez) en entrée.
   Si best vrai, affichez schaque onglet converti en nespaces.
   Sinon, affichez le savec tous les nespaces convertis en tabulations.
   Exemple: f("if (x) {\n\tdoStuff();\n}", 4, true)=> "if (x) {\n[sp][sp][sp][sp]doStuff();\n}"( [sp]signifie espace)

4. Piliers de golf

   Prenez une chaîne s, un nombre net un autre nombre men entrée.
   Sortie sen colonnes de nlignes chacune et mcaractères par colonne.
   Ayez également un espace d'un espace entre les colonnes.
   Exemple: f("this is some placeholder text, foo bar baz...", 3, 5)=>

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

5. Lettres amicales

   Prenez une chaîne set un nombre nen entrée.
   Sortez le groupe de nlettres le plus courant s.
   S'il y a une égalité, sortez tout ou partie d'entre eux.
   Exemple: f("abcdeabcfghiabc", 3)=>"abc"

6. Brouillées œufs lettres pour le petit déjeuner

   Prenez une chaîne en entrée.
   Sortez la chaîne avec tous ses mots brouillés (ordre des lettres aléatoire) à l'exception de leurs première et dernière lettres.
   Par souci de simplicité, supposons que l'entrée sera une liste de "mots", séparés par des espaces (c'est-à-dire dans @$&_():;" foo bar, @$&_():;"est considéré comme un "mot").
   Exemple: f("this is a sentence that will be scrambled")=>"tihs is a stcneene that wlil be sclamrbed"

7. ASCIIfy

   Prenez une chaîne en entrée.
   Si la chaîne ne contient que des nombres et des espaces, remplacez les nombres par leurs caractères ASCII respectifs (en supprimant les espaces).
   Sinon, faites l'inverse (des caractères aux chiffres).
   Exemple: f("ASCIIfy challenge")=> "65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101"
   Exemple 2: f("65 83 67 73 73 102 121 32 99 104 97 108 108 101 110 103 101")=>"ASCIIfy challenge"

8. Transformation mini-mini-démarque

   Prenez une chaîne en entrée.
   Sortez la chaîne convertie avec mini-markdown, comme utilisé dans les commentaires sur Stack Exchange.
   Ceci est une version encore mini-er: il vous suffit de gérer **bold**, *italics*et `code`.
   Vous n'avez pas besoin de gérer l'imbrication invalide, comme **foo *bar** baz*. Supposons également que lorsque vous voyez un délimiteur ( *ou `), cela signifie toujours de formater (c'est-à-dire te**st**ing=> te<b>st</b>inget foo* bar *baz=> foo<i> bar </i>baz).
   Exemple: f("**foo** *bar **baz*** `qux`")=>"<b>foo</b> <i>bar <b>baz</b></i> <code>qux</code>"

9. Seuls les meilleurs personnages

   Prenez une chaîne s, un nombre net une chaîne ren entrée.
   Sortez le ne caractère de chaque mot s. (Indexés 0, les mots sont séparés par des espaces).
   Si la longueur du mot est inférieure à n, utilisez rplutôt ce mot.
   Exemple: f("this is a test sentence foo bar baz", 2, "-")=>"i--snorz"

Notation

Votre score est la somme du nombre de caractères de vos programmes. Pour chaque langue répétée, multipliez par 110%. Par exemple, si vous avez trois solutions Ruby et que le nombre total de caractères de toutes vos solutions est de 1000, votre score est de 1000 * 1,1 * 1,1 = 1210. Arrondissez si vous avez un score non entier.

Bonne chance!

Résultat: 382 * 1,1 ² = 462

Langues sujettes à changement.

1. APL, 8 4

Merci @marinus d'avoir rasé 4 caractères.

f←⍴~

Appelé avec les chaînes comme arguments gauche et droit, par exemple.

      'foobarbaz' f 'ao'
5

2. Ruby, 35 31

Merci @DoorknobofSnow d'avoir rasé 4 caractères.

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;

Suppose que les arguments sont sur la pile. Testez en ligne

5. J, 50

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

Appelé avec la chaîne comme argument de gauche et le nombre comme droite, par exemple.

   'abcdeabcfghiabc' f 3
abc

6. Ruby, 61

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

7. GolfScript, 39 35 34

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

Encore une fois, suppose que l'argument est sur la pile. Testez en ligne

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

Gee, j'aime vraiment les lambdas.

Remarque : 3 et 5 ont été copiés sans vergogne de la réponse de Volatility , car je ne pouvais pas trouver une meilleure alternative. De plus, cela a été fait juste pour le plaisir .

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 : Merci à Volatility pour les conseils.

Score 513 * 1,1 ⁵ = 826 

Il a fallu beaucoup de coups à la peine de même langue. Résolu la plupart de ces problèmes en Ruby juste pour les terminer aussi vite que possible. Peut changer certaines langues plus tard. Ajout d'un petit récapitulatif / explication sur chaque réponse.

1: Python (46)

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

Premièrement, une réponse plus courte dans Ruby 2.0 (30) qui donne plus de pénalités et un score global plus élevé:

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

2: Rubis 1.9+ (37)

Renvoie chaque ligne de spréfixe avec t:

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

3: Rubis 1.9+ (48)

Renvoie savec des tabulations remplacées par des nespaces ou vice versa, selon b:

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

4: Rubis 1.9+ (95)

Quelqu'un m'a tiré dessus.

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

5: Rubis 1.9+ (58)

Renvoie la série de ncaractères la plus courante dans s:

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

6: J (47)

Brouille le texte d'une manière ou d'une autre; Mot à mot volé sans vergogne à Marinus :

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

7: Rubis (57 + 1)

Imprime l'entrée ASCIIfied ou dés-ASCIIfied. Courez avec l' -pinterrupteur.

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

8: Sed (87)

Imprime l'entrée convertie du (mini) markdown en HTML:

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

9 Rubis 1.9+ (37)

Renvoie une chaîne des ne caractères de chaque premier mot de s, ou r:

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

Travail en cours

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.