text:
Quine/Error Quine Polyglot
Your task is simple: Write a program that can be run in two languages. It should be a normal quine (prints its own source code) in language 1, and should be an error quine (generates an error message identical to its own source code) in language 2.
This is code-golf, so the shortest valid submission (in bytes) wins.
Rules:

The languages may be arbitrarily similar. Supersets/similar versions/similar dialects are not disallowed.
The error quine rules are the same as those in Make an Error Quine!.

Related, and Related.

Are two different dialects of BASIC allowed?

@MDXF If they have the exact same behavior except that one outputs to STDERR instead, then no. Otherwise, yes.

So my answer is valid, then.

@MDXF It is valid.

Do C and C++ count as the same language / supersets?

@MDXF I don't see why you're asking. I explicitly said that languages can be arbitrarily similar.

@MDXF But no, they do not.

Sounds good, thanks. Most polyglot challenges define C/C++ submissions as invalid.

Since error messages frequently display the filename, can I specify an exact filename? And can it contain code that will be executed?

Befunge-93 (FBBI) / C (tcc), 93 + 62 = 155 bytes
^"
>#001p#"<>:#,_@#1-8*3:-1*57+55-1*79*57:-1:*77**278\-1:*57$p:1: error: declaration expected

Try it online!: Befunge-93, C
Thanks to randomdude999 for noting that the filename requires matching quotes to work.
Must be saved under the filename ^"\n>#001p#"<>:#,_@#1-8*3:-1*57+55-1*79*57:-1:*77**278\-1:*57$p, where \n is a newline. Because of this, the TIO for C doesn't run exactly as intended. Tested to work on Lubuntu.
Explanation (C):
The program fails to compile, and tcc happily outputs the name of the file as part of its error message. There are multiple compilation errors you can get, based on the beginning of the code. ^ at the start gives us a declaration expected, which is short and doesn't contain any problematic characters like ". On the other hand, the gcc and clang developers are very pessimistic and they chose to output multiple errors at once, which is not very nice, so we aren't using their compilers.
Explanation (Befunge-93):
Befunge is convenient for quines in that its code can also be utilised as character data, thanks to the " command, which toggles string mode. At the beginning, we perform some useless stack operations, then issue a p (put command) which places a NUL character at (0, 1). Then we reflect the instruction pointer to the left and begin reading everything as a string. This has to be done to the left, because of the stack's LIFO nature. After wrapping around and reaching the " character again, the string ends. Note that the NUL character replaced the $ character, creating a delimiter midway through the string. We then push 3 numbers onto the stack and jump over the NUL (because it unfortunately hangs the interpreter when run as an instruction). The static part of the error message has to be executed here. Most of its characters are no-ops, but the p command consumes three arguments (hence why we pushed 3 numbers, otherwise part of the string would be eaten here), and : & 1 characters push a total of 4 values to the stack, which we counteract with a p and a $ (pop and discard) instruction. Then, some arithmetic is performed to push the ASCII codes for ^"\n>#001p#" and finally a loop prints out all the values on the stack as characters until it finds a NUL character and terminates.

You need to find an OS that supports such a filename and list it. I know Windows doesn't support that.

@mbomb007 Supposedly, Linux will usually accept any printable character in a filename except for /. I can't test that myself right now.

What version of tcc did you use? I'm using 0.9.27-3 straight from Arch repos, and the error I get is <define>:1: error: missing terminating " character.

Alright, I found the exact version of tcc used on TIO, and I got the same error message, but only if the quotes of the filename match. Having unmatched quotes seems quite necessary for this answer to function. Here's something that may help you out: Linux also allows newlines in filenames. This is the tcc output when adding a newline and a quote to the end of the filename: (long gist link). This does mean you'll need to find a way to print the newline and the stuff on the 2nd line though.

@randomdude999 Thanks. I've updated the solution to account for this. Quite interesting indeed that an unmatched quote causes such an issue...

Yup, can confirm it works on my Arch now.

Applesoft BASIC / Commodore LCD BASIC, 13 bytes
?SYNTAX ERROR

In the Apple ][ emulator, hit the RESET key to enter BASIC mode.
In the Commodore LCD emulator, hit RightArrowEnter to get into the BASIC application.
In both of them, don't type ?SYNTAX ERROR in all caps, because they automatically capitalize.

non-competing status is reserved for submissions in languages that were made after the challenge. If it is invalid according to the rules, delete it. Await OP's confirmation first because I think this should be valid (assuming it works).

@HyperNeutrino Thanks, edited.

Please update..

Going to have to suspect this one too, then. This question is rather more brutal than it looks...

@ØrjanJohansen Well, I'm not so sure about this one. Technically, the Commore LCD had no standard error byte stream, so is it really an error quine?

As Challenger5's last comment on the error quine thread implies, that's hard to define objectively. :(

@ØrjanJohansen this? I guess that could mean it's impossible to tell whether this is valid or not. We could wait for confirmation from the OP?

I undelete my answer because it didn't seem substantively different from this. The language prints "?SYNTAX ERROR" on all syntax errors (on whatever stream); it's a language feature instead of a property of the program itself.

@RobertFraser Yes, but the fact that /// prints everything except a slash makes it cheating. BASIC does not print everything except a certain character set.

Either way seems to be exploiting language choice instead of actually programming but whatever.

Brainfuck ignores all characters that aren't commands, so be careful betting your money... I'm pretty sure that's possible as long as you don't require it to be short. (I'm too lazy though.)

@ØrjanJohansen Oh that's right. Comment deleted :P

My point is: the vast majority of possible inputs to /// output the same as their input. The vast majority of possible inputs to BASIC output "?SYNTAX ERROR". There's no real problem solving to either method. https://codegolf.meta.stackexchange.com/questions/4877/what-counts-as-a-proper-quine says that one part of the program must encode another part. If my answer is invalid, this should definitely be invalid also.


text:
Partial Sum of Harmonic Sequence!
Definition

In Mathematics, Harmonic Sequence refers to a sequence where
$$a_n = \frac 1 n$$
i.e. the \$n_{th}\$ term of the sequence equals the reciprocal of \$n\$.

Introduction
In this challenge, given a positive integer \$n\$ as input, output the Partial Sum of first \$n\$ terms of the Harmonic Sequence.

Input
You'll be given a positive integer (within the range of numbers supported by your language). It can be either of Signed and Unsigned (depends on you), since the challenge requires only positive integers.
You can take the input in any way except assuming it to be present in a predefined variable. Reading from file, terminal, modal window (prompt() in JavaScript) etc. is allowed. Taking the input as function argument is allowed as well.

Output
Your program should output the sum of the first \$n\$ terms of the Harmonic Sequence as a float (or integer if the output is evenly divisible by 1) with precision of 5 significant figures, where \$n\$ refers to the input. To convey the same in Mathematical jargon, you need to compute
$$\sum_{i=1}^n \frac 1 i$$
where \$n\$ refers to the input.
You can output in any way except writing the output to a variable. Writing to screen, terminal, file, modal window (alert() in JavaScript) etc. is allowed. Outputting as function return value is allowed as well.

Additional Rules

The input number can be either of 0-indexed or 1-indexed. You must specify that in your post.

You must not use a built-in to calculate the partial sum of the first \$n\$ elements. (Yeah, it's for you Mathematica!)

You must not abuse native number types to trivialize the problem.

Standard Loopholes apply.

Test Cases
The Test Cases assume the input to be 1-indexed
Input     Output
1         1
2         1.5
3         1.8333
4         2.0833
5         2.2833

Winning Criterion
This is code-golf, so the shortest code in bytes wins!

Could you give us some testcases?

What precision is required?  Exact output is generally only possible as a fraction, but in many languages that will have to be separate numbers for numerator and denominator. Can we output a)a float, b)a fraction or integer pair c)either?

@Arjun  The harmonic series grows to infinity so it will get hard to meet 10 decimal places as the number gets into the thousands and millions. I would go for significant figures rather than decimal places, and I see no need to be so precise. 5 significant figures should be enough. so 9.9999E10 rather than 99999999999.9999999999

Can we go over 5 significant figures?

By the way, it's known that the harmonic sequence does not contain any integers other than the initial a_1 = 1. (Idea of proof that a_n is not an integer for n>1: let 2^k be the largest power of 2 not exceeding n; then 2^k divides the denominator of a_n.)

Is it fine if the output is a fraction instead of a float? Clojure's default type in division is a ratio, which is basically a fraction.

@Qwerp-Derp No, sorry, that's not allowed.

Jelly, 3 bytes
İ€S

Try it online!
1-indexed.
Explanation:
İ€S Main link, monadic
İ€         1 / each one of [1..n]
  S Sum of

Python 3, 27 bytes
h=lambda n:n and 1/n+h(n-1)

0-indexing or 1-indexing?

Throws RuntimeError when handling input greater than the recursion limit, 1000 by default.

you can do sys.setrecursionlimit(473755252663) but the stack will eventually overflow quite easily

@Arjun it's 1-indexed

JavaScript, 19 18 bytes
1 byte saved thanks to @RickHitchcock
f=a=>a&&1/a+f(--a)

This is 1-indexed.

f=a=>a&&1/a+f(--a)

for(i=0;++i<10;)console.log(f(i))

From what I've seen of other posts, you can remove f= from your answer to save 2 bytes.

@RickHitchcock I cannot remove f= because the function is recursive and it references itself in f(--a). But if this was not a recursive solution, I would have been able to do that

Ah, makes sense!  Save one byte with f=a=>a&&1/a+f(--a).

@RickHitchcock Nice one!

Mathematica, 21 20 16 bytes
This solution is 1-indexed.
Sum[1./i,{i,#}]&

It is 1-indexing

You must not use a built-in to calculate the partial sum of the first n elements. (Yeah, it's for you Mathematica!)

OP means I can't use      HarmonicNumber[#] &

@Jenny_mathy True.

Question only asked for 5 sig fig so you can shorten it to: Sum[1./i,{i,#}]&

And one can further shorten to Tr[1./Range@#]&.

@Ian Miller  If you see the edit you'll see that OP was asking for 10. Thanks for letting me know! and for -4 bytes

@Greg Martin nice approach!

@GregMartin come on, 1 more byte and this will be as short as the built-in :-)

@Ian Mathematica may display 5 sig fig, but the function returns machine-precision numbers (52 binary bits or just under 16 decimal digits of precision)

APL (Dyalog), 5 bytes
+/÷∘⍳

Try it online!
You can add ⎕PP←{number} to the header to change the precision to {number}.
This is 1-indexed.
Explanation
+/÷∘⍳                     Right argument; n
    ⍳                     Range; 1 2 ... n
  ÷                       Reciprocal; 1/1 1/2 ... 1/n
+/                        Sum; 1/1 + 1/2 + ... + 1/n

Pari/GP, 18 bytes
n->sum(i=1,n,1./i)

1-indexing.
Try it online!

CJam, 11 bytes
1.ri,:)f/:+

Try it online!
1-indexed.

PHP, 33 Bytes
1-indexing

for(;$i++<$argn;)$s+=1/$i;echo$s;

Try it online!

Japt -x, 8 6 5 3 bytes
õpJ

With some thanks to ETHproductions
Try it online

0-indexing or 1-indexing?

I think you can save a byte with õ x@1/X

...and another couple bytes by using XpJ instead of 1/X :-)

Thanks, @ETHproductions :) I twigged those as soon as I walked away.

Actually I don't think you even need the _ due to auto-functions. I should really write that tip :P (I should have time today or tomorrow, due to it being Memorial Day)

Nice one, @ETHproductions.

CJam, 11 10 bytes
1 byte removed thanks to Erik the outgolfer
ri),{W#+}*

This uses 1-based indexing.
Try it online!
Explanation
ri            e# Read integer, n
  )           e# Increment by 1: gives n+1
   ,          e# Range: gives [0 1 2 ... n]
    {   }*    e# Fold this block over the array
     W#       e# Inverse of a number
       +      e# Add two numbers

You can use W instead of -1.

@EriktheOutgolfer has outgolfed himself :-)

@LuisMendo I like my name, it's just a name. And yes I outgolfed myself in the process of helping a fellow golfer golf even further.

@Erik It was meant as a joke. Thanks for the help

05AB1E, 3 bytes
LzO

Try it online!
1-indexed.

Haskell, 20 bytes
f 0=0
f n=1/n+f(n-1)

Original solution, 22 bytes
f n=sum[1/k|k<-[1..n]]

These solutios assumes 1-indexed input.

R, 15 bytes
sum(1/1:scan())

Try it online!

Tcl 38 bytes
proc h x {expr $x?1./($x)+\[h $x-1]:0}

That's a very dirty hack, and the recursive calls pass literal strings like "5-1-1-1..." until it evaluates to 0.

Thanks @Christopher for the formatting. With that, the duplication of backslash was no longer necessary.

No problem! It looks better

Pyth, 5 bytes
scL1S

Try it here.
1-indexed.

Axiom, 45 34 bytes
f(x:PI):Any==sum(1./n,n=1..x)::Any

1-Indexed; It has argument one positive integer(PI) and return "Any" that the sys convert
(or not convert) to the type useful for next function arg (at last it seems so seeing
below examples)
(25) -> [[i,f(i)] for i in 1..9]
   (25)
   [[1,1.0], [2,1.5], [3,1.8333333333 333333333], [4,2.0833333333 333333333],
    [5,2.2833333333 333333333], [6,2.45], [7,2.5928571428 571428572],
    [8,2.7178571428 571428572], [9,2.8289682539 682539683]]
                                                      Type: List List Any
(26) -> f(3000)
   (26)  8.5837498899 591871142
                                        Type: Union(Expression Float,...)
(27) -> f(300000)
   (27)  13.1887550852 056117
                                        Type: Union(Expression Float,...)
(29) -> f(45)^2
   (29)  19.3155689383 88117644
                                                   Type: Expression Float

MATL, 5 bytes
:l_^s

This solution uses 1-based indexing.
Try it at MATL Online
Explanation
    % Implicitly grab input (N)
:   % Create an array from [1...N]
l_^ % Raise all elements to the -1 power (take the inverse of each)
s   % Sum all values in the array and implicitly display the result

Husk, 3 bytes
ṁ\ḣ

Try it online!
Output is a fraction.

Vyxal, 3 bytes
ɾĖ∑

Lame answer, but range -> reciprocal -> sum -> implicit out, same as jelly
Try it Online!
Vyxal s, 2 bytes
ɾĖ

2 Bytes w/ -s from @lyxal, -s sums the stack
Try it Online!

2 bytes

Haskell, 21 bytes
f n=sum$map(1/)[1..n]

Brachylog, 6 bytes
⟦₁/₁ᵐ+

Try it online!
This is 1-indexed.
Explanation
⟦₁         Range [1, …, Input]
    ᵐ      Map:
  /₁         Inverse
     +     Sum

C, 54 bytes
i;float f(n){float s;for(i=n+1;--i;s+=1./i);return s;}

Uses 1-indexed numbers.

QBIC, 13 bytes
[:|c=c+1/a]?c

Explanation
[ |        FOR a = 1 to
 :            the input n
   c=c+    Add to c (starts off as 0)
   1/a     the reciprocal of the loop iterator
]          NEXT
?c         PRINT c

Gol><>, 8 bytes
F1LP,+|B

Try it online!
Example full program & How it works
1AGIE;GN
F1LP,+|B

1AGIE;GN
1AG       Register row 1 as function G
   IE;    Take input as int, halt if EOF
      GN  Call G and print the result as number
          Repeat indefinitely

F1LP,+|B
F     |   Repeat n times...
 1LP,       Compute 1 / (loop counter + 1)
     +      Add
       B  Return

Rust, 36 bytes
|n|(1..=n).map(|n|1./n as f64).sum()

Try it online!
Input is an integer, if the input is <=0 the output is zero, and inputting one gets one.

J, 9 bytes
1#.1%1+i.

I'm only posting this because I think it looks really pretty.
Attempt This Online!
1#.1%1+i.
       i.  NB. range 0..n-1
     1+    NB. add 1
   1%      NB. 1 divided by each element
1#.        NB. sum the result

Pyt, 3 bytes
ř⅟Ʃ
        implicit input
ř       produces a list containing 1 to n
 ⅟      takes the reciprocals
  Ʃ     sums the list
        (implicit print)

Try it online!

Scala, 47 bytes
Try it online!
def h(n:Int):Double=if(n==0)0 else 1.0/n+h(n-1)

Thunno 2 S, 2 bytes
RỊ

Try it online!
Explanation
RỊ  # Implicit input
R   # One range
 Ị  # Reciprocal
    # Take the sum
    # Implicit output

Tcl, 61 bytes
proc h {x s\ 0} {time {set s [expr $s+1./[incr i]]} $x;set s}

Try it online!

C (gcc), 35 bytes
float f(n){return n?1./n+f(--n):0;}

Try it online!

Braingolf, 20 bytes [non-competing]
VR1-1[1,!/M,$_1+]v&+

This won't actually work due to braingolf's inability to work with floats, however the logic is correct.
Explanation:
VR1-1[1,!/M,$_1+]v&+   Implicit input
VR                     Create new stack and return to main stack
  1-                   Decrement input
    1                  Push 1
     [..........]      Loop, always runs once, then decrements first item on stack at ]
                       Breaks out of loop if first item on stack reaches 0
      1,!/             Push 1, swap last 2 values, and divide without popping
                       Original values are kept on stack, and result of division is pushed
          M,$_         Move result of division to next stack, then swap last 2 items and
                       Silently pop last item (1)
              1+       Increment last item on stack
                 v&+   Move to next stack, sum entire stack
                       Implicit output of last item on current stack

Here's a modified interpreter that supports floats. First argument is input.

GolfScript, 17 bytes
~),{2.-1??./\/+}*

Try it online!
1-indexed
~                   # Parse n to an integer
 ),                 # Make an array from 0 to n
   {           }*   # For each number in the array, skipping the 0
    2.-1??          # 2^(2^-1) = sqrt( 2 )  We just need any float
          ./        # Divide previous number by itself, this will result in the float 1.0
            \/      # Divide 1.0 by the current number of the array
              +     # Add the result

Without the convertion to float it could be reduced to 10 bytes, but the output would be a fraction.
~),{-1?+}*

Try it online!

Pip, 6 bytes
$+/\,a

Try it online!
Explanation
     a  First command-line argument
   \,   Inclusive range from 1 through that number
  /     Invert each number in the range
$+      Fold on + (summing the list)
        Autoprint (implicit)

Ly, 14 12 bytes
n[:1f/f1-]&+

Try it online!
Found a simpler way to do this...  The original was: 0ns[1f/+l1-s]p
And here's what it's doing.
n

Get 'n' from the challenge (the number of iterations) from the input and push onto the stack.
[...]

As long as the top of the stack is non-zero.
:1f/

Duplicate the top of the stack (the iteration counter), and compute 1/n.
f1-

Flip the two entries on the stack so that the 1/n calculation is second and the iteration counter is on the top.  Then decrement the iteration counter.
&+

Once all the values have been computed, sum the stack and print.

Excel (2016), 28 bytes
=SUM(1/ROW(OFFSET(A1,,,A1)))

Excel (current), 20 bytes
=SUM(1/SEQUENCE(A1))

Desmos, 16 bytes
total(1/[1...n])

Try it on desmos!
Uses the total function instead of sigma notation to be able to shave off the latex. Also uses desmos's built-in vectorization.

HP 28S, 18 bytes
0 1 ROT FOR K K INV + NEXT

Raku, 15 bytes
{sum 1 X/1..$_}

Try it online!
1 X/ 1..$_ is 1 cross-divided by the numbers from 1 up to the input number $_, producing the list 1, 1/2, 1/3, ..., 1/$_.  Then (of course) sum sums them.

J-uby, 16 bytes
:+|:sum+(:/&1.0)

Attempt This Online!

><>, 17 bytes
0$:@?!n$:1-}1$,+!

Try it online!

Itr, 4 bytes
#¹¯S
outputs result as fraction
online interpreter
append 0e* for floating point output
Explanation
#    ; read number from stdin
 ¹   ; 1-based range
  ¯  ; replace elements with their reciprocals
   S ; sum
     ; implicit output

source: Stack Exchange

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

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

sort: votes


text:
Shortest way to generate 12 repeated characters in JavaScript
'---------'
'-'.repeat(9) // longer!

'------------'
(x='----')+x+x
'-'.repeat(12) // same length

Is there any cleverer way of generating strings of 12 repeated characters in JavaScript?

Don't think so but depending on the challenge you may be able to golf multiple runs to save bytes using e.g. RLE

For the special case of commas you can do Array(12)+'', which is shorter than the literal starting at 11 commas and then remains shorter than repeat.

Cool - how often do you need a string of commas?

@SteveBennett sometimes you only care about the string length and not the actual character, and many PPCG challenges allow you to use some ASCII character of your choice for output.

If you're going to be reusing repeat, you can alias it.

If you don't really need 12 identical characters but rather a 12-character string, you can also do 1e11+''.

I'm not sure about javascript, but in python you can do '-'*12

Yeah, that's awesome but doesn't work in JS.

Unfortunately, after what seems an eternity of searching documentation, I can't seem find any solution that will work with the 12-character constraint and generate for any given character given. However, there are a few neat tricks one can do to save some bytes for specific cases:

1eL-1+'' will give a string, filled with 9s, of L length.

''.padEnd(L) will give a string, filled with spaces, of L length. It's only useful when L > 10, otherwise it's too long. This one can be immediately chained with a function.

N/9+'' will give a string, starting with 0. then followed by a bunch of Ns. This does not work when N < 1 or N > 8, and the result obviously does not contain the same characters the whole way, but pretty close and pretty short.

Array(L)+'' will give a string, filled with commas, of length L - 1.

Along the lines of your 1/3+'' tip, you can repeat a digit D (except 0 and 9) a bunch of times similarly with D/9+''.

Array(L)+'' gives L-1 length, right?

Which means that for L=13, the code is 12 characters and the output is 12 characters, so the same as ','.repeat(12)

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


text:
User Appreciation Challenge #1: Dennis ♦
I got the spontaneous idea of making a series of challenges of users that have helped and continue to help the PPCG community be an enjoyable place for everyone, or maybe just specifically for me. :P
If you convert Dennis's name to an array of 1s and 0s where each consonant is 1 and each vowel is 0, the array is [1, 0, 1, 1, 0, 1], which is symmetrical. Thus, your challenge is to determine what other names are like this.
Challenge
Given an ASCII string, remove all characters that aren't letters and determine if the configuration of vowels and consonants are symmetrical. y is not a vowel.
Please note that your program does not have to be this type of string itself.
Test Cases
Dennis -> truthy
Martin -> truthy
Martin Ender -> truthy
Alex -> falsy
Alex A. -> truthy
Doorknob -> falsy
Mego -> falsy

Reference Implementation
This Python 3 code will give the correct output given a test case. It is as ungolfed as I could make it without being ridiculous.
Python 3
s = input()
l = []
for c in s:
	if c in 'AEIOUaeiou':
		l.append(0)
	elif c in 'BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz':
		l.append(1)
print(l == list(reversed(l)), end = '')

Try it online!

When and who is #2?

@cairdcoinheringaahing Thanks for reminding me. It's going to be about Mego (TNB RO hence the italics) but I haven't gotten around to finalizing it yet.

@cairdcoinheringaahing I'm pretty sure he knows already; I said I'd do one about him but I haven't decided if I'm going to do something relating to penguins or TNB yet.

@HyperNeutrino Umm, you can't use italics in titles.

@EriktheOutgolfer Aww :( That sucks.

@Hyperneutrino so multicharacter variable names are ridiculous now? ;)

@dylnan Yes, this is code golf :P At least I don't have spaces in my variable names (cough Kotlin)

Vyxal, 4 bytes
ǍAḂ⁼

Try it Online!
Ǎ    # Non-alphabet chars removed
 A   # Vowel mask (1 for vowel, 0 for not)
  Ḃ⁼ # Is equal to its reverse?

Vyxal 2.4.1, 7 bytes
Ǎk∨vcḂ⁼

Try it Online!
-6 thanks to lyxal
-1 thanks to Underslash

Try it Online! for 8 bytes

Try it Online! for a flagless 8 bytes

Try it Online! another 8 bytes, but this time it uses a fancy double vectorize :D

@Underslash Nice! I think that works with a single vectorise, so 7!

@Ausername I have mixed feelings about that, on the one hand, rip the double vectorize, but on the other hand, ez 7 bytes

@Underslash I'm not actually sure how double vectorise is meant to work :P

@Ausername that's strange, I assumed having multiple vectorizes would go a layer deeper so to speak, but it actually doesn't, so the fact that it worked there I believe is just coincidence.

Jelly, 11 bytes
ŒufØAe€ØCŒḂ

Try it online!
Alternate versions:
ŒlfØae€ØCŒḂ

ŒufØAe€ØcŒḂ

ŒlfØae€ØcŒḂ

Of course a challenge appreciating Dennis must have an answer in a language of his.

Œuf is Egg in french. Just sayin'

05AB1E, 9 bytes
žM¹álSåÂQ

Try it online!
-2 thanks to Adnan.
This attacks Jelly's pain point exactly. It uses l and A, 1-byte equivalents for Jelly's Œl and Øa respectively.

Are you sure that this works? Run this

@MCCCS Hmm, you may be right.

You can replace AÃ by á and DR by Â.

@Adnan Forgot about á, didn't know what Â does, thanks!

Not to rain on your parade, but I'm pretty sure this is not 9 bytes in any encoding. :-) Nine characters is another thing entirely... Is there some guidance on this in the site docs?

@alexis most of these golfing languages use 256 different characters and a custom codepage that maps hex 00 to FF to those 256 characters, see the Jelly answer

@alexis 4.5 years later, but to clarify Stephen's comment a bit more: 05AB1E uses this custom codepage of the 256 characters it knows. The program žM¹álSåÂQ above are the bytes 9E 4D B9 E1 6C 53 E5 C2 51. We can use the --osabie flag to compile and run it in Python. Here a Bash script with the same program as raw bytes.

x86 32-bit machine-code function, 42 41 bytes
Currently the shortest non-golfing-language answer, 1B shorter than @streetster's q/kdb+.
With 0 for truthy and non-zero for falsy: 41 40 bytes.  (in general, saves 1 byte for 32-bit, 2 bytes for 64-bit).
With implicit-length strings (C-style 0-terminated): 45 44 bytes
x86-64 machine-code (with 32-bit pointers, like the x32 ABI): 44 43 bytes.
x86-64 with implicit-length strings, still 46 bytes (the shift/mask bitmap strategy is break-even now).
This is a function with C signature _Bool dennis_like(size_t ecx, const char *esi).  The calling convention is slightly non-standard, close to MS vectorcall/fastcall but with different arg registers: string in ESI and the length in ECX.  It only clobbers its arg-regs and EDX.  AL holds the return value, with the higher bytes of EAX holding garbage (as allowed by the SysV i386 and x32 ABIs, and the Windows x64 calling convention.)

Explanation of the algorithm:
Loop over the input string, filtering and classifying into a boolean array on the stack:  For each byte, check if it's an alphabetic character (if not, continue to next char), and transform it to an integer from 0-25 (A-Z).  Use that 0-25 integer to check a bitmap of vowel=0/consonant=1.  (The bitmap is loaded into a register as a 32-bit immediate constant).  Push 0 or 0xFF onto the stack according to the bitmap result (actually in the low byte of a 32-bit element, which may have garbage in the top 3 bytes).
The first loop produces an array of 0 or 0xFF (in dword elements padded with garbage).  Do the usual palindrome check with a second loop that stops when pointers cross in the middle (or when they both point to the same element if there were an odd number of alphabetic characters).  The upward-moving pointer is the stack pointer, and we use POP to load+increment.  Instead of compare / setcc in this loop, we can just use XOR to detect same/different since there are only two possible values.  We could accumulate (with OR) whether we found any non-matching elements, but an early-out branch on flags set by XOR is at least as good.
Notice that the second loop uses byte operand-size, so it doesn't care what garbage the first loop leaves outside the low byte of each array element.

It uses the undocumented salc instruction to set AL from CF, in the same way that sbb al,al would.  It's supported on every Intel CPU (except in 64-bit mode), even Knight's Landing!  Agner Fog lists timings for it on all AMD CPUs as well (including Ryzen), so if x86 vendors insist on tying up that byte of opcode space ever since 8086, we might as well take advantage of it.
Interesting tricks:

unsigned-compare trick for a combined isalpha() and toupper(), and zero-extends the byte to fill eax, setting up for:
immediate bitmap in a register for bt, inspired by some nice compiler output for switch.
Creating a variable-sized array on the stack with push in a loop.  (Standard for asm, but not something you can do with C for the implicit-length string version).  It uses 4 bytes of stack space for every input character, but saves at least 1 byte vs. optimal golfing around stosb.
Instead of cmp/setne on the boolean array, XOR booleans together to get a truth value directly.  (cmp/salc isn't an option, because salc only works for CF, and 0xFF-0 doesn't set CF.  sete is 3 bytes, but would avoid the inc outside the loop, for a net cost of 2 bytes (1 in 64-bit mode)) vs. xor in the loop and fixing it with inc.

; explicit-length version: input string in ESI, byte count in ECX
08048060 <dennis_like>:
 8048060:       55                      push   ebp
 8048061:       89 e5                   mov    ebp,esp  ; a stack frame lets us restore esp with LEAVE (1B)
 8048063:       ba ee be ef 03          mov    edx,0x3efbeee ; consonant bitmap

08048068 <dennis_like.filter_loop>:
 8048068:       ac                      lods   al,BYTE PTR ds:[esi]
 8048069:       24 5f                   and    al,0x5f    ; uppercase
 804806b:       2c 41                   sub    al,0x41    ; range-shift to 0..25
 804806d:       3c 19                   cmp    al,0x19    ; reject non-letters
 804806f:       77 05                   ja     8048076 <dennis_like.non_alpha>
 8048071:       0f a3 c2                bt     edx,eax    # AL = 0..25 = position in alphabet
 8048074:       d6                      SALC     ; set AL=0 or 0xFF from carry.  Undocumented insn, but widely supported
 8048075:       50                      push   eax
08048076 <dennis_like.non_alpha>:
 8048076:       e2 f0                   loop   8048068 <dennis_like.filter_loop>   # ecx = remaining string bytes
 ; end of first loop

 8048078:       89 ee                   mov    esi,ebp  ; ebp = one-past-the-top of the bool array
0804807a <dennis_like.palindrome_loop>:
 804807a:       58                      pop    eax      ; read from the bottom
 804807b:       83 ee 04                sub    esi,0x4
 804807e:       32 06                   xor    al,BYTE PTR [esi]
 8048080:       75 04                   jne    8048086 <dennis_like.non_palindrome>
 8048082:       39 e6                   cmp    esi,esp             ; until the pointers meet or cross in the middle
 8048084:       77 f4                   ja     804807a  <dennis_like.palindrome_loop>

08048086 <dennis_like.non_palindrome>:
 ; jump or fall-through to here with al holding an inverted boolean
 8048086:       40                      inc    eax
 8048087:       c9                      leave
 8048088:       c3                      ret
;; 0x89 - 0x60 = 41 bytes

This is probably also one of the fastest answers, since none of the golfing really hurts too badly, at least for strings under a few thousand characters where the 4x memory usage doesn't cause a lot of cache-misses.  (It might also lose to answers that take an early-out for non-Dennis-like strings before looping over all the characters.)  salc is slower than setcc on many CPUs (e.g. 3 uops vs. 1 on Skylake), but a bitmap check with bt/salc is still faster than a string-search or regex-match.  And there's no startup overhead, so it's extremely cheap for short strings.
Doing it in one pass on the fly would mean repeating the classification code for the up and down directions.  That would be faster but larger code-size.  (Of course if you want fast, you can do 16 or 32 chars at a time with SSE2 or AVX2, still using the compare trick by range-shifting to the bottom of the signed range).

Test program (for ia32 or x32 Linux) to call this function with a cmdline arg, and exit with status = return value.  strlen implementation from int80h.org.
; build with the same %define macros as the source below (so this uses 32-bit regs in 32-bit mode)
global _start
_start:
    ;%define PTRSIZE 4   ; true for x32 and 32-bit mode.

    mov  esi, [rsp+4 + 4*1]  ; esi = argv[1]
    ;mov  rsi, [rsp+8 + 8*1]  ; rsi = argv[1]   ; For regular x86-64 (not x32)

%if IMPLICIT_LENGTH == 0
        ; strlen(esi)
         mov     rdi, rsi
         mov     rcx, -1
        xor     eax, eax
        repne scasb    ; rcx = -strlen - 2
        not     rcx
        dec     rcx
%endif

    mov  eax, 0xFFFFAEBB   ; make sure the function works with garbage in EAX
    call dennis_like

    ;; use the 32-bit ABI _exit syscall, even in x32 code for simplicity
    mov ebx, eax
    mov eax, 1
    int 0x80           ; _exit( dennis_like(argv[1]) )

    ;; movzx edi, al   ; actually mov edi,eax is fine here, too
    ;; mov eax,231     ; 64-bit ABI exit_group( same thing )
    ;; syscall

A 64-bit version of this function could use sbb eax,eax, which is only 2 bytes instead of 3 for setc al.  It would also need an extra byte for dec or not at the end (because only 32-bit has 1-byte inc/dec r32).  Using the x32 ABI (32-bit pointers in long mode), we can still avoid REX prefixes even though we copy and compare pointers.
setc [rdi] can write directly to memory, but reserving ECX bytes of stack space costs more code-size than that saves.  (And we need to move through the output array.  [rdi+rcx] takes one extra byte for the addressing mode, but really we need a counter that doesn't update for filtered characters so it's going to be worse than that.)

This is the YASM/NASM source with %if conditionals.  It can be built with -felf32 (32-bit code) or -felfx32 (64-bit code with the x32 ABI), and with implicit or explicit length.  I've tested all 4 versions.  See this answer for a script to build a static binary from NASM/YASM source.
To test the 64-bit version on a machine without support for the x32 ABI, you can change the pointer regs to 64-bit.  (Then simply subtract the number of REX.W=1 prefixes (0x48 bytes) from the count.  In this case, 4 instructions need REX prefixes to operate on 64-bit regs).  Or simply call it with the rsp and the input pointer in the low 4G of address space.
%define IMPLICIT_LENGTH 0

; This source can be built as x32, or as plain old 32-bit mode
; x32 needs to push 64-bit regs, and using them in addressing modes avoids address-size prefixes
; 32-bit code needs to use the 32-bit names everywhere

;%if __BITS__ != 32   ; NASM-only
%ifidn __OUTPUT_FORMAT__, elfx32
%define CPUMODE 64
%define STACKWIDTH 8    ; push / pop 8 bytes
%else
%define CPUMODE 32
%define STACKWIDTH 4    ; push / pop 4 bytes
%define rax eax
%define rcx ecx
%define rsi esi
%define rdi edi
%define rbp ebp
%define rsp esp
%endif

    ; A regular x86-64 version needs 4 REX prefixes to handle 64-bit pointers
    ; I haven't cluttered the source with that, but I guess stuff like %define ebp rbp  would do the trick.

    ;; Calling convention similar to SysV x32, or to MS vectorcall, but with different arg regs
    ;; _Bool dennis_like_implicit(const char *esi)
    ;; _Bool dennis_like_explicit(size_t ecx, const char *esi)
global dennis_like
dennis_like:
    ; We want to restore esp later, so make a stack frame for LEAVE
    push  rbp
    mov   ebp, esp   ; enter 0,0 is 4 bytes.  Only saves bytes if we had a fixed-size allocation to do.

    ;         ZYXWVUTSRQPONMLKJIHGFEDCBA
    mov  edx, 11111011111011111011101110b   ; consonant/vowel bitmap for use with bt

;;; assume that len >= 1
%if IMPLICIT_LENGTH
    lodsb   ; pipelining the loop is 1B shorter than  jmp .non_alpha
.filter_loop:
%else
.filter_loop:
    lodsb
%endif

    and   al, 0x7F ^ 0x20  ; force ASCII to uppercase.
    sub   al, 'A'          ; range-shift to 'A' = 0
    cmp   al, 'Z'-'A'      ; if al was less than 'A', it will be a large unsigned number
    ja  .non_alpha
    ;; AL = position in alphabet (0-25)

    bt    edx, eax              ; 3B
%if CPUMODE == 32
    salc                        ; 1B   only sets AL = 0 or 0xFF.  Not available in 64-bit mode
%else
    sbb   eax, eax              ; 2B   eax = 0 or -1, according to CF.
%endif
    push  rax

.non_alpha:
%if IMPLICIT_LENGTH
    lodsb
    test   al,al
    jnz .filter_loop
%else
    loop .filter_loop
%endif
    ; al = potentially garbage if the last char was non-alpha
    ; esp = bottom of bool array

    mov   esi, ebp  ; ebp = one-past-the-top of the bool array
.palindrome_loop:
    pop   rax

    sub   esi, STACKWIDTH
    xor   al, [rsi]   ; al = (arr[up] != arr[--down]).  8-bit operand-size so flags are set from the non-garbage
    jnz .non_palindrome

    cmp   esi, esp
    ja .palindrome_loop

.non_palindrome:  ; we jump here with al=1 if we found a difference, or drop out of the loop with al=0 for no diff
    inc   eax     ;; AL transforms 0 -> 1  or  0xFF -> 0.
    leave
    ret           ; return value in AL.  high bytes of EAX are allowed to contain garbage.

I looked at messing around with DF (the direction flag that controls lodsd / scasd and so on), but it just didn't seem to be a win.  The usual ABIs require that DF is cleared on function entry and exit.  Assuming cleared on entry but leaving it set on exit would be cheating, IMO.  It would be nice to use LODSD / SCASD to avoid the 3-byte sub esi, 4, especially in the case where there's no high-garbage.

Alternate bitmap strategy (for x86-64 implicit-length strings)
It turns out this doesn't save any bytes, because bt r32,r32 still works with high garbage in the bit-index.  It's just not documented the way shr is.
Instead of bt / sbb to get the bit into / out of CF, use a shift / mask to isolate the bit we want from the bitmap.
%if IMPLICIT_LENGTH && CPUMODE == 64
    ; incompatible with LOOP for explicit-length, both need ECX.  In that case, bt/sbb is best
    xchg  eax, ecx
    mov   eax, 11111011111011111011101110b   ; not hoisted out of the loop
    shr   eax, cl
    and   al, 1
%else
    bt    edx, eax
    sbb   eax, eax
%endif
    push  rax

Since this produces 0/1 in AL at the end (instead of 0/0xFF), we can do the necessary inversion of the return value at the end of the function with xor al, 1 (2B) instead of dec eax (also 2B in x86-64) to still produce a proper bool / _Bool return value.
This used to save 1B for x86-64 with implicit-length strings, by avoiding the need to zero the high bytes of EAX.  (I had been using and  eax, 0x7F ^ 0x20 to force to upper-case and zero the rest of eax with a 3-byte and r32,imm8.  But now I'm using the 2-byte immediate-with-AL encoding that most 8086 instructions have, like I was already doing for the sub and cmp.)
It loses to bt/salc in 32-bit mode, and explicit-length strings need ECX for the count so this doesn't work there either.
But then I realized that I was wrong: bt edx, eax still works with high garbage in eax.  It masks the shift count the same way shr r32, cl does (looking only at the low 5 bits of cl).  This is different from bt [mem], reg, which can access outside the memory referenced by the addressing-mode/size, treating it as a bitstring.  (Crazy CISC...)
Intel's insn set ref manual entry for bt does document the masking in the description section:  If the bit base operand specifies a register, the instruction takes the modulo 16, 32, or 64 of the bit offset operand (modulo size depends on the mode and register size).  Apparently I missed it when writing this answer originally; I checked a Jan 2015 version of the PDF and it was already there.
A neat trick here is using xchg eax,ecx (1 byte) to get the count into CL.  Unfortunately, BMI2 shrx  eax, edx, eax is 5 bytes, vs. only 2 bytes for shr eax, cl.  Using bextr needs a 2-byte mov ah,1 (for the number of bits to extract), so it's again 5 + 2 bytes like SHRX + AND.

The source code has gotten pretty messy after adding %if conditionals.  Here's disassembly of x32 implicit-length strings (using the alternate strategy for the bitmap, so it's still 46 bytes).
The main difference from the explicit-length version is in the first loop.  Notice how there's a lods before it, and at the bottom, instead of just one at the top of the loop.
    ; 64-bit implicit-length version using the alternate bitmap strategy
    00400060 <dennis_like>:
      400060:       55                      push   rbp
      400061:       89 e5                   mov    ebp,esp
      400063:       ac                      lods   al,BYTE PTR ds:[rsi]

    00400064 <dennis_like.filter_loop>:
      400064:       24 5f                   and    al,0x5f
      400066:       2c 41                   sub    al,0x41
      400068:       3c 19                   cmp    al,0x19
      40006a:       77 0b                   ja     400077 <dennis_like.non_alpha>
      40006c:       91                      xchg   ecx,eax
      40006d:       b8 ee be ef 03          mov    eax,0x3efbeee  ; inside the loop since SHR destroys it
      400072:       d3 e8                   shr    eax,cl
      400074:       24 01                   and    al,0x1
      400076:       50                      push   rax
    00400077 <dennis_like.non_alpha>:
      400077:       ac                      lods   al,BYTE PTR ds:[rsi]
      400078:       84 c0                   test   al,al
      40007a:       75 e8                   jne    400064 <dennis_like.filter_loop>

      40007c:       89 ee                   mov    esi,ebp
    0040007e <dennis_like.palindrome_loop>:
      40007e:       58                      pop    rax
      40007f:       83 ee 08                sub    esi,0x8
      400082:       32 06                   xor    al,BYTE PTR [rsi]
      400084:       75 04                   jne    40008a <dennis_like.non_palindrome>
      400086:       39 e6                   cmp    esi,esp
      400088:       77 f4                   ja     40007e <dennis_like.palindrome_loop>

    0040008a <dennis_like.non_palindrome>:
      40008a:       ff c8                   dec    eax  ; invert the 0 / non-zero status of AL.  xor al,1 works too, and produces a proper bool.
      40008c:       c9                      leave
      40008d:       c3                      ret

   0x8e - 0x60 = 0x2e = 46 bytes

Update: instead of using 32-bit pointers, I could have used push rsp / pop rbp to copy a 64-bit register in 2 bytes of code.  (Tips for golfing in x86/x64 machine code).  But sub rsi,0x8 and cmp    rsi,rsp would need REX prefixes which I'm avoiding here by using 32-bit pointers.  Perhaps comparing the low 32 could work if the stack doesn't cross a 4GiB boundary, so just the sub.
I wonder if pop rdx / std / lodsq / cld / xor al, dl could work?  No, that's 7 bytes, break-even with just using sub rsi, 8 in the loop body.

Some tricks I used in Vowels up, consonants down probably apply here, but I haven't yet re-golfed this one.  Ideally we could have the interesting bit from the bitmap shifted to bit 7 so we could XOR / JS or JNS without needing and al, 1 anywhere, but that would require the top of the bitmap to extend past 32 bits.

Retina, 49 47 45 bytes
\P{L}

i`[aeiou]
1
\D
2
+`^(.)(.*)\1$
$2
^.?$

Try it online!
Saved 2 bytes thanks to Neil.
Saved another 2 bytes thanks to Martin.
Removes non-letters then replaces vowels with 1 and consonants with 2, to get consistent values. Then repeatedly removes the first and last character if they are the same. Once they aren't, the word was symmetric if there are one or zero characters remaining.

Does \D 2 work to save you a couple of bytes over T`lL`2?

@Neil Yes it seems to, nice catch!

Well done. I was trying to do this :(

PHP, 82 Bytes
<?=strrev($s=preg_replace(["#[^a-z]#i","#[aeiou]#i","#\pL#"],["",0,1],$argn))==$s;

Try it online!

You could prepend typecasting (bool) and remove the $s= and the ==$s check to save 1 byte.

If I am not mistaken, you could replace the (bool) with just 0|| to say false, or … instead, saving 3 additional bytes.

Hm. Couldn't you use \w for word characters instead of the a-z?

@kaiser \w contains digits underscore and letters . This will not work and [^/p{L}] is longer as [^a-z] plus i. I compare the reverse string with the string so $s is needed to create the boolean

That is true. Still the others should work. "Should" … they do.

@kaiser If really neccessary somewhere then typecast to bool is best done by !!.

MATL, 14 bytes
t3Y2m)13Y2mtP=

Try it at MATL Online.
Here is a slightly modified version to check all test cases.
Explanation
        % Implicitly grab the input as a string
        %     STACK: {'Martin Ender'}
t       % Duplicate the input
        %     STACK: {'Martin Ender', 'Martin Ender'}
3Y2     % Push the string 'ABC...XYZabc...xyz'
        %     STACK: {'Martin Ender', 'Martin Ender', 'ABC...XYZabc...xyz'}
m       % Find which characters of the input are letters using this string
        %     STACK: {'Martin Ender', [1 1 1 1 1 1 0 1 1 1 1]}
)       % Use this boolean array to select only the letters
        %     STACK: {'MartinEnder'}
13Y2    % Push the string literal 'aeiouAEIOU' to the stack
        %     STACK: {'MartinEnder', 'aeiouAEIOU'}
m       % Check for membership of each letter of the input in this string.
        %     STACK: {[0 1 0 0 1 0 1 0 0 1 0]}
tP      % Create a reversed copy
        %     STACK: {[0 1 0 0 1 0 1 0 0 1 0], [0 1 0 0 1 0 1 0 0 1 0]}
=       % Perform an element-wise comparison yielding a truthy (all 1's) or
        % falsey (any 0's) result
        %     STACK: {[1 1 1 1 1 1 1 1 1 1 1]}
        % Implicitly display the result

You demonstrate it with "Martin Ender" instead of "Dennis"? i have to look at the challenge title again.

Presumably Suever wanted a demonstration that had some amount of filtering at the first step.

Then he should use "Alex A." instead, it has a period too.

I'm confused what the issue is. I chose Martin Ender because it would actually be true if you remove spaces and false otherwise. I also included a link to all test cases

Haskell, 84 75 74 69 bytes
-10 thanks to @nimi
-5 thanks to @Zgarb
f x=(==)<*>reverse$[elem c"aeiouAEIOU"|c<-x,'@'<c,c<'{','`'<c||c<'[']

The list comprehension replaces each letter with a boolean and removes all other characters. The first part checks whether or not the resulting list is a palindrome.
Try it online!

Two tips: 1) A list comprehension is often shorten than filter followed by map even if you have to switch to non-poitfree. 2) The <$>id is superfluous. f x=(==)<*>reverse$[elem c"aeiouAEIOU"|c<-x,celem['A'..'Z']++['a'..'z']].

You can drop the space between c and " for one more byte.

I think c`elem`['A'..'Z']++['a'..'z'] can be shortened to '@'<c,c<'{','`'<c||c<'['

Pyth, 18 15 bytes
_I/L"aeiou"@Gr0

Try it here.
-2 thanks to KarlKastor, and subsequently -1.

16 bytes: _I/L"aeiou"@Grz0 (using the invariance operator I)

@KarlKastor I knew there had to be some operator like that...thanks. (BTW I can now remove the z too, I will assume quoted input)

Brachylog, 13 bytes
ḷ{∈Ṿg|∈Ḅg}ˢ.↔

Try it online!
Explanation
ḷ                Lowercase the input
 {       }ˢ.     Select each char if:
  ∈Ṿg              it's a vowel, and replace it with ["aeiou"]
     |             Or
      ∈Ḅg          it's a consonant, and replace it with ["bcdfghjklkmnpqrstvwxyz"]
           .↔    The resulting list is a palindrome

JavaScript (ES6), 72 69 bytes
Saved 3 bytes thanks to Neil
Returns a boolean.
s=>(a=s.match(/[a-z]/gi).map(c=>!/[aeiou]/i.exec(c)))+''==a.reverse()

Test cases

let f =

s=>(a=s.match(/[a-z]/gi).map(c=>!/[aeiou]/i.exec(c)))+''==a.reverse()

console.log(f("Dennis"))        // -> truthy
console.log(f("Martin"))        // -> truthy
console.log(f("Martin Ender"))  // -> truthy
console.log(f("Alex"))          // -> falsy
console.log(f("Alex A."))       // -> truthy
console.log(f("Doorknob"))      // -> falsy
console.log(f("Mego"))          // -> falsy

Save a couple of bytes by replacing the 2 empty strings with 2.

Do you even need the +'' at the end? That would save 3 bytes instead.

I like @Neil's idea better!

Python 3, 72 71 bytes
-1 byte thanks to @ovs
def f(s):s=[c in'AEIOU'for c in s.upper()if'@'<c<'['];return s==s[::-1]

Try it online!

def f(s):s=[c in'AEIOU'for c in s.upper()if'@'<c<'['];return s==s[::-1] for 71 bytes

Alice, 28 bytes
/uia.QN."-e@
\1"lyuy.Ra$i1/o

Try it online!
Outputs 1 as truthy and nothing as falsy.
Explanation
Every command in this program executes in ordinal mode, but with a slight twist in the template that allows me to save a byte.  If a newline is an acceptable truthy value, I can save one more byte by the same method.
Linearized, the program is as follows:
1il.uN."aei ou"ayQy.R-$@1o1@

1                           % Append "1" to top of stack
                            % STACK: ["1"]
 i                          % Push input to stack
                            % STACK: ["1", "Dennis"]
  l                         % Convert to lowercase
                            % STACK: ["1", "dennis"]
   .                        % Duplicate
                            % STACK: ["1", "dennis", "dennis"]
    u                       % Convert to uppercase
                            % STACK: ["1", "dennis", "DENNIS"]
     N                      % Take multiset difference; this removes all non-alphabetic characters
                            % STACK: ["1", "dennis"]
      .                     % Duplicate
                            % STACK: ["1", "dennis", "dennis"]
       "aei ou"             % Push "aei ou"
                            % STACK: ["1", "dennis", "dennis", "aei ou"]
              a             % Push newline
                            % STACK: ["1", "dennis", "dennis", "aeiou", "\n"]
               y            % Transliterate: replace all vowels with newlines
                            % STACK: ["1", "dennis", "d\nnn\ns"]
                Q           % Reverse stack
                            % STACK: ["d\nnn\ns", "dennis", "1"]
                 y          % Transliterate: replace remaining characters with "1"
                            % STACK: ["1\n11\n1"]
                  .         % Duplicate
                            % STACK: ["1\n11\n1", "1\n11\n1"]
                   R        % Reverse top of stack
                            % STACK: ["1\n11\n1", "1\n11\n1"]
                    -       % Remove occurrences: for same-length strings, result is "" iff strings are equal.
                            % STACK: [""]
                     $      % Pop stack, and skip next command if ""
                      @     % Terminate (skipped if c/v pattern is palindromic)
                       1o   % Output "1"
                         1  % Push "1" (useless)
                          @ % Terminate

Braingolf,  4  3 bytes
&JP

-1 byte thanks to Erik the Outgolfer
Turns out I had P all along, even before this challenge.
J however, despite being created before this challenge, wasn't pushed to github before the challenge, thus is still non-competing.
Explanation:
&JP  Implicit input, push ASCII value of each char in string to stack
&J   Replace each item in stack with 1 if vowel, otherwise 0
  P  Pop entire stack, push 1 if stack is palindromic, 0 otherwise
     Implicit output of last item on stack

Why do you need n?

@EriktheOutgolfer because I'm a certified moron

Hmm, you forgot to remove it from the explanation.

@EriktheOutgolfer I was gunna write "Erick" then strike out the c, but it just looks like "Eriek"

Won't this fail for the likes of Alex A.?

@Shaggy no, because after J, the stack would be 101001, assuming you exclude the dot, if you include it there'd be an extra 0 at the end. Either way the result would be 0 for false, as expected because Alex A. is not a Dennis name

You might want to double check the spec ;) Non-letter characters should be ignored completely, making Alex A. truthy.

PHP, 87 bytes

Regex free PHP version. Added a "vowel" since stripos can return 0 which is false in PHP.
Flaw fixed by Jörg.
for(;a&$c=$argn[$p++];)!ctype_alpha($c)?:$s.=stripos(_aeiou,$c)?0:1;echo$s==strrev($s);

Try it online!

Same Byte count. for(;a&$c=$argn[$p++];)ctype_alpha($c)?$s.=stripos(_aeiou,$c)?0:1:0;echo$s==strrev($s); but it get the right result for strings that contains zero

@JörgHülsermann Thank you.

Python 3, 92 87 74 72 69 68 bytes
l=[c in'aeouiAEOUI'for c in input()if c.isalpha()]
print(l==l[::-1])

Try it online!

You can remove the space before the for c in s

And you can remove the s variable by replacing s on the second line to input().lower()

CJam, 26 bytes
lel_'{,97>--"aeiou"fe=_W%=

Try it online!
-1 thanks to Esolanging Fruit.

You can replace 26,'af+ with '{,97> to save a byte.

@EsolangingFruit such an old answer...

A byte saved half a year ago is no different than a byte saved now. It's not like there's byte inflation or anything :P

@EsolangingFruit I was referring to my always developing experience with golfing...of course you got a credit as usual, don't worry!

Mathematica, 113 bytes
PalindromeQ@StringCases[StringReplace[#,{Characters["aeiouAEIOU"]->"1",CharacterRange["A","z"]->"0"}],{"0","1"}]&

You can get rid of quite a few bytes: PalindromeQ@StringReplace[#,{Characters@"aeiouAEIOU"->"1",LetterCharacter->"0",_->""}]&

q/kdb+, 42 38 bytes
Solution:
{x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower

Example:
q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Dennis"
1b
q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Adam"
0b
q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Alex A."
1b

Explanation:
lower        // converts argument on the right to lowercase
.Q.a         // lowercase alphabet "abc..xyz"
inter[x;y]   // intersection of x and y (thus only return a-z)
x in "aeiou" // returns boolean list whether x is a vowel; "dennis" = 010010b
|:           // k shorthand for 'reverse'

Edits:

-4 bytes; switching out reverse for k equivalent |:

GolfScript, 42 bytes
{123,65>.26>6<-?)},{"AEIOUaeiou"?)!}%.-1%=

Try it online!
The hard part is generating both the uppercase and lowercase alphabet in one string, which we'll use in a filter function to filter the letters out of the input. Luckily, since strings in GolfScript are just codepoint arrays with a special property, so we can just generate the codepoints in an efficient way. Here's how we generate them:
First, we generate range [0..122], 122 being the codepoint for z. Then, we take the elements from the element at index 65 onwards. 65 is the codepoint for A. Right now, we have [65..122]. All fine, except we have some unwanted codepoints ([91..96]) in there. So, we first make a duplicate of that range. Then, we take the elements from index 26 onwards, and we have [91..122]. After that, we get the elements up to and including index 5. Now we have [91..96]. Finally, we remove those elements from our [65..122], leaving us wil [65..90, 97..122]. Those are the codepoints we want.
Now that we made the upper/lower alphabet codepoint list, we continue our filtering function. The function gets mapped to each character on the input string, which, as I initially said, gets parsed as its codepoint instead. So now we essentially have [codepoint, [65..90, 97..122]]. To find out if char codepoint is a letter, we simply take its index in the list we made. If it isn't there, we'll get -1 as the index instead.
Right now, we get a falsey value only if codepoint == 65, i.e. the first index of our list, since only then would the index be 0. But a single increment will fix this problem, and, now, if codepoint is in our list, we'll get its index + 1, which is always a positive number, thus always truthy, while if it's not there we'll get -1 + 1 = 0, i.e. falsey.
We finally apply the function I described to every char of the input, and we only take the chars for which the function returned a truthy result.
Next up we have to determine if each char is a vowel or consonant. Since the vowels are fewer than the consonants, creating a string of vowels so that we check for that condition is shorter than creating a string of consonants, so we check if each char is a vowel. But, to check if the boolean list is palindromic, we need booleans, which we don't get just by taking the index + 1, since that can result in any number of [1..10] if the char is a vowel. And, as most golfing languages, this one, doesn't have a bool function either. So, we simply use not not x, since not always returns a boolean. But wait; do we really need to have specific booleans? Since not always returns a boolean, why don't we just remove the second not, and actually check if each char is a consonant? Yeah, that's exactly what we'll do!
After the check, which returns a list of booleans, we check if this boolean list we got is a palindrome, which is what this challenge asks us to do. Well, what is the definition of a palindrome? Yes, a palindrome is a list or string which is equal to its reverse. So, how do we check? Simple, we duplicate it, take its reverse, and check against the original list. The result we get is, finally, what our code should return.

Giant explanation for a 42-byte program. Now I guess that it's pretty much self-explanatory...

Stax, 18 bytes
⌠╟%╜«¥│▒g♦°pC₧╤WsV

Run and debug it
Explanation
^"[^A-Z]"zR{VVI0<FLcr=
^                      capitalize input
 "[^A-Z]"zR            remove all non alphabet characters
           {     F     loop over modified string
            VV         "AEIOU"
              I        Index of character (-1 if not present)
               0<      less than 0
                       push the result to stack
                  L    wrap the stack in an array
                   c   duplicate it
                    r  reverse it
                     = are they equal?

Bash, 82 bytes
i=${1//[^a-zA-Z]};a=aeouiAEOUI;b=${i//[$a]/0};c=${b//[!0$a]/1};[ $c = `rev<<<$c` ]

Try it online!
Recives name as parameter, removes non-leters, replaces vowels with 0, non-vowels nor 0 with 1 and compares with same reversed.
Could golf some more if can get to work double or triple substitution
Exit status is 0 for true and 1 for no.

In recent bash versions, i=${i^^*}; converts i to uppercase.  But I think it only saves you an a-z and an aeiou, which is less than the 10B it costs.

APL (Dyalog Unicode), 34 33 24 bytes
Saved bytes thanks to Adám
≡∘⌽⍨'AEIOU'∊⍨⎕a∩⍨819⌶⍨∘1

Try it online!
819⌶⍨∘1 uppercase argument
⎕a∩⍨ intersection with uppercase alphabet
'AEIOU'∊⍨ belongs-to-'AEIOU'? resulting in a boolean vector
≡∘⌽⍨ reversed equivalent to self?

Save a byte with 819⌶⍨∘1

And two with (⊢≡⌽)

… but I can solve this in 24. Want any hints?

@Adám That ⌶ trick is nice, thanks, got 24 too after over two years

In a few of months, you can save another 2 bytes with 819⌶ → ⎕C, or you can go Extended today, and do 819⌶⍨∘1 → ⌈

Python 2, 83 bytes
def f(x):k=map(lambda y:y.lower()in"aeiou",filter(str.isalpha,x));return k==k[::-1]

Defines a function that either gives True or False

You can save 2 bytes by using "aeiouAEIOU".__contains__ instead of lambda y:y.lower()in"aeiou".

CJam, 79 bytes
First-timer! (I did what I could)
r{:X"AEIOUaeiou"#W>{X"BCDFGHJKLMNPQRSTVWXYZbdfghjklmnpqrstvwxyz"#W={'0}&}'1?~}%

Try it online!

Welcome to PP&CG!

Japt v2.0a0, 19 11 bytes
k\L mè\v ê¬

Try it online

Explanation
        :Implicit input of string U.
 k\L    :Remove all non-letter characters from U.
 m      :Map over resulting string, replacing each character ...
 è\v    :with the count of the number of vowels in each single character substring.
 ê¬     :Is the above a palindrome?
        :Implicit output of boolean result.

Ruby, 57 bytes
->s{x=s.scan(/\p{L}/).map{|c|c=~/[aeiou]/i};x==x.reverse}

Try it online!

Perl, 42 bytes
s!(.)\PL*!1+aeiou=~lc$1!ge;$_=$_==reverse

Run with perl -p.

64-bit machine code, 89 bytes.
A function of following signature: eax = f(char * edi)
48 89 F8 48 89 FE 41 B8 22 82 20 00 8A 0E 84 C9
74 23 89 CA 83 E2 DF 0F BE D2 83 EA 41 83 FA 19
77 0E 44 89 C2 48 FF C0 D3 FA 83 E2 01 88 50 FF
48 FF C6 EB D7 C6 00 02 48 FF C7 48 FF C8 8A 17
40 8A 30 40 38 77 FF 75 05 80 FA 02 75 EA 31 C0
80 FA 02 0F 94 C0 C3

Assembled using NASM, from such assembly code:

; edi => input string.
; eax <= 1 or 0.

; notes:
; the string needs to be null terminated and located in a
; writable memory location, as it will be mutated.

BITS 64

DENNIS: MOV RAX, RDI
        MOV RSI, RDI
        MOV R8D, 0x208222
.CTOR:  MOV CL, BYTE [RSI]
        TEST CL, CL
        JE .SP
        MOV EDX, ECX
        AND EDX, -33
        MOVSX EDX, DL
        SUB EDX, 65
        CMP EDX, 25
        JA .LI
        MOV EDX, R8D
        INC RAX
        SAR EDX, CL
        AND EDX, 1
        MOV BYTE [RAX-1], DL
.LI:    INC RSI
        JMP .CTOR
.SP:    MOV BYTE [RAX], 2
.EQL:   INC RDI
        DEC RAX
        MOV DL, BYTE [RDI]
        MOV SIL, BYTE [RAX]
        CMP BYTE [RDI-1], SIL
        JNE .EQE
        CMP DL, 2
        JNE .EQL
.EQE:   XOR EAX, EAX
        CMP DL, 2
        SETE AL
        RET

Not a killer, not even close, but it has a couple of advantages over the 41-byte answer:

Requires no memory (not even stack).
Doesn't require to check the length of a string - it uses null-termination instead.
Doesn't use undocumented CPU instructions.

Just my $0.02 :).

My answer includes a 46-byte x86-64 version using implicit-length (null-terminated) strings, vs. the smaller C++ std::string style explicit-length string version.  It uses 32-bit pointers in 64-bit mode (x32 ABI), but I had a look and I think it 64-bit pointers could be done with only 1 extra byte.  My 64-bit versions don't use any undocumented instructions or behaviour (at the time I thought bt's masking of the count was undocumented, but I just missed it in the manual!)  salc was removed in 64-bit mode.

So the interesting thing about your answer is not using any stack space. But using the input string for scratch space is using memory.  Many callers would need to copy the string before calling this function, which is even worse than just needing to find its length if they didn't already have that value.  Anyway, a different approach is fine and interesting; I don't mean to rain on your parade. :P

MOVSX EDX, DL could be avoided if you did MOVSX EDX, CL earlier, before the AND EDX, -33.  Or loaded ECX originally with movsx ecx, byte [rsi].  -33 is all-ones outside the low 8 bits, so doing it before or after sign-extension is equivalent.  I'm not sure you even need to sign-extend to 32-bit at all, though; the sub/cmp/ja trick to check for alphabetic ASCII works in 8-bit, after setting or clearing the lower-case bit like you're doing with and edx, ~32.  You can probably use lea to copy-and-subtract, and mask cl instead of dl (the shift count gets masked mod 32)

Also, you can copy 64-bit registers in 2 bytes using push reg / pop reg. Tips for golfing in x86/x64 machine code .  Using different registers could let you use AL for more of your 8-bit operations, allowing 2-byte instructions like cmp al, 25.  (Tips for golfing in x86/x64 machine code).  Having a pointer in RSI would allow lodsb to load into AL, and then you could copy from there into CL.  Or not if the pointer increment needs to be conditional.

bt edx, ecx / setc BYTE [RAX-1] might save space over sar/and/mov.  In the 2nd loop, CL instead of SIL would avoid a REX prefix.

Ly, 84 64 bytes
"aeiou">0i['aL[p' +0]ps'a,Gf'z`Lfp*[p<l~sp>rlr0]p]p&sJ>lrJs<l=u;

Try it online!
Still not that short, but getting a stack oriented language with no concept of characters to do this seemed interesting enough to submit.  Plus it's a lot shorter than the initial version I posted in June...

Setup a vowel testing stack

    "aeiou"   - push vowels onto a stack
           >  - swtich to a clean stack

Switch to an input processing stack, prep input

    0   - add a "0", acts as a stopper
     i  - read input into the stack as codepoints

Check each codepoint/char on the stack, building a 0|1 list

    [                                      ]p - loop over the stack
     'aL[p' +0]p                              - lowercase the char
                s                             - stash the character
                 'a,Gf'z`Lfp*                 - check if in "a-z" (3.1)
                             [p<l~sp>rlr0]p   - do 0,1 vowel check (3.2)

3.1 Make sure the character is in a-z
'a,G          - load "a", decrement, do ">" check
    f         - pull char forward (flip top two on stack)
     'z`L     - load "z", increment, do "<" check
         fp   - pull char forward, delete it
           *  - compute "and" of two tests

3.2 Compare char to vowel list, generate 0 or 1 result
    [p         0]p  - if/then, true if char in "a-z"
      <             - switch to "vowel check" stack
       l            - load current char
        ~           - search stack, get 0,1 result
         sp         - save results, delete from stack
           >        - switch to processing stack
            rlr     - reverse stack, load result, reverse again

Compare 0|1 list against it's reverse

    &s             - copy the 0,1 stack to the backup cell
      J            - join the stack elements
       >lrJs       - repeat on another stack, reversed
            <l     - switch back, load 2nd joined stack
              =u;  - print 0,1 depending on equals check

C (gcc), 130 bytes
d(a,l)char*a,*l;{char*y=alloca(*l),*z=y;for(*l=1;*a;a++)if(isalpha(*a))*y++=!strchr("aeiou",*a|32);for(a=y-z;a--;*l*=*z++==*--y);}

Try it online!
Takes input as the string and its length, with the length passed by reference (d(str, &len)), and outputs by modifying len.

Arturo, 58 bytes
$=>[=reverse<=map replace&{/\p{^L}}""=>[in?&"aeiouAEIOU"]]

Try it

Scala 3, 78 bytes
Golfed version. Attempt it online!
_.filter(_.isLetter).map(c=>"aeiou".contains(c.toLower)).pipe(c=>c==c.reverse)

Ungolfed version. Try it online!
case class Test(input: String, output: Boolean)

object Main {
  def f(s:String): Boolean = {
    val filtered = s.filter(_.isLetter)
    val vowels = "aeiou"
    val isVowel = filtered.map(c => vowels.contains(c.toLower))
    isVowel == isVowel.reverse
  }
  def main(args: Array[String]): Unit = {
    val tests = List(
      Test("Dennis", true),
      Test("Martin", true),
      Test("Martin Ender", true),
      Test("Alex", false),
      Test("Alex A.", true),
      Test("Doorknob", false),
      Test("Mego", false)
    )
    for (Test(input, expected) <- tests) {
      val actual = f(input)
      if (actual != expected) throw new AssertionError()
    }
  }
}

Thunno 2, 4 bytes
ỊṃḲ⁼

Explanation
ỊṃḲ⁼  # Implicit input
Ị     # Remove non-alphabets
 ṃ    # For each character: 1 if vowel, 0 otherwise
  Ḳ   # Bifurcate (i.e. duplicate and reverse)
   ⁼  # Are the two lists exactly equal?
      # Implicit output

Screenshot
 (click to enlarge)

Python 3, 65 bytes
lambda s:(l:=[c in'aeiou'for c in s.lower()if'`'<c<'{'])==l[::-1]

Try it online!

Pyke, 12 bytes
#B)l1~-L{D_q

Try it here!
#B)          -    filter(is_alpha, input)
   l1        -   ^.lower()
     ~-L{    -  ^ - "bcdfghjklmnpqrstvwxyz"
         D_q - ^ == reversed(^)

PowerShell, 87 Bytes
$s=("$args"-replace '\P{L}'-replace'[aeiou]',0-replace'\D',1);$s-eq(-join($s[-1..-99]))

Get a copy of the string where vowels are 0 and consonants are 1, with all special chars removed,
compare that string to a reversed version joined back to a string
Output:
PS C:\Users\Connor> "Dennis","Martin","Martin Ender","Alex","Alex A.","Doorknob","Mego" | % {
    $s=("$_"-replace '\P{L}'-replace'[aeiou]',0-replace'\D',1);$s-eq(-join($s[-1..-99]))
}
True
True
True
False
True
False
False

PowerShell, 108 bytes
read-host|%{[char[]]$_|%{$d=$_-replace'\P{L}'-replace'[aeiou]',0-replace'\D',1;$s="$s$d";$r="$d$r"};$s-eq$r}

Axiom, 126 bytes
g(x)==~member?(x,alphabetic());v(s:String):Boolean==(w:=remove(g,s);a:=[member?(w.r,"aeiouAEIOU")for r in 1..#w];a=reverse(a))

test
(8) -> [[i,v(i)] for i in ["Dennis", "Martin", "Martin Ender", "Alex", "Alex A.", "Doorknob", "Mego"]]
   (8)
   [["Dennis",true], ["Martin",true], ["Martin Ender",true], ["Alex",false],
    ["Alex A.",true], ["Doorknob",false], ["Mego",false]]
                                                      Type: List List Any

Actually, 20 bytes
ù⌠úc⌡░⌠"aeiou"c⌡M;R=

Try it online! (runs all test cases)
-3 bytes from Erik the Outgolfer's suggestion on a different answer
Explanation:
ù⌠úc⌡░⌠"aeiou"c⌡M;R=
ù                     lowercase input
 ⌠úc⌡░                characters where function is truthy:
  úc                    is the character a lowercase letter?
      ⌠"aeiou"c⌡M     for each letter:
       "aeiou"c         does the vowel string contain the letter?
                 ;R=  compare equality with reverse (is it a palindrome?)

Retina, 47 bytes
i(`[^a-z]

[aeiou]
1
\D
0
+`^(.)(.*)\1$
$2
^.?$

Try it online!
This is just a different approach for non alphabet chars

Google Sheets, 248 bytes
=ArrayFormula(REGEXREPLACE(REGEXREPLACE(REGEXREPLACE(UPPER(A1),"[^A-Z]",""),"[AEIOU]","0"),"[^0]","1")=REGEXREPLACE(REGEXREPLACE(REGEXREPLACE(UPPER(JOIN("",(MID(A1,LEN(A1)-ROW(INDIRECT("1:"&LEN(A1)))+1,1)))),"[^A-Z]",""),"[AEIOU]","0"),"[^0]","1"))

Three nested REGEXREPLACE functions transform it from the original to a string of ones and zeroes. The JOIN function is used to reverse the original string so it's nested into the same REGEXREPLACE functions to transform it to the reverse string of ones and zeroes. It's a nightmare.

Excel VBA, 115 Bytes
Anonymous VBE immediate window function that takes input from range [A1] and outputs to the VBE immediate window.
For i=1To[Len(A1)]:a=Mid([A1],i,1):b=IIf(Instr(1,"AEIOU",a,1),1,IIf(a Like"[A-Za-z]",0,""))&b:Next:?b=StrReverse(b)

Kotlin, 75 bytes
filter{it.isLetter()}.map{"aeiou".contains(it,true)}.let{it==it.reversed()}

Beautified
filter { it.isLetter() }.map { "aeiou".contains(it, true) }.let { it == it.reversed() }

Test
data class Test(val input: String, val output: Boolean)

val tests = listOf(
    Test("Dennis",true),
    Test("Martin",true),
    Test("Martin Ender",true),
    Test("Alex",false),
    Test("Alex A.",true),
    Test("Doorknob",false),
    Test("Mego",false)
)

fun String.f() =
filter{it.isLetter()}.map{"aeiou".contains(it,true)}.let{it==it.reversed()}
fun main(args: Array<String>) {
    for ((input, expected) in tests) {
        val actual = input.f()
        if (actual != expected) throw AssertionError()
    }
}

TIO
TryItOnline

Julia 0.6, 65 bytes
f(s,b=[c in "aeiouAEIOU" for c in s if isalpha(c)])=b==reverse(b)

Try it online!

Pyt, 59 bytes
ɬ←ąĐ0↔ą∈⇹6²Ĩ*ž1ᴇ-5²⁺%⁺+ĐĐĐĐ1=⇹5=⇹04Ș9=06Ș+35*=0↔+37*=∨∨∨∨+₽

Try it online!
Much of this code is because Pyt is not very good at strings.
Explanation:
ɬ               Push "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
←ą              Get input string as an array of characters
Đ               Duplicate the array of characters
0↔              Push 0 and flip the stack
ą               Get the top of the stack as an array of characters
∈               Is each character in the input a letter?
⇹               Swap top two on the stack (input as array of characters)
6²Ĩ             Interpret element-wise as base-36 **
*ž              Remove all non-letters
1ᴇ-             Subtract 10 from each element
5²⁺%            Mod 26
⁺               Increment
+               Let's get rid of that 0
ĐĐĐĐ            Push 4 additional copies of the top of the stack
1=⇹             Is it equal to 1 ('a')
5=⇹04Ș          Is it equal to 5 ('e')
9=06Ș           Is it equal to 9 ('i')
+               Get rid of a 0
35*=            Is it equal to 15 ('o')
0↔              Push 0 and flip the stack
+               Get rid of a 0
37*=            Is it equal to 21 ('u')
∨∨∨∨            OR the arrays
+               Get rid of that last 0
₽               Is the top of the stack a palindrome?

GolfScript, 34 bytes
{32|}%.123,97>--{"aeiou"?)!}%.-1%=

Try it online!
Explanation
{32|}%                             # Convert to lowercase (Works at least with alpha)
      .123,97>--                   # Keep only lowercase letters
                {"aeiou"?)!}%      # Foreach: is it a vowel?
                             .-1%= # Is it a palindrome?

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


text:
Generate Hamming codes
Given a stream of bits, output the shortest possible Hamming code that encodes it.
The steps to generate the Hamming code are as follows, although your submission does not necessarily have to conform to them as long as it produces identical output. The input 110100101 will be used as an example.

Pad the input with trailing zeroes until its length is 2m - m - 1 for some integer m.
110100101        becomes
11010010100

Insert spaces at every position with an index of 2i (note that all indexing is 1-based for the purposes of this algorithm). This will insert m spaces for parity bits, resulting in 2m - 1 bits total.
11010010100      becomes
__1_101_0010100

Fill in the parity bits. A parity bit at index i is calculated by taking the sum modulo 2 of all bits whose index j satisfies i & j ≠ 0 (where & is bitwise AND). Note that this never includes other parity bits.
__1_101_0010100  becomes
111110100010100

Input may be taken as a list (or a string) of any two distinct elements, which do not necessarily have to be 0 and 1. Output must be in an identical format. (Input or output as an integer with the corresponding binary representation is disallowed, as this format cannot express leading 0s.)
The input will always have a length of at least 1.
Test cases (of the form input output):
0 000
1 111
01 1001100
1011 0110011
10101 001101011000000
110100101 111110100010100
00101111011 110001001111011
10100001001010001101 0011010100010010010001101000000

What significance does the padding have?

JavaScript (ES6), 116 bytes
f=(a,p=i=0)=>1/a[p]?f(a,p+p+1,a.splice(p,0,0)):[...Array(p)].map(_=>i&++i?~~a[i-1]:a.reduce((p,e,j)=>p^=++j&i&&e,0))

If the padding is unnecessary, then for 97 bytes:
f=(a,p=i=0)=>1/a[p]?f(a,p+p+1,a.splice(p,0,0)):a.map(e=>i&++i?e:a.reduce((p,e,j)=>p^=++j&i&&e,0))

APL (Dyalog Unicode), 64 bytes
{u∨(~k)\⌽m≠.∧u←(⍵↑⍨g l)\⍨k←1<1⊥m←2⊥⍣¯1⍳¯1+2*l←⌈(g←2∘*-+∘1)⍣¯1≢⍵}

Try it online!
A dfn that takes a boolean vector as its right argument.
Ungolfed with comments
f←{
  g←2∘*-+∘1  ⍝ A function that gives the data size from parity size; 2^x - (x+1)
  l←⌈g⍣¯1≢⍵  ⍝ Parity size from input length by inverting(⍣¯1) g
  m←2⊥⍣¯1⍳¯1+2*l  ⍝ Column matrix of bit patterns of 1..2^l-1
  k←1<1⊥m  ⍝ A boolean mask indicating where the data bits should go
  u←(⍵↑⍨g l)\⍨k  ⍝ Data pattern moved into appropriate positions:
     ⍵↑⍨g l      ⍝ Overtake ⍵ by length (g l)
            \⍨k  ⍝ Move the bits to the positions of 1 bits of k
  u∨(~k)\⌽m≠.∧u  ⍝ Complete the codeword:
          m≠.∧u  ⍝ Compute the parity (data AND each row of m, then reduce by XOR)
         ⌽       ⍝ Reverse so that LSB goes first
    (~k)\        ⍝ Fill in the parity positions with parity bits
  u∨             ⍝ Combine with data bits
}

Mathematica, 332 bytes
R[n_,m_]:=Module[{a,l,i},i=n;If[i==0,a={0},a={};While[i>0,If[IntegerQ[i/2],PrependTo[a,0];i/=2,PrependTo[a,1];i=(i-1)/2]]];l=Length[a];Do[PrependTo[a,0],{i,m-l}];a];F[m_]:=Transpose@Table[R[i,m],{i,2^m-1}];F[m_,K_]:=Module[{Z,i,N,Y},Z=F[m];N=NullSpace[Z,Modulus->2];Y=Mod[Reverse@K.N,2]];Row@F[#,PadRight[IntegerDigits@#2,2^#-1-#]]&

Try it online : copy and paste code using ctrl+v, place input at the end of the code and hit shift+enter to run
(Wolfram-cloud will print "x" between digits but this doesn't happen in mathimatica)

Input

[4,10101]

Output

001101011000000

Input

[5,10100001001010001101]

Output

0011010100010010010001101000000


text:
Maximal discrepancy-2 sequence with minimal entropy
Background
As noted in the PPCG challenge Compress a maximal discrepancy-2 sequence – which inspired this challenge – the authors of the paper Computer-Aided Proof of Erdős Discrepancy Properties found a maximal discrepancy-2 sequence, namely
-1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1, -1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1,  1, -1,  1, -1,  1, -1, -1, -1, -1,  1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1, -1, -1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1,  1, -1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1,  1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1,  1, -1,  1,  1, -1, -1, -1,  1, -1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1, -1,  1,  1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1, -1,  1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1, -1, -1,  1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1,  1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1,  1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1, -1,  1,  1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1, -1, -1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1,  1, -1, -1, -1, -1,  1,  1,  1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1, -1,  1,  1, -1, -1, -1, -1,  1,  1,  1, -1,  1,  1, -1, -1,  1,  1, -1, -1, -1, -1,  1,  1, -1,  1,  1,  1, -1, -1,  1,  1, -1, -1, -1,  1,  1,  1, -1, -1, -1, -1,  1, -1,  1, -1,  1,  1, -1,  1,  1, -1,  1,  1, -1,  1, -1,  1, -1, -1, -1, -1,  1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1,  1, -1,  1,  1,  1,  1, -1, -1, -1,  1, -1,  1, -1,  1,  1, -1, -1,  1, -1, -1,  1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1,  1,  1, -1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1, -1,  1,  1, -1, -1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1, -1,  1,  1,  1, -1,  1, -1, -1,  1,  1, -1, -1,  1, -1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1,  1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1,  1, -1,  1, -1, -1, -1, -1,  1,  1, -1, -1,  1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1, -1,  1, -1,  1,  1, -1,  1, -1, -1,  1,  1,  1, -1, -1, -1, -1,  1, -1,  1, -1,  1,  1, -1, -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, -1,  1, -1, -1,  1,  1,  1,  1, -1, -1, -1,  1,  1, -1, -1, -1,  1, -1,  1, -1,  1,  1, -1,  1, -1,  1,  1,  1, -1, -1,  1, -1,  1,  1, -1, -1,  1, -1,  1, -1, -1,  1, -1,  1, -1,  1,  1, -1, -1, -1,  1,  1,  1, -1,  1,  1

However, this is not the the only discrepancy-2 sequence of the length 1160; apart from the obvious variation of negating every term of the sequence, the are many valid variations that involve negating a pair of terms, and possibly entirely unrelated approaches that also lead to maximal sequences. The papers's authors made several design decisions that sped up their algorithm, but would a different set of decisions lead to a more compressible sequence? Let's find out!
Definitions
Let \$k\$ and \$n\$ be positive integers. A finite sequence \$x_1, \dots, x_n\$ over \$\{-1, 1\}\$ is of discrepancy \$d\$ if
$$ \max_{1\leq k\leq m\leq n} \left| \sum_{1\leq jk\leq m} x_{jk} \right| \leq d $$
In other words, the partial sums of the subsequences resulting of taking every \$k\$th term of \$x\$ all lie in the interval \$[-d, d]\$.
The sequence provided by the authors is of discrepancy 2, as can be verified programmatically. For the first three values of \$k\$, we get the following subsequences and partial sums.
k = 1: -1,  1,  1, -1,  1, -1, -1,  1,  1, -1,  1,  1, -1,  1, -1, -1,  1, -1, ...
(sums) -1,  0,  1,  0,  1,  0, -1,  0,  1,  0,  1,  2,  1,  2,  1,  0,  1,  0, ...

k = 2:      1,     -1,     -1,      1,     -1,      1,      1,     -1,     -1, ...
(sums)      1,      0,     -1,      0,     -1,      0,      1,      0,     -1, ...

k = 3:          1,         -1,          1,          1,         -1,         -1, ...
(sums)          1,          0,          1,          2,          1,          0, ...

Later terms of the sequences of partial sums never reach -3 or 3.
In contrast, 1, -1, -1,  1,  1, -1, -1,  1,  1, -1, -1,  1 is not a discrepancy-2 sequence.
k = 1:  1, -1, -1,  1,  1, -1, -1,  1,  1, -1, -1,  1
(sums)  1,  0, -1,  0,  1,  0, -1,  0,  1,  0, -1,  0

k = 2:     -1,      1,     -1,      1,     -1,      1
(sums)     -1,      0,     -1,      0,     -1,      0

k = 3:         -1,         -1,          1,          1
(sums)         -1,         -2,         -1,          0

k = 4:              1,              1,              1
(sums)              1,              2,              3

Task
Write a full program or a function that takes no input, prints or returns a single discrepancy-2 sequence with 1160 terms, and abides to the following rules.

You can use any kind of iterable (arrays, strings, etc.) that consists of exactly two different symbols: one representing -1 and one representing 1.
Your output must be consistent, i.e., every time your code is run, it must output the same sequence.
You must include the output of your program in your answer.
Hardcoding your output sequence is allowed.
To prevent trivial brute-force solutions, your code must finish in under a minute. For borderline-compliant solutions, I'll determine the official run time on my own machine (Intel Core i7-3770, 16 GiB RAM, openSUSE 13.2) or a sufficiently similar one if I cannot test your code on mine.
Any built-in that is itself a valid submission to this challenge or a variation that takes the discrepancy as input (e.g., FindMaximalDiscrepancySequence) may not be in your answer. All other built-ins – including built-ins that calculate the discrepancy of a sequence – are allowed.

While finding a suitable sequence is a big part of the task, only your implementation contributes to your score. In other words, this is code-golf, and may the shortest code in bytes win!
Validation
You can use this Python script to verify the output of your submission. It expects a string of comma-separated -1's and 1's.

I don't know if other people will understand it but defining discrepancy in less mathy notation would be good.

Everything after the image is a less mathy explanation of discrepancy. Which part is unclear?

"the partial sums of the subsequences resulting of taking every kth term of x all lie in the interval [-d, d]. Is the hard part to understand, I am getting it slowly but other words may work better

I am trying to figure out a way to get it easier for others to understand, It is a good challenge otherwise

I think you forgot one rule: it may not be the sequence displayed at the top or it's negated form? What stops me from simply outputting the sequence at the top and post it at as answer right now?

@KevinCruijssen Nothing. There are many more sequences that are trivial variations (only changing a couple of elements) of the one at the top. The idea is to find a more compressible sequence though, and if/when someone does, I expect it to outgolf answers using the sequence at the top by quite a bit.

I'm really interested in this topic. Just now, I had completed brute-forced the sequence of 500 integers and found the mentioned one has a realtively low entropy.

C (gcc), 416 bytes
f(i){for(i=1160;i--;)putchar(L"\x72ca563b\xd24f18ad\xa70acd36\x59a6b345\xd669d0cb\x729b4962\xcd34ba65\x6359a2d2\x2e5c6936\x592ad729\xda652af1\xe69b4934\xc70adb50\xcc3b30dc\x96934dac\x69b1c6c3\x5b49369c\x3692ed26\xc9c6d329\xda4cf493\xa6716962\x6d349b43\xf26d349a\xa6934f22\xab14f235\xa569a4d5\xb4d26996\xd1a652e9\x9a6d2671\xa4e54bb4\x750e938d\xd369369a\x469b4d22\x69b0dacd\xb345a4f2\xb49a4d36i"[i/32]>>i%32&1?43:45);}

-a ton of bytes thanks to ceilingcat!
Try it online!
C (gcc), 416 bytes
f(i){for(i=1160;i--;)putchar(L"\x72ca563b\xd24f18ad\xa70acd36\x59a6b345\xd669d0cb\x729b4962\xcd34ba65\x6359a2d2\x2e5c6936\x592ad729\xda652af1\xe69b4934\xc70adb50\xcc3b30dc\x96934dac\x69b1c6c3\x5b49369c\x3692ed26\xc9c6d329\xda4cf493\xa6716962\x6d349b43\xf26d349a\xa6934f22\xab14f235\xa569a4d5\xb4d26996\xd1a652e9\x9a6d2671\xa4e54bb4\x750e938d\xd369369a\x469b4d22\x69b0dacd\xb345a4f2\xb49a4d36i"[i/32]>>i%32&1?45:43);}

Try it online!
C (gcc), 1148 bytes, non-competing
#include <limits.h>
#include <stdint.h>
#include <stdio.h>

#define DISCREPANCY 2
#define NTERMS 1160

#define NBITS(x) (sizeof(x) * CHAR_BIT)

static int terms[NTERMS];

/* non-branching abs */
static inline int abs_(int x)
{
    return (x ^ (x >> (NBITS(x) - 1))) - (x >> (NBITS(x) - 1));
}

/* generate and print terms */
int main(void)
{
    register int result = 0, iter, incr;

    for(iter = 0; iter < NTERMS; iter++)
        terms[iter] = 1;

    for(incr = NTERMS; incr > 0; incr--)
    {
        result = 0;

        for(iter = incr - 1; iter < NTERMS; iter += incr)
        {
            result += terms[iter];
            if(abs_(result) > DISCREPANCY)
            {
                /* undo change */
                /* result -= terms[iter]; */
                /* change term to fit requirements */
                terms[iter] = -terms[iter];
                /* do correct change */
                result += 2 * terms[iter];
            }
        }
    }

    for(iter = 0; iter < NTERMS; iter++)
    {
        if(iter == NTERMS-1)
            printf("%d\n", terms[iter]);
        else
            printf("%d, ", terms[iter]);
    }
}

This is my half-brute-force half-calculating solution but it breaks when you check every third term. I hope to improve it to the point where it generates a correct solution. Replace the 1 with -1 on line 24 to negate the sequence. Please feel free to help me make this correct.
Try it online!


text:
Is it a Cyclic number?
A cyclic number is a number of "n" digits that when multiplied by 1, 2, 3,...n, results in the same digits but in a different order.
For example, the number 142,857 is a cyclic number since 142,857 x 2 = 285,714, 142,857 x 3 = 428,571, 142,857 x 4 = 571,428, and so on. Given an integer input, determine if it is a cyclic number by outputting a truthy value if it is, and a falsy value if not.
Also, to be clear, the input can contain leading 0's: e.g. 0344827586206896551724137931
This is due to the fact that if leading zeros are not permitted on numerals, then 142857 is the only cyclic number in decimal.
Since it is code-golf, shortest answer in bytes wins!

Hi and welcome to PPCG. This is not a bad question, but if you take a look at some of the recently posted questions I think that you will see that it could be better. Specifically, it would be very beneficial for the community if you provided more test cases to work with. When posting future challenges, please consider using the sandbox.

05AB1E, 9 6 bytes
Thanks to Emigna for saving 3 bytes!
ā*€{ïË

Explanation:
ā        # Push range(1, len(input) + 1)
 *       # Multiply by the input
  €{     # Sort each element
    ï    # Convert to int to remove leading zeros
     Ë   # Check if all elements are equal

Uses the 05AB1E encoding. Try it online!

What is the reason for ¦‚˜?

@kalsowerus If the input has a leading zero, multiplying by 1 would make it disappear, which makes it not work for 0588235294117647.

@Adnan why didn't 0169491525423728813559322033898305084745762711864406779661 work?

@tfbninja Oh okay, is adding leading zeroes after the multiplication also something to take into account? These are the individual sorted results I get after multiplying, with some missing leading zeroes, which would probably indicate the problem here.

@Adnan Yup, that's the problem! Definitely take the leading zeroes into account. Good Luck!

@tfbninja Thanks for the notification, fixed.

@Adnan, Nice Job! Works for everything I tried.

@Emigna Actually, I can leave the entire flatten out, since the leading zeros will still be removed by the int haha.

Actually, is it really OK to remove all zeroes? I don't have an example but couldn't one number end up with the same digits as the other numbers apart from an extra zero?

Consider the number 0212765957446808510638297872340425531914893617 as mentioned in the comments of another answer. Looking at the sorted numbers I would assume it to return false, but when removing zeroes it becomes true.

@Emigna Hm, that's weird, because you can always add extra zeros in front of the number to equalize the number of zeros. At least, that's how I understood the question.

@tfbninja Is the output for Emigna's test case truthy or falsy?

@Emigna, and Adnan  I checked, and it is a cyclic number, at least, according to Wikipedia, which I know isn't the best source but it's one of the only options. So, truthy

@Adnan: Ah yes, I didn't consider that :)

Actually, 18 bytes
;;ru@≈*♂$♂S♂≈╔@S≈=

Try it online! (expects quoted input)
Explanation:
;;ru@≈*♂$♂S♂≈╔@S≈=
;;                  duplicate input twice
  ru                range(1, len(input)+1)
    @≈              convert input to an integer
      *             multiply input by each element in range
       ♂$♂S♂≈       convert each product to a string, sort the digits, and convert back to int
             ╔      uniquify: remove duplicate elements
              @S≈   sort input and convert to int
                 =  compare equality

@tfbninja I posted this before the bit about leading zeroes. I have another 15-byte solution that will work with leading zeroes that I will edit in soon.

What character encoding do you use to achieve 18 bytes? I tried UTF-8 and it weighed in at 32 bytes. EDIT: Oh, I see, it's code page 437.

Python, 86 bytes
lambda n:all(sorted(n)==sorted(str(int(n)*i).zfill(len(n)))for i in range(2,len(n)+1))

Try it online!
Input numbers as strings.

@tfbninja should work on any python (2 and 3)

why does it fail with 0212765957446808510638297872340425531914893617 ?

@Jenny_mathy now it doesn't.

PHP, 64 Bytes
for(;$i++<9;)$r+=($c=count_chars)($argn)==$c($argn*$i);echo$r>1;

Online Version

Haskell, 36 33 32 45 bytes
c n=let l=length n in(10^l-1)`div`read n==l+1

Example usage:
*Main> c "142857"
True

I don't think this algorithm needs any explanation.
TOL
Thanks for suggestions: Generic Display Name, Laikoni.
Thanks for correction: Antony Hatchkins.
EDIT Nope, fails on "33".

does it work for 052631578947368421 ?

Yes, it returns True in that case.

Save some bytes by replacing ns with n

Can you use <1 instead of ==0? Also here is a TIO link: Try it online!

How about 111111?

Ah, good point. It needs to be the minimum period, not the length of the input number.

dc, 24 25 bytes
[1]sa0?dZd10r^1-r1+/rx=ap

Prints "0" if the number is not cyclic, otherwise "1". Requires the number to be entered as a string.
Example usage:
$ echo "[052631578947368421]" | dc -e '[1]sa0?dZd10r^1-r1+/rx=ap'
1
$ echo "[052631578947368422]" | dc -e '[1]sa0?dZd10r^1-r1+/rx=ap'
0

TOL
Explanation: Same algorithm as my Haskell submission.
EDIT Nope, fails on "33".

Mathematica, 81 bytes
Length@Union@PadLeft[Sort/@IntegerDigits[ToExpression@#*Range@StringLength@#]]<2&

Try it online!
input string
Input

"010309278350515463917525773195876288659793814432989690721649484536082474226804123711340206185567"

Output

True

FromDigits is shorter than ToExpression

because in this challenge you need to work with inputs like 034324...

Scala 3, 85 bytes
n=>(2 to n.size).forall(i=>n.sorted==(BigInt(n)*i).toString.padTo(n.size,'0').sorted)

Attempt This Online!