text:
Burning Bridges
Note: When I refer to a bridge, I mean it in the non-mathematical sense
Introduction
You are on a network of islands which are connected by wooden bridges and you want to see if you can burn every bridge in the island network. However, you can only burn a bridge once you've walked over it.
Once a bridge has been burned, it has gone and you cannot go back over it. None of the islands are connected.
Since you are going on a stroll, you cannot swim.
Challenge
Given a list of the bridges and which islands they connect, output a truthy value if you can burn every bridge and falsey value if you cannot.
Input
The input will be a list of numbers. A bridge is defined as:
X,Y

Where are X and Y are integers. Each bridge has an integer number which X and Y refer to.
For example,
2,6

Means that there is a bridge between the islands 2 and 6.
The input will be a list of these bridges:
2,6 8,1 8,2 6,1

You may take this a flat array, if you wish.
Rules
The numbers for the islands will always be positive integers, n, where 0 < n < 10. The island numbers will not always be contiguous.
When you walk over a bridge, you must burn it.
You will be given a maximum of eight islands. There is no limit on the number of bridges.
Island networks will always connect together. There will always be exactly one connected component.
This is an undirected network. For example, you can go either way across the bridge 1,2.
Examples
Input > Output
1,2 1,3 1,3 1,4 1,4 2,3 2,4 > Falsey
1,5 1,6 2,3 2,6 3,5 5,6 > Truthy
1,2 1,3 1,4 2,3 2,4 3,4 > Falsey
1,2 > Truthy

Winning
Shortest code in bytes wins.

Can we assume that there will not be more than one bridge between two islands (sorry, didn't notice this during review)?

this is an undirected graph, yes? So I can walk on a (1,2) bridge from 2 to 1

@HyperNeutrino No, see the first example where there are two bridges between 1 and 2 and two bridges between 1 and 3

@rogaos Correct

Oh whoops I'm dumb >.< Also in your third test case, 4 doesn't show up; does that mean that island 4 does not exist?

@HyperNeutrino Correct

So you're just asking us to check if the graph has an Eulerian path?

@Notatree Yes, basically

Possible duplicate

Should "at least one connected component" say "exactly one connected component"?

Python 2,  102 92 43 bytes (40 in Python 3)
Thanks to @Neil for reminding me that you can't have an odd number of vertices with odd degree – and saving 5 bytes.
lambda x:sum(x.count(a)%2for a in set(x))<3

Try it online!
You can cut it down to 40 bytes in Python 3 (thanks to @shooqie):
lambda x:sum(x.count(a)%2for a in{*x})<3

A graph has a Eulerian trail iff the number of vertices with odd degree is 0 or 2.
This takes the input as a flat list, as explicitly allowed by the spec.
This assumes all of the islands are connected.

Yup, BetaDecay says you must burn a bridge after walking over it, so I'll delete my comments.

@Rod Oh yeah, true. :P

lambda x:sum(x.count(a)%2for a in{*x})in[0,2] - you need Python 3 though

Wow, how does that work?

@BetaDecay *x "explodes" x into x1,x2,x3..., so you can pass it straight into {} which is essentially syntactic sugar for the set constructor.

Why not just <4? It's not as if you're going to have an odd number of vertices of odd degree...

@Neil good point... silly oversight. Thanks!

Mathematica, 27 26 bytes
Assuming that it is a connected graph.
Tr@Mod[Last/@Tally@#,2]<3&

Takes a flat list as input.
Example:
In[1]:= Tr@Mod[Last/@Tally@#,2]<3&[{1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 2, 3, 2, 4}]

Out[1]= False

I'm surprised that there's no builtin for this!

...aand there's the built-in :D

Is the FindEulerianCycle part of that answer useful?

Jelly, 9 bytes
Qċ@€%2S<3

Try it online!
Port of rogaos's Python answer. If you upvote this answer, please upvote that one too. :)

Pyth,  14 11  10 bytes
>3sm%/Qd2{

Try it online!
My first Pyth program! I'm sure it could be golfed a great deal.
Thanks to @Rod for saving 1 byte by using Q implicitly.
Same general idea as my Python answer.

I guess you could reverse the check, to use the last Q implicitly ->  >3sm%/Qd2{


text:
Index of the row with most non-zero elements
This is a simple one: Take a matrix of integers as input, and output the index of the row with the most non-zero elements. You may assume that there will only be one row with the most non-zero elements.
Test cases:
These are 1-indexed, you may choose if you want 0 or 1-indexed.
1
0
row = 1
---
0  -1
0   0
row = 1
---
1   1   0   0   0
0   0   5   0   0
2   3   0   0   0
0   5   6   2   2
row = 4
---
0   4   1   0
0   0  -6   0
0   1   4  -3
2   0   0   8
0   0   0   0
row = 3

MATL, 6 bytes
!gs&X>

Input is a matrix, with ; as row separator.
Try it online! Or verify all test cases.
Explanation
!     % Transpose
g     % Logical: convert non-zeros to 1
s     % Sum of each column, or sum of row if there's a single row
&X>   % Arg max. Implicitly display

Mathematica, 23 bytes
Ordering[Count@0/@#,1]&

R, 31 bytes
pryr::f(which.min(rowSums(!m)))

returns an anonymous function which takes a matrix:
function(m)which.min(rowSums(!m))

rowSums sums the rows, with !m transforming 0 to 1 and everything else to 0. which.min returns the 1-based index of the first row which contains the min sum (i.e., which row has the fewest zeros).
Try it online!

You need which.min() since non-zero elements will become FALSE with !m.

@user2390246 oh, wow, I completely misread the question. Fixed, thank you.

05AB1E, 8 6 bytes
ΣĀO}θk

Try it online!
-2 Bytes thanks to Erik the Outgolfer
Explanation
ΣĀO}θk
Σ  }   # Sort input by following code
 Ā      # Is element not 0? (vectorized)
  O     # Sum
    θk # Get index of "largest" element
       # Implicit print

Use Ā instead of Ä0› for -2.

Yee just realized there is probably a better way to do that part than what I had. Damn I feel like I'm learning a new 05AB1E command every day ^^

Haskell, 46 42 41 bytes
snd.minimum.(`zip`[1..]).map(filter(==0))

Try it online!
How it works
    map                    -- for each row
        (filter(==0))      -- collect the 0s
    (`zip`[1..])           -- pair with row index  (<#0s>, <index>)
  minimum                  -- find the minimum
snd                        -- extract index from pair

Nice! Better than mine, good to learn something.

C#, 69 bytes
using System.Linq;m=>m.IndexOf(m.OrderBy(r=>r.Count(n=>n!=0)).Last())

Takes a List<int[]> as input and returns the 0-indexed result.

Python 3, 54 48 bytes
lambda a:a.index(min(a,key=lambda r:r.count(0)))

Shaved off 6 bytes. Old solution:
lambda a:min(range(len(a)),key=lambda i:a[i].count(0))

Just noticed it matches directly with the changes to the python 2 answer now.

Actually, 9 bytes
0@♀cñ♂RmN

Try it online!
Explanation:
0@♀cñ♂RmN
0@♀c       count zeroes in each row
    ñ♂R    enumerate and reverse each row (each row becomes [count, index] pair)
       m   minimum
        N  last element (the index)

APL (Dyalog), 11 bytes
(⊢⍳⌈/)+/0≠⎕

Try it online!
0≠⎕ Boolean matrix where non-zero
+/ sum rows
( apply the following tacit function to the list of sums
 ⌈/ the maximum's
 ⍳ index
 ⊢ in the argument list
)

Brachylog, 17 bytes
{{∋0}ᶜ}ᵐA;.∋₎~⌋A∧

Try it online!

Jelly, 5 bytes
TL$€M

Try it online!
1-indexed.
So many 5-byte versions...
TL$€M, T€L€M, TJ$€M, T€J€M, ¬¬Ṣ€M, ṠAṢ€M, ṠAS€M, AṠṢ€M, AṠS€M, ¬ċ€0M, ...

Why do they all look like words?

Clojure, 64 bytes
This one works also with negative numbers in the input, luckily the same length as the original:
#(nth(sort-by(fn[i](count(filter #{0}(% i))))(range(count %)))0)

Original:
#(last(sort-by(fn[i](count(filter pos?(% i))))(range(count %))))

numbers in matrix are integers. so pos? isn't correct

True, I forgot to account for negative integers. Fixed now.

05AB1E, 5 bytes
€ĀOZk

Try it online!
0-indexed.

Haskell - 69 68 Bytes
Saved one byte thanks to Siracusa!
Rows are zero indexed
g=filter
m y=head$g((==maximum y).(y!!))[0..]
f=m.map(length.g(0/=))

Usage
f [[1,1,0,0,0],[2,3,0,0,0],[0,5,6,2,2],[1,1,1,1,1]]

Try it online!

Defining g=filter saves you one byte

You can even remove a few bytes more with m y=length$takeWhile(<maximum y)y and shortening length instead of filter

CJam, 11 bytes
{0fe=_:e<#}

Try it online!
-2 thanks to Challenger5.

11: {0fe=_:e>#}

@Challenger5 > should be < instead...thanks anyways. :)

q/kdb+, 25 17 16 bytes
Solution:
(*)(<)sum(+)0=/:

Example:
q)(*)(<)sum(+)0=/:enlist(1;0)
0
q)(*)(<)sum(+)0=/:(0 -1;0 0)
0
q)(*)(<)sum(+)0=/:(1 1 0 0 0;0 0 5 0 0;2 3 0 0 0;0 5 6 2 2)
3
q)(*)(<)sum(+)0=/:(0 4 1 0;0 0 -6 0;0 1 4 -3;2 0 0 8;0 0 0 0)
2

Explanation:
first iasc sum flip 0=/:  / ungolfed
                      /:  / each right, apply a function to each item to the right
                    0=    / returns boolean 1b or 0b if item in each list is equal to zero
               flip       / flip (rotate) the output
           sum            / sum these up
      iasc                / return indices if we were to sort ascending
first                     / take the first one

Notes:
The problem is fairly straightforward, this solution feels overly complicated. As soon as I hit submit I realised the error of my ways.
Bonus:
Here's a k solution that weights in at 16 10 9 bytes - almost exactly the same but 7 bytes shorter due to the fact we don't need brackets when using the k built-ins, and as a result some become shorter than the q keywords (e.g. +/ for sum (would be (+/) in q)).
*<+/+0=/:

Jelly, 7 bytes
ċ0$ÞḢi@

Try it online!
ċ0$ÞḢi@  Main link
   Þ     Sort by
ċ0$              the number of occurences of 0
    Ḣ    Take the first element
     i@  Index in the original array

Python 2, 62 bytes
lambda m:max(range(len(m)),key=lambda n:len(filter(abs,m[n])))

Try it online!

Python 2, 64 55 52 48 bytes

Thanks to @Rod for shaving 9 bytes!!: count 0s and use min() instead of max()
@Rod saved yet another 3 bytes: use input() instead of def
@ovs saved 4 bytes: use of lambda and hash-map

lambda x:x.index(min(x,key=lambda n:n.count(0)))

Try it online!

48 bytes

Thanks @ovs. I didn't exactly understand how it works though.

It's more or less the same logic that you had on your answer, but using min with the key parameter

JavaScript (ES6), 62 bytes
0-indexed. Takes a 2D array as input.
a=>(a=a.map(x=>x.filter(y=>y).length)).indexOf(Math.max(...a))

Can you add an explanation for this one? Does filter implicitly "filter" zeroes?

You're supposed to return the index of the row...

Still trying to golf some more off it, @TheLethalCoder, will be adding a demo and an explanation when I'm done. In the meantime, see here for more info on filter, keeping in mind that 0 is falsey.

@Neil: Fixed now.

@Shaggy I assumed that was the case with filter was just making sure.

You may already be below that score by now, but here's a 61: a=>a.map((r,i)=>m=r.map(v=>n+=!!v,n=0)&&n>m?(o=i,n):m,m=0)&&o (not really tested).

PHP, 58 bytes
0-Indexed

<?=array_search(max($a=array_map(array_filter,$_GET)),$a);

Try it online!

V, 18 bytes
òø0
jòÚDuu/"
dGØ¾

Try it online!
Unlike most V answers, this is 0-indexed.
00000000: f2f8 300a 6af2 da44 7575 2f12 220a 6447  ..0.j..Duu/.".dG
00000010: d8be                                     ..

Not bad for a language with no numeric support! ;P
I also have discovered that the uppercase variant of the count command, that is Ø, is horribly broken.

Python 3, 92 bytes
def f(x):
    for e in x:
        e.sort()
    y=x[:]
    y.sort()
    return x.index(y[-1])

First sort each row such that the entrys are [0,0,..,0,x,x,x] then sort the whole matrix, so that the last entry in y is the row we are looking for.
The copy y=x[:] is necessary, since .sort() works inplace, hence we don't know the original index after sorting.
I appreciate any help how to golf this solution further. Most bytes are lost because of the whitespaces in each line. The code itself is only 68 bytes long.
Try it online!

I don't know Python but can't you remove most of the whitespace from this?

@TheLethalCoder Python uses indentation instead of brackets for codeblocks, instead of brackets or keywords (e.g. for .. end).

Even then python can be golfed a fair amount. The following is equivalent to your original code: def f(a):b=list(map(sorted,a));return b.index(sorted(b)[-1])

This answer uses a for loop and a function but with no newlines so I assume you can remove a lot of them although it is Python 2 the whitespace restrictions should be similar.

Don't works for lists with negative numbers

59 bytes with an equivalent def-function that also handles negative values

Even 56 bytes: def f(x):k=[i.count(0)for i in x];print(k.index(min(k)))

JavaScript (ES6), 51 Bytes
m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)

where m is a 2D array and the index returned is 0-indexed
Test cases:

f=
m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)

console.log(f([[1], [0]]))
console.log(f([[0,-1], [0,0]]))
console.log(f([[1,1,0,0,0], [0,0,5,0,0], [2,3,0,0,0], [0,5,6,2,2]]))
console.log(f([[0,4,1,0], [0,0,-6,0], [0,1,4,-3], [2,0,0,8], [0,0,0,0]]))

Pyth, 6 bytes
xQh/D0

Demonstration
Instead of finding the row with the most non-zero elements, I find the row with the least zero elements.
/D0: Order (D) by count (/) of zeros (0). Implicitly applied to Q, the input.
h: Take the first, and minimum, element.
xQ: Find the index (x) in the input (Q) of that element.

This was exactly what I had a well. It felt clunky and like I was missing something, but it seems like there's just not a clean way to do it :(

Retina, 46 bytes
%M`\b0
m`(?<=(¶.+)*)$
;$#1
O#`.+
!`(?<=^.+;).+

Try it online!
0-indexed. Works with positive and negative integers (and 0). Assumes no leading zeros.

J, 16 bytes
0{[:/:@:+/@|:0=]

Try it online!

0{&\:1#.|@* for 11: Try it online!

Java (OpenJDK 8), 119 101 bytes
m->{int i=m.length,M=0,I=0,c;for(;i-->0;){c=0;for(int x:m[i])if(x!=0)c++;if(c>M){M=c;I=i;}}return I;}

Try it online!
Java, that sweet verbose language :)
Thanks for saving 18 bytes, @KevinCruijssen ;)

+1 nice answer. Was about to post an even more verbose answer myself.. Was doubting whether to post it, and it's a good thing I hadn't since it's 145 bytes and ugly.. ;) Here it is... EDIT: Hmm, btw, your last two test cases fail..

Checking your code just made me realize there's a bug in my answer! o_O I don't even know how my test cases pass...

Good to go, I fixed it!

Nice! Btw, you can golf it by using a for-each inner loop to get rid of j and other longer parts like j=m[i].length, and m[i][j] like this: m->{int i=m.length,M=0,I=0,c;for(;i-->0;){c=0;for(int x:m[i])if(x!=0)c++;if(c>M){M=c;I=i;}}return I;} (101 bytes)

Java 8, 145 bytes
import java.util.*;m->{int t=0,s=0,i=0,r=0;for(;i<m.size();i++){List l=(List)m.get(i);for(;l.remove(0L););s=l.size();if(s>t){t=s;r=i;}}return r;}

Ugly, but it works..
Explanation:
Try it here.
import java.util.*;         // Required import for List

m->{                        // Method with List parameter and integer return-type
  int t=0,s=0,i=0,          //  Temp integers
      r=0;                  //  Result integer
  for(;i<m.size();i++){     //  Loop over the List of Lists
    List l=(List)m.get(i);  //   Get the inner List
    for(;l.remove(0L););    //   Remove all zeros
    s=l.size();             //   Get the size of the List
    if(s>t){                //   If this size is larger than the previous
      t=s;                  //    Set `t` to this size
      r=i;                  //    And set the result to the index of this row
    }
  }                         //  End of loop
  return r;                 //  Return result-integer
}                           // End of method

Python 2, 51 bytes
def f(x,i=0):print i;x[i].remove(0);f(x,-~i%len(x))

Try it online!
This version removes 0s progressively through the arrays, printing the current index, and crashes when there are no more zeros to remove. Last printed index is the answer.
Python 2, 57 bytes
lambda x,i=0:0in x[i]>x[i].remove(0)and f(x,-~i%len(x))|i

Try it online!
Wanted to try a different approach from what's already here. So here I recursively iterate over the array removing one 0 at a time until the current array no longer has any zeroes - and then output the index of that array.

Java 8, 100 bytes
m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())

Explanation
The power of Lists and Streams! (and without the imports, to boot!)
Let's break this little lambda down into chunks:
m.stream().map(z->{z.removeIf(x->x==0);return z;}

We turn our List of Lists (the matrix in the question) into a Stream and go through each element, removing all of those pesky zeroes from each sub-List. We need to explicitly return the sublist each time here, because Stream.map() converts each object in the Stream to whatever the mapping returns, and we don't want to change them.
.max((q,r)->q.size()-r.size()).get()

We go through our newly de-zeroed sublists, and simply check how big they are next to each other, getting us the biggest sublist. The .get() is because the Stream.max() returns an Optional, requiring that extra function call.
m.indexOf()

We take that biggest sublist, and find where it is in the main List, giving us our result!
Notes
This breaks if the outer list is empty, but I'm taking

You may assume that there will only be one row with the most non-zero elements.

to imply that there will always be at least one row. Correct me if I'm wrong.

Japt, 7 bytes
0-indexed. Takes input as an array of arrays.
mè
bUrw

Test it

Explanation
Implicit input of array U.[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]
mè

Map (m) over U returning the count of truthy (non-zero) elements in each sub-array. Implicitly assign this new array to U.[2,1,3,2,0]
Urw

Reduce (r) array U by getting the greater of the current value and the current element.3
b

Get the first index in U where the element equals that value and implicitly output the result.2

Vyxal, 34 bitsv2, 4.25 bytes
vT@ÞM

Try it Online!
Bitstring:
1000101100100011101101110100011000

optimally encoded solution

Uiua, 7 bytes
⊢⍖/+≠0⍉

Try it!
⊢⍖/+≠0⍉
      ⍉  # transpose
    ≠0   # where is it not equal to zero?
  /+     # sum columns
⊢⍖       # index of maximum

Perl 5 -pa, 25 bytes
$;[grep$_,@F]=$.}{$\=pop@

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
MacGyver's Second Toolbox
In this question each answer will get a "toolbox" that can be used to construct a program/function.  The toolbox will consist of two things:

a list of programming languages
a list of valid characters

You must write a valid program/function in one of the languages provided using only the characters in the toolbox.  Your program/function should output the number of answers already present on this question.
Once you have written and posted an answer the language and characters you have used will be removed from the toolbox and 1 new language and 8 new characters will be randomly added to be used as the toolbox for the next answer.
Rules

Each answer will:

Output the number of valid answers coming before it
Contain a subset of the characters provided in the toolbox for that answer.  (repeats are allowed)
Be in one of the languages from the provided toolbox

The next toolbox will determined by this python program.  To generate the next toolbox put in the remaining languages and characters along with the post id of the last answer.
The language list here is all the languages available on try it online at the time of this post.  The characters have char codes 0-127.
You may write either a full program or a function as your answer.  Since REPLs are different languages they will not be allowed.  (use the TIO version of every language)
If a language uses a special encoding the characters should be interpreted as bytes (decoded from ASCII and padded with a zero).
The starting toolbox will be randomized from this questions post id (128464), there will be 7 languages to start and I will add the characters echoprint0 and ascii 0-31 for free to get people started.
You may not answer twice in a row

Scoring
Each time a person answers they will get a number of points for their answer.  The goal is to get as many points as possible. For an answer in language X you will get as many turns as language X has gone unused in the toolbox. For example the first person to answer will get 1 point because the language was just added to the toolbox.  There will not necessarily be an end and I will not be accepting any answers.
Sporting
This is a competition, but I encourage you to put fun above winning while still staying competitive (if I could make the winning criteria "fun had" I would).  Some things that are not fun:

Intentionally using characters you don't need to stunt future answers.
Attempting to game the post id system to make future tool boxes harder to use.
Attempting to game the post id system to make future tool boxes easier to use.

I can't prevent any one from doing these things, but I will be downvoting any answers I suspect are doing this.
On a more positive note, here are some things that are good sporting and encouraged:

Coordinating with other users in chat.
Saving characters for harder or more restrictive languages

This is a second iteration of a challenge found here.  It improves a number of problems with the first one. Here is a meta discussing these questions.

What's the first toolbox?

@CalculatorFeline Its linked in the question, it is seeded with the question id.

The python script is assuming an answer ID of 126443.

Who is supposed to handle updating the toolbox?

@CalculatorFeline You should post a link to the next toolbox in your answer.  To avoid a storm of edits the question will not be updated.

So I should remove everything I used from lines 2 and 3 and replace line 1 with 128470?

@CalculatorFeline Yes, I've already done this one for you, but thats the correct method.

@tuskiomi The previous question was very broken.  I used data from it to make a better version.  The differences are small but they are far from insignificant.  Here's the meta about this question.

@tuskiomi the older question and the newer question are created by the same person, and it is appropriate to close older questions as duplicates of newer, better questions.

Oh. I think you should put the meta in your post.

@tuskiomi The biggest difference is the number of characters added to the sandbox each time.  Previously it was 12, which quickly spiraled out of control, meaning that practically every answer had all of ASCII available to it.  I've lowered it to 8, which was the average number of characters used by all the answers in the last version.  I would agree that the difference in seed and scoring are minor changes, but the decrease in characters is the entire reason I've done a second iteration.

@WheatWizard The answer-chain already looks kind of dead :/

After a time, such as three days, without a new solution, adding another 8 chars might help the chain get un-stuck. You could seed it as the last post number, with an 'a' appended to the end, and then 'b' the next three days if it is still stuck. Just an idea.

Is this challenge even possible?

@ppperry I'm not sure it is at this point. I will add more letters to the box when I get the chance.

@WheatWizard Did you ever get around to doing that?

In the current toolbox, what language is "str"?

@ppperry Each language is given by its TIO identifier.  https://github.com/ConorOBrien-Foxx/str

I'm pretty sure this is impossible. Str programs require a ; (not in toolbox) to do anything when given no input. Condit and Tcl programs require a space (not in toobox) as part of the syntax. Scheme needs (. Brain-Flak can't work for obvious reasons (only character in toolbox it understands is )). Java 8 needs a { (not in toolbox) to declare a function. That leaves only maxima, which I don't think can print things without "print" or declare a function without the use of parentheses.

The above comment isn't quite correct, because I forgot about the -> syntax for Java functions, however that isn't in the toolbox either. Doesn't make it possible ...

@ppperry Wish I'd seen your comment before spending an hour trying to continue this, muddling through undocumented/weirdly documented features, and coming to the same conclusion. Unfortunate that half the languages ended up being mainstream languages that require elaborate syntax, and none of the other half use a code page that could make use of the ASCII 0-31 bytes.

This is impossible
Going through all of the languages in the langbox:

The tcl programming language consists of words separated by spaces. The space character is not in the toolbox, so no valid programs can be written.
Str programs by default transform input. In order for them to do anything when given no input, the ; character is required, which is not in the toolbox.
The only means for a program in scheme-chez to do anything is by calling a function using parentheses. All scheme-chez programs therefore need the ( character, which is not in the toolbox
Brain-Flak programs need balanced brackets. The only bracket character in the toolbox is ), so no programs containing balanced brackets are possible.
Similar to scheme, maxima programs require parentheses to do anything.
Java programs require the { or -> character sequences to declare a function (and all full programs need at least one function), none of which are in the toolbox.
Condit programs require the word when, which contains the "e" character, which is not in the toolbox.

Proofs of impossibility are allowed as answers

2. Oasis
n!

Try it online!
Next toolbox

1. Bash, outputs 0
echo	0

Try it online!
The code contains a literal tab.
Next toolbox

Oh :( That's too bad.

Update: This is valid once again :D

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Hello, World! (Every other character)
Write a program that prints "Hello, World!".
But also, if you take only the first, third, fifth, etc. characters of your program, the resulting program should still print "Hello, World!".
If your program is:
abc
def

It should output "Hello, World!", but so should
acdf

No solutions with fewer than 2 characters.

Can there be whitespace around the output?

@rogaos Sure, as long as it's the same in both variations.

Amazing first post!

Seeing all the answers with "HHeelllloo" reminded me of speaking Whale.

Pro tip for avoiding "Hello, World!" built-ins in challenges like this: use a slightly different string of similar complexity like "Greetings, Earthlings!"

I suppose creating a Stuck program (which prints Hello World by default) with 2 ASCII NUL characters (which are both ignored by the interpreter) is considered cheating?

@Daniel Well it is not banned so :/

"No solutions with fewer than 2 characters." Amazing.

What does "take" mean? take out? keep? And I'm assuming that you are counting the newline after 'c', in your example, because you have "acdf".

can there be quotes around the output?

Honestly, I would just say "no use of 'Hello World' builtins." But I'd also add a penalty for golfing languages (or exclude them entirely), so I'm not necessarily the best person to ask.

@trlkly Not all golfing languages have a built-in for "Hello, World!", so I think your former proposition would be a lot fairer than the latter. And to be honest, I don't think the built-ins are that much of problem either. On this challenge (at the moment) only three of the thirty answers on the first page use a built-in.

Is program purposefully excluding functions or are functions that print ok?

@NonlinearFruit The consensus is, that just saying program means that both full programs and functions are allowed.

Golfing languages are specifically designed for small code, and thus get an unfair advantage in golfing contests. That is why I do not like them. Similarly, having a Hello World built-in also gives an unfair advantage. If we actually treated this like real code-golfing, these languages would always win. Instead we just rely on people not liking them. Objective criteria would be better, IMHO.

Python 3, 61 bytes
rant="partisn't"
print(("HHeelllloo,,  WWoorrlldd!!"""[::2]))

Try it online!
Abusing the fact that print is a function in Python 3 :)
The least partisan solution you'll find here on PPCG.
Becomes
rn=print
rn("Hello, World!"[:])

This is beautiful.

If you want to do a Python REPL version, it would just be "HHeelllloo,,  WWoorrlldd!!"""[::2], and that works in 2 or 3.

@musicman523 But, Doesn't REPL surround the text with single-quotes in that case.

@officialaimm Yes, I suppose it does

What is the point of the rant="partisn't. It runs perfectly fine without it

@yamboy1  Try deleting every other letter

I didn't realise it was every other character off the source code. I though that it was every other letter off of the output

I did not know [:] actually worked :o Nice!

This is art. This made me cry.

Cardinal, 29 bytes
%
"
H
e
l
l
o
,

W
o
r
l
d
!

Try it online!
Removing every other character removes all the linefeeds, which still results in Hello, World!:
%"Hello, World!

Try it online!
The reason this works is that % creates four instruction pointers, moving in each of the four cardinal directions. IPs that leave the source code are simply removed. So in the first case, only the south-going IP remains and in the second case, only the east-going IP remains, all the others are simply dropped. In either case, the executed program is then just "Hello, World!. The " toggles to string mode where each cell is simply printed to STDOUT. We don't need to terminate the string, because leaving the source code still terminates the program.
Note that the same idea works in Beeswax, using * instead of % and ` instead of " (this is because Beeswax was largely inspired by Cardinal but uses a hexagonal grid).
Try it online! (vertical) | | Try it online! (horizontal)

C, 125 bytes
xpxuxtxs( ) { }xuxs ( ) { } main( ) {puts ( "Hello, World!" ) ; } mxaxixn ( ) {xpxuxtxs ( " H e l l o ,   W o r l d ! " ) ; }

Try it online!
With even characters removed:
xxxx(){}us(){}mi(){us("el,Wrd");}main(){puts("Hello, World!");}

Try it online!

Actually, 2 bytes
HH

Explanation:
H, as you might expect, pushes Hello, World! to the stack.
The main program (HH) will encounter the first H and push Hello, World! to the stack. On the second H, however, it will try to use two arguments (as the stack needs to be empty to push Hello, World!) and fail. However, this error will be ignored and then Hello, World! will be implicitly printed.
The second program (H) will push Hello, World! once, and that will be impliclty printed.
This is similar to Fatalize's 2-byte answer, but this doesn't really "cheat".
Try it online!

Nice solution, but I think this shouldn't count since it's too much like a one-character solution.

@LeoTenenbaum Why not? It conforms to the rules perfectly fine.

What you explain isn't the case, H would only push Hello, World! on an empty stack, and if the stack isn't empty, it would expect 2 arguments, so there will be an error, and errors are ignored. And no Actually doesn't implicitly print only the topmost element.

@EriktheOutgolfer Oops. Will fix.

This is why Actually is my favorite golfing language. It's at the perfect level of stupid.

Lua, 89 bytes
--- [ [
print("Hello, World!")
--[[ ] ]
pCrAiLnCtU(L"AHTeOlRlFoE,L IWNoEr:lDd !:"D)
---]]

Try it online! As the syntax highlighting shows, this is massive comment abuse.
Alternate:
--[[pit"el,Wrd"
-[]]print("Hello, World!")--]

Try it online!
And for convenience, a program to convert a program into every other character form: Try it online!

I like this one! The commenting format of Lua seems similar to T-SQL, I'm going to try and work on one for that language.

This sort of trick should work for any language with both block comments and line comments (C, JS, etc)

CALCULATORFELINE:D :D

HHeelllloo  WWoorrlldd!! is kinda boring :P

Retina, 39 bytes

HHeelllloo,,  WWoorrlldd!!

(.).x?
$1

Try it online!
Taking every other character gives:

Hello, World!
()x
1

Try it online!
The first program creates a string with the greeting duplicated. Then it replaces each pair of characters with the first character. There is also an empty stage that replaces all empty strings with empty strings in between, but that doesn't do anything. The second program fails to match the letter "x" so it doesn't replace anything after creating the greeting.
Perhaps more amusingly, if the third stage is changed slightly the first set of characters doesn't have to be the same message. This could lead to many identical length solutions such as full and halved.

Charcoal, 25 bytes
H→e→l→l→o→,→ →W→o→r→l→d→!

Try it online!
If you remove the even characters, you just remove the arrow commands that indicate the direction of the next text, and that leaves the following code:
Hello, World!

Try it online!
That also prints the greeting.

Haskell, 85 bytes
{--}main=putStr"Hello, World!"--} m a i n = p u t S t r " H e l l o ,   W o r l d ! "

Try it online!
Every second character removed:
{-mi=uSrHlo ol!-}main=putStr"Hello, World!"

Try it online!
This exploits the two comment formats in Haskell: {- -} for in-line or multi-line comments and -- to comment the rest of the line.

Javascript, 67 bytes
/**/alert`Hello, World`// * / a l e r t ` H e l l o ,   W o r l d `

Every second letter removed:
/*aetHlo ol`/*/alert`Hello, World`

Just like many other answers, this exploits comments.

Nice answer, +1! Saved 2 bytes by creating a port of your answer in my Java 8 answer, and an additional byte when I changed // * / to //**/ (which unfortunately isn't possible in your case due to /**/alert`Hello, World`  being an odd amount of bytes, instead of even like in my case.

Brachylog, 4 bytes
Ḥ~wḤ

Try it online!
Explanation
~w writes its right variable to STDOUT, and ignores its left argument. Ḥ is "Hello, World!", so this prints Hello, World!.
If we only take the first and third chars, we get Ḥw. In that case w writes its left variable and ignores its right variable, so it also prints Hello, World!.
2 bytes
ḤḤ

Try it online!
This is technically a valid answer, but this unifies the output variable of the program instead of printing to STDOUT, so I guess the 4 bytes program is more in the spirit of the challenge.

I do not think the 2 byte answer is 'technically' valid, as the challenge states print.

@Okx print, as in onto a piece of paper?

@theonlygusti It means print to STDOUT.

@Okx the challenge doesn't specify that, so you can't use it as your reason for invalidating Fatalize's answer.

@theonlygusti Sigh... that's what's meant by print by default.

@Okx you're trying to be pedantic to invalidate a solution, but actually there's nothing invalid about it. The challenge only says "output."

x86 machine code, 162 bytes

PROG.COM Download and run it in MS-DOS emulator, DOSBox for example.
90 B3 B4 B4 02 90 90 B3 B2 B2 48 90 90 B3 CD CD 21 90 90 B3 B2 B2 65 90
90 B3 CD CD 21 90 90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 CD CD 21 90
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 2C 90 90 B3 CD CD 21 90
90 B3 B2 B2 20 90 90 B3 CD CD 21 90 90 B3 B2 B2 77 90 90 B3 CD CD 21 90
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 72 90 90 B3 CD CD 21 90
90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 B2 B2 64 90 90 B3 CD CD 21 90
90 B3 B2 B2 21 90 90 B3 CD CD 21 90 90 B3 CD CD 20 90

after removal MINI.COM Download
90 B4 02 90 B2 48 90 CD 21 90 B2 65 90 CD 21 90 B2 6C 90 CD 21 90 CD 21
90 B2 6F 90 CD 21 90 B2 2C 90 CD 21 90 B2 20 90 CD 21 90 B2 77 90 CD 21
90 B2 6F 90 CD 21 90 B2 72 90 CD 21 90 B2 6C 90 CD 21 90 B2 64 90 CD 21
90 B2 21 90 CD 21 90 CD 20

How to run?
Install DOSBox, for Ubuntu/Debian
sudo apt install dosbox

Run it
dosbox

In DOSBOX
mount c /home/user/path/to/your/directory
c:
PROG.COM
MINI.COM

How does it works?
Machine operation codes represents assembly language instructions.
In MS-DOS to print char you will set registers and make interrupt. AH register will be 0x02, DL register contains your char. Interrupt vector is 0x21.
mov ah,0x2  ;AH register to 0x2 (B4 02)
mov dl,0x48 ;DL register to "H" (B2 48)
int 0x21    ;0x21 interrupt     (CD 21)

MS-DOS COM file tiny model is good choise, because it doesn't have any headers. It is limited by 64K, but in our case it doesn't matters.
To stop program use 0x20 interrupt
int 0x20    ;0x20 interrupt     (CD 20)

Magic
If you want to execute 0xAB opcode command with one parameter 0xCD, you write
AB CD

In PROG.COM
90 B3 AB AB CD 90
nop         ; No operation (90)
mov bl,0xb4 ; BL register to AB (B3 AB)
AB CD command (AB CD)
nop         ; No operation (90)

In MINI.COM
90 AB CD
nop         ; No operation (90)
AB CD command (AB CD)

It is equal machine codes, if you don't use BL register.
Generator
Convert text file with hex to hex binary
cat hex_file | xxd -r -p > exec.com

function byte2hex(byte){
 var ret=byte.toString(16).toUpperCase();
 return ret.length==1 ? "0"+ret : ret;
}

function str2hex(str){
 var ret = [];
 for(var i=0;i<str.length;i++){
  ret.push(byte2hex(str.charCodeAt(i)));
 }
 return ret;
}

function genCode(hexArr){
 var ret = [["B4","02"]];
 for(var i=0;i<hexArr.length;i++){
  if(hexArr[i]!=hexArr[i-1]){
   ret.push(["B2",hexArr[i]]);
  }
  ret.push(["CD","21"]);
 }
 ret.push(["CD","20"]);

 return ret;
}

function magicCode(str){
 var ret=[""];
 var code=genCode(str2hex(str));

 for(var i=0;i<code.length;i++){
  ret.push("90 B3 "+code[i][0]+" "+code[i][0]+" "+code[i][1]+" 90");
  if(i%4==3){ret.push("\n");}
 }
 return ret.join(" ");
}

function magicCodeMinified(str){
 var ret=[""];
 var code=genCode(str2hex(str));

 for(var i=0;i<code.length;i++){
  ret.push("90 "+code[i][0]+" "+code[i][1]);
  if(i%8==7){ret.push("\n");}
 }
 return ret.join(" ");
}

var str=prompt("string","Hello, world!");
var out="PROG.COM\n" + magicCode(str)+"\n\nMINI.COM\n"+magicCodeMinified(str);

document.write(out.replace("\n","<br>"));
alert(out);

Remove all  90 90 for -52 bytes.

Also the nop at the very end will never be reached.

Haskell, 102 bytes
The full program:
main= putStr"Hello, World!";;
putSt   x ="p u t S t r  \" H e l l o ,   W o r l d !\"";
mmaaiin = main

and with every other character removed:
mi=ptt"el,Wrd";ptt x=putStr "Hello, World!";main=mi

You can take off 2 bytes by removing the spaces between p u t S t r and \".

Pyth, 31 bytes
p% 2"HHeelllloo,,  WWoorrlldd!!

Try it online!
Becomes
p "Hello, World!

Thanks to @CalculatorFeline for pointing out an error and removing one byte.

Characters kept start from the first, not the second. You can drop the leading space.

Ah, thanks @CalculatorFeline. I read "Take" as "Remove" in the spec.

V, 32 bytes
i;H;e;l;l;o;,; ;w;o;r;l;d;!;<esc>;Ó;

Note that <esc> is a single character, e.g. 0x1b
Try it online!
Removing every other character gives:
iHello, world!<esc>Ó

Try it online!

Jelly, 26 25 bytes
““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »

Try it online!
After removing every second character, we're left with the following code.
“3a;»“3ḅaė;œ»

Try it online!
How it works
““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »  Main link.

““3ḅaė;œ»                  Index into Jelly's dictionary to yield
                           ["", "Hello, World!"].
          “ 3 ḅ a ė ; œ »  Index into Jelly's dictionary to yield.
                          " FullERebitingBEfluffiest adoptable".
         ḷ                 Take the left result.

“3a;»“3ḅaė;œ»  Main link.

“3a;»          Index into Jelly's dicrionary to yield " N-".
               Set the argument and the return value to the result.
     “3ḅaė;œ»  Index into Jelly's dicrionary to yield "Hello, World!".
               Set the return value to the result.

PHP, 53 bytes
#
echo date(
$e_c_h_o='\H\e\l\l\o\,\ \W\o\r\l\d\!
');

With every other character removed:
#eh ae
echo'Hello, World!';

05AB1E, 29 bytes
”ïŸŸ™ ,ï‚‚ï ! ”# ¦2 ä ø¨øJð ý

Try it online!
Explanation
”ïŸŸ™ ,ï‚‚ï ! ”                # push the string "Weekly Hello , Changed World ! "
               #               # split on spaces
                               # RESULT: ['Weekly','Hello',',','Changed','World','!','']
                ¦              # remove the first element (Weekly)
                 2ä            # split in 2 parts
                               # RESULT: [['Hello', ',', 'Changed'], ['World', '!', '']]
                   ø           # zip
                               # RESULT: [['Hello', 'World'], [',', '!'], ['Changed', '']]
                    ¨          # remove the last element
                     ø         # zip
                               # RESULT: [['Hello', ','], ['World', '!']]
                      J        # join each inner list
                       ðý      # join on space

After removing every other character we are left with the code
”Ÿ™,‚ï!” 2äøøðý

Try it online!
Explanation
”Ÿ™,‚ï!”       # push the string "Hello, World!"
        2ä     # split in 2 parts
               # RESULT: ['Hello, ', 'World!']
          ø    # zip, as the string has an odd length the space is lost
               # RESULT: ['HW', 'eo', 'lr', 'll', 'od', ',!']
           ø   # zip again
               # RESULT: ['Hello,', 'World!']
            ðý # join on space

Cubically v2.1, 222 bytes
+0503 @@6 :22 //1 +050501 @@6 :55 +0502 @@6@6 :33 //1 +050502 @@6 :55 +03 //1 +04 @@6 :55 //1 +03 @@6 :55 +01 //1 +0504 @@6 :33 //1 +050502 @@6 :55 +01 //1 +050502 @@6 :55 +0502 @@6 :11 //1 +050501 @@6 :55 +01 //1 +03 @@6

Try it online!
Every other letter:
+53@6:2/1+551@6:5+52@66:3/1+552@6:5+3/1+4@6:5/1+3@6:5+1/1+54@6:3/1+552@6:5+1/1+552@6:5+52@6:1/1+551@6:5+1/1+3@6

Try it online!

Befunge-93, 43 41 bytes
Coming back to this a few years later, I found a way to avoid running those unsupported instructions, meaning this can even be run on implementations that treat those differently.
"!!ddllrrooWW  ,,oolllleeHH"""> :$# ,#__@

Try it online!
Second version
"!dlroW ,olleH">:#,_@

is the shortest possible "Hello World!". This therefore is the shortest possible answer to this question for Befunge-93.
Try It Online

That's brilliant! Much better than my Befunge answer. Can't believe you haven't got any votes for this.

Octave, 49 45 bytes
Saved 4 bytes since Octave doesn't require brackets to do indexing.
'HHeelllloo,,  WWoorrlldd!! ' (1:2 : 3 ^ 3)''

Try it online!
And the reduced one:
'Hello, World!'(:    )'

Try it online!
Explanation:
The initial code has the letters in the string duplicated, so that we're left with Hello, World! when every second is removed. Some spaces are added to ensure the brackets and apostrophes are kept.
The indexing is really 1:2:end. There are 27 characters, and we can't use end or 27 since we must remove a character, so we go with 3 ^ 3 instead. When we remove every third character, the indexing becomes (:) (and some additional spaces).
(:) means "flatten and turn into a vertical vector". So, we need to transpose it, using '. We don't need to transpose the string in the original code, but double transposing works, so the first string is transposed twice using '', and the second is transposed just once.

///, 25 bytes
H\e\l\l\o\,\ \W\o\r\l\d\!

Try it online!
With every other character removed:
Hello, World!

Mathematica, 62 bytes
P0r0i0n0t0@0"0H0e0l0l0o0,0 0W0o0r0l0d0!0"Print@"Hello, World!"

It returns "0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0], and prints Hello, World! as a side effect. When run as a program (not in the REPL), the return value will not be printed.
After removing every other character:
Print@"Hello, World!"rn@Hlo ol!

It returns Null ol! rn[Hlo], and prints Hello, World!.

CJam, 32 bytes
"HHeelllloo,,  WWoorrlldd!! "2 %

Try it online!
Taking every other character gives:
"Hello, World!"

Try it online!

Note the trailing space on the alternated version.

,,,, 34 bytes
 2"Hteoltlaol,l yWhourmladn!! "⟛

On removing the even numbered characters...
 "Hello, World!"

Explanation
With all the characters:
 2"..."⟛

               no-op
 2             push 2 to the stack
  "..."        push "Hteoltlaol,l yWhourmladn!! " to the stack
       ⟛      pop 2 and the string and push every 2nd character of the string
               implicit output

Without the even numbered characters:
 "..."

               no-op
 "..."         push "Hello, World!" to the stack
               implicit output

This implies you don't need to say this is non-competing.

But you're supposed to keep all of the even-indexed characters... (0-indexed)...

Whoops, fixed. Just add another character lol.

Help, WarDoq!, 2 bytes
Hi

Try it online!
H prints Hello, World!, i is a no-op.
Help, WarDoq! can add two numbers and test for primes, so it is considered as a valid programming language per this meta post.

why was this downvoted?

NOP and massive spaces are against the spirit.

+1 because of the novelty on how the resulting source code re-emphasizes the message that gets output.

APL (Dyalog), 35 34 bytes
-1 thanks to Martin Ender.
'0H0e0l0l0o0,0 0W0o0r0l0d0!0'~ ⍕ 0

Try it online!
'0H0e0l0l0o0,0 0W0o0r0l0d0!0' the message with zeros as removable filler characters
~ except
⍕ formatted (stringified)
0 number zero
Leaving just the odd characters, this becomes
'Hello, World!'  .

><>, 47 bytes
Original:
| v~" H e l l o ,   W o r l d ! "

~o<< ;!!!? l

With every second character removed:
|v"Hello, World!"
o<;!?l

Try them online: original, modified
The original program pushes the characters of "Hello, World!" to the stack (in reverse order) interspersed with spaces, then alternately prints a character and deletes one until the length of the stack is zero. The second program does the same, except the deletion instructions ~ are gone.
If you don't mind halting with an error, we can take a leaf out of Martin Ender's Cardinal book: the modified code is
\"!dlroW ,olleH"!#o#

and the original is the same but with newlines inserted between all the characters, for 39 bytes. Try them online: original, modified.

JavaScript, 138 bytes
A lot of people used comments and I found it too easy so here's one entry without comments:
c_n_o_e_l_g ="c o n s o l e . l o g"; console.log ( "_H_e_l_l_o_,_ _W_o_r_l_d_!".replaceAll( "_","") ) ;[ ' s l i c e ' ]+( 0 , - 9 )+ ")"

Taking every other character out:
cnoelg=console.log;cnoelg("Hello, World!.elcAl _,"  ['slice'](0,-9) )

Important
This code uses String.prototype.replaceAll(), which is a fairly recent feature, and thus wont work in older browsers/NodeJS versions (NodeJS v15.0.0 and above is required, for example).
Explanation

First it create an alias of console.log named c_n_o_e_l_g which returns the same as console.log when every other character is removed.
Then console.log is called (being replaced with cnoelg when converted).
Inside console.log there's "_H_e_l_l_o_,_ _W_o_r_l_d_!" in which every underscore (_) is removed, but not in the converted version (they will be removed anyway because in even position); because of the clever placement of the last double quote ("), the string will look like "Hello, World!.elcAl _,".
Since "Hello, World!.elcAl _," needs to be cleaned up, a slice() is applied with the brackets notations ([]), removing the last 9 characters (".elcAl _,").
But we don't want any modification to happen to the not converted version, so a ) closes the console.log being removed when converted alongside a ; (since in even position). Then it will apply correctly to the converted version but nothing will happen to the not converted one, since it's a value not assigned to anything.
This consist of [ ' s l i c e ' ], ( 0 , - 9 ) and ")", concatenated with a + sign (removed during conversion), so that the script stays valid. The last ")" is there to close the console.log in the converted version.

Brainfuck, 155 bytes
- - < - < < + [ + [ < + > - - - > - > - > - < < < ] > ] < < - - . < + + + + + + . < < - . . < < . < + . > > . > > . < < < . + + + . > > . > > - . < < < + .

Try it online!
Every second character removed:
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.

Well, it's valid, I guess...

T-SQL, 75 bytes
---
PRINT 'Hello, World!'
/*
-P-R-I-N-T-'-H-e-l-l-o-,- -W-o-r-l-d-!-'
---*/

Single- and multi-line comment abuse, inspired by CalculatorFeline's LUA version.
After removal of all even-numbered characters, some of which are line breaks:
--PIT'el,Wrd'/
PRINT'Hello, World!'--/

Javascript, 73 bytes
a ='a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/';eval(a.replace(/0/g,''))

Constructs a string a with the content a0l0e0r0t0`0H0e0l0l0o0,0 0W0o0r0l0d0!0`0/0/, then removes all 0's to give alert`Hello, World!`//, which is eval'd.
Taking every other character of the program gives
a=alert`Hello, World!`//;vlarpae//,')

which alerts Hello, World using template string syntax the same way as what was eval'd in the full program, then stores the result of the call in a and includes the insightful comment //;vlarpae//,').

My naive solution
C/C++, 111 105 byes 97 bytes
(6 bytes saved using "puts", inspired by Hawkings)
///
f(){puts("Hello, World!");}
#define x\
_f_(_)_{_p_u_t_s_(_"_H_e_l_l_o_,_ _W_o_r_l_d_!_"_)_;_}

After takeaway
//f)pt(Hlo ol!)}#eiex
f(){puts("Hello, World!");}

Befunge-98, 39 bytes
"" '!'d'l'r'o'W' ','o'l'l'e'H ""c k , @

Try it online!
Every second character removed:
" !dlroW ,olleH"ck,@

Try it online!

Jelly, 32 bytes
 2“HHeelllloo,,  WWoorrlldd!! ”m

Try it online!
-2 bytes thanks to @totallyhuman's answer
Now mine is a dupe >.<
Go upvote that one too :D

dc, 112
 6   C * P
A d * 1 + d P
7 + d P
d P
3 + d P
B   4 * d P
C - P
F   6 * 3 - P
d P
3 + d P
6 - d P
8 - P
B   3 * P

All odd-indexed characters are whitespace that don't affect the output of the program.  Character values are built arithmetically from single digits
Try it online.

Java 8, 245 243 241 239 238 237 bytes (full program)
/**/interface M{static void main(String[]a){System.out.print("Hello, World!");}}//**/ iinntteerrffaaccee  MM{{ssttaattiicc  vvooiidd  mmaaiinn((SSttrriinngg[[]]aa)){{SSyysstteemm..oouutt..pprriinntt((""HHeelllloo,,  WWoorrlldd!!""));;}}}

Try it online.
After removing every other character:
/*itraeMsai odmi(tig])Sse.u.rn(Hlo ol!)}/*/interface M{static void main(String[]a){System.out.print("Hello, World!");}}

Try it online.
-2 bytes (243 → 241) thanks to @OlivierGrégoire.
-2 bytes (241 → 239) by creating a port of @SuperStormer's JavaScript answer.

Java 8, 63 bytes (lambda function)
/**/v->"Hello, World!"//**/vv-->>""HHeelllloo,,  WWoorrlldd!!""

Try it online.
After removing every other character:
/*v>Hlo ol!/*/v->"Hello, World!"

Try it online.
Explanation:
Utilizes //abc single-line comments and /*abc*/ multi-line comments.
See the Java-highlighting of the two programs/functions to see how these type of comments are used.

JavaScript (ES6), 65 bytes
Latecomer to the game...
01?alert`Hello, World!` : a_l_e_r_t ` H e l l o ,   W o r l d ! `

Becomes:
0?lr`el,Wrd`:alert`Hello, World!`

Obviously, neither the a_l_e_r_t function nor the lr function does exist. That's OK, because their respective code paths are never executed.
Demo

let code0 = "01?alert`Hello, World!` : a_l_e_r_t ` H e l l o ,   W o r l d ! `";
let code1 = code0.replace(/../g, s => s[0]);

console.log(code0);
eval(code0);
console.log(code1);
eval(code1);

C (MSVC), 60 bytes
As Stack Exchange doesn't like me posting null bytes, here is an xxd -g1:
00000000: 6d 00 61 00 69 00 6e 00 28 00 29 00 7b 00 70 00  m.a.i.n.(.).{.p.
00000010: 75 00 74 00 73 00 28 00 22 00 48 00 65 00 6c 00  u.t.s.(.".H.e.l.
00000020: 6c 00 6f 00 2c 00 20 00 57 00 6f 00 72 00 6c 00  l.o.,. .W.o.r.l.
00000030: 64 00 21 00 22 00 29 00 3b 00 7d 00              d.!.".).;.}.

For an infinitely less readable textual version, with 0 representing a raw 0x00 byte:
m0a0i0n0(0)0{0p0u0t0s0(0"0H0e0l0l0o0,0 0W0o0r0l0d0!0"0)0;0}0

Explanation
I'll see your small brain comment abuse and raise you one cosmic brain text encoding abuse.
Unlike GCC and Clang, MSVC supports files encoded in UTF-16.
That is what we abuse. MSVC will """incorrectly""" auto-detect this file as-is as UTF-16LE, causing it to """incorrectly""" read it as this, encoded in UTF-16LE:
main(){puts("Hello, World!");}

If we remove every other character (a.k.a. removing every 00 byte), it treats it as UTF-8 (well, technically, the current SBCS/MBCS codepage), and it is compiled as you would probably expect, as the codepoints are now the same as they were in UTF-16LE:
main(){puts("Hello, World!");}

You may say "but this is UTF-16, it should be mi({us"el,Wrd";", but I say that U+0000 is a valid UTF-8 codepoint, and it just looks like UTF-16 by """coincidence""".

Japt, 25 23 bytes
Saved 2 bytes thanks to @Shaggy
`\H\e\¥\o\,\ \W\Ž\l\d\!

Try it online!
This seems to be the optimal compressed string that would output Hello, World! while ignoring every other \.

PHP, 63 bytes
#
echo"Hello, World!";
#eecchhoo""HHeelllloo,,  WWoorrlldd!!"";

Try it online!
PHP, 32 bytes
#eh"el,Wrd"
echo"Hello, World!";

Try it online!

Standard ML (MLton), 75 bytes
(*p r i n t " H e l l o ,   w o r l d ! " ( *)print"Hello, world!"(*  * )*)

Try it online!
After removing every other character, we have:
(print"Hello, world!"(*pitHlo ol!( *))

Try it online!
Just exploits the fact that comments are a digraph.

Pip, 33 bytes
"0H0e0l0l0o0,0 0W0o0r0l0d0!0"RM 0

Removes the 0s from the string, leaving just Hello, World!. Try it online!
The every-other-character version:
"Hello, World!"M0

Uses the map operator to replace each character in 0 with the string "Hello, World!". Try it online!

TeX, 54 bytes
Full version:
 %H e l l o ,   W o r l d ! \ e n d%
Hello, World!\end

Every other character:
 Hello, World!\end
el,Wrd\n

A bit boring, but for completeness.

Alice, 37 bytes
"_!_d_l_r_o_W_ _,_o_l_l_e_H_"_d_&_o_@

Try it online!
Removing every other character gives:
"!dlroW ,olleH"d&o@

Try it online!
The way this works is that Alice's string mode doesn't push all cell values directly to the stack. Some characters have a special meaning. In particular, _ is a wall which retains it's control flow meaning even when in string mode. But a horizontal wall is a no-op when the IP moves horizontally, so none of those _ do anything. Hence, they can be safely removed.

Self-modifying Brainfuck, 39 bytes
< - [ . <<- ] " e m s p X ! - p m m f I

Try it online!
Explanation
For anyone that is not familir with self-modifying brainfuck: The program itself gets put into registers directly left to where you start out from. This allows for some cool stuff you can't do with regular brainfuck.
This program will move back two registers (one with every second char removed) increment it and output in until the loop stops. The loop will stop once you increment the char that ends the loop itself thus making brainfuck ignore it.
Version without every second character:
 <-[.<-]"emspX!-pmmfI

Ruby, 58 bytes
$/>%< <> > ;puts a= %w( H e l l o ,\  W o r l d ! )* "#{}"

Which becomes:
$><<  pt =%(Hello, World!) #}

I borrowed the puts/assignment trick from @G B's solution
Explanation:
The first version compares the ruby global $/ which evaluates to \n to the string " <> " and does nothing with it. Then it creates an array of all the characters in "Hello, World!" and joins them by multiplying by empty string
The second pushes the return value of assignment of the string "Hello, World!" (which happens to be "Hello, World!" directly to $> which is the global for standard out.
Try it online!

Bash, 36 bytes
e\c\h\o  "H"e"l"l"o"," "W"o"r"l"d"!"

With every other character removed:
echo Hello, World!

Invalid escape sequences will be ignored, so \c\h\o makes no difference from cho.

Rust, 85 bytes
| | /**/print!("Hello, World!")//___*//_p_r_i_n_t_!_(_"_H_e_l_l_o_,_ _W_o_r_l_d_!_"_)

Try it online
Every other character:
||/*pit(Hlo ol!)/_*/print!("Hello, World!")

Try it online
Full program, 113 bytes
/**/fn main(){print!("Hello, World!")}//__*//_f_n_ _m_a_i_n_(_)_{_p_r_i_n_t_!_(_"_H_e_l_l_o_,_ _W_o_r_l_d_!_"_)_}

Try it online
Every other character:
/*f an)pit(Hlo ol!)/_*/fn main(){print!("Hello, World!")}

Try it online

Noodel, 25 bytes
Hðeðlðlðoð,ð¤ðWðoðrðlðdð!

Try it:)

How it works
Hðeðlðlðoð,ð¤ðWðoðrðlðdð! # The ð character breaks the string into an array and pushes the array ["H", "e", "l", "l", "o", ",", "¤", "W", "o", "r", "l", "d", "!"].
                          # Implicitly printed to the screen (¤ is the space).

Without every other character gives you :
Hello,¤World!

<div id="noodel" code="Hðeðlðlðoð,ð¤ðWðoðrðlðdð" input="" cols="12" rows="2"></div>

<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

Lua, 85 bytes
I decided to try making a function copying Lua answer. It's slightly shorter than the comment abuse submission.
paints= p_r_i_n_t----
print("Hello, World!")

paints( " H e l l o ,   W o r l d ! " )

Try it online!
Alternated:
pit=print--pit"el,Wrd"
pit("Hello, World!")

Try it online!
Alternator script is in my other answer.

05AB1E, 32 bytes
"
H
e
l
l
o
,

W
o
r
l
d
!
"¶ K

Basically the "s make a string, and the ¶ K removes all newlines.
Try it online!
Version with even characters removed, 16 bytes.
"Hello, World!"

Try it online!

Actually, the even characters are removed, not the odd ones.

Just remove the first space. Then everything works out and you can save a byte in the process :)

My bad, fixing...

Ruby, 63 bytes
puts a= 'Hello, World!'#; p u t s ' H e l l o ,   W o r l d ! '

Which becomes:
pt ='el,Wrd';puts'Hello, World!'

(Abusing comments like a lot of people do)
Try it online!

Very cool, I couldn't think about any way to write it in Ruby. Here's another way to Try it online

61 bytes (Includes Eric Duminil's test suite)

Python 2, 63 bytes
#
print'Hello, World!'
#p r i n t ' H e l l o ,   W o r l d ! '

Try it online!
After transformation, this becomes:
#pitHlo ol!
print'Hello, World!'

Braingolf, 42 40 bytes
#"#H#e#l#l#o#,# #W#o#r#l#d#!#" $_ <$_& @

Try it online!
After removing odd characters:
"Hello, World!"$ $&@

Try it online!
Explanation
Full program:
#"#H#e#l#l#o#,# #w#o#r#l#d#!#" pushes "Hello, World!" (including quotes)

$ adds the silent modifier to the next operator
space does nothing
_ Pops and prints the last item on the stack, but due to silent mode, does not print
< moves the first item on the stack to the end of the stack

This means that $_ <$_ will remove both quotes from the stack

& adds the greedy modifier to the next operator
@ pops and prints the last item on the stack as an ASCII character
  greedy modifier means it prints the entire stack.

With characters removed:
"Hello, World!" Pushes Hello, World!
Spaces are no-ops
&@ Prints entire stack as ASCII
@ is not affected by the silent modifier (apparently)

It feels really cheap using no-ops for this, but it's better than the Java/Python comment solutions imo

C, 111 101 bytes
10 bytes saved thanks to Jasen
Full version:
//*
main(){puts("Hello, World!");}
//**// m a i n ( ) { p u t s ( " H e l l o ,   W o r l d ! " ) ; }

Every other character
/*mi({us"el,Wrd";
/*/main(){puts("Hello, World!");}

Python 2, 73 bytes
print"=#0##Hello, World!"[5:]
#portionate ""IHeeelallof,A TWookralade!?"

Try it online!
Python 2, unfortunately doesn't have that nifty trick the Python 3 answer used :( So I did the obvious comment trickery. "Try it online" code provides the halved version and execs it to make checking easier.
Halved version:

pit=0#el,Wrd"5]
print "Hello, World!"

shell (ksh), 58 bytes
 #e c h o   H e l l o ,   W o r l d ! #
echo Hello World!

(in interactive bash, you'd need to add '\' before the '!')

JavaScript (ES6), 66 bytes

/ /;alert`Hello, World!`
'a l e r t ` H e l l o ,   W o r l d ! `'

//aetHlo ol!
alert`Hello, World!`

Ly, 38 bytes
"""!!ddllrrooWW  ,,oolllleeHH" [po ]

Try it online!
Explanation:
"""HHeelllloo,,  WWoorrlldd!!" [po ]

"""           # open a string literal, close it, then open one again
   ...        # push "HHeelloo,,  WWoorrlldd!!" backwards
      "       # close string literal
         [    # until the stack is empty
          po  # pop off the stack, then output
            ] # end loop

Every other character:
"!dlroW ,olleH"[o]

Try it online!
Explanation:
"!dlroW ,olleH"[o]

"!dlroW ,olleH"    # push "Hello, World!" backwards
               [o] # output until the stack is empty

Befunge-93, 51 bytes
Inspired by Martin's Cardinal solution, I thought it might be fun to try and do something vertical in Befunge as well. It's a little more complicated in Befunge though.
?
"
!
d
l
r
o
W

,
o
l
l
e
H
" :
>>:v$
#^,__@@
v >

Try it online!
We start with a ?(random direction) command, which can potentially send the instruction pointer in any direction. Left and right will just wrap around back to the start, and going up will hit the v at the bottom of the program and reflect back to the start as well. So while we may bounce around for a while, we'll eventually be forced down at some point, pushing the "Hello, World!" string (in reverse) onto the stack. Which brings us to this sequence:
>>:v
 ^,__@

This is just a simple output loop that writes out the string on the stack. The only thing out of the ordinary is the extra _ (branch) when the loop terminates. But because there are only zeros on the stack at that point, the second test will safely continue on to to the right, finishing with the @ (exit) command.

Once we remove every second character, the code looks like this:
?"!dlroW ,olleH":>:$#,_@v>

Try it online!
Again we start with a ?(random direction) command, and again most directions will just end up wrapping back to the start. So eventually we're forced to go to the right, pushing "Hello, World!" (in reverse) onto the stack. Which then brings us to this sequence:
:>:$#,_@

Again this is just a loop outputting the string on the stack. It's very similar to the classic inline print loop, but we've got an extra : (dup) command, and thus require a $ (drop) to cancel it out.

Cubically, 155 bytes
R U + 4 3 2 @ 6 + 5 0 - 4 @ 6 + 3 - 4 @ 6 @ 6 + 1 - 0 0 @ 6 - 3 3 1 @ 6 - 0 0 @ 6 + 4 1 1 0 @ 6 + 0 0 0 0 @ 6 + 1 - 0 0 @ 6 - 0 @ 6 - 2 + 4 @ 6 - 3 3 1 @ 6

The new parser strips out all spaces ¯\_(ツ)_/¯ so either way the code is interpreted like this:
RU+432@6+50-4@6+3-4@6@6+1-00@6-331@6-00@6+4110@6+0000@6+1-00@6-0@6-2+4@6-331@6

Try it online! (spaced)
Try it online! (every other character)

Stax, 33 bytes
"zHzezlzlzoz,z zWzozrzlzdz!z"'z -

Run and debug it
Every other character, 17 bytes
"Hello, World!"z-

Run and debug it
In the first version, 'z - remove all zs from the string.
In the second version, z by itself is empty set, and z- is noop.

Lost, 113 bytes
v<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
>.%?"Hello, worldvU"-+@
v>v%v?v"vHvevlvlvov,v
wvovrvlvdvvvUv"v-v+v@

Try it online!
With removal, 57 bytes
v<<<<<<<<<<<<<<<<<<<<<
.?Hlo olv"+
>%?"Hello, worldvU"-+@

Try it online!

Vyxal, 7 bytes
ka`a`kH

Try it Online!
Pretty straightforward: The kH at the end is a builtin for Hello, World!, and that's the only thing that gets implicitly printed.
With characters removed:
k``H

Try it Online!
This makes use of a quirk in Vyxal where you can put a string in the middle of a constant diagraph, and the constant will be pushed after the string, making this equivalent to ``kH, which pushes the same builtin as before and prints it.

:( I had this

Quite neat version without using kH

Vyxal, 29 bytes
`HHeelllloo,,  WWoorrlldd!!`√

Try it Online!
`Hello, World!√

Try it Online!
Without using the kH builtin, which returns "Hello, World!"
`HHeelllloo,,  WWoorrlldd!!`  # String
                            √ # Get every second character

`Hello, World!  # String (unterminated)
              √ # Ignored due to parsing bug

Pyth, 31 bytes
%y1t"pHEeGlGlhoz,e QwjolrDlBdJ!

eh

Forth, 61 bytes
This uses the fact that \ makes the rest of the line a comment.
 \  . (   H e l l o ,   W o r l d ! )   \
 .( Hello, World! )

Full program
Remove every other byte to get:
  .( Hello, World!) \ (Hlo ol!)

Every other

Japt, 32 28 bytes
Wrote this up and then noticed Oliver beat me to it with the same method in 05AB1E.
Note: The empty line after the comma contains a space character and the empty line after the "W" contains an unprintable.
`
H
e
¥
o
,

W

l
d
!
` rR

Test it
With every second character removed, it becomes (with the unprintable still present between the "W" and the "l"):
`He¥o, Wld!`r

Test it

Swift, 77 bytes
/**/print("Hello, World!")//  * / p r i n t ( " H e l l o ,   W o r l d ! " )

Every other character:
/*pit"el,Wrd"/ */print("Hello, World!")

Java 8, 123 122 bytes
Here is the full code
/**/()->System.out.print("Hello, World!")//_*_/_(_)_-_>_S_y_s_t_e_m_._o_u_t_._p_r_i_n_t_(_"_H_e_l_l_o_,_ _W_o_r_l_d_!_"_)_

Try it online here

Here is the 'every other' code
/*(-Sse.u.rn(Hlo ol!)/*/()->System.out.print("Hello, World!")

Try it online here

LOGO, 63 bytes
 ;p r [ H e l l o ,   W o r l d ! ] e r [
 pr[Hello, World!] ;]

With characters at even index removed
 pr[Hello, World!]er[ rHlo ol! ]

Explanation:
; starts an inline comment in Logo. Therefore the first program is equivalent to
 pr[Hello, World!]

which obviously print "Hello, World!".
In the second program, a function er is invoked. er stands for erase, receive a list in a suitable format as input, and erase some contents specified in the list (the details does not matter). The key point is that er does not return anything, so it is a shorter alternative to ignore, which ignores its contents.

x86 machine code, 73 bytes
Inspired by Евгений Новиков's solution, I thought it should be doable with less tricks, i.e., just jumping around to otherwise "disjoint" codes for all three variants. I'm still trying with a smart variant that uses lodsb; lodsb as central point (so only one string constant is needed for all variants)
EB 14 00 00 8A 8A 17 16 01 01 B4 B4 09 09 CD CD
21 21 CD CD 20 20 8A 1f 01 B4 09 CD 21 CD 20 48
65 6c 6c 6f 2c 20 57 6f 72 6c 64 21 00 48 48 65
65 6c 6c 6c 6c 6f 6f 2c 2c 20 20 57 57 6f 6f 72
72 6c 6c 64 64 21 21 00 00

If I recall correctly from my childhood days, COM's tiny model starts with DS=CS=SS and the code is loaded beginning from CS:0100h. I do not assume it is guaranteed that the code is loaded into a zeroed memory block (if it were guaranteed, I could drop two bytes).
Disassembly of the long code should be
  JMP *+14h
  ; 20 irrelevant bytes
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
message:
  DB "Hello, World!\0"
  DB "HHeelllloo,,  WWoorrlldd!!\0\0"

Disassembly of odd code
  JMP *+00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

Disassembly of even code:
  ADC AL,00h
  MOV DX,message
  MOV AH,09h
  INT 21h;  print string pointed to by DS:DX
  INT 20h;  exit program
  ; some irrelevant bytes
message:
  DB "Hello, World!\0"

dc, 52 bytes
0#[#H#e#l#l#o#,# #W#o#r#l#d#!#]#P#q
[Hello, World!]P

Try it online!
The first line puts a zero on the stack, and then the rest of the line is commented out. The second line prints 'Hello, World!'
With every even character removed, all the #s in the first line disappear, and the line is no longer commented out. It then prints 'Hello, World!' and quits before hitting the second line.

Brainfuck 156 bytes
-
-
<
-
<
<
+
[
+
[
<
+
>
-
-
-
>
-
>
-
>
-
<
<
<
]
>
]
<
<
-
-
.
<
+
+
+
+
+
+
.
<
<
-
.
.
<
<
.
<
+
.
>
>
.
>
>
.
<
<
<
.
+
+
+
.
>
>
.
>
>
-
.
<
<
<
+
.

Powershell, 46 bytes
Full version:
#
"Hello, World"
#" H e l l o ,   W o r l d "

Try it online here
Every other character
#"el,Wrd
"Hello, World"

Try it online here

MAWP, 169 bytes
9/8/W/;/5/5/W/4/W/1/M/;/9/3/W/4/W/;/9/3/W/4/W/;/9/4/W/1/M/3/W/;/5/8/W/4/M/;/8/4/W/;/9/8/M/5/W/2/M/;/9/4/W/1/M/3/W/;/9/9/M/1/M/6/W/;/9/3/W/4/W/;/5/5/W/4/W/;/9/2/M/3/W/;/.

Try it!
Code with every other character removed:
98W;55W4W1M;93W4W;93W4W;94W1M3W;58W4M;84W;98M5W2M;94W1M3W;99M1M6W;93W4W;55W4W;92M3W;.

Try It!

Java (JDK), 123 bytes
/*/ */System.out.print("Hello, world!"); ///\ u 0 0 0 d S y s t e m . o u t . p r i n t ( " H e l l o_,_ _w o r l d ! " ) ;

Try it online!
This isn't a full program - you'll have to paste it into a method somewhere.

Every other character, 62 bytes
//*Sse.u.rn(Hlo ol!) /\u000dSystem.out.print("Hello, world!");

Try it online!
It takes advantage of the way the compiler turns unicode escapes into their corresponding characters.

Julia, 59 bytes
".H.e.l.l.o. .W.o.r.l.d.!\" | > p r i n t #"[2:2:24]|>print

Shortened version :
"Hello World!"|>print#[::4|pit

Try it online!

05AB1E, 25 bytes
”Ÿ™,‚ï!”,””q”
Ÿ
™
,
‚
ï
!

Try it online!
”Ÿ™,‚ï!”,””q”Ÿ™,‚ï!  # full program (newlines aren't important here)
        ,            # output...
”Ÿ™,‚ï!”             # "Hello, World!"
         ””          # push empty string
           q         # exit program
            ”Ÿ™,‚ï!  # push "\nŸ\n™\n,\n‚\nï\n!" (never executed)

Every other character, 13 bytes
”™‚!,””Ÿ™,‚ï!

Try it online!
”™‚!,””Ÿ™,‚ï!  # full program
”™‚!,”         # push "Situation!,"
      ”Ÿ™,‚ï!  # push "Hello, World!"
               # implicit output

Zsh, 35 bytes
e\c\h\o  \H\e\l\l\o\,\ \W\o\r\l\d\!
Attempt This Online!
AtmtTi nie

AWK, 87 bytes
BEGIN {print"Hello, World!" }
B#E#G#I#N# #{#p#r#i#n#t#"#H#e#l#l#o#,# #W#o#r#l#d#!#"# #}

Try it online!
The resulting code is:
BGN{rn"el,Wrd"}BEGIN {print"Hello, World!" }

Because the BGN variable is false (not assigned), the first part of the code has no effect.
dc, 49 bytes
[Hello, World!]p #[[HHeelllloo,,  WWoorrlldd!!]]p

Try it online!

Ly, 39 [40] bytes
"x!xdxlxrxoxWx x,xoxlxlxexHx"'_p_p[xop]

Try it online!
 Thanks to Aaroneous Miller for the -1 improvement hint in the comments.
The alternate code, with all the odd number characters deleted is,
"!dlroW ,olleH"__[o]

Which is straightforward.  The only trick used is relying on Ly's willingness to ignore any character is doesn't recognize.  So the _ characters (and the x characters in the longer code) can be replaced by any character that's undefined in the language.
The longer code works because the loop running through the stack and printing things, meaning
 [xop]

deleted one character for every one it prints.

The challenge says that the modified program should keep the odd-numbered characters, but you removed those ones. This means that you can just remove the first x to make it valid, which also gives you 39 bytes.

ha! thanks for clarifying...

Backhand, 33 bytes
>'l"o'"'l','!'e' 'd'H'WHl'"'o.r'H

Try it online!
Only works in the latest interpreter, so the entire interpreter is copied into the TIO link (TIO's Backhand seems to not have ' implemented).
This one has only one copy of "Hello, World!" in the entire code.
>'l"o'"'l','!'e' 'd'H'WHl'"'o.r'H   Full program
>  "  "                             Push empty string (no-op)
         '  !  '  d  '  l  '  r     Push "!dlr" (`'` pushes next char)
    o  '  ,  '     '  W  '  o  '    Bounce off and push "oW ,o"
 'l  '  l  '  e  '  H               Bounce off and push "lleH"
                       H            Halt and print entire stack

>lo"l,!e dHWl"orH   Halved program
>  "                Start string mode
      !  d  l  r    Push "!dlr"
  o  ,     W  o     Bounce off and push "oW ,o"
 l  l  e  H  "      Bounce off and push "lleH" and end string mode
                H   Halt and print entire stack

Backhand, 34 bytes
>>lvo""!ld,l!reo Wd H,Woll"loerHH"

Try it online!
Halved:
>lo"l,!e dHWl"orH

Try it online!
This one works in the TIO version, and has two disjoint program paths. The full program has its step size reduced at an odd position, which makes the rest of its path totally invisible to the halved program. (Bonus points for looking totally jumbled, I guess.)
>>lvo""!ld,l!reo Wd H,Woll"loerHH"   Full program
>  v                                 Reduce step size to 2
     " ! d l r o W   , o l l e H "   Push the string
                               H     Halt and print

>lo"l,!e dHWl"orH   Halved program
>  "  !  d  l  r    →
  o  ,     W  o     ←
 l  l  e  H  "      →  Push the string
                H   Halt and print

Stacked, 60 bytes
'Hello, World!'  '''H e l l o ,   W o r l d !''' @oouutt out

Try it online!
I generated the second code with this snippet. Second code is:
'el,Wrd' 'Hello, World!' out u

The first one generates two strings, Hello, World! and 'H e l l o ,   W o r l d !'. The latter is saved to variable oouutt, and the former is printed.
The second one generates two strings, outputs the second, then errors after encountering u.

BotEngine, 91 bytes
 vv
 v <
 eHH
 eee
 ell
 ell
 eoo
 e,,
 e
 eWW
 eoo
 err
 ell
 edd
 e!!
 P

Keg, 47 39 35 bytes
`1H1%1;1,1 1c1¡1;1!1`_`H%;, c¡;!` $

Try it online!
And, unless I've somehow misread the challenge, the program with alternating characters:
-hd, 18 bytes
`H%;, c¡;!``%,c;`$

Try it online!

Pari/GP, 47 bytes
p r i n t ( H e l l o "\,\ """W o r l d "\!""")

Try it online!
print(Hello", "World"!")

Try it online!
A boring answer. In PARI/GP, all spaces not contained in a string are simply ignored. Hello and World are variables that can be used in polynomials.

Python 3, 60 bytes
#
exec(#
'p_r_i_n_t_(_"_H_e_l_l_o_,_ _W_o_r_l_d_!_"_)'[::2])

Try it online!
The [::2] slice the string to have 'print("Hello, World!")'. Then we execute it with exec
Every other char :
#ee(
print("Hello, World!")[:]

This prints Hello, World! and then error due to the slice on a None object

x86 machine code (DOS), 53 bytes
Full:
00000000: ba 00 0d b0 01 b0 b4 b0 09 b0 cd b0 21 b0 c3 be  ............!...
00000010: 1a 01 ad cd 29 3c 21 75 f9 c3 48 00 65 00 6c 00  ....)<!u..H.e.l.
00000020: 6c 00 6f 00 2c 00 20 00 57 00 6f 00 72 00 6c 00  l.o.,. .W.o.r.l.
00000030: 64 00 21 00 24                                   d.!.$

Even bytes only, 27 bytes
00000000: ba 0d 01 b4 09 cd 21 c3 1a ad 29 21 f9 48 65 6c  ......!...)!.Hel
00000010: 6c 6f 2c 20 57 6f 72 6c 64 21 24                 lo, World!$

Assembly (NASM syntax)
    [org 0x100]
start:
    ; Encode the half version using the defacto hello world with some
    ; harmless mov instructions. I haven't found a good use for these bytes
    ; yet (point of interest: get 13 in CX or (hello - start) in AX.
    ; mov dx, hello
    ; The offset is halved, then shifted left 8 to get it to encode in the
    ; upper byte.
    ;
    ; As a 3 byte opcode, this jumps the full variant to an odd address,
    ; causing a desync.
    mov dx, ((hello - start) / 2) << 8
    mov al, 0x01
    ; mov ah, 0x09
    mov al, 0xB4
    mov al, 0x09
    ; int 0x21
    mov al, 0xCD
    mov al, 0x21
    ; ret
    mov al, 0xC3

    ; Now for the thicc code. Instead of INT 21:09H, which expects a byte
    ; string terminated with '$', I print each char manually using INT 29H
    ; since I can do that with LODSW.

    ; Get the address of str into SI
    mov si, hello
.loop:
    ; Load one padded UTF-16 character into AX, and advance SI.
    lodsw
    ; Print AL using INT 29H.
    int 0x29
    ; Check for the last character
    cmp al, '!'
    jne .loop
    ; Return to exit
    ret
    ; On the minified version, this is a $-terminated string for INT 21:09H.
    ; db "Hello, World!$"
    ; On the non-minified version it is just dummy thicc.
hello:
    dw __UTF16__("Hello, World!") ; Unicode strings are proof that nasm > gas
    ; this one doesn't need padding
    db '$'

The full variant does this:
    [org 0x100]
start:
    ; bunch of pointless mov instructions

    mov si, str
.loop:
    lodsw
    int 0x29
    cmp al, '!'
    jne .loop
    ret
str:
    dw __UTF16__("Hello, World!")

while the small variant does this
    [org 0x100]
start:
    mov dx, str
    mov ah, 0x09
    int 0x21
    ret
    ; Unexecuted nonsense here
str:
    db "Hello, World!$"

This does not attempt to do even bytes only, unlike Hagen von Eitzen's solution. This allows me to simplify it greatly.
As the comments say, I use two methods for printing the string. For the larger code, I loop over the padded string with LODSB; INT 29H, and for the shorter code I use INT 21:09H to just print the string directly from memory. This means I don't need to use any complex tricks.
I feel like there is some improvement possible, as I think I could take better advantage of the nops and padding.

JavaScript (V8), 66 bytes
"";alert`Hello, World`; " ; a l e r t ` H e l l o ,   W o r l d `"

Try it online!
String as comment, nothing wrong