[Question]
  [
Your task is simple, just remove the odd indices and double the even indices
## Example
the input is `Hello, World!` and we get indices
```
H e l l o , _ W o r  l  d  !
1 2 3 4 5 6 7 8 9 10 11 12 13
```
and remove the odd indices
```
el,Wrd
```
Double!
```
eell,,WWrrdd
```
and you are done
1-Indexing
## Test cases
```
abcdef => bbddff
umbrella => mmrrllaa
looooooooong text => ooooooooooggttxx
abc => bb
xkcd => kkdd
Hello, World! => eell,,WWrrdd
D => <empty>
KK => KK
Hi => ii
odd_length! => dd__eegghh
<empty> => <empty>
```
The input can be list if you want.
  
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 8 bytes
```
,,[..,,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fRydaT09HJ/b///yUlPic1Lz0kgxFAA "brainfuck – Try It Online")
[Answer]
# [convey](http://xn--wxa.land/convey/), 8 bytes
*-1 thanks to Wheat Wizard!*
```
v2{
0"!}
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoidjJ7XG4wXCIhfSIsInYiOjEsImkiOiInSGVsbG8sIFdvcmxkIScifQ==)
[![example run](https://i.stack.imgur.com/px7Oo.gif)](https://i.stack.imgur.com/px7Oo.gif)
The 0 and 2 loop around, applying themselves to the input via `!` (take), thus duping the element 0 or 2 times.
[Answer]
# [J](http://jsoftware.com/), 8 bytes
```
#~0 2$~#
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/lesMFIxU6pT/a3KlJmfkK6QpqHuk5uTk6yiE5xflpCiqw4UrspNT1P8DAA "J – Try It Online")
* `0 2$~#` Repeat the pattern `0 2` for the length of the string:
```
Hello, World
020202020202
```
* `#~` Use that mask to "copy" the characters: zeros get deleted, twos get doubled:
```
eell,,WWrrdd
```
[Answer]
# [R](https://www.r-project.org/), ~~35~~ ~~34~~ 32 bytes
*Edit: -1 byte thanks to Giuseppe*
```
function(x)rep(x,`[<-`(x,0:1*2))
```
[Try it online!](https://tio.run/##jc@9TsMwFAXgPU9hymJXqQRMCLWdGKiyFmVgSJPca8eKfyrrBpmnD2YAV0z2YulY35FPWAPazgN0MJgOP91hlYsbSXvHowh45bG@fOx3l3Q/vDxun4RYtaOzfyf5zP9ZvqTw7E@O@KYfRkC5EUKwe3Y4smEAkLIqsosdAhrTZ21tCCnoy7zxv8cpRhgpF/29eKWIYqxKx9wuKUNxHiGreQYoc29puq9Z64OBu1yAKa7rtg2htOg14z3aK30dy1zTZNg0hZ/W2WhdZn5ig07RdDMzZR2iUtNUrd8 "R – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
y2•
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJ5MuKAoiIsIiIsInVtYnJlbGxhIl0=)
Vyxal has a better built-in for this than Jelly.
```
y2•     Full Program
y       Uninterleave; push a[::2] and a[1::2]
 2•     Repeat each character twice
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), 4 bytes
```
Ḋm2Ḥ
```
[Try It Online!](https://jht.hyper-neutrino.xyz/tio#WyIiLCLhuIptMuG4pCIsIiIsIiIsWyJ1bWJyZWxsYSJdXQ==)
```
Ḋm2Ḥ    Main Link
Ḋ       Remove the first character
 m2     Return every other character
   Ḥ    Double. This turns ["a", "b"] into ["aa", "bb"], which
        is not the correct format for a Jelly string, but displays
        correctly when printed.
```
[Answer]
# [Python](https://www.python.org), 37 bytes
```
lambda a:"".join(x*2for x in a[1::2])
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3VXMSc5NSEhUSrZSU9LLyM_M0KrSM0vKLFCoUMvMUEqMNrayMYjWhinUKijLzSjTSNJRKc5OKUnNyEpU0NbnggvkpKfE5qXnpJRmKQHGIngULIDQA)
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
Ṙ2Ċ2t
```
[Try it online!](https://tio.run/##yygtzv7//@HOGUZHuoxK/v//75Gak5OvoxCeX5SToggA "Husk – Try It Online")
### Explanation
```
Ṙ2Ċ2t
    t   drop first char
  Ċ2    take every 2-nd char
Ṙ2      repeat each char 2 times
```
[Answer]
# [ayr](https://github.com/ZippyMagician/ayr), ~~9~~ 8 bytes
Using Jonah's J method gets me -1 byte
```
]#0 2$`#
```
I have the advantage of `#`'s args being swapped compared to J, but unfortunately monadic 2-trains are not hooks like in J.  
Old answer:
```
:,_2]/,@:
```
[Try it!](https://zippymagician.github.io/ayr#Zjo@/XSMwIDIkYCM@/PWYiICdIZWxsbywgV29ybGQhJyAnYWJjZGVmJyAndW1icmVsbGEn//)
# Explained
`:` is partial application (K-style train)
```
     ,@:   Zip-self with concatenation
 _2]/      Split into groups of two, take right element
,          Flatten
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 29 bytes
```
x=>x.replace(/.(.?)/g,'$1$1')
```
[Try it online!](https://tio.run/##PYzNTsQgFEb3PEVNJikY7Ni1tm6MmaRLF102FC4US6FSxjAxPnuF8YfN/e75uOeNfbCNe72GO@sE7LLZY9PGysNqGAd8rHD1RI6Klof6UJdkf0Ae3s/aAy7lVpL0kYkXbeD1Yjm@p6VhQdv6WvwacHVLiqYt8kwiPFBGR9K0n9zZzRmojFM4ISoxI@SL7GzkAmQ@GUchpETnZfRgDMtoWbxPkSHj/p5VRYAYcvvPnFIhxIiS60eE4sxFjvMsBDolnaNF77wRN5lCApT2vfepfc7kEZY1XFrUdXnrOnTSOWiNnBCDAavCdD1N2wCg1DR9Aw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Factor](https://factorcode.org/) + `sequences.repeating`, 19 bytes
```
[ <odds> 2 repeat ]
```
Get the odd-indexed elements then repeat them twice.
[![enter image description here](https://i.stack.imgur.com/jVlhQ.gif)](https://i.stack.imgur.com/jVlhQ.gif)
[Answer]
# Excel, 46 bytes
```
=CONCAT(REPT(MID(A1,SEQUENCE(2^15,,2,2),1),2))
```
Input is in cell `A1`. Output is wherever the formula is.
Working from the inside out:
* `SEQUENCE(2^15,,2,2)` creates an array of even numbers from 2 to 32,768. This is the [limit](https://support.microsoft.com/en-us/office/excel-specifications-and-limits-1672b34d-7043-467e-8e27-269d656771c3) for how many characters can be in a cell so it's the limit of the input.
* `MID(A1,SEQUENCE(~),1)` pulls out all the even-index characters one at a time.
* `REPT(MID(~),2)` doubles all those characters.
* `CONCAT(REPT(~))` combines them all into a single string.
[![Screenshot](https://i.stack.imgur.com/oWHG9.png)](https://i.stack.imgur.com/oWHG9.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ιθºS
```
I/O as a list of characters.
[Try it online](https://tio.run/##yy9OTMpM/f//3M5zOw7tCv7/P1rJQ0lHKRWIc6A4H4hBUAGIw6H8IqhcChArKsUCAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn1l8P9zO8/tOLQr@L@Xzv/EpOSU1DSu0tykotScnESunHwYyEtXKEmtKOECquCqyE5O4fIAKsjXUQjPL8pJUeRy4fL25vLI5MpPSYnPSc1LL8lQBAA).
**Explanation:**
```
ι     # Uninterleave the (implicit) input-list into two parts
      #  e.g. ["a","b","c","d","e","f"] → [["a","c","e"],["b","d","f"]]
 θ    # Only leave the last/second part
      #  → ["b","d","f"]
  º   # Mirror/double each character
      #  → ["bb","dd","ff"]
   S  # Convert the list of strings to a flattened list of characters
      #  → ["b","b","d","d","f","f"]
      # (after which it is output implicitly as result)
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 10 bytes
```
.(.?)
$1$1
```
[Try it online!](https://tio.run/##K0otycxL/P9fT0PPXpNLxVDF8P//xKTklNQ0rtLcpKLUnJxErpx8GMhLVyhJrSjhAqrgqshOTuHyACrI11EIzy/KSVHkcuHy9ubyyOTKT0mJz0nNSy/JUAQA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: Port of @l4m2's JavaScript answer. In Retina 1 you can write `2*$1` for the same byte count.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
⭆Ｓ×ι⊗﹪κ²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaHjmFZSWQLgamjoKIZm5qcUamToKLvmlSTmpKRq@@SmlOfka2ToKRpogYP3/v0dqTk6@jkJ4flFOiiLXf92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 Ｓ          Input as a string
⭆           Map over characters and join
   ι        Current character
  ×         Repeated by
      κ     Current index
     ﹪      Modulo
       ²    Literal integer `2`
    ⊗       Doubled
```
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 9 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
```
⊢/˜≠⥊0‿2˙
```
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oqiL8uc4omg4qWKMOKAvzLLmQoKUyDihpAgKCjiiqIty5wrYMOXwqwp4oiYPeKKlOKKoikKPijiiqLii4jCt0Ygwq8x4oaTwrfiipEnPSfiirhTKcKoKEArMTApIFMgImFiY2RlZiA9PiBiYmRkZmYKdW1icmVsbGEgPT4gbW1ycmxsYWEKbG9vb29vb29vb25nIHRleHQgPT4gb29vb29vb29vb2dndHR4eAphYmMgPT4gYmIKeGtjZCA9PiBra2RkCkhlbGxvLCBXb3JsZCEgPT4gZWVsbCwsV1dycmRkCkQgPT4gPGVtcHR5PgpLSyA9PiBLSwpIaSA9PiBpaQpvZGRfbGVuZ3RoISA9PiBkZF9fZWVnZ2hoCiA9PiA8ZW1wdHk+Ig==)
Uses Jonah's J idea.
# [BQN](https://mlochbaum.github.io/BQN/), 10 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
```
2/1⊑˘⌊‿2⊸⥊
```
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAgMi8x4oqRy5jijIrigL8y4oq44qWKCgpTIOKGkCAoKOKKoi3LnCtgw5fCrCniiJg94oqU4oqiKQo+KOKKouKLiMK3RiDCrzHihpPCt+KKkSc9J+KKuFMpwqgoQCsxMCkgUyAiYWJjZGVmID0+IGJiZGRmZgp1bWJyZWxsYSA9PiBtbXJybGxhYQpsb29vb29vb29vbmcgdGV4dCA9PiBvb29vb29vb29vZ2d0dHh4CmFiYyA9PiBiYgp4a2NkID0+IGtrZGQKSGVsbG8sIFdvcmxkISA9PiBlZWxsLCxXV3JyZGQKRCA9PiA8ZW1wdHk+CktLID0+IEtLCkhpID0+IGlpCm9kZF9sZW5ndGghID0+IGRkX19lZWdnaGgKID0+IDxlbXB0eT4i)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 28 bytes
```
f=([,y,...z])=>y?y+y+f(z):''
```
[Try it online!](https://tio.run/##PYxNbsMgEIX3nGK6MiiUAzQi3aRSJB/AiyRKsPkxNTYWppGdqmd3IVU6QsOb7828T3ETUxPsGF8HL9WqeXr4SBfKGLufCd8t78tm2Wh8J29FsUbgcEWibqTSwHdQ11Jqjb76OijnREZ9H0KSAjn/rMFAVHPM7j/zxsQ4zznrLwjNXSOz7Dop0SHFeQqVD06@ZKoSoLSqQkjuPhNUlvkrS3SwWViLvJQXpwYT28dNmi5KGdO26MpisD0mbBqdjbg4DQVhvRixy4vuifNQELJFkWkfPkTTYny0FNSZZOsbATR@mLxTzHmDFXAOGltCHz3d/ZDt@gs "JavaScript (Node.js) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) -p, 14 bytes
```
s/.(.?)/$1$1/g
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX09Dz15TX8VQxVA//f//xKTklNQ0rtLcpKLUnJxErpx8GMhLVyhJrSjhAqrgqshOTuHyACrI11EIzy/KSVHkcuHy9ubyyOTKT0mJz0nNSy/JUPyXX1CSmZ9X/F@3AAA "Perl 5 – Try It Online")
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 10 bytes
```
(2*2!!#:)#
```
[Try it online!](https://ngn.codeberg.page/k#eJxlkFFPgzAUhd/vr2DMB2dgRGI0Ad3THpbwA/awLBu0l9JQ6Czd0sXob7e1Q6fyQO45597T5Kuz2/QunUym2WwKoLO3m835Q2V1EAQm38s2v93XJRe5yc+5mm3fQW/CsiIU6zAPq4rSug63zjx2lUIhSmt3nVJ2Kn0g5Pj1LNBotN34tiRjWhvjN23vV6lXpiXUyral1BsrWy+jYC2VoBOboNVRtF4rddmIwqW1/XJR2NH+/CW3gnMvJKU7gT3TjSuxYofIWNP41Bck0Gh9GLIkIZIik6KeD7okLRrSlD3DOZFd8nrEQXPZD0n6cJ8+PiUKO3nC2D4Q855ygkNc9jSm8lgJjHWDMZ6wHzMAzzF4WQQeJIwMnTVChH/8XPoXoOvyReC4udGBg1/MnHsNDZbOecbuoM8LKAqnigJW3A2cwxUp5/yggsvN1fknfze9SQ==)
* `(...)#` set up a filter/replicate, where the code in `(...)` is run on the (implicit) input and returns a list of numbers. for each such number, that many copies of the corresponding input item will be returned.
* `(2*2!!#:)` return a sequence like `0 2 0 2 ... 0 2` that matches the length of the input. this removes items at even indices (0-based), and doubles those at odd indices
[Answer]
# [Uiua](https://www.uiua.org/), 7 bytes
```
▽↯△,0_2
```
[Try it online!](https://www.uiua.org/pad?src=ZiDihpAg4pa94oav4pazLDBfMgoKZiAiSGVsbG8sIFdvcmxkISI=)
```
▽↯△,0_2    input: a string
  ↯△,0_2    [0, 2] cycled to the length of the input:
      0_2      [0, 2]
   △,         shape of the input ([length])
  ↯            reshape [0, 2] to the shape [length]
▽           keep; delete chars at 0s and duplicate at 2s
```
[Answer]
# [Haskell](https://www.haskell.org/), 23 bytes
```
f(a:b:c)=b:b:f c
f _=[]
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfm5iZp2CrkJlXklqUmFyikPY/TSPRKskqWdM2CUilKSRzpSnE20bH/v/vAVSfr6MQnl@Uk6IIAA "Haskell – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 53 bytes
```
func[s][foreach c extract/index s 2 2[prin c prin c]]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85ujg2Oi2/KDUxOUMhWSG1oqQoMblEPzMvJbVCoVjBSMEouqAoMw8oBaFiY/@nKSh5pObk5OsohOcX5aQoKv0HAA "Red – Try It Online")
`extract/index s 2 2` says "get every other element of `s` starting at index 2" (keeping in mind Red is 1-indexed). Then print each of those elements twice.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 35 bytes
```
f(char*c){for(;*c++;c++)c[-1]=*c;}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpJqU1ySkpmvl2H3P00jOSOxSCtZszotv0jDWitZW9saiDWTo3UNY221kq1ruf7nJmbmaWhWgxQqJEfH2ip5pObk5OsohOcX5aQoKlkDzdC0LijKzCsBs2r/AwA "C (gcc) – Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 4 bytes
```
i#o:
```
[Try it online!](https://tio.run/##S8sszvj/P1M53@r///yUlPic1Lz0kgxFAA "><> – Try It Online")
Terminates with an error.
[This again?](https://codegolf.stackexchange.com/questions/237085/swap-every-two-elements-in-a-list/237115#237115)
## How?
```
i     Take an input (instruction pointer (IP) going right)
 #    IP bounces off # and starts going left
i     Take another input
   :  Duplicate it
  o   Output it
 #    IP bounces off # and starts going right
  o   Output again
   :  Duplicate (Useless)
And now, we're back to where we started, at the first character facing right.
The code will continue executing until it terminates with an error when running out of input.
```
[Answer]
# [GNU AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 35 bytes
```
BEGIN{RS=".|"}{printf NR%2?e:RT RT}
```
or
```
BEGIN{RS=".|";ORS=e}$0=NR%2?e:RT RT
```
[Try it online!](https://tio.run/##SyzP/v/fydXd0686KNhWSa9Gqba6oCgzryRNwS9I1cg@1SooRCEopJZLGUWRtT@QkVqrYmCLrIpLubggJ7NEQ8VAJ1EnVbM6Lb9II1MhM08hURNqZiZYcWJ0ZiwI1/7/75Gak5OvoxCeX5SToggA "AWK – Try It Online")
This is possible thanks to the `RT` variable, only available in GNU AWK. The characters are stored one at a time in `RT`, and the ternary conditional operator is used to skip the odds and double the even characters.
# AWK, 47 bytes
```
split($0,a,e){for(i in a)printf i%2?e:a[i]a[i]}
```
[Try it online!](https://tio.run/##SyzP/v9f2cnV3dOvOijYVkmvRqm2uqAoM68kTcEvSNXIPtUqKEQhKKSWC1WRtT@QkVqrYmCLrIqruCAns0RDxUAnUSdVszotv0gjUyEzTyFRE2pkJlhtYnRmLAjX/v/vkZqTk6@jEJ5flJOiCAA "AWK – Try It Online")
Splits the input character by characters into the array `a`, and does the skip-and-double magic through the ternary operator `?:`.
[Answer]
## **[MATLAB](https://www.mathworks.com/products/matlab.html), 25 bytes**
```
@(x)repelem(x(2:2:end),2)
```
[Answer]
# [Lua](https://www.lua.org/),77 83 bytes
Edited to comply with code golf rules. Assumes at least a space in input because I'm not entirely sure how to make it work with nil input without throwing an error.
```
p,t=io.read(),{} for i=0,#p,2 do t[i],t[i+1]=string.sub(p,i,i),string.sub(p,i,i)end
```
[Try it online!](https://tio.run/##yylN/P@/QKfENjNfryg1MUVDU6e6ViEtv0gh09ZAR7lAx0ghJV@hJDozVgdIaBvG2haXFGXmpesVlyZpFOhk6mRq6mCIpOal/P//HwA "Lua – Try It Online")
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$4\log\_{256}(96)\approx\$ 3.292 bytes
```
eh]y
```
[Try it online!](https://fig.fly.dev/#WyJlaF15IiwiYWJjZGVmIl0=)
## Explanation
```
eh]y
   y   Uninterleave the input - return a list like [a[::2], a[1::2]]
  ]    Get the last element (which is a[1::2])
e      Over each character...
 h     Double it
```
[Answer]
# [4](https://github.com/urielieli/py-four), 25 bytes
```
3.72372382352352372372394
```
[Try it online!](https://tio.run/##M/n/31jP3MgYiCyMjE3BCMK1NMEjBQA "4 – Try It Online")
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 4 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
zt2Ḅ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWy6pKjB7uaFlSnJRcDBVasNYjNScnX0chPL8oJ0URIggA)
#### Explanation
```
zt2Ḅ  # Implicit input
z     # Uninterleave
 t    # Leave only the tail
  2Ḅ  # Double each character
      # Implicit output
```
]