Riempire reciprocamente gli spazi vuoti

11

Dato un input di due stringhe con sequenze di caratteri di sottolineatura che rappresentano le parole corrispondenti, emette le frasi con gli "spazi vuoti" riempiti.

Il modo migliore per descrivere questa sfida è l'esempio. Ecco un esempio di input:

programming _____________ and code golf
programming puzzles ______ code ____

Ed ecco l'output corrispondente:

programming ___puzzles___ and code golf
programming puzzles _and__ code golf

Ai fini di questa sfida, una "parola" è definita come una sequenza di una o più lettere minuscole e uno "spazio" è definito come uno o più caratteri di sottolineatura (l'input conterrà sempre solo lettere minuscole, spazi e caratteri di sottolineatura) . Le parole e gli spazi vuoti nelle stringhe di input sono separati da spazi singoli e la somma del numero di parole e spazi vuoti nelle frasi sarà sempre uguale.

L'obiettivo della sfida è riempire tutti gli spazi vuoti con le parole corrette , che sono le parole che occupano lo stesso indice nell'altra stringa quando vengono divise per spazi.

  • La parola deve essere centrata nello spazio vuoto, come mostrato con la parola "puzzle" nell'esempio sopra: un numero uguale di caratteri di sottolineatura rimane su entrambi i lati.

  • Se la parola non può essere esattamente centrata, il carattere di sottolineatura aggiuntivo può andare a sinistra oa destra (es. La parola "e" nell'esempio sopra).

  • Ci saranno sempre abbastanza caratteri di sottolineatura per adattarsi alla parola, ma potrebbero esserci esattamente tanti quanti la lunghezza della parola (es. La parola "golf" nell'esempio sopra).

  • Non ci sarà mai uno spazio vuoto nella stessa posizione in entrambe le stringhe.

Input / output può essere uno dei seguenti (input / output non devono necessariamente essere tramite lo stesso metodo):

  • stringa singola separata da qualsiasi carattere che non sia alfabetico, uno spazio o un carattere di sottolineatura (es. newline o stringa separata da virgola)

  • un array / elenco / ecc. di due stringhe

  • due argomenti della riga di comando / funzione (solo input)

Poiché si tratta di code-golf , vincerà il codice più breve in byte.

L'esempio sopra può essere usato come test case. Ecco un caso di test più ampio (la seconda stringa in output può variare leggermente a causa del diverso comportamento di centraggio):

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
code-golf  string 
— Maniglia
fonte
Bella sfida bilaterale.
— Rɪᴋᴇʀ

Risposte:

5

Pyth, 30

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

Accetta input e output come un elenco di due stringhe. Utilizza un approccio di base piuttosto suddiviso – zip – doppia mappa – centro – zip – join.

Provalo qui

Allargato:

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

Spiegherò di più quando sarò davvero soddisfatto di non poter più giocare a golf, anche se dovrebbe essere abbastanza chiaro, data l'ubiquità dell'approccio split-zip – double map – center – zip – join e tutto il resto.

— FryAmTheEggman
fonte
8
Ahhh, il classico approccio split-zip-double map-center-zip-join. Ricordo con affetto che veniva usato come esempio introduttivo nella mia lezione di Algorithms 101.
— Martin Ender,
3
@ MartinBüttner Sì, ho dei brutti ricordi perché ho dormito durante quella lezione, ho dovuto risolvere i problemi dell'esame usando invece l'approccio duplicate-append-lookback-match-add-center.
— FryAmTheEggman,
4
Vado ad applicare dell'acqua fredda sull'ustione.
— Martin Ender,
7

Retina , 102 100 93 88 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Le stringhe saranno separate da un avanzamento riga. Se è rimasto un numero dispari di trattini bassi, quello estraneo sarà dopo la parola.

Provalo online!

Spiegazione

Immagino che questo sia l'approccio "duplicate-append-lookback-match-add-center", o qualcosa di simile ...

$
!¶$`

Iniziamo duplicando l'input (separato con una !e un avanzamento riga). Lo scopo di questo è che possiamo quindi elaborare entrambe le righe recuperando le parole dalla riga successiva (invece di dover trattare la seconda riga separatamente).

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

Questo antepone la parola corretta a ogni spazio vuoto. Iniziamo contando la posizione della parola corrente con il lookbehind (?<=^(\w+ )*)(la posizione viene memorizzata come profondità del gruppo 1). Quindi il lookahead a) assicura che siamo all'inizio di uno spazio abbinando _, quindi salta alla riga successiva con .*¶, abbina il numero corretto di parole con (?<-1>\w+ )*per raggiungere la posizione giusta e quindi abbina la parola trovata lì con (\w+)in gruppo 2.

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

Questa fase fa tre cose:

  • Rimuove i caratteri di sottolineatura corrispondenti alla lunghezza di ogni parola. Questo viene fatto contando la lunghezza della parola in gruppo 2con ([a-z])+e poi abbinando quel carattere di sottolineatura (che non viene mai riscritto).
  • Sposta la parola al centro del divario catturando metà dei caratteri di sottolineatura rimanenti con (_*)\3e riscrivendo $3$1$3.
  • Rimuove l'input duplicato abbinandolo !\D+e sostituendolo con nulla.
— Martin Ender
fonte
4

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 funzione accetta due stringhe come argomenti e stampa l'output come negli esempi. Utilizza un approccio noioso, con la str.center(width, fillchar)maggior parte del lavoro.

Provalo online .

— GRC
fonte
1
Non penso che tu abbia bisogno z, a meno che non mi manchi qualcosa, puoi semplicemente fare lo scambio dopo la stampa e in linea z.
— FryAmTheEggman,
@FryAmTheEggman sì, hai ragione. Grazie :)
— GRC
2

Rubino, 111 109 caratteri

->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*' '}}

Input: matrice di 2 stringhe; output: matrice di 2 stringhe.

Esecuzione di esempio:

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
— uomo al lavoro
fonte
1

JavaScript, 194 185 byte

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)])

Accetta due stringhe come parametri e genera due stringhe come matrice / elenco

Mostra snippet di codice

— rimosso
fonte
1

Mathematica 223

Ci deve essere un modo più breve per farlo.

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]}

Esecuzione del campione

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

inserisci qui la descrizione dell'immagine

— DavidC
fonte
0

Gema, 208 203 caratteri

\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

Solo perché Gema ha la funzione perfetta per questo compito: .@fill-center{background;value}

Input: 2 righe separate di nuova riga (nessuna riga finale finale); output: 2 righe separate di nuova riga (con spazi finali - non sembrano essere proibite).

Esecuzione di esempio:

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
— uomo al lavoro
fonte
0

C, 197 byte

#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]);}

Produzione

$ ./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
— Cole Cameron
fonte
0

ES6, 122 byte

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` `)

Accetta una matrice di due stringhe come singolo parametro e restituisce un'altra matrice di due stringhe.

— Neil
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.