Ovviamente sono ellissi.

Ispirato da un messaggio di chat .

La tua sfida

Dato un elenco o uno spazio o una stringa di parole separate da virgole, i puntini di sospensione li identificano.

Per ellissisessieses-ify una parola:

1. Inizia con la parola.
2. Aggiungi la prima lettera della parola originale alla fine.
3. Aggiungi 2 dell'ultima lettera della parola originale alla fine.
4. Aggiungi la penultima lettera della parola originale alla fine.
5. Aggiungi la prima lettera della parola originale alla fine.
6. Aggiungi l'ultima lettera della parola originale alla fine.
7. Ripeti i passaggi 5 e 6 una volta.
8. Hai finito!

Puoi presumere:

• Le parole di input saranno solo alfanumeriche
• Input e output possono essere una stringa o un elenco separati da spazi
• L'input conterrà solo parole
• Le parole saranno lunghe almeno 2 lettere
• L'input corrisponderà alla regex /^[a-z0-9]{2,}( [a-z0-9]{2,})*$/i
• Puoi avere un formato di input e output diverso
• E c'è dell'altro...

Casi test:

ellipsis -> ellipsisessieses
goat -> goatgttagtgt
covfefe -> covfefeceefcece
programmer5000 -> programmer5000p000p0p0
up vote down goat -> upuppuupup voteveetveve downdnnwdndn goatgttagtgt
it is golf yo -> itittiitit isissiisis golfgfflgfgf yoyooyyoyo
crossed out 44 is still 44 -> crossedcddecdcd outottuotot 4444444444 isissiisis stillslllslsl 4444444444

Shorteststtsstst answerarrearar ininniinin bytesbssebsbs winswssnwsws!

JavaScript (ES6), 58 57 byte

NB: Questo risulta usare lo stesso trucco di Jonathan Allan in questa risposta di Jelly (anche se ho notato dopo la pubblicazione).

Salvato 1 byte grazie a Jonathan Allan

Funziona su matrici di stringhe.

s=>s.map(s=>s+'01120101'.replace(/./g,n=>s.substr(-n,1)))

Casi test

let f =

s=>s.map(s=>s+'01120101'.replace(/./g,n=>s.substr(-n,1)))

console.log(f(['ellipsis']))
console.log(f(['goat']))
console.log(f(['covfefe']))
console.log(f(['programmer5000']))
console.log(f(['up', 'vote', 'down', 'goat']))
console.log(f(['it', 'is', 'golf', 'yo']))
console.log(f(['crossed', 'out', '44', 'is', 'still', '44']))

Gelatina ,  13 12  11 byte

⁽×ʠb3’ịṭµ€K

Un programma completo che prende un elenco di elenchi di caratteri e stampa l'output separato da spazio.

Provalo online!

Come?

⁽×ʠb3’ịṭµ€K - Main link: list of lists of characters e.g. ["this","is","it"]
        µ€  - for each word in the input:            e.g. "this"
⁽×ʠ         -   base 250 literal 5416                     5416
   b3       -   converted to base 3                       [2,1,1,0,2,1,2,1]
     ’      -   decrement                                 [1,0,0,-1,1,0,1,0]
      ị     -   index into the word                       "tssitsts"
       ṭ    -   tack to the word                          ["this",["tssitsts"]]
          K - join the results with spaces                ["this",["tssitsts"]," is",["issiisis"]," it",["ittiitit"]]
            - implicit print                              thistssitsts isissiisis itittiitit

In alternativa, è possibile un elenco di parole in un elenco di parole in 11 byte :

⁽×ʠb3’ị;@µ€

⁽×ʠb3’può anche essere sostituito da 4,⁵Bj-per lo stesso conteggio byte
( [4,10]in binario è [[1,0,0],[1,0,1,0]]unito da -1is [1,0,0,-1,1,0,1,0]).

05AB1E , 12 byte

εD•Lz•3вÍèJ«

Provalo online!

Spiegazione

ε              # apply on each word in input
 D             # duplicate the word
  •Lz•         # push the base-255 compressed number 5416
      3в       # convert to a list of base-3 digits (yields [2, 1, 1, 0, 2, 1, 2, 1])
        Í      # subtract 2 from each (yields [0, -1, -1, -2, 0, -1, 0, -1])
         è     # index into the word with these numbers
          J    # join to string
           «   # append to the original word

Retina , 52 49 byte

3 byte grazie ad Arnauld.

(\w)(\w+)
$1$2$1
(.)(.)(.)\b
$1$2$3$2$2$1$3$2$3$2

Provalo online!

Python 2 , 56 byte

lambda s:[i+i[0]+i[-1]*2+i[-2]+(i[0]+i[-1])*2for i in s]

Provalo online!

Penso che questo sia il mio FGITW più veloce e non è nemmeno così impressionante. : P

Python 3 , 60 byte

lambda k:[x+''.join(x[-int(i)]for i in"01120101")for x in k]

Provalo online!

Carbone , 20 byte

Ｆ⪪Ｓ «ι↑Ｅ”o∨↙8”§ι±Ｉκ→

Provalo online! Il collegamento è alla versione dettagliata del codice. Mi è capitato di leggere la risposta di @ Arnauld solo dopo aver codificato questo, ma questo è fondamentalmente una porta di esso. Spiegazione:

Ｆ   «                   Loop over
  Ｓ                     Input string
 ⪪                       Split at spaces
     ι                  Print the word
        ”o∨↙8”          Compressed string 01120101
       Ｅ                Map over each character
                 Ｉκ     Cast character to integer
                ±       Negate
              §ι        Circularly index into word
      ↑                 Print array upwards, prints each element rightwards
                    →    Move right

sed, 46 byte

s/^\(\(.\).*\(.\)\(.\)\)$/\1\2\4\4\3\2\4\2\4/g

Provalo online!

JavaScript (ES6), 74 60 byte

s=>s.map(s=>s+(a=s[l=s.length-1],b=s[0])+a+a+s[l-1]+b+a+b+a)

Prende l'input come un array e genera un array.

-9 byte grazie a Programmer5000

Casi test:

let f=

s=>s.map(s=>s+(a=s[l=s.length-1],b=s[0])+a+a+s[l-1]+b+a+b+a)

console.log(JSON.stringify(f(['ellipsis']))) // ellipsisessieses
console.log(JSON.stringify(f(['goat']))) // goatgttagtgt
console.log(JSON.stringify(f(['covfefe']))) // covfefeceefcece
console.log(JSON.stringify(f(['programmer5000']))) // programmer5000p000p0p0
console.log(JSON.stringify(f(['up', 'vote', 'down', 'goat']))) // upuppuupup,voteveetveve,downdnnwdndn,goatgttagtgt
console.log(JSON.stringify(f(['it', 'is', 'golf', 'yo']))) // itittiitit,isissiisis,golfgfflgfgf,yoyooyyoyo
console.log(JSON.stringify(f(['crossed', 'out', '44', 'is', 'still', '44']))) // crossedcddecdcd,outottuotot,4444444444,isissiisis,stillslllslsl,4444444444

Mathematica, 89 byte

((f[a_]:=#~StringTake~a;k=#<>(q=f@1)<>(w=f[-1])<>w<>f@{-2}<>q<>w<>q<>w)&/@StringSplit@#)&

Pyth , 17 byte

Usa lo stesso trucco della risposta di @ Jonathan .

m+dsm@dttkj5416 3

Provalo qui! oppure Dai un'occhiata alla suite di test (dai un po 'di tempo).

Porta della mia soluzione Python, 19 byte 18 byte :

m+dsm@d_k+0j1144 3

Dyalog APL, 51 49 byte

Richiede ⎕ML←3

∊{⍺,' ',⍵}/{S←1,L←≢⍵⋄⍵,⍵[∊S(L-0 1)S S]}¨' '(≠⊂⊢)⍞

-9 byte grazie a @ Adám in chat!

Provalo online!

Paradoc (v0.2.10), 13? byte (CP-1252)

µ96Qó3BÌDX=v+

Provalo online!

Prende un elenco di parole e genera un elenco di parole in pila.

Una piccola variazione sul trucco base-3. Forse è tempo di lavorare sul mio compressore da 250 qualunque.

Spiegazione:

μ             .. Map the following block over each word (the block is
              .. terminated by }, but that doesn't exist, so until EOF)
              .. (The word is on the stack now.)
 96Qó         .. 96 * 26 (Q in base 26) = 2496, a hack to prevent us from
              .. needing a space to separate this from the following number.
     3B       .. Convert 2496 to base 3 to get [1,0,1,0,2,1,1,0]
       ÌD     .. Negate and reverse to get [0,-1,-1,-2,0,-1,0,-1]
         X    .. Push the loop variable: the word being mapped over
          =v  .. Index, vectorize; map over the indices by indexing them
              .. into the word
            + .. Concatenate with the original word

(Domanda di conteggio dei byte: ora che sto dimostrando questo in TIO, prende un elenco di parole nello stack e risulta in un elenco di parole nello stack, ma non puoi davvero fare molto con quell'elenco di parole a meno che non chiuda il blocco avviato da µ. Devo contare quel controvento di chiusura?)

Wolfram Language / Mathematica, 66 byte

StringJoin[StringSplit[#,""]/.{a_,___,b_,c_}:>{#,a,c,c,b,a,c,a,c}]&

L'ho appena montato molto velocemente, potrebbe avere un piccolo miglioramento qui o là.

Perl 5 , 55 49 + 1 (-a) = 56 50 byte

usato un trucco dal post di @ Arrnauld per salvare un paio di byte

say map$_.'01120101 '=~s/\d/substr$_,-$&,1/egr,@F

Provalo online!

Carbone , 38 30 byte

-8 byte grazie solo a ASCII.

Ｆ⪪Ｓ «ι§ι⁰ײ§ι±¹§ι±²×²⁺§ι⁰§ι±¹ 

Provalo online!Il collegamento è alla versione dettagliata.

Nota lo spazio finale.

Java 8, 117 byte

a->{int i=0,l;for(String s:a){char c=s.charAt(0),d=s.charAt(l=s.length()-1);a[i++]+=""+c+d+d+s.charAt(l-1)+c+d+c+d;}}

Prende l'input come array String e ha modificato questo array originale invece di restituirne uno nuovo per salvare i byte.

Molto probabilmente si può giocare a golf ancora ..

Spiegazione:

Provalo qui.

a->{                          // Method with String-array as parameter and no return-type
  int i=0,                    //  Index-integer (starting at 0)
      l;                      //  Length-integer which we use multiple times
  for(String s:a){            //  Loop over the input array
    char c=s.charAt(0),       //   The first character of the word
         d=s.charAt(          //   The last character of the word
            l=s.length()-1);  //    and set `l` at the same time to `length()-1`
    a[i++]+=                  //   Append to the current value in the array:
      ""                      //    String so the characters aren't appended as integers
      +c                      //    + the first character
      +d+d                    //    + two times the last character
      +s.charAt(l-1)          //    + the single-last character
      +c+d+c+d;               //    + the first + last character two times
  }                           //  End of loop
}                             // End of method

C # (.NET Core) , 106 byte

n=>{for(int i=0,x;i<n.Length;){var h=n[i];x=h.Length-1;char y=h[0],j=h[x];n[i++]=h+y+j+j+h[x-1]+y+j+y+j;}}

Provalo online!

Funzione lambda che accetta l'input come array di stringhe e modifica l'array originale per l'output