text:
Smallest possible runnable Mach-O executable
What is the smallest possible runnable Mach-O executable on x86_64? The program can do nothing (not even returning a return code), but must be a valid executable (must run without errors).
My try:
GNU Assembler (null.s):
.text
.globl _main

_main:
    retq

Compilation & Linking:
as -o null.o null.s
ld -e _main -macosx_version_min 10.12 -o null null.o -lSystem

Size: 4248 bytes
Looking at the hex values it seems there is a lot of zero padding which maybe can be removed, but I don't know how. Also I don't know if it is possible to make the exectubale run without linking libSystem...

relevant / answer: http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html

@JanDvorak There is even a Mach-O version of "teensy": http://osxbook.com/blog/2009/03/15/crafting-a-tiny-mach-o-executable/

This GitHub Gist could also return a tiny exectubale by defining the Mach-O header on its own: https://gist.github.com/softboysxp/1084476

Smallest runnable Mach-O has to be at least 0x1000 bytes. Because of XNU limitation, file has to be at least of PAGE_SIZE.
See xnu-4570.1.46/bsd/kern/mach_loader.c, around line 1600.
However, if we don't count that padding, and only count meaningful payload, then minimal file size runnable on macOS is 0xA4 bytes.
It has to start with mach_header (or fat_header / mach_header_64, but those are bigger).
struct mach_header {
    uint32_t    magic;      /* mach magic number identifier */
    cpu_type_t  cputype;    /* cpu specifier */
    cpu_subtype_t   cpusubtype; /* machine specifier */
    uint32_t    filetype;   /* type of file */
    uint32_t    ncmds;      /* number of load commands */
    uint32_t    sizeofcmds; /* the size of all the load commands */
    uint32_t    flags;      /* flags */
};

It's size is 0x1C bytes.
magic has to be MH_MAGIC.
I'll be using CPU_TYPE_X86 since it's an x86_32 executable.
filtetype has to be MH_EXECUTE for executable, ncmds and sizeofcmds depend on commands, and have to be valid.
flags aren't that important and are too small to provide any other value.
Next are load commands.
Header has to be exactly in one mapping, with R-X rights -- again, XNU limitations.
We'd also need to place our code in some R-X mapping, so this is fine.
For that we need a segment_command.
Let's look at definition.
struct segment_command { /* for 32-bit architectures */
    uint32_t    cmd;        /* LC_SEGMENT */
    uint32_t    cmdsize;    /* includes sizeof section structs */
    char        segname[16];    /* segment name */
    uint32_t    vmaddr;     /* memory address of this segment */
    uint32_t    vmsize;     /* memory size of this segment */
    uint32_t    fileoff;    /* file offset of this segment */
    uint32_t    filesize;   /* amount to map from the file */
    vm_prot_t   maxprot;    /* maximum VM protection */
    vm_prot_t   initprot;   /* initial VM protection */
    uint32_t    nsects;     /* number of sections in segment */
    uint32_t    flags;      /* flags */
};

cmd has to be LC_SEGMENT, and cmdsize has to be sizeof(struct segment_command) => 0x38.
segname contents don't matter, and we'll use that later.
vmaddr has to be valid address (I'll use 0x1000), vmsize has to be valid & multiple of PAGE_SIZE, fileoff has to be 0, filesize has to be smaller than size of file, but larger than mach_header at least (sizeof(header) + header.sizeofcmds is what I've used).
maxprot and initprot have to be VM_PROT_READ | VM_PROT_EXECUTE. maxport usually also has VM_PROT_WRITE.
nsects are 0, since we don't really need any sections and they'll add up to size.
I've set flags to 0.
Now, we need to execute some code. There are two load commands for that: entry_point_command and thread_command.
entry_point_command doesn't suit us: see xnu-4570.1.46/bsd/kern/mach_loader.c, around line 1977:
1977    /* kernel does *not* use entryoff from LC_MAIN.  Dyld uses it. */
1978    result->needs_dynlinker = TRUE;
1979    result->using_lcmain = TRUE;

So, using it would require getting DYLD to work, and that means we'll need __LINKEDIT, empty symtab_command and dysymtab_command, dylinker_command and dyld_info_command. Overkill for "smallest" file.
So, we'll use thread_command, specifically LC_UNIXTHREAD since it also sets up stack which we'll need.
struct thread_command {
    uint32_t    cmd;        /* LC_THREAD or  LC_UNIXTHREAD */
    uint32_t    cmdsize;    /* total size of this command */
    /* uint32_t flavor         flavor of thread state */
    /* uint32_t count          count of uint32_t's in thread state */
    /* struct XXX_thread_state state   thread state for this flavor */
    /* ... */
};

cmd is going to be LC_UNIXTHREAD, cmdsize would be 0x50 (see below).
flavour is x86_THREAD_STATE32, and count is x86_THREAD_STATE32_COUNT (0x10).
Now the thread_state. We need x86_thread_state32_t aka _STRUCT_X86_THREAD_STATE32:
#define _STRUCT_X86_THREAD_STATE32  struct __darwin_i386_thread_state
_STRUCT_X86_THREAD_STATE32
{
    unsigned int    __eax;
    unsigned int    __ebx;
    unsigned int    __ecx;
    unsigned int    __edx;
    unsigned int    __edi;
    unsigned int    __esi;
    unsigned int    __ebp;
    unsigned int    __esp;
    unsigned int    __ss;
    unsigned int    __eflags;
    unsigned int    __eip;
    unsigned int    __cs;
    unsigned int    __ds;
    unsigned int    __es;
    unsigned int    __fs;
    unsigned int    __gs;
};

So, it is indeed 16 uint32_t's which would be loaded into corresponding registers before thread is started.
Adding header, segment command and thread command gives us 0xA4 bytes.
Now, time to craft the payload.
Let's say we want it to print Hi Frand and exit(0).
Syscall convention for macOS x86_32:

arguments passed on the stack, pushed right-to-left
stack 16-bytes aligned (note: 8-bytes aligned seems to be fine)
syscall number in the eax register
call by interrupt

See more about syscalls on macOS here.
So, knowing that, here's our payload in assembly:
push   ebx          #; push chars 5-8
push   eax          #; push chars 1-4
xor    eax, eax     #; zero eax
mov    edi, esp     #; preserve string address on stack
push   0x8          #; 3rd param for write -- length
push   edi          #; 2nd param for write -- address of bytes
push   0x1          #; 1st param for write -- fd (stdout)
push   eax          #; align stack
mov    al, 0x4      #; write syscall number
#; --- 14 bytes at this point ---
int    0x80         #; syscall
push   0x0          #; 1st param for exit -- exit code
mov    al, 0x1      #; exit syscall number
push   eax          #; align stack
int    0x80         #; syscall

Notice the line before first int 0x80.
segname can be anything, remember? So we can put our payload in it. However, it's only 16 bytes, and we need a bit more.
So, at 14 bytes we'll place a jmp.
Another "free" space is thread state registers.
We can set anything in most of them, and we'll put rest of our payload there.
Also, we place our string in __eax and __ebx, since it's shorter than mov'ing them.
So, we can use __ecx, __edx, __edi to fit the rest of our payload.
Looking at difference between address of thread_cmd.state.__ecx and end of segment_cmd.segname we calculate that we need to put jmp 0x3a (or EB38) in last two bytes of segname.
So, our payload assembled is 53 50 31C0 89E7 6A08 57 6A01 50 B004 for first part, EB38 for jmp, and CD80 6A00 B001 50 CD80 for second part.
And last step -- setting the __eip. Our file is loaded at 0x1000 (remember vmaddr), and payload starts at offset 0x24.
Here's xxd of result file:
00000000: cefa edfe 0700 0000 0300 0000 0200 0000  ................
00000010: 0200 0000 8800 0000 0000 2001 0100 0000  .......... .....
00000020: 3800 0000 5350 31c0 89e7 6a08 576a 0150  8...SP1...j.Wj.P
00000030: b004 eb38 0010 0000 0010 0000 0000 0000  ...8............
00000040: a400 0000 0700 0000 0500 0000 0000 0000  ................
00000050: 0000 0000 0500 0000 5000 0000 0100 0000  ........P.......
00000060: 1000 0000 4869 2046 7261 6e64 cd80 6a00  ....Hi Frand..j.
00000070: b001 50cd 8000 0000 0000 0000 0000 0000  ..P.............
00000080: 0000 0000 0000 0000 0000 0000 2410 0000  ............$...
00000090: 0000 0000 0000 0000 0000 0000 0000 0000  ................
000000a0: 0000 0000                                ....

Pad it with anything up to 0x1000 bytes, chmod +x and run :)
P.S. About x86_64 -- 64bit binaries are required to have __PAGEZERO (any mapping with VM_PROT_NONE protection covering page at 0x0). IIRC they [Apple] didn't make it required on 32bit mode only because some legacy software didn't have it and they're afraid to break it.

This is an incredibly thorough answer. Welcome to the site! :)

I used truncate -s 4096 foo (with foo being the exectuable file) to make it fit 0x1000 bytes and it works perfectly :)

28 Bytes, Pre-compiled.
Below is a formated hex dump of the Mach-O binary.
00 00 00 00 FF FF FF FF 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|---------| |---------| |---------| |---------| |---------| |---------| |---------/
|           |           |           |           |           |           +---------- uint32_t        flags;          // Once again redundant, no flags for safety.
|           |           |           |           |           +---------------------- uint32_t        sizeofcmds;     // Size of the commands. Not sure the specifics for this, yet it doesn't particularly matter when there are 0 commands. 0 is used for safety.
|           |           |           |           +---------------------------------- uint32_t        ncmds;          // Number of commands this library proivides. 0, this is a redundant library.
|           |           |           +---------------------------------------------- uint32_t        filetype;       // Once again, documentation is lacking in this department, yet I don't think it particularly matters for our useless library.
|           |           +---------------------------------------------------------- cpu_subtype_t   cpusubtype;     // Like cputype, this suggests what systems this can run on. Here, 0 is ANY.
|           +---------------------------------------------------------------------- cpu_type_t      cputype;        // Defines what cpus this can run on, I guess. -1 is ANY. This library is definitely cross system compatible.
+---------------------------------------------------------------------------------- uint32_t        magic;          // This number seems to be provided by the compiling system, as I lack a system to compile Mach-O, I can't retrieve the actual value for this. But it will always be 4 bytes. (On 32bit systems)

Consists entirely of the header, and does not need the data nor the cmds. This is, by nature, the smallest Mach-O binary possible. It might not run correctly on any conceivable hardware, but it matches the specification.
I'd supply the actual file, but it entirely consists of unprintable characters.

The very first line of description starts with "once again". I'm guessing you wrote them in a different order.

Read bottom to top, which is like left to right. Yes, I wrote them in that order.

This doesn't actually run in any meaningful sense, though.

Although it doesn't technically run in any meaningful sense is is technically run-able. Assuming the specification is correct, this is a library without any data. Or, more simply, just the header of a library.

How can this be run? Putting it in a binary file and executing it throws an error saying "Exec format error"

The Error is almost definitely in the Magic part of the Header, for which I can't actually get the 4 bytes for. Unless someone can find me the x86 Magic Number.

(uint)0x00000007 is "I386" and "X86" (name depending upon where in the XNU spec you are looking, but it's the correct arch)
(uint)0x0x01000007 is X86_64
Theoretically, you can OR any CPU value with 0x1000000 to make it a 64bit version.  XNU seems to not always consider them discrete values; e.g., ARM 32 and 64 are 0x0000000C and 0x0100000C, respectively.
Ah heck, here's the list I wound up having to figure out a few years back, note that most of these predate OS/X:
VAX       =          1,    // Little-Endian
ROMP      =          2,    // Big-Endian -- 24bit or 32bit
NS32032   =          4,    // Hybrid -- Treat as Little Endian -- First 32b procs on the market
NS32332   =          5,    // Hybrid -- Treat as Little Endian -- These introduced a 20 byte "instruction cache"
MC680x0   =          6,    // Big-Endian
X86       =          7,    // Little-Endian
I386      =          7,    // alias for X86 and gets used interchangeably
MIPS      =          8,    // Big-Endian
NS32532   =          9,    // Hybrid -- Treat as Little Endian -- These ran from 20MHz up to a stunning 30MHz
MC98000   =         10,    // Big-Endian
HPPA      =         11,    // Big-Endian
ARM       =         12,    // Both! -- will treat as Little-Endian by default
MC88000   =         13,    // Big-Endian
SPARC     =         14,    // Big-Endian
I860      =         15,    // Little-Endian
ALPHA     =         16,    // Big-Endian -- NB, this is a 64-bit CPU, but seems to show up w/o the ABI64 flag . . .
POWERPC   =         18,    // Big-Endian
X86_64    =   16777223,    // Little-Endian
POWERPC64 =   16777234,    // Big-Endian
ARM_64    = 0x0100000C     // Both! -- wil treat as Little-Endian by default

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


text:
Shuffle a ragged array
A ragged array is an array where each element is an array of unknown number of positive integers.
For example, the following are ragged arrays:
[[1,2,3],[4],[9,10]]               Shape:  3,1,2
[[1],[2],[3]]                      Shape:  1,1,1
[[1,2,3,4,5,6,8]]                  Shape:  7

The following are not ragged arrays:
[1]   Each element will be an array
[]    The array will contain at least 1 element
[[1,2,3],[]]  Each subarray will contain at least 1 integer

You need to input a ragged array, and return a ragged array with the integers shuffled

The output array must have the same shape as the input array. We define the shape of the array as the length of each subarray.
Each integer must have an equally likely chance to appear in each possible location.
You can assume that your language's built-in random is random.

For example, if I passed in:  [[4],[1,2,3],[4]], then [[1],[4,4,2],[3]] would be a valid output, but [[4,1,3],[3],[4]] or [[4],[4],[1,2,3]] would not.

Related.

Will the input always be a 2D array?

Jelly, 3 bytes in Jelly's codepage
FẊṁ

Explanation:
FẊṁ
F    flatten list
 Ẋ   shuffle the output from the previous line
  ṁ  unflatten the list, shaping it like…

Because the program is incomplete (ṁ doesn't have a second argument stated), the default is to use the program input; thus ṁ causes the output to have the same sublist pattern as the input.
Try it online!

Wow, unflatten is a neat and unexpected command.

Unflatten might not be the best term since the left argument doesn't have to be flat. The mnemonic is mold.

@Dennis: Does that mean that it wouldn't work correctly for this challenge on an input ragged array that contained lists as elements, rather than integers (because it'll flatten the inside lists first)? That's a little disappointing, you'd expect it to work regardless of the type that the ragged array had. (Update: I checked, it seems that both F and ṁ work for multiple layers of flattening, not just one.)

I mean that the left argument of ṁ can be anything, not just a flat list. For example: https://tio.run/nexus/jelly#@/9wZ@P///@jow11FIxidRSijXUUTEC0qY6CWWzs/2gDIBuIDWJjAQ

Oh, I'd call that an unflatten operation; the left argument is being treated as a flat list (just it happens to contain lists as elements, but those elements are being interpreted as opaque). Actually, I suspect we agree on what unflattening is but disagree on what flattening is…

Clever! This is an excellent demonstration of why a good explanation can improve an answer.

PowerShell v2+, 86 bytes
param($n)$a=$n-split'[^\d]'-ne''|sort{random};-join($n-split'\d+'-ne''|%{$_+$a[$i++]})

Works via string manipulation. Input is passed in as a string representing the array, in whatever format works for your language. ;-)
-splits out the input on non-digits, sorts them based on the random script block (which will assign a different random weight for each input to the sort), stores that into $a. We then split the input again, this time on digits, and for each one output the current value (usually brackets and commas) string-concatenated with the corresponding number from $a. That's -joined together back into a string, and output is implicit.
Examples
PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(3,2,1),4)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "@(@(1,2,3),4)"
@(@(1,2,4),3)

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[4],[1,2,3],[4]]"
[[4],[2,4,3],[1]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[10],[5,2,1],[3]]

PS C:\Tools\Scripts\golfing> .\shuffle-a-ragged-array.ps1 "[[10],[1,2,3],[5]]"
[[5],[10,2,1],[3]]

Python 2, 89 bytes
from random import*
x=input();r=sum(x,[]);shuffle(r)
print[[r.pop()for _ in t]for t in x]

Try it online!

I don't know python that well, but couldn't you do shuffle(r=sum(x,[]))?

No, shuffle shuffles in place and returns None.

JavaScript (ES6), 78 75 bytes
x=>x.map(y=>y.map(z=>+s.splice(Math.random()*s.length,1)),s=eval(`[${x}]`))

This is the first time I can remember using .splice() in a code-golf challenge...
You can golf off two bytes by shuffling the array beforehand:
x=>x.map(y=>y.map(z=>s.pop()),s=eval(`[${x}]`).sort(_=>Math.random()-.5))

However, this seems to put the last integer first the majority of the time, so I'm going to assume that the integers aren't uniformly distributed.

"You can assume that your language's built-in random is random."

@ConorO'Brien "Each integer must have an equally likely chance to appear in each possible location."

sort doesn't work properly when given an inconsistent comparison key. Even if the language's random is random, its sort will malfunction in this situation, and that's what's creating the bias you're seeing. As such, I think the second solution is incorrect.

Ruby, 47 bytes
->a{b=a.flatten.shuffle;a.map{|x|x.map{b.pop}}}

05AB1E, 17 bytes
˜.r¹vDyg£DˆgF¦}}¯

˜                 Unflatten input
 .r               tmp = shuffle(flattened_input)
   ¹v             For each sub-array
     Dyg£         Take the first length(current_array) elements from tmp
         Dˆ       Append the result to a global array
           gF¦}   Remove the first elements from tmp
               }  End for
                ¯ Display the global array

Try it online!
I'm waiting for the 05AB1E or 2sable solution using some unflattening/molding built-in I don't know yet :) .

7 bytes: ˜.rI€g£ - try it online (with 10 random outputs). It's likely £ didn't act like that yet with a list argument when you posted your answer, although it does work in the latest legacy version.

Brachylog, 17 bytes
c@~P,?:{l~l}a.cP,

Try it online!
Explanation
We basically create a list of sublists with variable elements that has the same "shape" as the Input, and then state that if we concatenate everything into a single list, it must result in a shuffle of the concatenation of the input into a single list.
c@~P,                 Concatenate the Input into a single list. Shuffle it and call that P.
     ?:{   }a.        The Output is the result of applying this to each element of the input:
        l~l               The Output is a list of same length as the Input.
             .cP,     P is the concatenation of the sublists of the Output.

Bash, 63, 58 bytes
EDITS:

Optimized sed expression a bit, -5 bytes

Note:
Bash does not really support multidimensional arrays (they can only be simulated, to some extent), so instead, this program will accept a "serialized" text representation of a rugged array, as depicted
in the task description, e.g.: [[1,2,3],[4],[9,10]], and provide output in the same format.
Golfed
printf `sed 's/\w\+/%d/g'<<<$1` `grep -Po '\d+'<<<$1|shuf`

Test
>./shuffle []
[]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[11,12,9,5,3,6,1,15,14,2,13,7,10,8,4]

>./shuffle [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
[9,15,11,10,7,6,1,14,2,3,12,5,4,13,8]

>./shuffle [[1,2,3],[4],[9,10]]
[[10,2,4],[9],[3,1]]

>./shuffle [[1,2,3],[4],[9,10]]
[[3,4,1],[10],[2,9]]

A nice bonus is that you can feed it rugged arrays of an arbitrary depth:
./shuffle [[1,[2,[3,[99,101]]],[4],[9,10]]
[[9,[4,[1,[101,2]]],[10],[3,99]]

and it will still operate correctly.
Try it online !

Perl, 37 bytes
36 bytes of code + -p flag.
@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge

To run it:
perl -pE '@n=/\d+/g;s/\d+/splice@n,rand@n,1/ge' <<< "[[4],[1,2,3],[4]"

Explanations:

@n=/d+/g                # store all the integers in @n
s/\d+/                  # replace each integer with ...
splice@n,rand@n,1/ge    # a element at a random position of @n (which is deleted from @n)

Pyth, 15 bytes
tPc.SsQ.u+NlYQ0

A program that takes input of a list and prints the result.
Test suite
How it works
tPc.SsQ.u+NlYQ0  Program. Input: Q
       .u    Q0  (1) Reduce Q with starting value 0, returning all results:
         +        Add
          N       the current value
           lY     to the length of the next element of Q
     sQ          Flatten Q
   .S            (2) Randomly shuffle
  c              Chop (1) at every location in (2)
tP               Discard the first and last elements
                 Implicitly print

PHP, 105 bytes
$m=array_merge(...$i=$_GET[i]);shuffle($m);foreach($i as$v)$o[]=array_splice($m,0,count($v));print_r($o);

reduced to 105 bytes thanks to user59178.
Original answer:
PHP, 132 bytes
$i=$_GET['i'];$m=call_user_func_array('array_merge',$i);shuffle($m);foreach($i as$v){$o[]=array_splice($m,0,count($v));}print_r($o);

$m=array_merge(...$i=$_GET[i]); is 25 bytes shorter than $i=$_GET['i'];$m=call_user_func_array('array_merge',$i); and does the same thing. In addition you can drop the {} after the foreach to save 2 more bytes.

APL, 35 bytes
I'm barely even beating Perl, there has to be something I'm missing.
{Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}

E.g:
      {Z[?⍨⍴Z]⊂⍨(⍳⍴Z←∊⍵)∊⊃¨{⍵+⊃⌽⍺}\⍳¨⍴¨⍵}(1 2 3)(,4)(9 10)
┌──────┬─┬───┐
│10 3 2│1│9 4│
└──────┴─┴───┘

Explanation:

Find the corresponding indices of the starts of the sub-arrays in a flattened array:

⍳¨⍴¨⍵: For each sub-array, get a list of the indices
{⍵+⊃⌽⍺}\: Starting with the first sub-array, add the last value in the array to each value in the next array.
⊃¨: get the first items of the arrays, which are the starting places
(⍳⍴Z←∊⍵)∊: store the flattened array in Z. Generate a bit-vector where the ones mark the places where the sub-arrays should start.

Shuffle the flattened array:

?⍨⍴Z: generate a random permutation of Z.
Z[...]: permute Z.

⊂⍨: Split up the permutation in sub-arrays according to the bit-vector.

You could do an in-place replacement. Assignment allowed you to flatten the variable: A⊣(∊A)←(∊A)[?⍨≢∊A←⎕]

@Adám: wow, I did not know you could do that. Is there a list of which functions can do this?

Yes. And it works with modified assignment too.

Mathematica, 67 Bytes
ReplacePart[#,Thread[RandomSample@Position[#,_Integer]->Union@@#]]&

Explanation:
This shuffles the list of positions of all integers in the 2D ragged array. Union@@ is short for Flatten@
Note:
Squiggly brackets {} are used instead of brackets [].

Factor + arrays.shaped, 67 bytes
[ [ flatten randomize ] [ array-replace ] bi [ cut swap ] map nip ]

Try it online!
Explanation
Assumes the input is always a 2D array.

[ flatten randomize ] [ array-replace ] bi Place the flat, shuffled version of the input and the lengths of its rows on the stack.
[ cut swap ] map nip Create a ragged array from a flat sequence and a list of lengths. See https://codegolf.stackexchange.com/a/233190/97916.

K (ngn/k), 18 bytes
{(,/x)@<==0N?&#'x}

Try it online!

&#'x build a list containing n-copies of each top level index, where n is the length of each element of the ragged list (e.g. 0 1 1 1 2)
0N? shuffle that list
<== group the indices, group them again (to essentially flip the keys and values of the dictionary), and sort them ascending (this preserves the original order of the lengths)
(,/x)@ index into the flattened input and (implicitly) return

Vyxal, 5 bytes
fÞ℅$•

Try it Online!
f     # Flatten
 Þ℅   # Shuffle
   $• # Mold to original shape

Octave , 60 bytes
@(a)mat2cell([a{:}](randperm(sum(s=cellfun(@numel,a)))),1,s)

MATLAB, 84 bytes
function b=g(c);a=[c{:}];a=a(randperm(numel(a)));b=mat2cell(a,1,cellfun('length',c))

Java, 368 bytes
interface Z{int w(int i);default Z m(int n,int s){return i->w(i)+i>=n?s:0;}static int[][]f(int[][]r){int L=0,o=0,x,d,e=0;Z u=i->0,v=i->i;for(int[]a:r){d=a.length;L+=d;u=u.m(L,1);v=v.m(L,-d);}int[]c=new int[L];for(;e<L;)c[e++]=(int)(L*Math.random());for(int[]a:r){for(x=0;x<a.length;){d=c[x+o];e=v.w(d);d=u.w(d);L=a[x];a[x++]=r[d][e];r[d][e]=L;}o+=a.length;}return r;}}

the method static int[][] f( int[][] r ){...} solves the challenge.
decided to roll my own functional interface to avoid an import and to add in a default method for ease of use
interface Z{ //define my own functional interface instead of importing

  int w(int i);

  //return a new lambda
  //where w(int i) adds the value s
  //to the result when i is greater than n
  default Z m(int n,int s){
      return i->w(i)+i>=n?s:0;
  }

  static int[][]f(int[][]r){
      int L=0,o=0,x,d,e=0;
      Z u=i->0, //lambda to convert a flattened index to the input's first dimension index
        v=i->i; //lambda to convert a flattened index to the input's second dimension index
      for(int[]a:r){
          d=a.length;
          L+=d; //running total of the lengths
          u=u.m(L,1); //increment the 1st conversion by 1 at every array length
          v=v.m(L,-d); //decrement the 2nd conversion by the array length after that length
      }
      int[]c=new int[L]; //will contain flattened index swapping positions
      for(;e<L;) //randomize the swap positions
          c[e++]=(int)(L*Math.random());
      for(int[]a:r){ //swap the elements from the input
          for(x=0;x<a.length;){
              d=c[x+o]; //flattened swap index
              e=v.w(d); //convert swap index to 2nd dimension index
              d=u.w(d); //convert swap index to 1st dimension index
              L=a[x];
              a[x++]=r[d][e];
              r[d][e]=L;
          }
          o+=a.length; //increment offset for flattened index array
      }
      return r;
  }

}

q, 36 bytes
{(0,sums -1_count each x)_0N?raze x}

k, 22 bytes
{(0,+\-1_#:'x)_0N?,/x}

source: Stack Exchange

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

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

sort: votes


text:
Print the missing primes
The Task
Write a program or function that, when passed a numerical input x, prints or returns the primes beneath the square root of x1 that are not factors of x.
Examples
Let f(x) be the function called:
>>> f(4)
[]

>>> f(5)
[2]

>>> f(20)
[3]

>>> f(60)
[7]

>>> f(100)
[3, 7]

>>> f(10000)
[3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Bonus Rules

You may use any builtins that your language provides.
Your program must support an x input as high as the upper bound defined by your language.

1 Using the square root as only primes below the square root can actually be involved within the factors of x. Without making this restriction, larger numbers would have a lot of excess printed numbers.

"Only primes below the square root can actually be involved within the factors of x" isn't true: a number can have one prime factor that's larger than its square root. Indeed, your first two examples (5 and 20) have this property, as do all primes, twice all odd primes, ....

@GregMartin Yes, they can - but they cannot be found within the first half of the factors. It makes sense not to include 7 in the missing primes of 48 as 7^2 is greater than 48. (my reasoning lies there)

Jelly, 6 bytes in Jelly's codepage
½ÆRḟÆf

Try it online!
Explanation:
½ÆRḟÆf
 ÆR    All primes less than or equal to
½      the square root of the input
   ḟ   but with the following removed:
    Æf All prime factors of {the input, by default}

Jelly answers often just literally describe the challenge :P

MATL, 10 9 bytes
X^ZqGYfX-

Try it online!
Explanation
X^    % Implicit input. Square root
Zq    % Array if primes up to that
G     % Push input again
Yf    % Array of prime factors
X-    % Set difference. Implicit display

MATLAB, 57 54 bytes
function h(p);a=primes(p^.5);a(~ismember(a,factor(p)))

Pretty straightforward, gets an array of primes up to sqrt(p) then removes any that are also factors of p. Prints the output of the last line by default because the semicolon is left off.

I never tried MATLAB, but according to what I read about it, sqrt(p) can be written as p^0.5 or maybe p^.5 although I am not sure about the second suggestion

Nice! :) I posted an Octave submission using the same approach.

Pyth, 10 bytes
fP_T-S@Q2P

A program that takes input of a number and prints a list.
Test suite
How it works
fP_T-S@Q2P   Program. Input: Q
fP_T-S@Q2PQ  Implicit input fill
f            Filter
     S@Q2    the 1-indexed range up to floor(sqrt(Q))
    -    PQ  with the prime factors of Q removed
 P_T         by primality
             Implicitly print

Python 3, 67 62 bytes
f=lambda n,k=1,m=1:k*k<n and(m%k*n%k>0)*[k]+f(n,k+1,m*k*k)or[]

Try it online!

05AB1E, 8 bytes
tLDpÏ¹fK

Try it online!
Explanation
tL        # range [1 ... sqrt(input)]
  DpÏ     # keep only primes
     ¹fK  # remove factors of input

PHP, 76 bytes
for($n=1;++$n*$n<$x=$argv[1];){for($i=$n;$n%--$i;);if($i<2&&$x%$n)echo$n,_;}

uses my is_prime solution golfed for $n>1
takes input from command line argument. Run with -r.

JavaScript (ES6), 79 76 bytes
f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]

Based on my recursive primality test function. I feel like there should be a few ways to simplify this, but I can't figure out how...
Test snippet

f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]
<input type="number" step=1 min=4 value=4 oninput="O.innerHTML='['+f(this.value)+']'">

[]

Mathematica, 46 bytes
Select[Prime@Range@PrimePi@Sqrt[a=#],!#∣a&]&

Anonymous function. Takes a number as input and returns a list of numbers as output. The Unicode character is U+2223 DIVIDES for \[Divides].

Ruby, 55 bytes
require'prime'
->x{Prime.to_a(x**0.5).select{|n|x%n>0}}

A rather lazy answer using the builtin prime enumerator.

Wonder, 14 bytes
@(_> > ^#0.5)P

Usage:
(@(_> > ^#0.5)P)10

Takes items from an infinite list of primes while the item is less than the square root of the argument.

Pyke, 10 bytes
,BS#_P)QP-

Try it here!
,B         -    int(sqrt(input))
  S        -   range(1, ^+1)
   #_P)    -  filter(^, is_prime)
         - - ^.remove(V)
       QP  -  factors(input)

PowerShell v2+, 71 bytes
param($n)1..[math]::Sqrt($n)|?{$n%$_-and'1'*$_-match'^(?!(..+)\1+$)..'}

Iterative solution. Takes input $n and creates a range from 1 to the Sqrt($n) (note that the range operator will implicitly cast the upper end to an [int] which will do Banker's Rounding by default). Then uses |?{...} (the Where-Object operator, which acts like a filter) to pull out those numbers where $n%$_ is non-zero (i.e., any remainder to the modulo means it's not a factor, and any non-zero is truthy) -and the usual regex prime test is $true. Those are left on the pipeline, and output is implicit.
Examples
(with some extra formatting to pretty up the output)
PS C:\Tools\Scripts\golfing> 5,20,60,100,10000|%{"f($_)";(.\print-the-missing-primes.ps1 $_)-join', ';""}
f(5)
2

f(20)
3

f(60)
7

f(100)
3, 7

f(10000)
3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

NB - This will fail on earlier versions if the input is bigger than around 2500000000, because the .. range operator can only support up to 50,000 items. But, since that is bigger than the default [int] datatype's max value, 2147483647, I'm presuming that to be OK. On my machine, PSv4 Win8.1, however, I can go higher, but I'm not able to find documentation explaining the difference.

Octave, 44 bytes
This answer is inspired by MattWH's MATLAB answer, but I've golfed it using some Octave-specific features.
@(x)(y=primes(x^.5))(~ismember(y,factor(x)))

This is an anonymous function that takes the input x. Octave has inline variable assignment and indexing allowing y to first be created in the function (not possible in MATLAB), then used as part of the logical mask created by ismember (again, not possible to do it this way in MATLAB).

Very nice, will have to look into Octave. Those features would be helpful for golf!

Perl 6, 37 bytes
{grep {$^a.is-prime&$_%$a},2.. .sqrt}

Expanded:
{   # bare block lambda with implicit parameter ｢$_｣

  grep
  {
    $^a.is-prime  # check if it is prime
    &             # and junction
    $_ % $a       # check if the input is not evenly divisible by it
  },
  2.. .sqrt          # Range of values up-to and including squareroot
}

TSQL, 130 bytes
DECLARE @v int=10000

,@ INT=2SELECT 2p INTO #
g:INSERT # SELECT @ FROM # HAVING isnull(min(@%p),1)>0SET @+=1IF @*@<@v GOTO g
SELECT*FROM # WHERE @v%p>0

This will only execute once, then you need to drop the temp table to execute again in the same editor
DROP TABLE #

I made a version to test it, it is a bit longer because the online permissions for creating tables is unavailable. For the same reason it doesn't need the drop table though.
Try it online

R, 58 63 bytes
for(i in 2:sqrt(x<-scan()))if(x%%i&numbers::isPrime(i))print(i)

Loops over all values from 2 to sqrt(x) and checks if they are prime with the numbers package. x%%i calculates x mod i which is 0 -> False if i is a divisor of x and >0 -> True if i is not.
+5 bytes because the numbers::Primes(n) function doesn't allow decimals, while 2:sqrt(x) does work, added prime check to if statement.

Haskell, 55 54 bytes
f x=[y|y<-[2..x],y*y<x,[z|z<-[1..y],gcd(z*x)y>1]==[y]]

Mostly straightforward nested list comprehensions. GCD performs two roles, testing whether the numbers below y are factors of y and also testing whether y is a factor of x.
Spaced out a little:
f x = [ y|y<-[2..x],     y*y<x,     [z|z<-[1..y], gcd (z*x) y > 1] == [y] ]

Save a byte with gcd(z*x)y>1.

I've also put the y*y<x check first to make it a bit faster.

Retina, 69 66 bytes
.+
$*
(11\1|^1)+
$#1$*1:$&
M!&`(?!(11+)\1+:)(1+):(?!\2+$)
M%`1
^0

Prints the primes on separate lines, from largest to smallest.
Try it online! (Takes about 10 seconds due to the last two test cases. The header and footer enable a linefeed-separate test suite, and convert the output to comma-separation for readability.)
Explanation
.+
$*

Convert the input to unary.
(11\1|^1)+
$#1$*1:$&

This prepends the square root of the input, separated by :. The square root is computed based on the fact that the square of n is also the sum of the first n odd integers. We can match consecutive odd integers with the forward reference (11\1|^1). In the process the group will be used exactly n times, where n is the largest number whose square fits into the input.
We insert a unary representation of this number with $#1$*1, followed by a colon and the match itself.
M!&`(?!(11+)\1+:)(1+):(?!\2+$)

This matches all the missing primes that fit into the square root. The prime detection is based on the standard prime checking regex, and then we simply make sure that the prime we've just captured does not divide the input with the second lookahead. By using the & option, we get overlapping matches to ensure that we get all primes.
M%`1

This converts each line (i.e. each missing prime) back to decimal by matching the number of 1s. The only issue is that this inserts a zero if no missing primes were found at all.
^0

So this stage removes that zero if it was added.

Vyxal, 6 bytes
√~æ?KF

Try it Online!
It's nice to have a massive toolbox again
Explained
√~æ?KF
√~æ     # Keep only primes from the range [1, sqrt(input)]
     F  # With items from
   ?K   # Factors of the input
     F  # Removed

Created with the help of Luminespire.

Uiua, 46 bytes
▽∵(=2/+⌕0◿+1⇡.).▽¬≡/+⊞=↷.⊃(+1⇡⌊√)(▽=0◿↷.+1⇡.).

Try it Online
Explained
▽∵(=2/+⌕0◿+1⇡.).▽¬≡/+⊞=↷.⊃(+1⇡⌊√)(▽=0◿↷.+1⇡.).
                         ⊃(     )(          ).  # To the input, apply:
                           +1⇡⌊√                #   Range [1, sqrt(input)]
                                  ▽=0◿↷.+1⇡.    #   All factors of the input by:
                                        +1⇡.    #     Creating a range [1, input]
                                      ↷.        #     Rolling a copy to the bottom of the stack
                                   =0◿          #     Pushing whether each number in that range divides the input
                                  ▽             #     And keeping only numbers that do
                ▽¬≡/+⊞=↷.                       #   Filter out divisors from the sqrt range by:
                     ⊞=                         #     Table via equality
                  ≡/+                           #     Sum of row
                 ¬                              #     != 0
# Essentially, keep only numbers where the number of occurrences in the divisor list is 0
 ∵(=2/+⌕0◿+1⇡.).                                # Push a mask of whether each number is prime (using the method in my "is a number prime" Uiua answer)

Created with the help of Luminespire.

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


text:
Shortest Konami Code
The Problem
You must write a program that, when the Konami Code is typed in during runtime, prints the string "+30 lives" and sounds a noise of your choice from the computer's speaker.
Definition
The "Konami Code" is defined as UUDDLRLRBA followed by pressing the enter key.
The Rules

You may choose to use the up arrow for U, down for D, left for L, and right for R, as long as your code is consistent with either arrows or letters.

Your input may be accepted from a controller or a keyboard, but does not need to support both.

Existing answers may continue to use BABA instead of BA, but may also shorten it if they wish to do so. Future answers should all use BA for consistency.

Empty input doesn't need to be supported.

Comments are not for extended discussion; this conversation has been moved to chat.

05AB1E, 33 bytes (Fine on Empty Input)
Dg0Qiq}•ï“ë™µyê!•36BQi7ç“+30™‹“J,

Try it online!
05AB1E, 30 26 bytes (Fails on Empty Input)
-4 thanks to Adnan
•ï“ë™µyê!•36BQi7ç,“+30™‹“,

Try it online!
•ï“ë™µyê!•36B                  # UUDDLRLRBABA in base-214, converted back to base-36.
             Qi                # If implicit input is equal to...
               7ç,             # Print 7 converted to a character to the console (bell sound)...
                  “+30™‹“, # Print +30 lives.

Disclaimer: Bell sound does not play on TryItOnline, maybe ask Dennis if one of his servers somewhere is pinging when you run it.

You almost won! Just one byte off

A compressed version of "+30 lives" is “+30™‹“ :)

This always outputs "+30 lives" for me on the online interpreter, even with empty input.

@redstarcoder Only* with empty input, crap, fixing

@carusocomputing can you fix this the BA should only be once (my fault sorry)

JavaScript (ES6), 202 200 198 bytes
Tested only on Chrome and Firefox. Uses UDLR rather than the arrow keys. Please make sure that CapsLock is off.

(o=(A=new AudioContext()).createOscillator()).connect(A.destination);s='';document.onkeyup=e=>{(s+=e.key[0]).slice(-11)=='uuddlrlrbaE'&&setTimeout('o.stop()',500,console.log('+30 lives'),o.start())}
Please click inside this area to make sure it gets focus.

No need for parens after constructor and move s='' to argument of createOscillator. 196: (o=(A=new AudioContext).createOscillator(s='')).connect(A.destination);document.onkeyup=e=>{(s+=e.key[0]).slice(-11)=='uuddlrlrbaE'&&setTimeout('o.stop()',500,console.log('+30 lives'),o.start())}

Python 3,  55  53 bytes
-1 byte thanks to isaacg (use bitwise not to replace -10 with ~9).
-1 byte thanks to CalculatorFeline (it is possible to use a literal BEL byte).
while'UUDDLRLRBA'!=input()[~9:]:1
print('+30 lives7')

where the 7 shown above is a literal byte 0x07 (an unprintable in a code block).
Once enter is pressed the while loop condition is checked. If the last ~9 = 10 characters (at most) do not match the Contra command code then the no-op 1 is executed (replacement of pass for brevity); if they do match then the while loop ends and the print statement is executed, which writes the required text along with an ASCII bell character ("alarm"), 0x07, which produces a sound unless it has been explicitly disabled (or the terminal has no speaker!).

can you fix this the BA should only be once (my fault sorry)

Fixed, thanks for the heads up.

-10 = ~9, which can save you a byte.

Can't you put a literal \x07 in the string for -1 byte?

@CalculatorFeline I have no idea, can I? Note people often use \n in strings in Python golfs, why would they not use \x0a?

*\a and it's because you can't have newlines in strings without triplequotes. That only applies to newlines, BELs are fine.

@CalculatorFeline Ah yes true about \n. To what does "* \a and" refer? When you said "Can't you..." did you mean to say "You can..."? If so, how is a bell written inside a string in one byte of source?

...i.e. is this valid?

Yes (when running from file).

Processing, 161 157 155 bytes
String k="";void keyTyped(){if(match(k+=key,"uuddlrlrba\\n$")!=null){print("+30 lives");new processing.sound.SoundFile(this,"a.mp3").play();}}void draw(){}

The audio file must be saved as sketchName/data/a.mp3. Note: I have only tested this program without the audio file because I am too lazy to download an mp3 file (since only limited extensions are supported from processing.sound.SoundFile).
The draw() function is needed to be there in order for keyTyped to work.
The reason we are using keyTyped is because Processing does not have STDIN, it can only listen for keys being pressed via the sketch being run.
Explanation
String k="";
void keyTyped(){
  if(match(k+=key,"uuddlrlrba\\n$")!=null){
    print("+30 lives");
    new processing.sound.SoundFile(this,"a.mp3").play();
  }
}
void draw(){
}

All of the user's keystrokes are stored as chars inside the String k. The keyTyped is an inbuilt function that is called whenever the user types a key. Simultaneously, we are checking if this String ends with the keystrokes. Then we print +30 lives and play the sound file. And the draw function is there to continuously update keyTyped. After the Konami code is entered, then nothing else will be outputted and no audio will be played.

it seems like you should count the size of your mp3 file

@ricyje Processing doesn't really have any other way of outputting sounds. Also, the size of the .mp3 file doesn't really matter since no matter what it is, Processing will play it as a sound

@KritixiLithos can you fix this the BA should only be once (my fault sorry)

@ChristopherPeart Done! (I'm glad to save 2 more bytes :)

Jelly, 33 30 29 27 bytes
ɠ⁻“UUDDLRLRBA”$¿ṛ7Ọ“¡}ʠƈ[ỵ»

Turns out, the append (ṭ) is not needed, strings are automatically joined together both printed.
ɠ⁻“UUDDLRLRBABA”$¿ṛ7Ọṭ“¡}ʠƈ[ỵ»

Uncompressed
ɠ⁻“UUDDLRLRBABA”$¿ṛ7Ọṭ“+30 lives”

Try it online
If you remove everything after ¿, you can mess with the input and see that it only returns when the input string is correct.
ɠ⁻“UUDDLRLRBABA”$¿ṛ7Ọṭ“+30 lives” - main link
ɠ                                 - takes a line of input
 ⁻“UUDDLRLRBABA”$                 - $ groups it into a monadic !="UUDDLRLRLRBABA"
                 ¿                - while (the inequality, which takes from the getline)
                  ṛ               - take the right argument (to ignore the input string)
                   7Ọ             - chr(7), the bell character
                     ṭ“+30 lives” - append that bell character to the output

Thanks @JonathanAllan for helping me figure out string compression :)

“+30 lives” compressed is “¡}ʠƈ[ỵ» (for future reference here is a post about it, it's linked in the tutorial on the Jelly wiki).

where is the sound?

I just tested it with the official interpreter and it does indeed loop until the Konami code is entered

@JayDepp can you fix this the BA should only be once (my fault sorry)

I believe that it's not so much automatic string concatenation as an implicit print of the LLC (leading constant chain) 7Ọ followed by an implicit print of the nilad “¡}ʠƈ[ỵ», appearing on stdout as if it were concatenation. As a showcase you can try adding a 2 second sleep between with ɠ⁻“UUDDLRLRBABA”$¿ṛ7Ọ2“+30 lives”œS.

Also I think the code should really be something like ɠUḣ⁵µ⁻“ABRLRLDDUU”$¿ṛ7Ọ“+30 lives” so that an entry like blahblahUUDDLRLRBA followed by  will also trigger the bell and message.

@JonathanAllan that's interesting about the printing. At some point I thought about matching the end of the string, but I looked at the other answers and from what I can tell, over half don't do it. I guess that's a result of the vague input specifications.

><>, 132 69 64 62 bytes *><>, 84 bytes
i:1+?\0[
:1+?!\i
BA"a~/"UUDDLRLR
{v!?l/!?=
7/"+30 lives"
o<;!?l

Try it here!
This relys on the bell chime (ascii 7) for the noise at the end (not heard on the online interpreter).
Thanks to @TealPelican for saving another 15 bytes!
Saved two bytes checking for BA instead of BABA.

Does this make a sound?

@KritixiLithos, yes you'll see on the second-last line at the very end is a "7", that's the bell chime.

I've refactored your code a little bit because i didn't quite understand the first lines use? Try it here This link is for ><> but works for *><> too (doesn't use the dive mechanic like you have) - it also saved on 19 bytes! :)

@Tealpelican, the first line is so it keeps running, waiting for input! Your linked version doesn't do that ;p.

You are right! I missed that! - I've added a line in to accommodate for my error and replaced some redundant reversing and printing Try the new version which I've gotten down to 67 bytes :D

@Tealpelican, almost there! It still exits when it gets the incorrect code, it should loop :p. That's what I had the dive/rise before! It still looks like a serious improvement though.

I'm sure a lot of the other answers haven't added these restrictions :/ but yes you are correct. This is a super easy fix (lucky!) V3.0 69 bytes - main change added to line 1 ~ becomes >0[ and on line 4 the ; becomes v to redirect back to the new top code.

@Tealpelican, do they not? Well I'd rather try to keep in the spirit anyways :). It works! I'll make that the answer. Thanks again!

C 119 -1 - 2 = 116 bytes
Golfed
i;f(){char a[14];a[13]=0;while(strcmp(a,"UUDDLRLRBA"))for(i=0;i<12;a[i]=a[i+++1]);a[i]=getch();puts("+30 Lives\a");}

Ungolfed
#include<stdlib.h>
#include<conio.h>

i;
f()
{
    char a[14];
    a[13]=0;
    while(strcmp(a,"UUDDLRLRBA"))
    {
        for(i=0;i<12;a[i]=a[i+++1]);
        a[i]=getch();
        puts(a); //This is to print every step in the runtime
    }
    puts("+30 Lives\a"); // '\a' is the acsii char that makes sound when passed to STDOUT
}

main()
{
    f();
}

s/UUDDLRLR BABA/UUDDLRLRBABA for -1 byte and the strcmp will be looking for the correct string!

@Christopher please never make edits to people's code on this Stack Exchange site. your edit should never have been approved.

Mukul, you can remove the space yourself.

@cat that okay?

@MukulKumar Of course :) it's important that the answerer edit their own code.

@MukulKumar can you fix this the BA should only be once (my fault sorry)

@Christopher fixed

GNU sed, 32 25 + 1 = 33 26 bytes
+1 byte for -n flag.
/UUDDLRLRBA$/a+30 Lives\a

Try it online!
Explanation
Every time enter is pressed ($), the program checks if the preceding 10 keystrokes were the code. If they were, the a command queues the text +30 Lives and the bell sound (\a) to be printed at the end of the current cycle (which, in this case, is immediately).

can you fix this the BA should only be once (my fault sorry)

This already has the BA just once.

Oh wow didn't notice

Mathematica, 50 bytes
While[x=!=UUDDLRLRBA,x=Input[]];Beep[];"+30 lives"

Initially, x is just a symbol and is thus not identical (=!=) to the symbol UUDDLRLRBA, so x=Input[] is evaluated. This will open a dialog box with the cursor already in the input field, so the user can immediately start typing on the keyboard.
If Enter is pressed or OK is clicked without typing anything, then InputField[] will return Null, which is not identical to UUDDLRLRBA, so the loop continues and another dialog box will be opened.
If the user clicks Cancel or otherwise exits the dialog box, then InputField will return $Canceled, which is also not identical to UUDDLRLRBA, so the loop will continue.
The user can type in the dialog box to their heart's desire. When they hit Enter, their input is interpreted as a Wolfram language expression (possibly just boxes). If that expression is anything other than the symbol UUDDLRLRBA, the loop will continue.
"Must loop until the Konami code is entered" is a little vague, but I believe this satisfies it. Once the While loop is completed, Beep[];"+30 lives".

can you fix this the BA should only be once (my fault sorry)

UUDDLRLRB? Where's A?

@CalculatorFeline Fixed

Stacked, 41 bytes
['+30 lives'BEL+out]prompt'UUDDLRLRBA'=if

Reads input from keyboard.
['+30 lives'BEL+out]prompt'UUDDLRLRBA'=if
[                  ]prompt'UUDDLRLRBA'=if  if the input is the desired string,
 '+30 lives'BEL+out                           output '+30 lives' and the BEL character.

Petit Computer BASIC, 91 bytes
@L
WAIT 1S$=S$+CHR$(B)*!!B
B=BTRIG()IF B<1024GOTO@L
IF"xxxxxxxxxx"==S$THEN BEEP?"+30 lives

Finally a solution that actually uses controller input!
I used Petit Computer rather than the newer version (SmileBASIC) because it has access to the Start button, and BTRIG() is shorter than BUTTON().
I've replaced the data string with x's, it should contain characters with ascii codes 1,1,2,2,4,8,4,8,32,16
Boring version, 46 bytes
INPUT S$IF"UUDDLRLRBA"==S$THEN BEEP?"+30 lives

I would recommend using SmileBASIC 2 for the name of Petit Computer entries, and where necessary specify SmileBASIC as SmileBASIC 3.

Nice job using controller!

AutoHotkey, 63 bytes
Input,K,L10
if(K="UUDDLRLRBA"){
MsgBox,"+30 lives"
SoundBeep
}

After running this script, it will check if the next 10 keys are the Konami code and if it is, it will show a message box saying "+30 lives" and it should play a beep (I don't have speakers now to test).

Cool! AutoHotkey is a interesting program.

Vyxal, 21 bytes
«_sa}]∷«⇧=`+30 æ§\7`*

Based on @Makonede's 05AB1E answer.
Try it Online!
Explained:
«_sa}]∷«⇧=`+30 æ§\7`*
                    *    # Repeat...
          `+30 æ§\7`     # the string '+30 lives␇'... (escape code \7 is BEL)
                         # once if ...
         =               # the (implicit) input equals...
«_sa}]∷«                 # the compressed code...
        ⇧                # in uppercase...
                         # otherwise repeat zero times

\a also works instead of \7.

Powershell, 89 86 Bytes
if((Read-Host)-eq"UUDDLRLRBABA"){"+30 Lives";[System.Media.SystemSounds]::Beep.Play()}

enter submits the string to the Read-Host, so it should.. work?

I think you just need to check for "UUDDLRLRBABA" not "UUDDLRLR BABA" as there's no " " in the Contra code. That'd also save you a byte. I think assuming enter because they have to press enter to send the input is valid.

I does work by the way

@ChristopherPeart Please don't make edits to others' code even if you are the OP, or if you are saving them a byte.

Ok I will do that. But It was my fault

@ConnorLSW can you fix this the BA should only be once (my fault sorry)

Wonder, 50 bytes
ol"•";f\@[="UUDDLRLRBA"rl0?ol"+30 lives•"?f0];f0

Replace • with the character of code \x07 (the BEL control char). Takes input through STDIN.

can you fix this the BA should only be once (my fault sorry)

Well I fixed. Thanks for the notice!

C# (the boring version), 80 bytes
void n(){while(Console.ReadLine()!="UUDDLRLRBA"){}Console.Write("+30 Lives\a");}

C# (The interesting one), 202 bytes
void n(){t();Console.Write("+30 Lives\a");}void t(){var k="UUDDLRLRBA";var s="";while(s!=k){s+=Console.ReadKey().Key.ToString();s=k.StartsWith(s)?s:"";}if(Console.ReadKey().Key!=ConsoleKey.Enter){t();}}

I think this works, sadly online testers do not support the existence of a console input, as such I will have to go on the tests I have done
Can most likely be golfed hugely - I'm not great at this! :)
Ungolfed:
void n()
{
    t();
    Console.WriteLine("+30 Lives\a");
}

void t()
{
    var k = "UUDDLRLRBA";
    var s = "";
    while(s != k)
    {
        s += Console.ReadKey().Key.ToString();
        s = k.StartsWith(s) ? s : "";
    }
    if(Console.ReadKey().Key != ConsoleKey.Enter)
    {
        t();
    }
}

Hmm, does C# have a way to read until a newline is detected? That'd save you from looking for the enter key. Look at how it's implemented in Python here.

There's Console.Readline but I thought that might be aganist the spirit of the challenge! If that's fine I can make this much shorter

@redstarcoder added a Console.ReadLine() version

@AlfieGoodacre can you fix this the BA should only be once (my fault sorry)

@ChristopherPeart It originally was but I had to change it ;)

flex, 37 + 5 = 42 bytes
%%
UUDDLRLRBA puts("+30 lives\a");

The code itself is 37 bytes, compile it with the "-main" option which adds 5 bytes.  Naturally, you have to compile the resulting C file with your favorite C compiler, but I don't think that step should count toward the byte count.
I could save a byte by using a literal BEL character instead of \a, but I'd rather be able to read my own code.

You really don't need to be able to read the code. This is code golf

Personally, I think I should get a bonus for using flex, due to how rarely it gets used here. :)

I believe you can reduce the penalty to 3 bytes via giving -ll as an option to the C compiler rather than -main as an option to flex.

C, 87 85 81 bytes
s[13];f(){for(;strcmp(s,"UUDDLRLRBA\n");fgets(s,12,stdin));puts("+30 Lives!\a");}

C, 114 bytes
#define X "UUDDLRLRBA"
main(i,j){for(i=j=0;!j;)(getchar()==X[i++])&&((j=1?!X[i]|puts("+30 lives\a"):0)|1)||(i=0);}

shortC, 52 bytes
s[13];AO;Ms,"UUDDLRLRBA\n");Ys,12,N));J"+30 Lives!\a

Explanation:
s[13];                                                // declare array with 13 members
      A                                               // main function
       O;Ms,"UUDDLRLRBA\n");                          // for loop while input is not equal to the Konami Code
                            Ys,12,N));                // read 12 characters of input into array
                                      J"+30 Lives!\a  // print the string

Try it online!

05AB1E, 22 bytes
.•›Gβ…Ýò•uQ7ç“+30™‹ÿ“×

Try it online!
.•...•uQ7ç“...“×  # trimmed program
          “...“   # push "+30 livesÿ"...
                  # (implicit) with ÿ replaced by...
         ç        # unicode character with codepoint...
        7         # literal...
               ×  # repeated...
       Q          # is...
                  # implicit input...
       Q          # equal to...
.•...•            # "uuddlrlrba"...
      u           # in uppercase...
               ×  # times
                  # implicit output

Stax, 21 bytes
é>Δ┼3Σöîc9qz╔°→cz╣╖↑└

Run and debug it
Explanation
`!j.o6F>"`=D"+30 lives"7+
`!j.o6F>"`=               input equals sequence?
           D              if so,
            "+30 lives"   push +30 lives
                       7+ add a bell to it


text:
Mondrian Puzzle Sequence
Partition an n X n square into multiple non-congruent integer-sided rectangles. a(n) is the least possible difference between the largest and smallest area.
 ___________
| |S|_______|
| | |   L   |
| |_|_______|
| |     |   |
| |_____|___|
|_|_________| (fig. I)

The largest rectangle (L) has an area of 2 * 4 = 8, and the smallest rectangle (S) has an area of 1 * 3 = 3. Therefore, the difference is 8 - 3 = 5.
Given an integer n>2, output the least possible difference.
All known values of the sequence at the time of posting:
2, 4, 4, 5, 5, 6, 6, 8, 6, 7, 8, 6, 8, 8, 8, 8, 8, 9, 9, 9, 8, 9, 10, 9, 10, 9, 9, 11, 11, 10, 12, 12, 11, 12, 11, 10, 11, 12, 13, 12, 12, 12

So a(3)=2, a(4)=4, ...
OEIS A276523
Related - this related challenge allows non-optimal solutions, has time constraints, and is not code-golf.
For more information, watch this video by Numberphile

CJam, 178
ri_1a*a*L{_:+1&{_[3{_\zW%}*]{_z}%:e<_@={:A0=_1#:X0<{;A1>j}{X>0+0#AzX=0+0#,\,m*1ff+{[_$\~1a*0aX*\+a*A\..-_])s'-&{;}&}%{~j\:X;{Xa&!},Xaf+:$~}%_&}?}{j}?}{;La}?}j{,(},{::*$)\0=-}%:e<

Try it online. It's veeery slow though, I wouldn't recommend going above 6.
To verify that it's really doing the work, you can check this slightly modified program that prints all the possible partitions (each partition is shown as an array of rectangle dimension pairs).

Wow, the time to run goes up steeply.

@mbomb007 yes, quite expected for a brute-ish solution. I actually included a bunch of optimizations to make it more efficient. If I remove them, I could make it quite a bit smaller (and slower and hungrier).

Befunge, 708 bytes
p&>:10p1-:>20p10g:20g\`v`\g02:-1\p00+1g<>g-#v_10g:*30p"~":40p50p060p070p$>^
1#+\#1<\1_^# !`0::-1$  _:00g3p\:00g2p00^^00:>#:

>>:2-#v_$30p50p60p70g1-70p
^<<<<<:#<<<<<<$$$_v#:!g87g78g79$  _v#!\-1:g88$<_ 98p87g97g*00 v:+!\`*84g++7<
^>$1-:77p1g:2g\3g1>78p97p87p10g97g->88p10g87g-0^!\-1:g89_v#-!\_$1-:v>/88g+7^
^|!-3$<   >\87g/88g+77++p:#v_$
^>:5->v   ^+g89%g78:\g77:-1<>98g88g48*577g387g97g98g88v ^>77g87g97v:^g78\+g<
^ v-4:_$77p88p98p:97p\:87p*^^g79g7>#8\#$_40pv5+"A"g77g< ^14g88g89g<>:87g%98^
^v_$88p98p97p87p:77p60g50g-:40g\`#^_$$>>>>>>>
 >#4!_::80p2g\3g*:90p30g`!v>>>#@>#.>#g^#0
^v:g06p03:-g09\2:g03g05g06_^^_7#<0#<g#<3#<1#<<`g04_$00g1->:#-8#10#\g#1`#:_>$
^>90g\-:0`*+:60p50g:90g-:0`*-:50p-80g70g:1+70p1p\!^

Try it online!
This is obviously not going to win any awards for size, but it's actually reasonably fast considering it's a basic bruce force implementation in an esoteric language. On the Befunge reference interpreter it can handle up to n=6 in a couple of seconds. With a compiler it can handle up to n=8 before it starts getting sluggish; n=9 takes a couple of minutes and n=10 is close on 2 hours.
In theory the upper limit is n=11 before we run out of memory (i.e. there's not enough space left in the playfield to fit a larger square). However, at that point, the time taken to calculate the optimal solution is probably longer than anyone would be willing to wait, even when compiled.
The best way to see how the algorithm works is by running it in one of the Befunge "visual debuggers". That way you can watch as it attempts to fit the various rectangle sizes into the available space. If you want to "fast forward" to the point where it has a good match, you can put a breakpoint on the 4 in the sequence $_40p near the middle of the tenth line (9 if zero-based). The value at the top of the stack at that point is the current area difference.
Below is an animation showing the first few frames of this process for n=5:

Each distinct rectangle is represented by a different letter of the alphabet. However, note that the final rectangle is never written out, so that section of the square will just be blank.
I've also written a debug version of the code that outputs the current layout each time it finds a new best match (Try it online!). For the smaller sizes, the first match is often the optimal solution, but once you get past n=6 you'll likely get to see several valid but non-optimal layouts before it settles on the final solution.
The best layout found for n=10 looks like this:
H F F F A A A C C I
H F F F A A A C C I
H J G G A A A C C I
H J G G A A A C C I
H J D D D D D C C I
H J D D D D D C C I
H J K K K K K K K I
H J B B B E E E E I
H J B B B E E E E I
H J B B B L L L L L

12 - 4 = 8

You are a god among befunge-rs.


text:
Zipper multiplication
Introduction
Let's define a new arithmetical operation, which I call zipper multiplication.
To zipper multiply two nonnegative integers, you add leading zeros to make the lengths match, multiply the corresponding base-10 digits of the numbers, add leading zeros to the results to get 2-digit numbers, concatenate them, and finally drop leading zeros.
Here's an example with A = 1276 and B = 933024:
1. Add leading zeros
 A = 001276
 B = 933024

2. Multiply digit-wise
 A = 0  0  1  2  7  6
 B = 9  9  3  0  2  4
 ->  0  0  3  0 14 24

3. Pad to 2 digits
 -> 00 00 03 00 14 24

4. Concatenate
 -> 000003001424

5. Drop leading zeros
 -> 3001424

The operation is extended to all integers with the usual sign rules: positive times negative is negative, negative times negative is positive and so on.
The task
Your inputs are two integers, and your output is their zipper multiplication.
You should be able to handle arbitrarily large inputs.
Input and/or output can be in string format (and indeed must be, if your language doesn't support arbitrarily large integers).
Note that -0 is not a valid input or output.
Rules and scoring
You can write a full program or a function, and the lowest byte count wins.
Test cases
0 0 -> 0
302 40 -> 0
302 -40 -> 0
-4352 448 -> -122016
0 6623 -> 0
0 -6623 -> 0
20643 -56721 -> -1000420803
63196 21220 -> 1203021800
1276 933024 -> 3001424
-1276 933024 -> -3001424
-1276 -933024 -> 3001424
5007204555 350073039 -> 12001545
-612137119 -8088606033 -> 816060042000327
3389903661 -6619166963 -> -18180881090018543603
-23082746128560880381 1116941217 -> -8050600723200060807
-668336881543038127783364011867 896431401738330915057436190556 -> -485448120906320001351224000900090235004021121824000900403042
402878826066336701417493206805490000415 312487283677673237790517973105761463808 -> 120004325656161618004242182118140007280900200921180018080025285400000000320040

Jelly, 11 10 bytes
ƓDUz0P€Uḅ³

Try it online!
I couldn't get this down to 10 bytes by myself, but @Pietu1998 pointed me to an atom I'd missed, this giving this 10-byte solution. Unusually for Jelly, this one takes input from standard input (in the form 1276,933024), not from the command line (this enables the use of the ³ command, which returns the command line argument, defaulting to 100).
Explanation:
ƓDUz0P€Uḅ³
Ɠ           read standard input
 D          convert to base 10
  U         reverse elements
   z0       transpose, padding the end with zeroes
     P€     take the product of each (€) inner list
       U    reverse elements back
        b³  convert from base 100

The use of base 100 is a simple way to implement the "pad to 2 digits, then convert to base 10" technique. The only other subtle thing here is the reversing; we want to pad with zeroes at the start of the number, but Jelly's z command pads at the end, so reversing the lists means that z will pad correctly.

You can replace b⁵ with D to get the 10 bytes. :P

Python 2, 99 bytes
a,b=input();o=0;p=1-2*(a*b<0);a,b=abs(a),abs(b)
while a:o+=a%10*(b%10)*p;p*=100;a/=10;b/=10
print o

A lot of the bytes are there to account for the sign in case of negative input. In Python, n%d is always non-negative if d is positive1.  In my opinion this is generally desirable, but here it seems inconvenient: removing the calls to abs would break the above code.  Meanwhile p keeps track of the "place value" (ones, hundreds, etc.) and also remembers the desired sign of the output.
The code is basically symmetric in a and b except in the while condition: we keep going until a is zero, and terminate at that time.  Of course if b is zero first, then we'll end up adding zeroes for a while until a is zero as well.

1 For example, (-33)%10 returns 7, and the integer quotient of (-33)/10 is -4. This is correct because (-4)*10 + 7 = -33.  However, the zipper product of (-33) with 33 must end in 3*3 = 09 rather than 7*3 = 21.

JavaScript (ES6), 44 bytes
f=(x,y)=>x&&f(x/10|0,y/10|0)*100+x%10*(y%10)

Conveniently this automatically works for negative numbers.

@Jakube I'm always doing that, although at least I included the f= in the byte count. Also, the |0 is because I need integer division, I don't know how you think you're getting the right answer without it.

Ah, that makes sense. Now I also get wrong answers when removing |0. Maybe the reassignment of the new function to f didn't work and I still tested the old version with |0.

C, 77 bytes
-2 bytes for removing redundant braces (* is associative).
r,t;f(a,b){t=1;r=0;while(a|b)r+=t*(a%10)*(b%10),a/=10,b/=10,t*=100;return r;}

t=1,100,10000,... is used for padding. As long as a or b is not zero keep multiplicating the last digit %10 with t and accumulate. Then erease the last digit of a and b (/=10) and shift t by 2 digits (*=100).
Ungolfed and usage:
r,t;
f(a,b){
 t=1;
 r=0;
 while(a|b)
  r+=t*(a%10)*(b%10),
  a/=10,
  b/=10,
  t*=100;
 return r;
}

main(){
 printf("%d\n", f(1276,933024));
}

Suggest for(r=0;a|b;t*=100)r+=a%10*t*(b%10),a/=10,b/=10 instead of r=0;while(a|b)r+=t*(a%10)*(b%10),a/=10,b/=10,t*=100

Actually, 23 19 bytes
Input is taken as two strings. Also, apparently attempting to convert from base 100, as ais523 does in their Jelly answer, doesn't work so well in Actually. Would have saved 9 bytes too if it worked :/ Golfing suggestions welcome! Try it online!
Edit: -4 bytes from changing how the result is built up into a new number.
k`♂≈R`M┬ñ`iτ╤@π*`MΣ

Ungolfing
          Implicit input a and b.
k         Wrap a and b into a list.
`...`M    Map over the list of strings.
  ♂≈        Convert each digit to its own int.
  R         Reverse for later.
┬         Transpose to get pairs of digits from a and b.
ñ         enumerate(transpose) to get all of the indices as well.
`...`M    Map over the transpose.
  i         Flatten (index, pair) onto the stack.
  τ╤        Push 10**(2*index) == 100**index to the stack.
  @π        Swap and get the product of the pair of integers.
  *         Multiply the product by 100**index.
Σ         Sum everything into one number.
          Implicit return.

R, 182 110 107 86 bytes
No longer the longest answer (thanks, Racket), and in fact shorter than the Python solution (a rare treat)! An anonymous function that takes two integers as input.
function(a,b)sum((s=function(x)abs(x)%%10^(99:1)%/%(e=10^(98:0))*e)(a)*s(b))*sign(a*b)

Here's how it works.
The zipper multiplication involves splitting the input numbers into their constituent digits.We take the absolute value of number and carry out modulo for descending powers of 10:
abs(x) %% 10^(99:1)

So here we're taking one number, x, and applying modulo with 99 other numbers (10^99 through 10^1). R implicitly repeats x 99 times, returning a vector (list) with 99 elements. (x %% 10^99, x %% 10^98, x %% 10^97, etc.)
We use 10^99 through 10^1. A more efficient implementation would use the value of number of digits in the longest number (check the edit history of this post; previous versions did this), but simply taking 99..1 uses fewer bytes.
For x = 1276 this gives us
1276 1276 1276 ... 1276 276 76 6

Next, we use integer division by descending powers of 10 to round out the numbers:
abs(x) %% 10^(99:1) %/% 10^(98:0)

This yields
0 0 0 ... 1 2 7 6

which is exactly the representation we want. In the code, we end up wanting to use 10^(98:0) again later, so we assign it to a variable:
abs(x) %% 10^(99:1) %/% (e = 10^(98:0))

(Wrapping an expression in parentheses in R generally evaluates the expression (in this case, assigning the value of 10^(98:0) to e), and then also returns the output of the expression, allowing us to embed variable assignments within other calculations.)
Next, we perform pairwise multiplication of the digits in the input. The output is then padded to two digits and concatenated. The padding to two digits and concatenating is equivalent to multiplying each number by 10^n, where n is the distance from the right edge, and then summing all the numbers.
 A = 0         0         1         2         7         6
 B = 9         9         3         0         2         4
 ->  0         0         3         0        14        24
 -> 00        00        03        00        14        24
 ->  0*10^6 +  0*10^5 +  3*10^4 +  0*10^3 + 14*10^2 + 24*10^1
 =  000003001424

Notably, because multiplication is commutative, we can perform the multiplication by 10^n before we multiply A by B. So, we take our earlier calculation and multiply by 10^(98:0):
abs(x) %% 10^(99:1) %/% 10^(98:0) * 10^(98:0)

which is equivalent to
abs(x) %% 10^(99:1) %/% (e = 10^(98:0)) * e

After applying this to A, we would then want to repeat this whole operation on B. But that takes precious bytes, so we define a function so we only have to write it once:
s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e

We do our embedding-in-parentheses trick to allow us to define and apply a function at the same time, to call this function on A and B and multiply them together. (We could have defined it on a separate line, but because we're eventually going to put all of this into an anonymous function, if we have more than one line of code then everything needs to be wrapped in curly braces, which costs valuable bytes.)
(s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)

And we take the sum of all of this, and we're nearly finished:
sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b))

The only thing to consider now is the sign of the input. We want to follow regular multiplication rules, so if one and only one of A and B is negative, the output is negative. We use the function sign which returns 1 when given a positive number and -1 when given a negative number, to output a coefficient that we multiply our entire calculation by:
sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)) * sign(a * b)

Finally, the whole thing is wrapped into an anonymous function that takes a and b as input:
function(a, b) sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)) * sign(a * b)

Remove the whitespace and it's 86 bytes.

It will be great if you could provide an ungolfed, explained version for everyone's benefit.

I've updated the post with an explanation.

Great job. Very clever method used.

Mathematica 66 Bytes
i=IntegerDigits;p=PadLeft;FromDigits@Flatten@p[i/@Times@@p[i/@#]]&

Ungolfed:
IntegerDigits/@{1276,933024}
PadLeft[%]
Times@@%
IntegerDigits/@%
PadLeft[%]
Flatten@%
FromDigits@%

where % means the previous output yields
{{1,2,7,6},{9,3,3,0,2,4}}
{{0,0,1,2,7,6},{9,3,3,0,2,4}}
{0,0,3,0,14,24}
{{0},{0},{3},{0},{1,4},{2,4}}
{{0,0},{0,0},{0,3},{0,0},{1,4},{2,4}}
{0,0,0,0,0,3,0,0,1,4,2,4}
3001424

Python 3, 92 bytes, 119 bytes
lambda m,n:(1-(n*m<0)*2)*int(''.join([f"{int(a)*int(b):02}"for a,b in zip(str(abs(n))[::-1],str(abs(m))[::-1])][::-1]))

Try it online!
Fix for handling negative numbers cost 29 bytes :/

Nice answer! I think you can replace the lstrip part by wrapping everything inside int() and returning a number.

You're right. Then I felt like keeping a consistent interface. Taking strings as arguments instead of int, then returning an int looks weird to me ;) I rather hoped to change the zip+for loop for a map call, but that would not work :/

I wouldn't worry too much about consistency in code golf, but it's up to you :). Mapping is usually not very golfy in Python if you'd need to make an extra lambda to do it.

This function seems to fail for negative inputs

You're right :/ The fix is quite expensive, maybe there's more potential for golfing it down.

Julia, 70 64 bytes
Big thanx to @MarcMush for his advices!
~=digits∘abs
a\b=evalpoly(big(100),prod.(zip(~a,~b)))sign(a*b)
Attempt This Online!

-3 bytes with ~=digits∘abs instead of !a=...

and -3 bytes with prod.() instead of map

05AB1E, 9 bytes
Tвí0ζPRтβ

Port of @user62131's Jelly answer
Try it online or verify all test cases.
Explanation:
Tв        # Convert both integers in the (implicit) input-pair to a base-10 list
  í       # Reverse each inner list
    ζ     # Zip/transpose; swapping rows/columns,
   0      # using 0 as filler for unequal length lists
     P    # Take the product of each inner pair
      R   # Reverse the list of integers
       тβ # Convert it from a base-100 list to a base-10 integer
          # (after which the result is output implicitly)

Pyke, 16 bytes
FY_),FBw�+`t)_sb

Try it here!
Where � is the byte 0x84 or 132

PHP, 84 bytes
for(list(,$a,$b)=$argv,$f=1;$a>=1;$a/=10,$b/=10,$f*=100)$r+=$a%10*($b%10)*$f;echo$r;

slightly longer with string concatenation (86 bytes):
for(list(,$a,$b)=$argv;$a>=1;$a/=10,$b/=10)$r=sprintf("%02d$r",$a%10*($b%10));echo+$r;

Racket 325 bytes
(let*((g string-append)(q quotient/remainder)(l(let p((a(abs a))(b(abs b))(ol'()))(define-values(x y)(q a 10))
(define-values(j k)(q b 10))(if(not(= 0 x j))(p x j(cons(* y k)ol))(cons(* y k)ol)))))(*(string->number
(apply g(map(λ(x)(let((s(number->string x)))(if(= 2(string-length s)) s (g "0" s))))l)))(if(<(* a b)0)-1 1)))

Ungolfed:
(define (f a b)
  (let* ((sa string-append)
         (q quotient/remainder)
         (ll (let loop ((a (abs a))
                        (b (abs b))
                        (ol '()))
               (define-values (x y) (q a 10))
               (define-values (j k) (q b 10))
               (if (not(= 0 x j))
                   (loop x j (cons (* y k) ol))
                   (cons (* y k) ol)))))
    (*(string->number (apply sa
                             (map (λ (x)
                                    (let ((s (number->string x)))
                                      (if (= 2 (string-length s))
                                          s
                                          (sa "0" s))))
                                  ll)))
      (if (< (* a b) 0) -1 1))))

Testing:
(f 1276 933024)
(f 302 40)
(f 0 6623)
(f 63196 21220)
(f 20643 -56721)

Output:
3001424
0
0
1203021800
-1000420803

Perl 5 -MList::Util=min, 140 bytes
@a=<>=~/\S/g;@F=<>=~/\S/g;$q=1+min$#a,$#F;say+('-'x("@a@F"=~y/-//%2).sprintf'%02d'x$q,map$F[$_]*$a[$_],-$q..-1)=~s/^-?\K0+//r=~s/^-0*$//r||0

Try it online!

PowerShell, 153 151 bytes
param($a,$b)do{$x,$y=$a[--$i],$b[$i]|%{if($_-eq45){$s+=$_;$_=0}$_}
$r=(+"$x"*"$y"|% t*g "00")+$r}while($x+$y)$s+$r-replace'(?<!\d)0+(?=\d)|--|-(?=0+$)'

Try it online!
Less golfed:
param($a,$b)
do{
    $x,$y=$a[--$i],$b[$i]|%{
        if($_-eq45){                                # [char]45 is '-'
            $signs+=$_
            $_=0
        }
        $_                                          # a digit or $null
    }
    $res=(+"$x"*"$y"|% toString "00")+$res          # "00" is the custom format to get 2-digit number
}
while($x+$y)
$signs+$res-replace'(?<!\d)0+(?=\d)|--|-(?=0+$)'    # cleanup and return