Mini-golf à 9 trous: manipulation de texte [fermé]

26

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!

Poignée de porte
la source
1
Le défi 8 touche à l'un des aspects les moins bien spécifiés de Markdown, et celui qui est le plus difficile à faire vraiment bien. Il a besoin d'une explication claire de la façon de gérer les ambiguïtés et d'une bonne suite de tests. Voir Emphasis.text de la suite mdtest.
Peter Taylor
@PeterTaylor Eh bien, cela _n'a pas d'importance puisque j'ai spécifié de ne pas l'inclure. J'ai édité pour clarifier certains des autres.
Poignée de porte
Et alors **foo***bar**baz*?
Peter Taylor
1
Le défi 6 est identique à celui-ci .
daniero
4
Je vote pour fermer cette question comme hors sujet car c'est un défi en plusieurs parties avec une interaction insuffisante entre les parties
pppery

Réponses:

12

Résultat: 382 * 1,1 2 = 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]
Volatilité
la source
Génial! Vous pouvez enregistrer quelques caractères sur Ruby en utilisant un proc ( f=->s,r{...}) au lieu d'une fonction. Je refuse cependant de voter jusqu'à ce qu'il soit terminé: P
Poignée de porte
@DoorknobofSnow ah, merci. Pas très compétent avec Ruby :)
Volatilité
Hourra, vous êtes le premier à terminer :-D +1
Poignée de porte
J'ai l'impression que toutes les fonctions sont censées retourner une chaîne, donc pour le numéro 4, je pense que vous allez devoir utiliser un caractère de plus.
Peter Taylor
@PeterTaylor fixed :)
Volatilité
4

Python - 697 × 1,1 9 ≈ 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.

Oberon
la source
Vous pouvez utiliser des expressions de générateur pour la plupart d'entre elles, ce qui vous fera économiser un tas de caractères. En outre, pour 1. il n'est pas nécessaire d'utiliser int, car les booléens sont une sous-classe d'entre eux, et pour 7. all([...])peut être raccourci àx.replace(' ','').isdigit()
Volatilité
La deuxième réponse ne préfixe pas la première ligne de a.
daniero
1

Score 513 * 1,1 5 = 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}*''}
daniero
la source
Ne serait - 8 votre sortie <b>test** **test2</b>pour **test** **test2**?
Poignée de porte
@DoorknobofSnow oui, ce serait le cas;) Corrigé (sed n'a pas de répétition non gourmande).
daniero
Que donnerait-il **foo *bar* baz**?
Volatilité du
@Volatility Oups. Je n'ai pas lu la question correctement, je pensais qu'il n'y aurait pas d'imbrication, mais cela disait pas d' imbrication invalide . Je ne suis pas sûr que je vais prendre la peine de le réparer maintenant.
daniero
Pour le 1er -opérateur de code rubis , fonctionne avec l'énumérateur?
Siva
1

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.

Justin
la source
Au premier trou, il devrait être for(char c:b.toCharArray())et replace(c+"","");et return s.length();(ou quelque chose comme ça) pour le faire fonctionner.
bobbel