[Question]
  [
# Task
Given a string as input, generate a "blurred" version of that string.
# Input
Your input will be a single-line string of ASCII characters, containing a minimum of 2 alphanumeric characters
# Output
A string that is the "blurred" version of the input string.
A blurred string is one where every alphanumeric character from the original string has been paired with the ones adjacent to it, and each pair is separated by a space.
Any non-alphanumeric characters (whitespace, puncuation) in the input string must be ignored when determining adjacency of alphanumeric characters, and they must not included in the blurred string.
There must be no leading or trailing whitespace in the output string.
# Examples
`Ab` -> `Ab`  
`Abc` -> `Ab bc`  
`Abcd` -> `Ab bc cd`  
`E?h?` -> `Eh`  
`Blurry vision` -> `Bl lu ur rr ry yv vi is si io on`  
`We're #1!` -> `We er re e1`  
`I'm an example!` -> `Im ma an ne ex xa am mp pl le`  
`This is _not_ legible` -> `Th hi is si is sn no ot tl le eg gi ib bl le`  
`(a*b*c)+5^-x` -> `ab bc c5 5x`  
`??a_%,1!=z#@` -> `a1 1z`
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins!
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~57~~ 55 bytes
```
lambda s:"".join((c+" "+c)*c.isalnum()for c in s)[2:-2]
```
[Try it online!](https://tio.run/##PVBda8IwFH3PrzirjLV@FLrhi1A7Bz74PtjD5iSt0WakaUiitIq/3d10MAiXe8/HvZyY3tetfrkf8q@74k2553CLKEp/WqnjuJpEiCZVMq5S6bjSpyZODq1FBanhks/nxex5e5eNaa2H6x1jgVVSi0HQu9T5vdQLBrgpuHbI0XATO2@JsdJMB3HqjJI@jmbLKElIa0l2iF1ojZXax4fo6m6YLXG1N3xebZ7Trts2Su6rMsCrkq3K6q9DWYVh/z@h2rN1URcBWNfsTZ2s7XGWTrY6YG8K6oSThaXXoz8TB@ngqLZoNfsQT1ZglD0E9YeAIB3VjG2eGgoF0fHGKDHQm4YCBpC@QHToqCfEwNARwd5r2ktvp1u/I@AoSyWC7b1G/X@UKvnptIcPNogjjoRTmGFLzMfluEom8@9ZF8z8L@Uc844VBd89TrOH/DJ6HbgM2eUX "Python 3 – Try It Online")
**How**:
* For each alpha-numeric character `c` in the string, replace it with `c+" "+c`.  
E.g: `"abcd" -> "a ab bc cd d"`
* Remove the redundant first and last 2 characters:  
E.g: `"a ab bc cd d" -> "ab bc cd"`
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
wX2f□
```
[Try it online!](https://tio.run/##yygtzv7/vzzCKO3RtIX///9X0kjUStJK1tQ2jdOtUAIA "Husk – Try It Online")
# Explanation
```
   f   Keep all items that
    □  Is an alphanumeric character.
 X     Pick all sublists
  2    With a length of 2.
w      Join the output list by spaces.
```
[Answer]
# [sed] -E (C locale), ~~46~~ ~~33~~ 23 bytes
```
s/\W|_//g;s/\B.\B/& &/g
```
[Try it online!](https://tio.run/##RY7BSsNAFEX37ytuU221GkMXrmwSkxJBKLgRuikOk@SZDKRJmBk1Sv89HQoSeFwe98Dl5NLUYyEtoshwKUyhVW@x2XjZ24s3muCwP4kgqJ7clz4c0mCBRVCNDhLx0HfaYrcVyW4Xbol@atUwNMsSlo1tVMsElJ0LgIu6g9/Cu/pnCCN4E5uAhxOcDPwM/icmrcuY2xyTHJTkxSVKUBbXMShtvrT@xbcyqmtBe15qxnw9A70uj5AteJDHvmFXvNfKwJ1oOyvQcKVyJ043cpWvitu7xw9/AMWxFNf361n4N3@mMw "Bash – Try It Online")
*Thanks to pizzapants184 for a 13-byte improvement.*
*10 more bytes off thanks to Dom Hastings.*
---
Input on stdin, and output on stdout.
If your locale isn't set to C, you can set it with: `export LC_ALL=C`
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~27 24 22~~ 21 bytes
```
" "/2':(2!"/9@Z`z"')_
```
[Try it online!](https://ngn.bitbucket.io/k#eJy9kk1Lw0AQhu/5FW8XIUlFCoUcTA7WQg+9e7LEZFPzRfPFJikbRX+771oUz1KyDLPDu8s8M8NkvoBYrW3fWS/E6n7zHL8J240sa/Dfbw7Tp/Iz6CBuT4ETZ7KsAh1MgXLDD2s4iMdEhMZh1nMhH7/R4D07+fUHDYbzkXfFA8G7Yt5xG/K2GpWacC77sm1Yw7ZCNWJUULQJ05lPKHv09C345WrkvV1DNki1rLsqXZC9r1FLozUpZWjGVDp0rCm90mgM+algQ7SoaYeIqfMyYf6QOorfZulZCFseMBg+0hw5dS7H/8oxZEcuk+XRvfVe7jSB8rJpHjz9N98XjjmwXw==)
`"/9@Z`z"'` binary search in the given string
`2!` mod 2
`(2!"/9@Z`z"')_` drop non-alphanumeric chars
`2':` make a list of pairs of adjacent chars
`" "/` join with spaces
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 14 bytes
```
jd.::Q"\W|_"k2
```
[Try it online!](https://tio.run/##K6gsyfj/PytFz8oqUCkmvCZeKdvo/3@lkIzMYgUgis/LL4lXyElNz0zKSVUCAA "Pyth – Try It Online")
* `:Q"\W|_"k` replaces each non-alphanumeric character of the input with the empty string by matching each character against the regex `\W|_`
* `.: --- 2` finds all substrings of length 2
* `jd` joins the substrings using spaces
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
fØB;ƝK
```
A monadic Link accepting a list of characters which yields a list of characters.
**[Try it online!](https://tio.run/##y0rNyan8/z/t8Awn62Nzvf///6@kkaiVpJWsqW0ap1uhBAA "Jelly – Try It Online")**
### How?
```
fØB;ƝK - Link: list of characters, S
 ØB    - base-62 characters = "01...89AB...YZab...yz"
f      - (S) filter keep if in (that)
    Ɲ  - for neighbours:
   ;   -   concatenate
     K - join with spaces
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ ~~7~~ 8 bytes
*-1 byte thanks to @CommandMaster*
*+1 byte again thanks to @KevinCruijssen finding an issue*
```
žKÃüJðý?
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6D7vw82H93gd3nB4r/3///b2ifGqOoaKtlXKDgA "05AB1E – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~17~~ 16 bytes
```
t8Y2m)2YC!Z{0&Zc
```
[Try it online!](https://tio.run/##y00syfn/v8Qi0ihX0yjSWTGq2kAtKvn/f3WnnNKiokqFsszizPw8dQA) Or [verify all test cases](https://tio.run/##y00syfmf8L/EItIoV9Mo0lkxqtpALSr5v0vIf3XHJHUuIJEMIVOAlKt9hj2QcsopLSqqVCjLLM7MzwPyw1PV1YtSFZQNFYEcT3X1XIXEPIXUisTcgpxUkFBIRmaxAhDF5@WXxCvkpKZnJuWkAsU1ErWStJI1tU3jdCuAXHv7xHhVHUNF2yplB3UA).
### Explanation
Consider input `'Blurry vision'`.
```
t      % Implicit input. Duplicate
       % STACK: 'Blurry vision', 'Blurry vision'
8Y2    % Push '012...9ABC...Zabc...z' (predefined literal)
       % STACK: 'Blurry vision', 'Blurry vision', '012...9ABC...Zabc...z'
m      % Ismember: true for chars of the first string that are in the second
       % STACK: 'Blurry vision', [1 1 1 1 1 1 0 1 1 1 1 1 1]
)      % Use as logical index. This keeps only letters and numbers in the input
       % STACK: 'Blurryvision'
2YC    % Character matrix with sliding blocks of length 2 as columns
       % STACK: ['Blurryvisio';
                 'lurryvision']
!      % Transpose
       % STACK: ['Bl';
                 'lu';
                 ...
                 'on']
Z{     % Cell array of matrix rows
       % STACK: {'Bl' 'lu ... 'on'}
0&Zc   % Join with character 0 (which will be displayed as space)
       % STACK: 'Bl lu ur rr ry yv vi is si io on'
       % Implicit display
```
[Answer]
# TEX (INITEX), 372 bytes
```
\catcode`~13\let~\catcode~`{1~`}2~`#6~`\ 12~`|13\let|\expandafter\def\z{}\def\f#1{#1}\def\i#1{}\def\b#1#2{\ifx#2\e|||\i|\i\else|\f\fi{\ifcat#1a|\f\else|||\b|||#2|\i\fi}{\ifcat#2a #1#2|\b|#2\else|\b|#1\fi}}\def\t{~`011~`111~`211~`311~`411~`511~`611~`711~`811~`911~`\|12~`\~12~`\#12~`\{12~`\}12~127=12~`\%12~`\\12\read16to\x\edef\r{|\b\x\e}\immediate\write16{|\i\r\z}\end}\t
```
For example, the program being saved in a file named "codegolf.tex", provided with input `??a_%,1!=\z#@`, `initex codegolf.tex` outputs:
```
This is TeX, Version 3.14159265 (TeX Live 2019/dev/Debian) (INITEX)
(./codegolf.tex
\x=??a_%,1!=\z#@
a1 1z
 )
No pages of output.
Transcript written on codegolf.log.
```
In the case of a degraded input, for example the strings `??`, `?a`, or `a?`, this implementation does not print any pair.
# Explanation
## Basis for a TEX program
```
\read16
```
Per [this Meta answer](https://codegolf.meta.stackexchange.com/a/13652/94729), the input of a program written in TEX should come from standard input, which is the *in register* number 16.
```
\immediate\write16
```
The TEX Codegolf community prefers to output to DVI or PDF, because it is simpler than writing to the terminal. However, this requires a valid `\output` routine, which either requires a format (with more category codes to alter1) or is longer to define. So I write to the terminal. (`\message` could also have been used, but I don't like how the output is surrounded by TEX chat on the same line).
Because I output to the terminal, I also feel that no DVI file should get produced, so `\immediate` is required2.
```
\end
```
This is a complete program, so it must end with `\end` to run cleanly.
## Category codes
Running on alphanumerics and ignoring punctuation is a trivial matter for TEX. All I have to do is to customize the category codes of those characters.
For this subject, I will use category code 11 ("letter") for characters that need to be blurred, and category code 12 ("other") for characters that are to be dropped. That choice comes from the defaults of (ini)TEX, where letters are already set to 11 and most of the other characters to 12.
```
\catcode`~13\let~\catcode
```
To save bytes, I make `~` an active character and set its meaning to `\catcode`. In the rest of the explanation, that alias will be ungolfed.
```
\catcode`{=1 \catcode`}=2 \catcode`#=6 \catcode`\ =12
```
These are required for INITEX to interpret my program correctly: `{` is now the begin-group character, `}` the end-group, `#` the macro argument, and `␣` is considered a normal character (so that the first spurious space of output can be removed). These choices are widely used in the TEX world and do not cost bytes3.
```
\catcode`|=13 \let|=\expandafter
```
This is an useful alias for later.
```
\def\t{\catcode`0=11 ... \end}
\t
```
This is a TEX design pattern that fools TEX's eyes. Everything that is written in the `\todo` macro definition will get a category code assigned, and this category code will not be reconsidered when TeX expands the macro. Most notably:
```
\catcode`\\=12
```
This makes the escape character `\` a normal character when read from the user input.
```
\read16to\x \edef\r{|\b\x\e} \immediate\write16{|\i\r\z} \end
```
When reading the macro definition, TEX has decided that these were control words, and TEX will not reconsider this choice after the macro has been expanded, even if `\` has lost its special meaning in the meantime.
```
\catcode127=12
```
The `DEL` character is contained in ASCII, so it should be valid input per the subject's rules. But in order to change its category code to 12, the DEL character has to be written, and the most efficient4 way to input it in TEX is to name it by its code point.
```
\catcode`0=11 ... \catcode`\\=12
```
Here are three groups of category code assignments: make the digits like letters, revert the changes made at the beginning of the program, and cancel other INITEX defaults (`DEL`, `%`, `\`, but not the new line because the subject emits the hypothesis:)
> 
> Your input will be a single-line string
> 
> 
> 
## The blurring command
Because I opted for terminal output, and because `\write` does not executes its argument (only expands it), I am forced to write the `\blur` macro as fully expandable.
```
\def\z{} \def\firstofone#1{#1} \def\ignore#1{}
```
As a prolog, I define three macros, which are commonly used in various fully-expandable design patterns. The first one is the empty macro, the second one is the identity macro, and the third one is the zero macro.
```
\def\blur#1#2{ ... }
```
The `\blur` macro is recursive5. It takes two characters at a time (because the rules say that the input is longer than two). Its definition is made of three parts.
```
\ifx#2\e \expandafter\expandafter \expandafter\ignore \expandafter\ignore
\else    \expandafter\firstofone
\fi
```
is the recursion condition: if the end-of-string marker (the undefined command `\e`6) is found, ignore the two other parts. (More precisely, drop the unused portion of the conditional `\else...\fi` at `\expandafter` level 0, then ignore the second part at `\expandafter` level 1, then ignore the third part at `\expandafter` level 2.) Otherwise, close the conditional and interpret the second part.
```
\ifcat#1a \expandafter\firstofone
\else \expandafter\expandafter \expandafter\blur
      \expandafter\expandafter \expandafter#2
      \expandafter             \ignore
\fi
```
handles the first character. If it is a letter or digit, go analysing a second character. Otherwise, skip the remaining of the conditional, ignore the third part, and call `\blur` recursively with #1 being dropped and #2 as the first character7 (an other one will get extracted from input).
```
\ifcat#2a ␣#1#2 \expandafter\blur \expandafter#2
\else \expandafter\blur \expandafter#1
\fi
```
handles the second character. If it is a letter or digit, output a space then the first part of the blur, then forget about #1 and call `\blur` recursively on #27. Otherwise, forget about it and call `\blur` recursively on #17.
## Calling the blurring command on real input
```
\read16 to \x
```
will store the input into an (expandable) macro `\x`.
```
\expandafter\blur \x \e
```
This is how the `\blur` macro is called. Because `\blur` acts on tokens, the input contained in `\x` must be expanded first. The end-of-string marker follows.
```
\edef\result{\expandafter\blur \x \e}
```
The result of the expansion, including the whitespace at front, is stored into the `\result` macro.
```
\expandafter\ignore \result \z
```
Inside the `\write16` command, the `\result` macro is first expanded. Then, `\ignore` eliminates the first token of output: the first space if the output is non-empty, or the `\z` macro call if the output is empty. In the first case, the `\z` macro will survive; but `\write16` will finally expand it, and its expansion is a no-op. This is the most efficient way of handling the “no trailing space” requirement, even if it requires 24 bytes (the definition and call of `\z` and `\return`); suppressing a space at the end of the output would have been nearly impossible.
## ☡ Footnotes
1. `$`, `&`, `^`, `\_`, `NUL`, `SPC`, `TAB`, `~` for plain TEX; 5 bytes each = 40 bytes.
2. Without `\immediate`, `\write` adds its content to a whatsit box, thus generating a page of output.
3. Because there are only three category code changes, it is not worth putting them in a group to save the reverting.
4. Decimal: `127=` (4); Hexadecimal: `"7F=` (4, harder to read); Octal: `'199=` (5); Escape sequence: ```\^^?` (5, plus `\catcode`^7` and revert)
5. It is even *tail-recursive*, which in TEX has the meaning of "it does not add tokens after the recursive call", and by doing so is more memory-friendly.
6. Because all input other than my program does not get interpreted, the `\e` command cannot be defined later.
7. This would fail if #2 was a simple group of arguments, but fortunately the input cannot contain simple groups, because no character has category code 1 nor 2.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 13 bytes
```
\W|_
Lw| `..
```
[Try it online!](https://tio.run/##K0otycxLNPz/Pya8Jp6Ly6e8RiFBT@//f6ec0iLFokqFsszizPw8AA "Retina – Try It Online")
## Explanation
`\W|_` Replace each character NOT in the regex group \W (which is `A-Z,a-z,0-9,_`) or a `_` with nothing
`Lw| `..` Compute lists (`L`) for each set of two characters (`..`) starting at all positions in the string (`w`) and separate the lists with a space (`|` )
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 74 bytes
This ended up very similar to the Python answer. I was trying something noticeably more interesting with Aggregate, but the terrible no trailing whitespace requirement made it too long.
```
s=>s.SelectMany(c=>char.IsLetterOrDigit(c)?c+" "+c:"").Skip(2).SkipLast(2)
```
[Try it online!](https://tio.run/##JY3LCsIwEEX3/YqQ1aSvheBG24ighUJFoa6FdBhqsEZJUrRfHytdnQuHy0GXodOhGg0Wzltt@pTVRzM@yapuoALvykrJKlay4Erp8pYGQn9SZgIs5V/ntWvIe7Jne9C99oBihwlnPMEN5yJvH/oNq4WNcn7eYRtFlznmwdCHLV2ogIOKuxhFsr5l3/l5fe2tVRMIIcIP "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 52 54 bytes
```
{gsub("\\W|_",a);for(b=$0;c=substr(b,++d,2);)$d=c}--NF
```
[Try it online!](https://tio.run/##SyzP/v@/Or24NElDKSYmvCZeSSdR0zotv0gjyVbFwDrZFihTXALk6Whrp@gYaVprqqTYJtfq6vq5/f/vqZ6rkJinkFqRmFuQk6oIAA "AWK – Try It Online")
*Fixed underscore rule goof (+2 chars), thanks to Pedro Maimere*
Here's what's going on with this one...
```
gsub("\\W",a)
```
Removes all the non-alphabetic characters from the input string since `$0` is the default target for `gsub`. Using an unitialized variable `a` instead of `""` saves a byte.
Next the code loops through the string taking 2 character slices and assigns them to positional variables.
```
for(b=$0;
```
The setup has to save `$0` to another variable, since changing the positional variables impacts the collected input in `$0` as well.
```
c=substr(b,++d,2);
```
The "test" at the top of the loop does a couple of things in one statement:
* increments `d`, the "current character" pointer
* sets variable `c` to the next 2 character slices of the input
* the true/false test simple has the code looping until we run off the string and get a null
The body of the loop sets the next positional variable to the slice we just took.
```
$d=c
```
After all the positional variables have been set, there's one "garbage" entry on the end with one character. So the test:
```
--NF
```
effectively drops that last positional variable and triggers the default action, which prints all the positional variables separated by a space.
[Answer]
# [Factor](https://factorcode.org/), ~~51~~ 37 bytes
-14 bytes thanks to chunes
```
[ [ alpha? ] filter 2 clump " "join ]
```
[Try it online!](https://tio.run/##JYrNSgMxFIX38xSnU6RaUajgRpHYgkg3blRclDrcibczVzJJTDLSWvrsY0rh8J0fzoZ0cmF4f12@PN@BohZBE1zvxTaI/NOz1RzhA6e080Fswn1R7FHO6/IIfeJXtifVqmwL04eww69EcTb3D54Exng2ynk56UAWvKXOGz4ub61EZFXWpQqGG6kN5/2cpvVUX1zefl5tc1WKqrPZ6OFv/FjiUAwrrEDGt6SwxkZM4oAbaNN3Hvn@7cRiPXTkcT38Aw "Factor – Try It Online")
# [Factor](https://factorcode.org/), 51 bytes
```
: b ( s -- s ) [ alpha? ] filter 2 clump " " join ;
```
[Try it online!](https://tio.run/##JY5fS8MwFMXf9ynOOmR/JMIEXzokUxDpy15UfBizpPGuzUiTmKTSKX72mjLu5XfuOQ@HexQyWj@8vRS75xwiSKVQe9s5ZWoE@urISApwnmI8O69MxGZS7HI86s6z2BCL1MchR4UFAhhLWGIPoV0jOA44Kh3J4xZSd61DluZklcFm@EX2UGUj5IWfSZ54w5OM7f6MbxWUNcm/09wTZutpuot5C2FAvWidpjF5bVRA2tLYWEJTrSpNKV@IVbWSy@u7D9Yny7kor9bT@5/ZNsPfZJ9@PqAVDjfDPw "Factor – Try It Online")
Unbelievably [Factor](https://factorcode.org/) is competitive with Python and JavaScript :)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~17~~ 16 bytes
```
\W|_
M&!`..
¶
 
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPya8Jp6Ly1dNMUFPj@vQNi6F//8dk7gck5JBOIXL1T7Dnsspp7SoqFKhLLM4Mz@PKzxVvShVQdlQkctTPVchMU8htSIxtyAnVZErJCOzWAGI4vPyS@IVclLTM5NyUrk0ErWStJI1tU3jdCu47O0T41V1DBVtq5QdAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: Now basically a port of @Jarmex's Retina 1 solution, except that `M!` always joins with newlines, so I have explicitly change them to spaces. Previous 17-byte approach:
```
\W|_
\B.\B
$& $&
```
[Try it online!](https://tio.run/##FcPdCoIwFADg@/MUR/zNfsCLLmM5iOg@8EZamx5yMGdMC4vefRV8n6NJW@nj7Hj1dfURADXf1ByiBKPE@1JBqZr/Fg6sY8DNw7kXPvWoBwsVpY4wLAI4pT1KizTL/m4ogHOnR/wRdpgEGrppZQgymau8WSy3l/UMjEkRr4pg9w73Xw "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
\W|_
```
Delete any non-word character and any underscore (which is the only non-alphanumeric character that counts as a word character).
```
\B.\B
$& $&
```
Duplicate each inner character and space separate the results.
[Answer]
# JavaScript (ES6), 57 bytes
```
s=>s.replace(/\W|_|(.)/g,(_,c)=>c?c+' '+c:'').slice(2,-2)
```
[Try it online!](https://tio.run/##dZHRboIwFIbv9xRHzQIVhGDizRJkmnjhvYk3y0ipFVhKS1owaHx3dtyyxVVGmpOm/b@vp@WDnqhhuqybmVQH3h/j3sRLE2heC8q4G77tr@nVDUiY@27qMxIvWcI8BxyPvTgOCYwoMTb3Z3PSMyWNEjwQKneP7niVjQmBgS8MYZU9PaTZcPwrDRkbAA6DxA8A7GAzm6RI/mM2hZ1ei1brM5xKUyp5j2F6LUC00GrQOM5wPmEMSgMGqwIlbdeeO5rDJBrZx6Nrz4GjBWtkY1unAiqBd7SqBb@DEdtWUNHbrkSygw7nuFJDja1xW7QrsDkcqVRNivt5mQl@06FoV0Dx2zxWNOIVGmhuIuA55LiOLzrkdek0mzLiLd5n3Z@roZd@/4UFLDobSxKaPvvRKL5MXh@wCKJL/wk "JavaScript (Node.js) – Try It Online")
[Answer]
# Q/KDB+, 38 bytes
**Solution:**
```
{" "sv -2_2#'next\[x inter .Q.an _52]}
```
**Examples:**
```
q){" "sv -2_2#'next\[x inter .Q.an _52]}"Ab"
"Ab"
q){" "sv -2_2#'next\[x inter .Q.an _52]}"Abc"
"Ab bc"
q){" "sv -2_2#'next\[x inter .Q.an _52]}"E?h?"
"Eh"
q){" "sv -2_2#'next\[x inter .Q.an _52]}"This is _not_ legible"
"Th hi is si is sn no ot tl le eg gi ib bl le"
```
**Explanation:**
```
{" "sv -2_2#'next\[x inter .Q.an _52]} / solution
{                                    } / lambda taking implicit x
                           .Q.an       / "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789"
                                 _52   / drop element at index 52
                   x inter             / intersection of x and alphanumerics
             next\[                 ]  / scan along input
          2#'                          / take first 2 characters of each
       -2_                             / drop final two items
 " "sv                                 / join (sv) with " "
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 32 bytes ([SBCS](https://github.com/abrudz/SBCS))
Port of Surculose Sputum's Python answer.
```
{¯2↓2↓⊃,/{⍵' '⍵}¨⍵∩⎕A,819⌶⎕A,⎕D}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqQ@uNHrVNBuFHXc06@tWPereqK6gDydpDK4Dko46Vj/qmOupYGFo@6tkGZgIJl1qgbgV1xcSkZEV7dS4gUyNRK0krWVPbNE63Qh0A)
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 18 bytes
```
1↓∊' ',¨2,/⍵
\W|_
```
[Try it online!](https://tio.run/##KyxNTCn6/9/wUdvkRx1d6grqOodWGOnoP@rdyhUTXhPP9f9/SEZmsQIQxefll8Qr5KSmZyblpAIA "QuadR – Try It Online")
Replaces all non-word characters and underscores (`\W|_`) with nothing , and then:
`2,/⍵` adjacent pairs
`' ',¨` prepend a space to each pair
`∊` **ϵ**nlist (flatten)
`1↓` drop the first space
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 80 bytes
```
p,b;f(char*s){for(p=b=0;*s;s++)isalnum(*s)?p&&printf(" %c%c"+!b--,p,*s),p=*s:0;}
```
[Try it online!](https://tio.run/##HUzNaoQwGLznKT5ddBN/QA@9NIjdQg@9F3oorSRp1ECMIdF228Vnt7Ewwwwzw4hyEGLfbcFpj8XIXObJrZ8dtg1vKpp56vOcKM@0WSccytamqXXKLD2OIRGJiPOIl2Vhi1AWtsn8fUW3/bgC/1ZX1TtFYQ0TUwYTuCH4HpWWgAe5eJx68p9Bjz2hQe0a0jg@/IbAyWV1BiqKNtgvHF24OPiJntqxRY96de4HvpRXs0Gv8uwknOoIPZ8nYAbklU1Wywi9jMpDQGfmpQMtB8W1RJhlPBMkv/sor6htWZcUddT8nh7@AA "C (gcc) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~23~~ ~~19~~ 18 bytes
```
žKÃ©g<F®Nè?®N>è?ð?
```
[Try it online!](https://tio.run/##yy9OTMpM/f//6L6sQysONx9amW7jdmid3@EV9kDSDkgd3mD//7@9fWK8qo6hom2VsgMA)
This probably could be really shorter, but I just wasn't able to find the right tools for the job. -4 bytes thanks to petStorm and a further byte thanks to Command Master.
## Old Answer Explained
```
žj'_ммм©g<F®Nè?®N>è?' ?
žj                      # Push [a-zA-Z0-9_]
  '_м                   # Remove the "_" from the above string
     м                  # Remove all alphanum characters from the input, leaving non-alphanum chars
      м                 # Remove those non-alphanum chars from the input, leaving alphanum chars
       ©                # Put this string into the register
        g<F             # For N in range(0, len(input) - 1):
           ®Nè?         #   Index the string at position N and print
               ®N>è?    #   Index the string at position N + 1 and print
                    ' ? #   Print a space
```
[Answer]
# Javascript ES6, ~~55~~ 54 chars
```
s=>s.replace(/\W|_/g,"").replace(/.(?=(.).)/g,"$&$1 ")
```
Test:
```
f=s=>s.replace(/\W|_/g,"").replace(/.(?=(.).)/g,"$&$1 ")
console.log(`Ab -> Ab
Abc -> Ab bc
Abcd -> Ab bc cd
E?h? -> Eh
Blurry vision -> Bl lu ur rr ry yv vi is si io on
We're #1! -> We er re e1
I'm an example! -> Im ma an ne ex xa am mp pl le
This is _not_ legible -> Th hi is si is sn no ot tl le eg gi ib bl le
(a*b*c)+5^-x -> ab bc c5 5x
??a_%,1!=z#@ -> a1 1z`.split`
`.map(s=>s.split` -> `).map(([s,k])=>f(s)==k).every(x=>x))
```
[Answer]
# [Kotlin](https://kotlinlang.org), ~~77~~ 76 bytes
```
{it.filter{it.isLetterOrDigit()}.zipWithNext{a,b->"$a$b"}.joinToString(" ")}
```
Old solution
```
{it.replace("\\W|_".toRegex(),"").zipWithNext{a,b->"$a$b"}.joinToString(" ")}
```
[Answer]
# [R](https://www.r-project.org/), 98 bytes
```
function(x,y=grep("[a-z0-9]",el(strsplit(x,"")),T,,T))for(i in seq(y)[-1])cat(y[i-1:0],' ',sep='')
```
[Try it online!](https://tio.run/##Hc2xCsMgEADQX7Eu3sEJydiCez8g0EEc0tQU4VCrBmp/3pbOb3hl3PkoZuxH3FpIEd7UzbP4DNKu@jPps5PkGWorNXNoP5cSkRaiBXFPBYIIUVT/go5Wzw63tUG3Qc@XyZESiqrPRin8RyCvnjmRuKXCj5PE8QU "R – Try It Online")
Unusually for [R](https://www.r-project.org/), a `for` loop is significantly shorter than a [matrix-based approach](https://tio.run/##Hc1LCsIwEADQq2hWMzCBZimYvetQcFG6SJOpFoY25APWy1fpBd7LxyQt22Nua6jLtsKHnHUcW2B0kHypTD4l2eHNPkKYljXCftevzAnU4PW307dREQuUmkuSpf4JpRCpJ@qR9kGbEUkbJEOOZnuaHeIZg3qwyEaX55YlXhUePw), mainly because it allows us to just use `cat` instead of the much-more-verbose `Reduce(paste` vectorized way to build a text string from a list of characters.
[Answer]
# [R](https://www.r-project.org/), 76 bytes
```
function(s)cat(substring(S<-gsub("[^a-z0-9]","",s,T),N<-1:(nchar(S)-1),N+1))
```
[Try it online!](https://tio.run/##K/qflFNapGCj@z@tNC@5JDM/T6NYMzmxRKO4NKm4pCgzL10j2EY3HcjTUIqOS9StMtC1jFXSUVLSKdYJ0dTxs9E1tNLIS85ILNII1tQ1BIpoG2pqgg3VUPJIzcnJ11EIzy/KSVFU0vwPAA "R – Try It Online")
Similar to Dominic van Essen's [answer](https://codegolf.stackexchange.com/a/220084/67312), uses `cat` to join by spaces; uses `substring` which recycles (as opposed to `substr` which doesn't).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
≔ΦＳ№⁺α⁺β⭆χλιθ⪫Ｅ⊖Ｌθ✂θι⁺²ι¹ 
```
[Try it online!](https://tio.run/##LYzBCsIwEETv/Yq1HtxABOu1J6kIikKhB88xLm0gbtt06@/HRr3MHN6bsZ0Jtjc@xsM0uZbx5LxQwDMPszQSHLeoNFT9zIK1nyc0Gr790PDjNzNgsdPglVpMl2JUZVYvTPDSO8ZkHMkGehELPfFK3EqHY1Ib7yzhuAz/v/v0oaFIMIdcqTLGO20CwbpYZXH79h8 "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔ΦＳ№⁺α⁺β⭆χλιθ
```
Filter out any character that can't be found in the upper or lower case alphabet and isn't a digit.
```
⪫Ｅ⊖Ｌθ✂θι⁺²ι¹ 
```
Extract all substrings of length 2 and join them together on spaces.
[Answer]
# [Icon](https://github.com/gtownsend/icon), 92 bytes
```
procedure f(s)
t:=""
find(k:=!s,&letters++&digits--'_')&t||:=k||' '||k&\z
return t[3:-2]
end
```
[Try it online!](https://tio.run/##TU9Na4NAEL37K0ZD3d2oh7T0IohNoIfeCz2kifgxJou6ht2xTcP@99SVHjoM83hv4PGerEd1v1/0WGMzaYSWG@FRmgWB10rV8C7NfBOHPRKhNlEUNvIkySQJK5gIydo066xlwKztws@bp5EmrYD2T2nyePBQNf/Mh1IqLjyYh9CQgTSDfbCtghjmW/9B4/A1P@cOd/2k9Q98SSNH5YQPZLPTauM78sYGKBXgtRwuPS7S@1kamLdQIxXQ40lWPboHL9fVuhbR8zG5Op7nZfEQb/zstnqZ@WGJ9a0lIW@5v@QTwlVyHX4B "Icon – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 130 bytes
```
func[s][a: charset[#"0"-#"9"#"A"-#"Z"#"a"-#"z"]parse s[any[p: change
a(rejoin[p/1" "p/1])| remove skip]]take/part/last s 2 at s 3]
```
[Try it online!](https://tio.run/##RY5vS8NADMbf91NkKbI/UuYUXzjQOsEXvhVB2HGWtE3Xc@31uOvGNvzu9To7DCH55XkSiOW8e@dcyKBYQlfsdCacFLSErCTruBUh3mAU4gOGuOph7YF6OKE0/Qo4QfoozPlEbzigieXvRmlh5gsE9FVOf8By3ez98lYZKVva8txft/OKXAsOboH6die7orFMWQkte0ME4ANXKV4g@6d8wNe4jAd8qXbWHmGvnGr0oH3y2DKEi9Ewv41rIA18oNpUfFE/SuXAZ6KbNoGKNyqtePAmNEtn2fT6/is6DFIcU3K1GD2ewmcMpABjlfbvZo05/n2O0RNCcWYpu18 "Red – Try It Online")
[Answer]
# JavaScript (ES6), ~~54~~ 76 bytes
```
a=>[...a.replace(/[\W_-]/g,'')].map((a,b,c)=>a+c[b+1]).slice(0,-1).join(' ')
```
[Try it online!](https://tio.run/##DcpBDoMgEADArxgv7EZY6wPwGz1Q0qwUDQaBiG36e9o5z84fru4M5VIpv3xbdWM9GyJiOn2J7DyM5nF/KjtuUgi0dHABYLlIh3rmwZllmCxSjeF/b1JNSHsOCUQnsLmcao6eYt5ghd5/@SjRdyGV99Ujth8 "JavaScript (ES6) – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 6 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
£Q·H°·
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=9c51fa48f8fa&i=Ab%0AAbc%0AAbcd%0AE%3Fh%3F%0ABlurry+vision%0AWe%27re+%231%21%0AI%27m+an+example%21%0AThis+is+_not_+legible%0A%28a*b*c%29%2B5%5E-x%0A%3F%3Fa_%25,1%21%3Dz%23%40&a=1&m=2)
### Unpacked (7 bytes) and explanation:
```
VL|&2BJ
VL         Push string of all alphanumeric characters.
  |&       Remove from the input all letters not in this string.
    2B     All length-2 substrings
      J    Join with spaces
```
[Answer]
# [C#], ~~163~~ ~~155~~ ~~133~~ ~~128~~ ~~127~~ ~~128~~ ~~114~~ ~~112~~ ~~133~~ 98 bytes
```
i=>{var b=i.Where(char.IsLetterOrDigit);return b.Select((n,i)=>i==0|i==b.Count()-1?n+"":n+" "+n);}
```
[Run it](https://tio.run/##XVHva9swEP1s/xVXd6NynZjmw77MdbKta6GQsbEW8qF0QVYutkCWE/3IkmX@27NTksEYiHvcuyfd052wQ2HFwVupa3jaWYdtEf@b5VOp1/9Rz7h1@XesveLmfrsyaK3stC3ieOUrJQUIxa2Fb6arDW/jfRydeeu4I9h0cgFfuNQsjSOqRhtuQOqVd1CCxp@kM9Tu5RX2kHyskkGI4gyLgPfNJMAn5Y3ZwUaG/oGY4ZVBuBxdhOTxqgWuAbe8XSk8Us@NtEBnrjs3B4W1rBSGAuPX1bVIs3c/htuQTyZ8/nYwuih/XX5IoKevnW0uzxYfvBa3J58DWOw0b6UYMzjIcrwPuqqU@axBg0w03OSPdorOoflqPstaurQw6LzRUOVPqFA4xvRApuVYluXNbwpVftd57Vg6HE10liTvKUCS6bToD1GUFsHOsjPAQi9Pnm4KgtvTFPMp6to1xGQZTfg4YoCgXJNyyY6iF/9Kz4TCHe2uU5jPjHRI60b2Jtn/1fQwHNMaTj8lU1pwx9Yp9Mnxdh/T6Q9/AA)
~~Have not used a Regex yet in a Codegolf, so very excite.~~ Regex uses way too many characters. No longer excite. 
* 127 bytes: removed a "." in the regex string
* 126 bytes: replaced String.Join("" with String.Concat
* 114 bytes: changed || to |, removed the ( ) { return; } from inside the Select
* 112 bytes: Removed + from regex
* 128 bytes: Reverting back to older solution. Entry now legal (thanks to @Neil and @my pronoun is monicareinstate)
* 98 bytes: Realization that char is way more powerful than I thought (thanks to @my pronoun is monicareinstate's C# solution), removed the string -> char -> string conversions
]