Rozciąganie słów

32

Napisz program lub funkcję, która powiela litery w słowie, aby wszystkie zduplikowane litery ułożone od lewej do prawej słowa tworzyły tablicę wejściową.

Na przykład:

input: chameleon, [c,a,l,n]
output: cchaamelleonn

Wkład

  • Słowo początkowe (np. chameleon)
  • Tablica znaków ( [c,a,l,n]) lub ciąg znaków reprezentujący tablicę ( caln) lub coś podobnego
  • Dane wejściowe mogą być wprowadzane za pomocą parametrów funkcji, STDIN lub odpowiedników językowych
  • Wszystkie dane wejściowe będą pisane małymi literami (az)

Wydajność

  • Zmienione słowo

  • Jeśli istnieje wiele rozwiązań, można je wydrukować

    input: banana [n,a]  
    possible outputs: bannaana, banannaa
                         |-|---------|-|--->[n,a]
    
  • Możesz założyć, że słowo wejściowe (niekoniecznie tablica) będzie zawierać litery w tablicy (w kolejności)

  • Możesz również założyć, że na wejściach nie ma kolejnych liter, które są takie same (NIE jabłko, maniak, zielony, szkło, drzwi ...)

Przykłady

input: abcdefghij, [a,b,c]
output: aabbccdefghij

input: lizard, [i,a,r,d]
output: liizaarrdd

input: coconut, [c,o]
ouput: ccooconut or coccoonut or ccocoonut

input: onomatopoeia, [o,o,a,o,o]
output: oonoomaatoopooeia

input: onomatopoeia, [o,a,o]
output: oonomaatoopoeia or onoomaatoopoeia or oonomaatopooeia etc.

Najkrótszy program wygrywa!

Tabela liderów (podziękowania dla Martina Büttnera za fragment)

Stretch Maniac
źródło
@AlexA. tylko jedna instancja, ponieważ w przeciwnym razie byłaby tablica utworzona przez zduplikowane litery [c,o,c,o], a nie [c,o].
Stretch Maniac
Tak, przepraszam, ponowne przeczytanie tego jest oczywiste. Dzięki.
Alex A.
2
Widząc to, otrzymałem całkiem sporo odpowiedzi i wielu w tych samych językach, czy byłbyś zainteresowany dodaniem fragmentu tabeli wyników ? Jeśli tak, chętnie go edytuję i zmieniam odpowiedzi, które nie używają wymaganego formatu nagłówka.
Martin Ender
@ MartinBüttner Zapomniałem o tym! Dodany. Musiałem zmienić #answer-listi #language-listszerokość, 50%aby uniknąć nakładania się kolumn w Twoim fragmencie.
Stretch Maniac
1
Wyjaśnienie (patrz moja bash+ sedodpowiedź): Czy to jest nielegalne dla banana, na=> baannana? Wierzyłem, że „Możesz założyć, że wszystkie dane wejściowe będą miały litery w tablicy (w kolejności)” ma na celu umożliwienie , ale nie wymaganie , odpowiedzi na przetwarzanie obu list sekwencyjnie, ale @manatwork zinterpretował to inaczej.
Toby Speight

Odpowiedzi:

5

Pyth, 14 bajtów

s+L&@d<Q1.(QZz

Demonstracja.

Styl wprowadzania:

banana
["b","a","n","a"]

Wyjaśnienie:

s+L&@d<Q1.(Q0z
                  Implicit: z = input(); Q = eval(input())
 +L          z    Map (lambda d) over z, adding the result to each character.
    @d<Q1         Intersection of d with Q[:1], up to the first element of Q.
   &              Logical and - if the first arg is truthy, evaluate and
                  return the second arg, otherwise return first arg.
         .(Q0     Q.pop(0)
                  The addition will either be the empty string, for the empty
                  intersection, or the character that was Q[0] otherwise.

s                 Concatenate and print.
isaacg
źródło
43

Brainfuck, 46 45 (63 z wejściowymi znakami do wydrukowania)

Kompatybilny z bff Alexa Pankratova (interpreter pieprzenia mózgu używany na SPOJ i ideone) oraz BFI Thomasa Corta (używany na Anarchy Golf).

Wersja do wydruku najpierw przyjmuje tablicę jako ciąg, następnie tabulator, a następnie ciąg początkowy bez końca nowej linii.

Demonstracja na ideonie.

-[+>,---------]
<[++++++++<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]

Możemy zapisać niektóre bajty, używając \x00jako separatora zamiast tab:

,[>,]
<[<]
<,+
[
  -.
  [>+>-<<-]
  >>
  [
    <[>+<-]
  ]
  <[.[-]]
  ,+
]
Mitch Schwartz
źródło
22
To uczucie, gdy BF jest krótszy niż mój kod Python .. :(
Kade
6
Zwykle nie dbam o Brainfuck, ale to jest niesamowite!
Dennis
To jest piękne.
Joshpbarron
14

CJam, 15 bajtów

rr{_C#)/(C@s}fC

Wypróbuj online.

Jak to działa

rr              e# Read two whitespace-separated tokens from STDIN.
  {         }fC e# For each character C in the second string.
   _            e#   Duplicate the first string.
    C#          e#   Compute the index of the character in the string.
      )/        e#   Add 1 and split the string in slice of that size.
        (       e#   Shift out the first slice.
         C      e#   Push the character.
          @     e#   Rotate the remainder of the string in top of the stack.
           s    e#   Stringify (concatenate the slices).
Dennis
źródło
To bitwa CJams! Zarówno ty, jak i Sp, macie 15 bajtowe odpowiedzi CJam, a 15 jest obecnie najkrótsze. :)
Alex A.
3
@AlexA. Poczekaj tylko na Pytha. Po prostu czekaj ...
Sp3000,
2
Wygląda na to, że lepiej się uczyć Pytha. ;)
Alex A.
12

C, 62 bajty

f(char*s,char*c){while(*s-*c||putchar(*c++),*s)putchar(*s++);}

Jest to zaskakująco konkurencyjne.

Definiujemy funkcję, f(char*, char*)która przyjmuje ciąg znaków jako pierwsze wejście, a tablicę znaków do skopiowania jako drugie wejście.

Niektóre kody testowe:

int main (int argc, char** argv) {
    f("onomatopeia", "oao");
    return 0;
}

Które wydruki:

oonomaatoopeia

Wypróbuj online !

Jeśli dopuszczalne jest przesłanie makra zamiast funkcji, poniższe #define g(s,c)to tylko 58 bajtów , ale wymaga si cmusi być rzeczywistymi wskaźnikami:

#define g(s,c)while(*s-*c||putchar(*c++),*s)putchar(*s++);
BrainSteel
źródło
1
Dzięki, że kazałem mi szukać operatora przecinka . To jest przydatne!
Oliphaunt - przywróć Monikę
11

CJam, 15 bajtów

rr{:X/(XX+@X*}/

Alternatywne podejście do CJam. Wypróbuj online

Wyjaśnienie

Dla każdego znaku w drugim ciągu wykonujemy dwie rzeczy.

  1. Podziel aktualny sufiks ciągu na znak, np "beeper" "e" -> ["b" "" "p" "r"]

  2. Odznacz pierwszy ciąg w tablicy, wstaw dwa znaki, a następnie ponownie dołącz do reszty tablicy ze znakiem, np "b" "ee" "eper". Ostatni ciąg to nowy przyrostek.

Sp3000
źródło
9

Siatkówka, 33 bajty

Więcej informacji o Retina.

+`(?=(.))(((.)(?<!\4.))+\n)\1
$1$2

Oczekuje to dwóch ciągów w STDIN, oddzielonych znakiem nowej linii.

Do celów zliczania każda linia przechodzi do osobnego pliku, \nnależy ją zastąpić rzeczywistym znakiem nowej linii (0x0A). Jeśli naprawdę chcesz to przetestować, wygodniej jest umieścić to w jednym pliku, w którym \npozostaje bez zmian, a następnie wywołać Retinę z -sopcją przed przekazaniem pliku.

Wyjaśnienie

(Nieaktualne ... Udało mi się pozbyć znacznika ... Zaktualizuję to później.)

Każda para linii jest podstawieniem wyrażenia regularnego (pierwsza linia wzoru, druga linia podstawienia).

^
#

To umieszcza #jako znacznik na początku ciągu wejściowego.

+`#(.*?(.))(.*\n)\2
$1$2#$3

Znajduje pierwszą literę na wejściu (za znacznikiem) odpowiadającą następnej literze, która ma zostać powielona, ​​powtarza tę literę, przesuwa znacznik za nią i upuszcza pierwszy znak drugiego ciągu. Z +`przodu nakazuje Retinie powtarzanie tej czynności, aż łańcuch przestanie się zmieniać (w tym przypadku, ponieważ drugi łańcuch jest pusty i wszystkie wymagane litery zostały zduplikowane).

#
<empty>

Na koniec oczyszczamy sznurek, upuszczając znacznik.

Martin Ender
źródło
2
Uznałem, że siatkówka będzie dobrym rozwiązaniem i miałem rację, ponieważ znalazłeś jedno. Ponadto, kiedy po raz pierwszy przejrzałem twój opis, przeczytałem koniec jako „oczyszczamy strunę, upuszczając mikrofon ”.
mbomb007
@ mbomb007 Miałem nadzieję pozbyć się „mikrofonu”, kopiując tylko pojedyncze litery, które nie mają po sobie duplikatów, ale nie mogę tego zrobić w mniej niż 33 bajty. (W historii zmian jest zepsuta wersja 28-bajtowa).
Martin Ender
@ mbomb007 FYI, udało mi się teraz usunąć znacznik, ale liczba bajtów jest nadal taka sama. Nadal wygląda to na golfa.
Martin Ender
Nawiasem
mówiąc
@ mbomb007 Tak, jestem tego świadomy. Prawdopodobnie dodam jedną po tym, jak zaimplementuję kilka ważniejszych, znakomitych funkcji.
Martin Ender
8

Python, 61

def f(s,l):b=s[:1]==l[:1];return s and-~b*s[0]+f(s[1:],l[b:])

Chciwe rekurencyjne rozwiązanie. Zapisuje, bczy pierwsza litera ciągu sjest pierwszą literą ciągu lliter, która ma zostać podwojona. Jeśli tak, weź jeden z tego listu i dołącz go do wywołania rekurencyjnego wraz z resztą s, usuwając z niego pierwszy element l. Jeśli nie b, zrób to samo, ale nie podwajaj litery i nie usuwaj z niej l.

Kod sprawdza, s[:1]==l[:1]zamiast s[0]==l[0]unikać błędu indeksu poza zakresem, gdy slub ljest pusty.

xnor
źródło
6

Prolog, 95 83 79 56 bajtów

d([A|S],H):-put(A),H=[A|T],put(A),d(S,T);d(S,H).
d(_,_).

Przykład:

d(`chameleon`,`caln`).

zwraca

cchaamelleonn

Edycja: Oszczędność 4 bajtów dzięki Oliphauntowi

Edycja2: Zapisano 20 bajtów przy użyciu przestarzałego put/1predykatu SWI-Prolog zamiast writef. Zapisano jeden bajt zastępując predykat końca rekurencji d([],_).na d(_,_).. Nie zadziała, jeśli kolejność dwóch definicji djest zamieniona, ale nie obchodzi nas to w kodzie golfowym. Zapisano kolejne 2 bajty usuwając nawias wokółH=[A|T],put(A),d(S,T)

Fatalizować
źródło
1
Nie jestem do końca pewien, dlaczego to zostało odrzucone. Może dodaj jakieś wyjaśnienie do swojego kodu?
Alex A.
1
Można zapisać cztery bajty poprzez ujednolicenie domyśle: H=[A|T]. Dlaczego by nie uczynić go bardziej czytelnym, zastępując spacje nowymi liniami?
Oliphaunt - przywróć Monikę
@Oliphaunt Dzięki za sugestię, nie widziałem tej drobnej optymalizacji po tym, jak pierwotnie zmodyfikowałem kod, aby używał klauzuli H = [A | T].
Fatalizuj
5

Python 2, 83 74 72 65 Bajtów

Nie ma tu żadnych specjalnych trików. xjest ciągiem, yjest tablicą powielonych znaków. Aby wyjaśnić, czy nie powiela się to poprawnie, pierwszy poziom wcięcia to spacja, następny to tabulator.

Edycja 1: Zapisano 9 bajtów, używając manipulacji ciągami zamiast pop ().

Edycja 2: Zapisano 2 bajty, używając -~do zwiększenia go 1.

Edycja 3: Zaoszczędzono 7 bajtów za pomocą y[:1]sztuczki, dzięki xnor za to!

def f(x,y,s=''):
 for c in x:g=y[:1]==c;s+=c*-~g;y=y[g:]
 print s

Sprawdź to tutaj.

Prawidłowo sformatowane i wyjaśnione:

def f(x,y,s=''):           # Defining a function that takes our input,
                           # plus holds a variable we'll append to.
  for c in x:              # For every character in 'x', do the following:
    g = y[:1] == c         # Get the first element from the second string, will
                           # return an empty string if there's nothing left.
                           # Thanks to xnor for this trick!
    s += c * -~g           # Since int(g) would either evaluate to 0 or 1, we
                           # use the -~ method of incrementing g to multiply
                           # the character by 1 or 2 and append it to 's'
    y = y[g:]              # Again, since int(g) would either evaluate to 0
                           # or 1, use that to cut the first value off y, or
                           # keep it if the characters didn't match.
  print s                  # Print the string 's' we've been appending to.
Kade
źródło
„Możesz założyć, że wszystkie dane wejściowe będą miały litery w tablicy (w kolejności).” To powinno zaoszczędzić sporo bajtów.
mbomb007
2
Pierwszy element możesz pobrać z możliwie pustego ciągu jako y[:1].
xnor
Teraz zdaję sobie sprawę, że nie możesz uratować tylu, ile myślałem ze względu na to, jak to robisz y=y[g:], więc „sporo” to dość przesada.
mbomb007
@ Vioz- Myślałem y[:1]==c. Czy to działa?
xnor
@ xnor Tak, dzieje się tak, jeśli wezmę zamiast tego litery, które wymagają wymiany. Dzięki!
Kade
5

Excel VBA, 110 bajtów

To mój pierwszy wpis do CodeGolf, więc mam nadzieję, że jest w porządku.

Wpisujesz słowo wejściowe w A1, a następnie litery, które chcesz zastąpić w B1, a słowo wynikowe jest wyświetlane w oknie komunikatu.

w = Cells(1, 1)
l = Cells(2, 1)
For i = 1 To Len(w)
x = Left(w, 1)
R = R + x
If InStr(l, x) > 0 Then
R = R + x
End If
w = Right(w, Len(w) - 1)
Next
MsgBox R
Wightboy
źródło
2
Jeśli VBA nie jest wrażliwe na wcięcia, możesz pozbyć się wszystkich wcięć i zaoszczędzić kilka bajtów. Myślę, że możesz także pozbyć się wszystkich miejsc po przecinkach i wokół operatorów. Należy zaoszczędzić kilka bajtów.
Pozew Fund Moniki w dniu
@QPaysTaxes Dziękujemy za edycję. Nacisnąłem rollback, żeby zobaczyć, co by to zrobiło. Nie wiesz, czy to spowodowało, że straciłeś punkty lub coś do edycji?
Wightboy
Nie, nadal mam +2, choć trochę się zdezorientowałem. Możesz chcieć ponownie wycofać; przynajmniej według trzech wysoko postawionych przedstawicieli była to dobra edycja.
Pozew Fund Moniki w dniu
@QPaysTaxes Zgadzam się, że podobała mi się edycja. Myślę, że cofnąłem się zbyt wiele razy.
Wightboy
Nie umiem powiedzieć Mobile nie wyświetla ładnie rzeczy. Ostatecznie jednak liczy się kod, a nie formatowanie.
Pozew Fund Moniki w dniu
4

Haskell, 42 bajty

(a:b)#e@(c:d)|a==c=a:a:b#d|1<2=a:b#e
a#_=a

Przykład użycia:

*Main> "coconut" # "co"
"ccooconut"
*Main> "lizard" # "iard"
"liizaarrdd"
*Main> "onomatopoeia" # "ooaoo"
"oonoomaatoopooeia"

Jak to działa:

Jeśli jeden ciąg jest pusty, wynikiem jest pierwszy ciąg. W przeciwnym razie: jeśli pierwsze znaki ciągów pasują do siebie, weź to dwa razy i dołącz rekurencyjne połączenie z ogonami ciągów. Jeśli znaki nie pasują, weź pierwszy znak pierwszego łańcucha i dołącz rekurencyjne wywołanie z ogonem pierwszego łańcucha i tym samym drugim łańcuchem.

nimi
źródło
4

Pyth, 18 17 bajtów

sm?+d.(QZqd&QhQdz

Demo na żywo.

Zapisano 1 bajt dzięki @Jakube.

Wyjaśnienie:

                z  Read the first line of input.
 m                 For each character in that line
  ?      qd&QhQ    If (?) the first char of the stretch list (`&QhQ`) 
                   and the current character are equal,
   +d.(QZ          Then double the current character and pop an element off
                   the stretch list.
               d   Otherwise, just return the same character.
s                  Join all the characters together.

Orginalna wersja:

jkm?+d.(QZqd&QhQdz

Wersja demonstracyjna na żywo dla oryginału.

kirbyfan64sos
źródło
4

JavaScript, 47 bajtów

(a,b)=>a.replace(/./g,d=>b[0]!=d?d:d+b.shift())

Korzystając z niektórych funkcji ES6.

Zboże
źródło
1
To działa prawidłowo onomatopoeia, oao?
Alex A.
1
@AlexA. Wyjścia: „oonoomaatoopooeiaa”. Oh rozumiem. Naprawimy
Cereal
Naprawdę, tak myślę. Dodano wiele postaci :(
Cereal
Zamiast b.indexOf(d)==0, spróbuj~b.search(d)
Ismael Miguel
@ IsmaelMiguel searchma zastosowanie tylko do ciągów znaków. Musiałem zmienić b na tablicę
Cereal
3

Pyth, 16 bajtów

u|pH<GJxGH>GJwz

Wypróbuj online: demonstracja

To jest dość zuchwałe. Zaletą mogą być języki oparte na stosie.

Wyjaśnienie

                   implicit: z = 1st input line, w = 2nd
u             wz   reduce, start with G = z
                   for each H in w, update G to:
        xGH          index of H in G
       h             +1
      J              store in J
    <GJ              substring: G[:J] (everything before index J)
  pH                 print substring then H (without newlines)
 |                   afterwards (actually or, but p always returns 0)
           >GJ       substring: G[J:] (everything from index J to end)
                     update G with ^
                   afterwards implicitly print the remainder G
Jakube
źródło
@isaacg Pomoc? Musi być coś krótszego ...
Jakube
I bardziej elegancki ;-)
Jakube
1
Mam go o 14-1 mniej niż CJam to najlepsze miejsce.
isaacg
3

JavaScript ES6, 47 bajtów

(w,s)=>w.replace(/./g,c=>c==s[0]?c+s.shift():c)

Zakłada, że sjest tablicą["c","a","l","n"]

Shmiddty
źródło
2

> <> (Ryby) , 68 34 bajtów

ri&:o&:&=\
l&io& /!?/
?!;20.\l!\

Możesz uruchomić go na stronie http://fishlanguage.com/playground, wprowadzając ciąg znaków jako początkowy stos (ze znakami „tj.„ Kameleon ”) i tablicę dodatkowych liter jako stos wejściowy (brak znaków„ tj. Caln).

Nie zapomnij nacisnąć przycisku Daj, aby zapełnić stos wejściowy.

r       reverses the stack
i&      reads in the first input, and stores it in the register
:o      copies the top of the stack, and outputs the top of the stack
&:&     puts register value on stack, copies it, then puts top stack into register
=       checks if the top two values are equal, if yes push 1, else push 0
?       if top value is non-zero, execute next instruction
!       skips the following instruction (unless it was skipped by the previous ?)

If yes, then we proceed on the same line
&o      puts register value on stack, and outputs it
i&      reads in the first input, and stores it in the register
l       puts length of stack on stack, then proceed to lowest line

If no, we go directly to the last line
l       As above.
?!;     If zero value (from length), then end execution
20.     Push 2 and 0 onto stack, then pop top two values, and go to that position (2,0) (i.e. next instruction is at (3,0))

EDYCJA: O połowę! :)

Fongoid
źródło
2

R 119

Na podstawie @ Alexa odpowiedzi , ten jest kilka bajtów krócej:

function(s,a){message(unlist(lapply(strsplit(s,"")[[1]],function(x){if(length(a)&x==a[1]){a<<-a[-1];c(x,x)}else x})))}

Nie golfowany:

function(s, a) {
  message(                             # Prints to output
    unlist(                            # Flattens list to vector
      lapply(                          # R's version of map
        strsplit(s,"")[[1]],           # Split vector to characters
        function (x) {
          if (length(a) & x == a[1]) { # If there are still elements in a
                                       # and there's a match
            a <<- a[-1]                # Modify a
            c(x, x)                    # And return the repeated character
          } else x                     # Otherwise just return it
        }
      )
    )
  )
}
jja
źródło
2

Perl, 73 62 59 56

Całkowicie nowe podejście daje znacznie lepsze wyniki. Mimo to założę się, że może być krótszy.

Jak zadzwonić f('coconut', ['c','o']).

sub f{($s,$a)=@_;$s=~s/(.*?)($_)/\U$1$2$2/ for@$a;lc$s}

Dla każdego znaku w tablicy znajdź pierwsze wystąpienie i zduplikuj je, a następnie zmień wszystko na wielkie. Następnie zwróć cały ciąg, przekonwertowany na małe litery.

EDYCJA: ogoliłem kilka innych postaci, pozbywając się shifti pop.


Poprzednia wersja:

sub f{join '',map{shift @{$_[0]}if s/($_[0][0])/$1$1/;$_}split //,shift}
jja
źródło
Nowa wersja nie respektuje już kolejności znaków. (BTW, „ foreachfor
Słowo
@manatwork To powinno to zrobić. I dzięki za forpodpowiedź. Teraz jest krótszy.
jja
2

Rubin, 52 47 bajtów

Rozwiązanie:

f=->(s,a){s.chars.map{|c|c==a[0]?a.shift*2:c}.join}

Przykład:

p f.call('banana', ['n','a']) # => "bannaana"

Wyjaśnienie:

Proc postaci metody, która przyjmuje ciąg jako pierwszy argument, a tablica znaków jako drugi argument. Mapuje blok na tablicę znaków w argumencie łańcuchowym, który sprawdza każdy znak względem pierwszego elementu tablicy porównawczej, a jeśli istnieje dopasowanie, usuwa pierwszy element tablicy porównawczej i podwaja go.


aktualizacja

f=->s,a{s.chars.map{|c|c==a[0]?a.shift*2:c}*''}

Brian Davis
źródło
Możesz pominąć nawiasy wokół parametrów s,a. I *''jest równoważne z .join. To 5 zaoszczędzonych bajtów, ale wciąż cię pokonałem o jeden (na razie): D
daniero
2

Perl, 51 bajtów

$s=<>;$s=~s=^.*$_=$_=,$,.=$&for split"",<>;print$,;

Dane wejściowe są dostarczane przez STDIN. Pierwsze wejście to słowo początkowe (np. chameleon), Drugie wejście to litery jako pojedynczy ciąg (np caln.).

Powyższe jest tylko zaciemnionym (czytaj „ładniejszym”) sposobem na wykonanie następujących czynności:

$word = <>;
for $letter(split "", <>) {
   $word =~ s/^.*$letter/$letter/;
   $result .= $&;
}
print $result;

Podczas przeglądania każdej litery zastępujemy od początku słowa do litery w słowie źródłowym tylko nową literą i dołączamy dopasowanie (zapisane w $&) do naszego wyniku. Ponieważ dopasowanie obejmuje literę, a następnie zostaje zastąpione literą, każda litera pojawia się dwukrotnie.

Ponieważ STDIN dołącza nowy znak linii do obu naszych danych wejściowych, gwarantujemy, że przechwycimy resztki pełnego słowa z ostatniego dopasowania, tj. Nowy znak linii.

Allen G.
źródło
2

REGXY, 24 bajty

Używa REGXY , języka opartego na podstawieniu wyrażenia regularnego. Przyjmuje się, że wejście jest słowem początkowym i tablicą oddzieloną spacją (np. „Calele kameleona”).

/(.)(.* )\1| /\1\1\2/
//

Program działa poprzez dopasowanie znaku w pierwszym ciągu do pierwszego znaku po spacji. Jeśli to pasuje, znak jest powtarzany w podstawieniu, a znak w tablicy jest usuwany (cóż, nie jest dołączany z powrotem do łańcucha). Przetwarzanie przechodzi do drugiej linii, która jest tylko wskaźnikiem z powrotem do pierwszej linii, co powoduje, że przetwarzanie powtarza się na wyniku poprzedniego podstawienia. Ostatecznie po spacji nie będzie żadnych znaków, w którym to momencie dopasuje się druga gałąź alternacji, usuwając końcowe spacje z wyniku. Wyrażenie regularne nie będzie wtedy pasować, przetwarzanie zostanie zakończone, a wynik zostanie zwrócony.

Jeśli to pomoże, iteracyjne kroki wykonania są następujące:

chameleon caln
cchameleon aln
cchaameleon ln
cchaameleonn n
cchaameleonn  (with trailing space)
cchaameleonn

Program kompiluje się i wykonuje poprawnie za pomocą przykładowego interpretera w powyższym linku, ale rozwiązanie może być nieco bezczelne, ponieważ opiera się na założeniu niejasności specyfikacji języka. Specyfikacja określa, że ​​pierwszy token w każdym wierszu (przed /) działa jako etykieta, ale założenie jest takie, że pusty wskaźnik-wskaźnik wskazuje z powrotem na pierwsze polecenie w pliku z pustą etykietą (lub innymi słowy, że „null” jest prawidłową etykietą). Mniej bezczelnym rozwiązaniem byłoby:

a/(.)(.* )\1| /\1\1\2/
b//a

Co odpowiada 27 bajtom

Jarmex
źródło
1

JavaScript ES6, 72 bajty

(s,a,i=0,b=[...s])=>a.map(l=>b.splice(i=b.indexOf(l,i+2),0,l))&&b.join``

Jest to anonimowa funkcja, która przyjmuje 2 parametry: słowo początkowe jako ciąg znaków oraz znaki, które rozciągają się jako tablica. Nieskluczony kod, który używa ES5 i testuje interfejs użytkownika poniżej.

f=function(s,a){
  i=0
  b=s.split('')
  a.map(function(l){
    i=b.indexOf(l,i+2)
    b.splice(i,0,l)
  })
  return b.join('')
}

run=function(){document.getElementById('output').innerHTML=f(document.getElementById('s').value,document.getElementById('a').value.split(''))};document.getElementById('run').onclick=run;run()
<label>Starting word: <input type="text" id="s" value="onomatopoeia" /></label><br />
<label>Leters to duplicate: <input type="text" id="a" value="oao"/></label><br />
<button id="run">Run</button><br />Output: <output id="output"></output>

NinjaBearMonkey
źródło
1

Python 2, 77

def f(x,y,b=''):
 for i in x:
    try:
     if i==y[0]:i=y.pop(0)*2
    except:0
    b+=i
 print b

Zadzwoń jako:

f('onomatopoeia',['o','a','o'])

Mogłem mieć strasznie błędną liczbę bajtów ... Używa kombinacji spacji i tabulatorów.

Rozpad beta
źródło
1

rs, 39 bajtów

Więcej informacji o rs.

Istnieje już odpowiedź Retina, ale myślę, że ta metoda jest nieco inna. Zostały one również utworzone osobno: kiedy zacząłem nad tym pracować, ta odpowiedź nie została opublikowana.

Poza tym ten i tak jest o 6 bajtów dłuższy. :)

#
+#(\S)(\S*) ((\1)|(\S))/\1\4#\2 \5
#/

Demo na żywo i pakiet testowy.

kirbyfan64sos
źródło
Naprawdę podoba mi się ten przełącznik debugowania w twoim tłumaczu.
Dennis
@Dennis Thanks!
kirbyfan64sos
1

JavaScript, 92 znaki

function f(s,c){r="";for(i=0;i<s.length;i++){r+=s[i];if(c.indexOf(s[i])>-1)r+=s[i]}return r}

Wersja nieobjawiona:

function stretch(str, chars) {
    var ret = "";
    for(var i = 0; i < str.length; i++) {
        ret += str[i];
        if(chars.indexOf(str[i]) > -1) {
            ret += str[i];
        }
    }
    return ret;
}
SirPython
źródło
1

R, 136 128 122 bajtów

function(s,a){p=strsplit(s,"")[[1]];for(i in 1:nchar(s))if(length(a)&&(x=p[i])==a[1]){p[i]=paste0(x,x);a=a[-1]};message(p)}

Spowoduje to utworzenie nienazwanej funkcji, która przyjmuje ciąg znaków i wektor znaków jako dane wejściowe i drukuje ciąg znaków do STDOUT. Aby to nazwać, nadaj mu nazwę.

Niegolfowane + wyjaśnienie:

f <- function(s, a) {
    # Split s into letters
    p <- strsplit(s, "")[[1]]

    # Loop over the letters of s
    for (i in 1:nchar(s)) {

        # If a isn't empty and the current letter is the first in a
        if (length(a) > 0 && p[i] == a[1]) {

            # Replace the letter with itself duplicated
            p[i] <- paste0(p[i], p[i])

            # Remove the first element from a
            a <- a[-1]
        }
    }

    # Combine p back into a string and print it
    message(p)
}

Przykłady:

> f("coconut", c("c","o"))
ccooconut

> f("onomatopoeia", c("o","a","o"))
oonomaatoopoeia

Zaoszczędź 8 bajtów dzięki MickeyT i kolejne 3 dzięki Jja!

Alex A.
źródło
Możesz użyć, cat(p,sep='')aby
przesłać
@MickyT: Nie myślałem o tym! Dzięki, zredagowane. :)
Alex A.
1
W rzeczywistości message(p)jest krótszy.
jja
@jja: Nie wiedziałem o messagetym, to niesamowite! Dzięki! Edytowane, aby użyć Twojej sugestii.
Alex A.
1

Bash + sed, 51

sed "`sed 's/./s!^[^&]*&!\U\&&!;/g'<<<$1`s/.*/\L&/"

Dane wejściowe ze standardowego wejścia; znaki, które należy podwoić jako pojedynczy argument:

$ echo chameleon | strtech caln
cchaamelleonn

Działa to poprzez zbudowanie programu sed z, $2a następnie wykonanie go przeciwko $1. Program sed zastępuje pierwsze wystąpienie każdej litery zastępczej dwiema kopiami jej wielkiej wersji, a na końcu zmniejsza całą partię. W powyższym przykładzie wygenerowany program sed to

s!^[^c]*c!\U&C!;s!^[^a]*a!\U&A!;s!^[^l]*l!\U&L!;s!^[^n]*n!\U&N!;s/.*/\L&/

ładnie wydrukowane:

# if only sed had non-greedy matching...
s!^[^c]*c!\U&C!
s!^[^a]*a!\U&A!
s!^[^l]*l!\U&L!
s!^[^n]*n!\U&N!
s/.*/\L&/

Używam wielkich liter do oznaczania znaków przetworzonych do tej pory; pozwala to uniknąć ponownego podwojenia postaci, które zostały już podwojone, lub zastosowania podwojenia wcześniejszego niż poprzedni.

Wcześniejsza wersja, przed wyjaśnieniem, że kolejność listy zamienników jest znacząca (44 znaki):

sed "`sed 's/./s!&!\U&&!;/g'<<<$1`s/.*/\L&/"
Toby Speight
źródło
Błędny. strtech na <<< bananawyprowadza „baannana”, ale najpierw wystąpienie „n” powinno zostać podwojone, a dopiero potem wystąpienie „a”.
manatwork
W takim razie źle zrozumiałem pytanie; nie było jasne, że kolejność oznaczała, że ​​wcześniejsze litery nie powinny być podwojone, po prostu, że będziesz w stanie znaleźć kolejną do podwojenia. Zastanowię się nad alternatywą, która spełnia ten nowy wymóg.
Toby Speight
Nie ma problemu, ani nie udało mi się tego za pierwszym razem. Sugeruję usunąć odpowiedź podczas myślenia (możesz cofnąć usunięcie w dowolnym momencie), aby uniknąć szansy na negatywne rozpatrzenie.
manatwork
@manatwork: Poprosiłem pytającego o wyjaśnienia i podałem alternatywną odpowiedź, która spełnia tę lekturę zasad (ale kosztowało mnie to 7 znaków)
Toby Speight
0

Python, 53 92 bajty

Stwierdziłem, że moje rozwiązanie ma tę samą długość zarówno w Pythonie 2, jak i 3.

EDYCJA: Człowieku, naprawienie tego przypadku przy wykonywaniu wielu zamian tej samej litery (wciąż przy użyciu tej samej metody) zajęło trochę pracy.

Python 2:

Wypróbuj tutaj

def f(s,t):
 for c in t:s=s.replace(c,'%',1)
 print s.replace('%','%s')%tuple(x*2for x in t)

Python 3:

s,*t=input()
for c in t:s=s.replace(c,'%',1)
print(s.replace('%','%s')%tuple(x*2for x in t))
mbomb007
źródło
0

Mathematica, 66 bajtów

""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

Przykład:

In[1]:= f = ""<>Fold[Most@#~Join~StringSplit[Last@#,#2->#2<>#2,2]&,{"",#},#2]&

In[2]:= f["banana", {"n", "a"}]

Out[2]= "bannaana"
alephalpha
źródło
0

Lua, 76 78 76 75 58 53 bajtów

Nowe, całkowicie przerobione rozwiązanie z pomocą wieselkatze i SquidDev! chodźcie chłopaki, możemy pokonać bzdury: P

function f(a,b)print((a:gsub("["..b.."]","%1%1")))end

Wyjaśnienie nadchodzi jutro. Wypróbuj tutaj.


Oryginalne rozwiązanie: zaoszczędzono 2 bajty dzięki @ kirbyfan64sos!

Lua jest dość okropnym językiem do gry w golfa, więc myślę, że dobrze sobie z tym poradziłem.

function f(x,y)for i=1,#x do g=y:sub(i,i)x=x:gsub(g,g..g,1)end print(x)end

Objaśnienie kodu wraz z wersją bez golfa:

function f(x,y) --Define a function that takes the arguements x and y (x is the string to stretch, y is how to stretch it)
  for i=1,#x do --A basic for loop going up to the length of x
    g=y:sub(i,i) -- Define g as y's "i"th letter
    x=x:gsub(g,g..g,1) --Redefine x as x with all letter "g"s having an appended g after them, with a replace limit of 1.
  end
  print(x)
end

Wypróbuj tutaj. (Nieaktualny kod, ale ta sama koncepcja, tylko mniej golfa, zaktualizuje jutro)


źródło
Dodano dwa bajty, ponieważ musiałem naprawić usterkę, która zastąpiłaby całą literę zdefiniowaną w tablicy ich duplikatami.
Myślę, że możesz usunąć nowe wiersze po function f(x,y)i po print(x), oszczędzając ci dwa bajty.
kirbyfan64sos