Étant donné une entrée de deux chaînes avec des séquences de soulignements représentant les mots correspondants, sortez les phrases avec les «blancs» remplis.

La meilleure façon de décrire ce défi est par l'exemple. Voici un exemple d'entrée:

programming _____________ and code golf
programming puzzles ______ code ____

Et voici la sortie correspondante:

programming ___puzzles___ and code golf
programming puzzles _and__ code golf

Aux fins de ce défi, un «mot» est défini comme une séquence d'une ou plusieurs lettres minuscules, et un «blanc» est défini comme un ou plusieurs traits de soulignement (l'entrée ne contiendra toujours que des lettres minuscules, des espaces et des traits de soulignement) . Les mots et les blancs dans les chaînes d'entrée sont séparés par des espaces simples, et la somme du nombre de mots et de blancs dans les phrases sera toujours égale.

L'objectif du défi est de remplir tous les blancs avec les mots corrects , qui sont les mots qui occupent le même index dans l'autre chaîne lorsqu'ils sont divisés par des espaces.

• Le mot doit être centré dans le blanc, comme indiqué avec le mot «puzzles» dans l'exemple ci-dessus - un nombre égal de traits de soulignement reste de chaque côté.

• Si le mot ne peut pas être exactement centré, le trait de soulignement supplémentaire peut aller à gauche ou à droite (ex. Le mot "et" dans l'exemple ci-dessus).

• Il y aura toujours suffisamment de soulignements pour que le mot tienne, mais il peut y en avoir exactement autant que la longueur du mot (ex. Le mot "golf" dans l'exemple ci-dessus).

• Il n'y aura jamais de blanc dans la même position dans les deux chaînes.

Les entrées / sorties peuvent être l'une des suivantes (les entrées / sorties ne doivent pas nécessairement être via la même méthode):

• chaîne unique séparée par un caractère non alphabétique, un espace ou un trait de soulignement (par exemple, une nouvelle ligne ou une chaîne séparée par des virgules)

• un tableau / liste / etc. de deux cordes

• deux arguments de ligne de fonction / commande (entrée uniquement)

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

L'exemple ci-dessus peut être utilisé comme cas de test. Voici un cas de test plus grand (la deuxième chaîne en sortie peut varier légèrement en raison du comportement de centrage différent):

lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum

lorem ipsum dolor _sit_ amet __consectetur__ adipiscing elit mauris dapibus tincidunt ____________metus____________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum dolor_ sit _amet__ consectetur __adipiscing___ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem _________fermentum__________ dictum

Pyth, 30

jL;Cmm|*}J\_k.[lkhx#JdJkdCcR;Q

Prend les entrées et sorties comme une liste de deux chaînes. Utilise une approche de base split – zip – double map – center – zip – join assez simple.

Essayez-le ici

Étendu:

jL;Cmm|*}J\_k.[lkhx#JdJkdCcR;Q   ##
                          cR;Q   ##  split
                         C       ##  zip
    mm                           ##  double map
      |*}J\_k.[lkhx#JdJkd        ##  centre
   C                             ##  zip
jL;                              ##  join

J'expliquerai plus une fois que je suis vraiment convaincu que je ne peux plus jouer au golf, même si cela devrait être assez clair, compte tenu de l'omniprésence de l'approche split – zip – double carte – centre – zip – join et tout.

Retina , 102 100 93 88 octets

Le nombre d'octets suppose un codage ISO 8859-1.

$
!¶$`
m`(?<=^(\w+ )*)(?=_.*¶(?<-1>\w+ )*(\w+))
$2
(([a-z])+)(?<-2>_)*(_*)\3|!\D+
$3$1$3

Les chaînes seront séparées par un saut de ligne. S'il reste un nombre impair de traits de soulignement, le caractère étranger sera après le mot.

Essayez-le en ligne!

Explication

Je suppose que c'est "l'approche duplicate-append-lookback-match-add-center", ou quelque chose de proche ...

$
!¶$`

Nous commençons par dupliquer l'entrée (séparée par un !et un saut de ligne). Le but de ceci est que nous pouvons ensuite traiter les deux lignes en récupérant les mots de la ligne suivante (au lieu d'avoir à traiter la deuxième ligne séparément).

m`(?<=^(\w+ )*)(?=_.*¶(?<-1>\w+ )*(\w+))
$2

Cela ajoute le mot correct à chaque espace. Nous commençons par compter la position actuelle du mot avec le lookbehind (?<=^(\w+ )*)(la position est stockée comme la profondeur du groupe 1). Ensuite, l'anticipation a) garantit que nous sommes au début d'un écart en faisant correspondre _, puis passe à la ligne suivante avec .*¶, correspond au nombre correct de mots avec (?<-1>\w+ )*pour arriver à la bonne position, puis correspond au mot trouvé là avec (\w+)en dans groupe 2.

(([a-z])+)(?<-2>_)*(_*)\3|!\D+
$3$1$3

Cette étape fait trois choses:

• Il supprime les traits de soulignement correspondant à chaque longueur de mot. Cela se fait en comptant la longueur du mot dans le groupe 2avec ([a-z])+puis en faisant correspondre autant de soulignements (qui ne sont jamais réécrits).
• Il déplace le mot au centre de l'écart en capturant la moitié des traits de soulignement restants avec (_*)\3et en réécrivant $3$1$3.
• Il supprime l'entrée dupliquée en la faisant correspondre !\D+et en la remplaçant par rien.

Python 2, 109

def f(a,b):exec"print' '.join([x,y][x<'`'].center(len(x),'_')for x,y in zip(a.split(),b.split()));a,b=b,a;"*2

La fonction prend deux chaînes comme arguments et imprime la sortie comme dans les exemples. Il utilise une approche ennuyeuse, avec str.center(width, fillchar)la plupart du travail.

Essayez-le en ligne .

Ruby, 111 109 caractères

->l{l.map(&:split).transpose.map{|c|c[m=c[0]<c[1]?0:1]=c[1-m].center c[m].size,?_
c}.transpose.map{|s|s*' '}}

Entrée: tableau de 2 chaînes; sortie: tableau de 2 chaînes.

Exemple d'exécution:

2.1.5 :001 > puts ->l{l.map(&:split).transpose.map{|c|c[m=c[0]<c[1]?0:1]=c[1-m].center c[m].size,?_;c}.transpose.map{|s|s*' '}}[[
2.1.5 :002 >       'programming _____________ and code golf',
2.1.5 :003 >       'programming puzzles ______ code ____',
2.1.5 :004 >       ]]
programming ___puzzles___ and code golf
programming puzzles _and__ code golf

JavaScript, 194185 octets

f=(m,n)=>(m=m.split` `,n=n.split` `,G=(x,i,a)=>x[0]!='_'?x:(b=(a?n:m)[i],s=x.length-b.length,(k='_'.repeat(s/2))+b+k+(s%2?'_':'')),H=(e,y)=>e.map((x,i)=>G(x,i,y)).join` `,[H(m,1),H(n)])

Prend deux chaînes comme paramètres et génère deux chaînes comme tableau / liste

f=(m,n)=>(
    m=m.split` `,
    n=n.split` `,
    G=(x,i,a)=>
        x[0]!='_'?x:
        (
            b=(a?n:m)[i],
            s=x.length-b.length,
            (k='_'.repeat(s/2))+b+k+(s%2?'_':'')
        ),
    H=(e,y)=>e.map((x,i)=>G(x,i,y)).join` `,
    [H(m,1),H(n)]
)

document.body.innerHTML = '<pre>' +
    "f('lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum', 'lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum')<br>" +
    f('lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum', 'lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum') + "<br><br>" +
    "f('programming _____________ and code golf', 'programming puzzles ______ code ____')<br>" +
    f('programming _____________ and code golf', 'programming puzzles ______ code ____')
'</pre>'

Mathematica 223

Il doit y avoir un moyen plus court de procéder.

k=StringLength;m=StringSplit;
g=Partition[Riffle[m@#,m@#2],2]/.{{a_,a_}:> a<>" ",{a_,b_/; StringTake[b,1]=="_"}:> a<>" ",
{a_,b_}:>Table["_",Ceiling[z=(k@a-k@b)/2]]<>b<>""<>Table["_",Floor@z]<>" "}&;
s_~h~t_:={""<>g[s,t],""<>g[t,s]}

Exemple d'exécution

h["programming _____________ and code golf", "programming puzzles ______ code ____"]

Gema, 208 203 caractères

\B=@set{i;0}
<I>=@push{${v;f};$0}@incr{i}
\n=@set{v;s}@set{i;0}
 =
\E=@repeat{$i;@cmps{$f;$s;@set{f;@fill-center{$f;$s}};;@set{s;@fill-center{$s;$f}}}@set{F;$f ${F;}}@set{S;$s ${S;}}@pop{f}@pop{s}}$F\n$S

Tout simplement parce que Gema a la fonction parfaite pour cette tâche: .@fill-center{background;value}

Entrée: 2 lignes séparées par une nouvelle ligne (pas de nouvelle ligne finale); sortie: 2 lignes séparées par des retours à la ligne (avec des espaces de fin - ne semblent pas être interdites).

Exemple d'exécution:

bash-4.3$ echo -ne 'programming _____________ and code golf\nprogramming puzzles ______ code ____' |
> gema '\B=@set{i;0};<I>=@push{${v;f};$0}@incr{i};\n=@set{v;s}@set{i;0}; =;\E=@repeat{$i;@cmps{$f;$s;@set{f;@fill-center{$f;$s}};;@set{s;@fill-center{$s;$f}}}@set{F;$f ${F;}}@set{S;$s ${S;}}@pop{f}@pop{s}}$F\n$S'
programming ___puzzles___ and code golf 
programming puzzles _and__ code golf 

C, 197 octets

#define c(w,y)l=strspn(w,"_"),r=strcspn(y," "),memcpy(w+(l-r)/2,y,r),w+=l,y+=r;
main(l,v,w,y,r)char**v,*w,*y;{for(w=v[1],y=v[2];*w;w++,y++)if(*w^*y)if(*w^95)c(y,w)else c(w,y)puts(v[1]);puts(v[2]);}

Production

$ ./a.out "lorem _____ dolor _____ amet _______________ adipiscing elit mauris dapibus tincidunt _____________________________ accumsan fringilla proin vulputate viverra lorem fermentum dictum" "lorem ipsum ______ sit _______ consectetur _______________ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem ____________________________ dictum"
lorem ipsum dolor _sit_ amet __consectetur__ adipiscing elit mauris dapibus tincidunt ____________metus____________ accumsan fringilla proin vulputate viverra lorem fermentum dictum
lorem ipsum dolor_ sit _amet__ consectetur __adipiscing___ elit mauris dapibus tincidunt metus accumsan fringilla proin vulputate viverra lorem _________fermentum__________ dictum

ES6, 122 octets

a=>a.map(s=>s.split` `).map((s,n,a)=>s.map((w,i)=>w<'a'?(l=w.length,t=w+a[n^1][i]+w,t.substr(t.length-l>>1,l)):w).join` `)

Prend un tableau de deux chaînes en tant que paramètre unique et renvoie un autre tableau de deux chaînes.