I think there is a distinction to be made, however it is not necessarily between "Compiled" and "Managed". These are not opposites; a language can be compiled and not managed, or interpreted (not compiled) and managed, or both, or even neither.
A "compiled" language is simply one in which there is a step that transforms the source code written by the developer into some more regular "bytecode" which is what is executed by the machine. The "machine" can be the actual processor, or a "virtual machine" that performs additional operations on the bytecodes to translate them to "native" machine instructions. The antonym for a "compiled" language is an "interpreted" language, in which the source code is transformed into bytecode instructions at runtime, without a compilation step.
A "managed" language is a language designed to produce programs that are consumed within a specific runtime environment, which almost always includes a bytecode interpreter; a "virtual machine" that takes the program's code and performs some additional machine or environment-specific transformation. The environment may also include memory management, such as a "garbage collector" and other "security" features meant to keep the program operating within its "sandbox" of space and tools, however such features are not the sole domain of "managed" runtimes. Virtually all interpreted languages could be considered managed, because they require the interpreter to be running underneath the lines of "user" code being executed. In addition, JVM and .NET languages (Java, Scala, C#, VB, F#, IronWhatever) are compiled into an intermediate language or IL, which is superficially similar in form and function to a binary assembly language, but doesn't adhere 100% to any "native" instruction set. These instructions are executed by the JVM, or by .NET's CLR, which effectively translates them to native binary instructions specific to the CPU architecture and/or OS of the machine.
So, languages can generally be described as "compiled" or "interpreted", and as "unmanaged" (or "native") and "managed". There are languages that can be described as any combination of these except possible "interpreted native"; if you consider the interpretation layer as a "runtime" (which is easy to argue for and hard to argue against), then all interpreted languages are "managed".
If you want to get technical, almost all programs targeting a multitasking OS nowadays are "managed"; the OS will create a "virtual machine" for each program that is running, in which the program thinks (or at least doesn't have to know otherwise) that it is the only thing running. The code may make calls within itself and to other referenced libraries as if that program was the only thing loaded in memory; similarly, calls to allocate RAM and other higher memory to store and manipulate data and control devices are coded as if the entire memory architecture was available. The VM (and the OS behind it) then translates various memory pointers to the actual location of the program, its data, and hooks to device drivers etc. This is most often done by applying a memory offset (each VM gets a block of 2GB or whatever of memory, starting at address X which the program can treat as if that X was address 0) and as such is very cheap to do, but there are other things the OS kernel is responsible for, such as process scheduling and inter-process communication, which are trickier to manage. However, this basic pattern is generally not considered "managed", as the program doesn't have to know that it's being run by a virtual machine. A program that was designed to be run on the MS-DOS command line can be run on newer Windows OSes that don't even have the MS-DOS environment underneath them anymore; the program is instead given a "virtual console" environment, and provided it doesn't try to leave this "sandbox" by trying to directly access protected areas of memory, it will run quite happily.