[Question]
  [
Write a quine... from which every other character can be removed it still be a valid quine. You can specify whether to start removing characters at the first or second character.
Scoring criteria (add bonuses/penatly percentages together for total percentage):
* Answers must be at least 4 characters long
* Program must contain at least one alphabetical character in its source, so for example, `12345!@#$%^&*()` is disqualified
* +750% if the language used is not Turing-complete (I'm looking at you, HTML!)
* -15% if the solution does not read its source from anywhere in any form
* -20% if you can also keep only every 5th character and still form a quine
The score is measured by the number of characters in the first program.
Example (not real programs):
If `123456789abcdef` and `13579bdf` are both quines, the score is 15. Additionally, if `159d` is also a quine, then the final score is 12.
This is code-golf, so lowest score wins.
  
[Answer]
## PHP, 4 chars − 15% − 20% = ~~2.72~~ 2.6 points
```
ABCD
```
Yes, PHP is a Turing-complete language. Nobody said I have to *use* any of its actual programming features. ;-)
**Edit:** Changed the score based on the clarification that bonuses are additive, not multiplicative.
[Answer]
## TI BASIC 4 - 35% = 2.6
*I might understand them wrong, but I think I am also eligible for the -15% and the -20% bonusses, meaning I have the lowest possible score.*
I can write the program:
```
123i
```
which will output `123i` where i is of course the imaginary unit. When you remove the 1st and the 3rd character all that remains is `2i` which outputs `2i`
[Answer]
# Python - 95
Great challenge. I thought this was pretty clever, and actually a legit solution!
```
00;"#";print(open(__file__).read())
0#;XpXrXiXnXtX(XoXpXeXnX(X_X_XfXiXlXeX_X_X)X.XrXeXaXdX(X)X)
```
[Answer]
## Golfscript, 5 points
```
{hai}
```
is a function that, when executed, will run the (non-existing) function `hai`. It's not executed, however, but rather printed when the program ends - including the outer brackets. Removing each other character yields:
```
{a}
```
Lame, I know :-)
[Answer]
## HQ9+ - 4 \* 7.5 \* 0.8 = 24 points
```
Q+++
```
Still a quine with every second character:
```
Q+
```
...and every fifth:
```
Q
```
Sorry, I couldn't resist. :)
[Answer]
# HTML/Markdown, 4\*7.5 = 30
```
HHHH
```
I admit this is lame, but it doesn't really go against any rule in the question. Except that HTML/Markdown may not be considered a real programming language.
[Answer]
# !/bin/sh
I liked [qwr's solution](https://codegolf.stackexchange.com/questions/23306/mandoline-quine#23311) so much, I shamelessly made a port for POSIX shell. Please don't save it into a filename containing spaces.
```
: '#';cat $0
#c a t   $ 0
```
Start removing at character number 1, and count newlines as characters. The second quine is of course:
```
 #;a 0
cat $0
```
*Please upvote qwr's answer instead of this one!*
[Answer]
# Bash, 23
Newline is a character!
Some messy comment work, so that when every other character starting from the first is removed, the comment becomes code and the code becomes a comment:
```
#cRaRtR R$R0R R#
cat $0
```
After every other character (*including the new line*) is removed:
```
cat $0 #ct$
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 8 bytes -15% = 6.8
```
` I,` I,
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgIEksYCBJLCIsIiIsIiJd)
## Every other char
```
`I`I
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgSWBJIiwiIiwiIl0=)
## Explanation :
```
` I,`    # push ` I,`
      I  # quote and prepend
       , # print
`I`  # push `I`
   I # quote and prepend
     # implicit output
```
[Answer]
## Brainf\*\*k, 37 - 15% = 31.45
Abusing the [Portable Brainfuck Interpreter](http://www.linusakesson.net/programming/brainfuck/pbi.c)
```
+A[B-C<D+E]F-GÿH<I<J<K<L<M<N<O[P.Q>R]
```
Start removing from the second character.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~145~~ 94 bytes -15% : Score = 79.9
```
s ="'psr=i%nrt;(p'rsi n=t%(rs;%e%xse)c;(xsc[s11:::2  2']; p)r'i%nst)(#s#%#s#)";exec(s[1:: 2] )
```
[Try it online!](https://tio.run/##dY0xCsMwDEX3nEIoGFuFQONuMe5FgifX0CyukTykp3fdhkKXDgLp6z9eedb7I19afNySZ0RsAh51EfabylydKZplg@yrMixOJbVLoujMLnGVeV6WxQJYHRwUYt0hqWRGGVUfQpf2FI2svQc2ALWu6Mc0h2EovOVq3mZyx47@ijR8kCP@lnDCkz3TL7N2cfgDHr/2Ag "Python 3 – Try It Online")
## every other char:
```
s='s=%r;print(s%%s);xcs1:2 ';print(s%s);xcs1:2 
```
[Try it online!](https://tio.run/##K6gsycjPM/6fnJ@SalukpKT0v9hWvdhWtci6oCgzr0SjWFW1WNO6IrnY0MpIQR0uiBD7D9QTbWilaxjLxQWRBRmlCVWppKukZWSgyZVakZoMkfgPAA "Python 3 – Try It Online")
## How it works :
The ugly string is the blending of :
* `print('s =%r;exec(s[1::2 ] )'%s)####` for the normal quine
* `'s=%r;print(s%%s);xcs1:2 ';print(s%s)` for the every-other-char quine
`xcs1:2`  is an annotation and doesn't throw any error as the part after the semicolumn can compile. Otherwise it would throw a `SyntaxError` and the program wouldn't run at all.
# [Python 3](https://docs.python.org/3/), with reading code source: ~~70~~ 62 bytes
```
s ="p-r-i-n-t-(-*-o-p-e-n-(-_-_-f-i-l-e-_-_-)-)";exec(s[::2] )
```
[Try it online!](https://tio.run/##jY7BCsIwEETP7leEPWWFBVtvKf2SUkTaLQZqEtII@vUxbU@CguxlZgfmTXilm3fnPPhR2oiIeVEtBo5s2XFizUf2HFiK03wpN5VkLn7VxISNPGXQS2dM3SvKpaKrDFc9wCiT8kGcnuws7noXMnCIkh7RKZsk6m6l9gQQonVJr46aXSPjsT4RbOXfgj/bt1mfiO31k7OnAPkN "Python 3 – Try It Online")
## every other char:
```
s=print(*open(__file__));xcs:2 
```
[Try it online!](https://tio.run/##JYxBCsMgEEXXnVOIKycQaNKdIScJQYqZUKEdZWIhPb2tdfcf//HSJz8i34qPG82itS7HnCRwNl1MxMa5PTzJOcTp9IcdVfk5y2D7YQXYaFd/qzp8fxFauAjlt7AKmcQsNbsiQEtWwqlt3etuvCLQSb4dUL4 "Python 3 – Try It Online")
[Answer]
#  HQ9+T, - 4 \* 0.8 = 3.2 points
```
qqqq
```
It's a valid quine (ish) and a quine every second and fifth char.
I couldn't resist . . . .
]