O idioma geobitsiano é uma nova perversão do inglês, onde uma palavra é dividida em segmentos que devem começar com uma letra diferente. Toda vez que uma dessas letras iniciais aparece em outra sequência, ela é substituída por todo o segmento correspondente, mantendo a capitalização.

Esse processo é chamado de geobitsizing .

Por exemplo, a palavra " Geobits " poderia ser quebrada geo bitse o poema sem sentido

Algy met a Bear
A Bear met Algy
The Bear was bulgy
The bulge was Algy

seria Geobitsized com ele como

Algeoy met a Bitsear
A Bitsear met Algeoy
The Bitsear was bitsulgeoy
The bitsulgeoe was Algeoy

porque todo gse torna geo, todo G(embora não exista) se torna Geo, todo bse torna bitse todo Bse torna Bits.

Observe que cada substituição é executada em relação à sequência original, não a nenhuma etapa intermediária. por exemplo, se geotivesse sido gbo, os bcriados não seriam substituídos por bits.

Desafio

Escreva um programa ou função que possa gerar linguagem Geobitsian.

Pegue uma cadeia de linha única composta por letras minúsculas (az) e espaços. Essa será a palavra usada como argumento de Geobitsizing, com os espaços separando os segmentos. Você pode assumir:

• Os segmentos não estarão vazios. Portanto, os espaços não serão vizinhos nem estarão no início ou no final da string.
• Cada segmento começa com uma letra diferente. Portanto, não pode haver mais de 26.

Por exemplo, algumas cordas segmentados válidos você deve apoiar são geo bits, butt ner, alex, e do o r k nob(segmentos de uma única letra não têm efeito, mas são válidos). Mas geo , butt ner, Alex, e do o r k n obsão inválidos.

Seu programa ou função também precisa incluir outra sequência arbitrária para aplicar o Geobitsizing e imprimir ou retornar o idioma geobitsiano resultante.

• Você pode assumir que essa sequência contém apenas novas linhas e ASCII imprimível.

• Lembre-se de que as maiúsculas e minúsculas devem ser preservadas da entrada para a saída.

Aqui estão mais alguns exemplos usando no pro gr am m ingcomo argumento Geobitsizing:

[empty string] → [empty string]

i → ing

I → Ing

Mmmm, mmm... MmmmMMM: m&m!→ Mmmm, mmm... MmmmMMM: m&m!(sem alteração)

People think bananas are great, don't you? → Proeoprole thingnok bamnoamnoams amre grreamt, dono't you?

Pet a Puppy
Google Wikipedia

↓

Proet am Prouproproy
Groogrle Wingkingproedingam

Observe que os resultados devem ser idênticos, independentemente da organização do argumento, por exemplo, ing pro m no am grdevem produzir os mesmos resultados acima.

O código mais curto em bytes vence.

Gelatina , 18 bytes

ṣ⁶;Œu1¦€$;©ZḢiЀị®

Experimente online!

Versão alternativa, 15 bytes (não concorrente)

A função maiúscula de Jelly teve um bug; não capitalizou a primeira palavra. Isso foi corrigido, então o seguinte funciona agora.

ṣ⁶;Œt$;©ZḢiЀị®

Esse código faz o mesmo que na versão concorrente, exceto que Œt(maiúscula) substitui a maiúscula condicional obtida por Œu1¦€.

Como funciona

ṣ⁶;Œu1¦€$;©ZḢiЀị®  Main link. Left argument: w (words). Right argument: s (string)

ṣ⁶                  Split w at spaces.
        $           Combine the two links to the left into a monadic chain.
       €              Map over the words.
   Œu1¦                 Uppercase the item at index 1.
  ;                   Append the result to the unmodified words.
         ;          Append all characters in s to the list of words.
          ©         Copy the result to the register.
           Z        Zip/transpose, grouping the first chars into the first list.
            Ḣ       Head; extract the list of first characters.
             iЀ    Find the first index of each character in s.
                ị®  Select the characters/strings from the list in the register
                    that are at those indices.

Python 3, 71 bytes

lambda w,s:s.translate({ord(t[0]):t for t in(w+' '+w.title()).split()})

Teste em Ideone .

Como funciona

No Python 3 , o interno str.translatepega uma string e um dicionário e substitui cada caractere na string cujo ponto de código é uma chave desse dicionário pelo valor correspondente, que pode ser uma string, um número inteiro ou None (equivalente ao string vazia).

Converter a sequência de palavras w em maiúsculas (ou seja, colocar em maiúscula a primeira letra de cada palavra) e anexá-la ao resultado w+' 'cria uma sequência de palavras separadas por espaço com a versão em maiúsculas e minúsculas (primeira letra). Sem um segundo argumento, str.splitdivide-se em espaço em branco e (w+' '+w.title()).split()cria a lista de todas as palavras.

Finalmente, a compreensão do dicionário {ord(t[0]):t for t in...}transforma cada palavra t em uma entrada de dicionário com a chave ord(t[0])(ponto de código da primeira letra) e o valor t , de modo str.translateque as substituições pretendidas serão executadas.

Python, 126 99 95 81 bytes

Muito obrigado a Dennis:

lambda G,S,j=''.join:j(s+j(g[1:]for g in G.split()if g[0]==s.lower())for s in S)

Edit1: não precisa anexar a um arquivo temporário

Edit2: Spode conter letras maiúsculas ...

Edit3: não duplique G

Edit4: compactou um pouco mais e empurrou-o em uma linha

Edit5: usando lambda sem nome e j=join' '

Pitão, 19 bytes

.rzsC_hMBsm,rd0rd3c

Experimente online!

Vim, 46 pressionamentos de teclas

Feio e Hacky.

A <esc>:s/\<\w/:%s\/\0\\c\/\\0/g<cr>:s/ /eg<C-v><Cr>/g<cr>dgg@"

Retina , 36 bytes

A contagem de bytes assume a codificação ISO 8859-1.

i`(?<=^.*\b\2(\w+)[^·]*?(\w))
$1
A1`

Experimente online!

Pyth, 18 16

MsXGhMJcjdrBH3)J

Experimente aqui

Define uma função gque executa o geobitsising. Como programa, isso seria um pouco mais curto se a segunda string fosse de linha única, mas a entrada de múltiplas linhas não valesse a pena:

sXwhMJcjdrBz3)J

A idéia geral aqui era nomear maiúsculas e minúsculas a string geobitsiana e anexá-la à string original. Em seguida, divida-o em espaços e, para cada sequência, pegue a primeira letra e mapeie-a para a sequência que representa. Dessa forma X, a primeira letra de cada palavra será convertida em palavra completa.

Python 2, 83 78 bytes

lambda w,s:''.join(c+w[(' '+w).find(' '+c.lower()):].split()[0][1:]for c in s)

Teste em Ideone .

Como funciona

Nós iteramos sobre todos os caracteres c na string s .

Anexamos um espaço à sequência de palavras w e , em seguida, procuramos uma ocorrência de minúsculas c , precedida por um espaço.

• Se essa ocorrência existir, findretornará o índice do espaço na string ' '+w, que corresponde ao índice de c em w .

  w[...:]assim, retorna a cauda de w , começando na palavra com a primeira letra c . split()divide a cauda em espaços, [0]seleciona o primeiro pedaço (a palavra) e [1:]remove sua primeira letra.

  Depois de anexar c ao resultado anterior, obtemos a palavra com letra correta que começa com c .

• Se nenhuma palavra começar com c , findretornará -1 .

  Assim, w[...:]gera o último caractere de w , split()agrupa-o em uma matriz, [0]desfaz a quebra automática e [1:]remove o único caractere da sequência.

  Após anexar c , obtemos a string singleton cujo caractere é c , portanto, toda a operação é não operacional.

Por fim, ''.joinconcatena todas as seqüências resultantes, retornando a versão Geobitsized de s .

Julia, 72 68 bytes

w%s=prod(c->"$c"join((W=w|>split)[find(t->t[1]==c|' ',W)])[2:end],s)

Experimente online!

CJam, 19 bytes

lq\S/_32af.^+_:c\er

Teste aqui.

Explicação

l       e# Read first line of input (list of words).
q\      e# Read remaining input and swap with first line.
S/      e# Split around spaces.
_       e# Duplicate.
32af.^  e# Convert the first letter of each word to upper case by taking
        e# the element-wise XOR with the list [32].
+       e# Append the upper-cased words to the original ones.
_:c     e# Duplicate and convert each word to its first character.
\       e# Swap characters with words.
er      e# Transliteration, replacing each character with the corresponding word.

JavaScript ES6, 67 63 70 bytes

g=>s=>s.replace(/\S/g,l=>l+(g.match(`\\b\\${l}(\\S+)`,'i')||[,""])[1])

Teste isso no Firefox. bugs estão fazendo isso mais do que eu gostaria

Explicação

function(gbarg, str) {
   return str.replace(/\S/g, function(chr) { // Replace non-whitespace w/...
        return chr + (
         gbarg.match(`\\b\\${l}(\\S+)`,'i')  // That word in the gbstr
        ||[,""])[1]                          // if not in gbstr, use blank str
   });
}

Ruby, 65 60 58 bytes

->w,s{s.gsub(/\w/){|c|w=~/\b#{c}(\w+)/i;c+($1||c)[1..-1]}}

Experimente online!