text:
The shortest distance between two points is a line
Code a program or function to construct an interactive canvas on the screen of at least 400 pixels x 400 pixels in size. The canvas can be any color you wish, bordered or borderless, with or without a title bar, etc., just some form of obvious canvas.
The user will click on two distinct areas of the canvas and the program must output the Euclidean distance (in pixels) between those two clicks in some fashion (STDOUT, displaying an alert, etc.). The two clicks can be only left clicks, only right clicks, a left click for the first and right click for the second, two double-left-clicks, etc., any combination is acceptable. Special Note: Clicking-and-dragging (e.g., using MOUSEUP as the second point) is specifically not allowed; they must be two distinct clicks.
The user must be able do this multiple times, and must get an output each time, until the program is closed/force-quit/killed/etc. You can choose the method of closure (clicking an X, ctrl-C, etc.), whatever is golfier for your code.
Rules

Either a full program or a function are acceptable. If a function, however, you must still display the output to the user somehow (simply returning the value is not acceptable).
Output can be to the console, displayed as an alert, populated onto the canvas, etc.
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Can we output exact results (which may contain square roots) or does it have to be decimals?

@MartinEnder Either/or. Output formatting isn't the interesting part of this challenge.

The HTML/JS solution, from the second click, outputs the distance from that click to previous click. (so if the user click n times, n-1 instead of floor(n/2) numbers are printed) Is that allowed?

@user202729 It's a little outside of what I was envisioning, but I can see how it complies with the rules I have written above, so I'll allow it.

Can we use a smaller canvas size if our language can't support a 400 x 400 canvas?

@ScottMilner If your language absolutely cannot support that size, then that's allowed. Please provide documentation showing that limitation.

Is it allowed to spawn a temporary (visual) turtle for each 'begin' point clicked? Each one is flushed out after the next 'begin' point is selected.

Regarding clicks, you say any combination is acceptable. Does that mean the program can require any specific combination or that it must be able to handle all the combinations?

@TuukkaX Sure, that's fine.

@EngineerToast The first - you can decide what clicks are required for your program to work right.

Hmm, I'll have to see if I can work up something using Minecraft command blocks...

Is touching the screen (on a touchscreen) acceptable?

@12Me21 Sure, that's the equivalent of clicking. I'll allow that.

Would it be allowed to have just a 400x400 pixel area of a bigger canvas work properly and do weird other stuff for the rest of the canvas?

@BradC Did it work? Even if not: What was your idea?

My answer is outputting for points distance (a,b) then distance (c,d). Is it valid if I make it to output every time except the first click of them all? I mean outputting for dist between points (a,b), and (b,c).

@sergiol Yes, outputting after every click except the first (that is, given three clicks A, B, C, treating the C click as the second-click in the pair (B,C)) is perfectly acceptable. There are a few answers already doing that.

LOGO (FMSLogo), 54 52 bytes
[mouseon[setpos mousepos]"[pr distance mousepos]"[]]

Unfortunately, I can't find any Logo interpreter online support mouse handling like FMSLogo.
This is a "explicit-slot template", which is similar to lambda in other programming languages. Click left mouse for first point and right mouse for second point (print distance).
Explanation: (Logo is a turtle graphics programming language)
mouseon                  Turn on mouse handling, with the following action:
[setpos mousepos]        Set the turtle to `mousepos` (the position of the mouse) on left mouse down
"                        Do nothing on left mouse up
[pr distance mousepos]   Print the distance from turtle position (`distance` is Logo builtin for that purpose) to `mousepos` on right mouse down
"                        Do nothing on right mouse up
[]                       Do nothing on mouse movement

The " is an empty word. Normally template is expected to be a list (where [], an empty list, does nothing), passing a word is acceptable (it is wrapped in a list), and in this case it saves 2 bytes.
Run:
apply [... <put the code here> ...] []

The apply is one way to run template in Logo, the [] is argument list, for which the template receive none.

How does this guarantee the minimum 400x400 canvas?

@DavidMulder FMSLogo by default (without additional command line) start with canvas 1000×1000.

Mathematica, 94 bytes
e="MouseDown";m:=x=MousePosition[];1~RandomImage~400~EventHandler~{e:>m,{e,2}:>Echo@Norm[x-m]}

The canvas is a random grey-scale image, the first click should be a left-click and the second one a right-click. The exact behaviour is actually that right-click prints the distance to the last click (left or right), so if you use right-click repeatedly, you can also get consecutive distances.
The results are exact, so they might contain a square root.
If the resolution of your webcam is at least 400x400, you could use CurrentImage[] instead of 1~RandomImage~400 for your canvas, saving 3 bytes.

@Jenny_mathy Mathematica version maybe? I tested this on 11.1.

Java 8, 469 389 388 385 380 357 348 325 bytes
import java.awt.event.*;interface F{static void main(String[]a){new java.awt.Frame(){{setSize(400,400);double[]a={-1,0};addMouseListener(new MouseAdapter(){public void mouseClicked(MouseEvent e){if(a[0]<0){a[0]=e.getX();a[1]=e.getY();}else{System.out.println(Math.hypot(e.getX()-a[0],e.getY()-a[1]));a[0]=-1;}}});}}.show();}}

import javafx.application.*;import javafx.scene.*;import javafx.scene.layout.*;import javafx.stage.*;public class E extends Application{double[]a={-1,0};public void start(Stage s)throws Exception{Pane p=new Pane();s.setScene(new Scene(p,400,400));s.show();p.setOnMouseClicked(e->{if(a[0]<0){a[0]=e.getX();a[1]=e.getY();}else {System.out.println(Math.sqrt(Math.pow(e.getX()-a[0],2)+Math.pow(e.getY()-a[1],2)));a[0]=-1;}});}public static void main(String[]a){launch(a);}}

Would be shorter with AWT, but I've never used it.

I think true could be 0<1.

Also, can main(String args[]) not be main(String[]Z)?

I think {F f=new F();} can be {new F();}.

setVisible(0<1); can be removed, and you can add .show() to the Frame; println can be print.

@KevinCruijssen I don't know how OP wants the output for multiple results

@RobertoGraham Ah, you're right. My bad, had read past that rule.

Can you include the ungolfed version?

Does double[] a have to be a double? Why not int? It's not said how accurate the result has to be.

303 bytes with int instead of double (you don't need sub-pixel precision) and two ints instead of an int array (have to be defined inside the MouseAdapter for some reason): import java.awt.event.*;interface F{static void main(String[]a){new java.awt.Frame(){{setSize(400,400);addMouseListener(new MouseAdapter(){int a=-1,b=0;public void mouseClicked(MouseEvent e){if(a<0){a=e.getX();b=e.getY();}else{System.out.println(Math.hypot(e.getX()-a,e.getY()-b));a=-1;}}});}}.show();}}

is it still necessary to use the verbose syntax for anonymous classes? Is it not possible to use lambda expressions?

sorry, forgot that MouseListener has more than one method, thus no lambda. sorry for noise.

Java (OpenJDK 8), 282 bytes
import java.awt.event.*;interface M{static void main(String[]a){new java.awt.Frame(){int k,x,y;{addMouseListener(new MouseAdapter(){public void mouseClicked(MouseEvent e){x=e.getX()-k*x;y=e.getY()-k*y;k^=1;if(k<1)System.out.println(Math.hypot(x,y));}});setSize(800,600);show();}};}}

I cannot test this right now; if someone could tell me if there are any compiler errors that would be great.
AWT would probably be shorter but I need an actual IDE for that lol. I've never used AWT before but I could make it work if I had an IDE. I could use the docs but that's really hard lol
-10 bytes using AWT thanks to Kevin Cruijssen
-44 bytes using an initializer block; developed independently of Roberto Graham though I now see that they did the same thing, I think
-6 bytes combining a few declarations thanks to Kevin
-11 bytes using an interface thanks to Kevin
-35 bytes eliminating some unnecessary variables thanks to mellamokb
-9 bytes removing the unnecessary import and using a qualified name thanks to mellamokb
-44 bytes thanks to mellamokb and aditsu

TI-Basic (TI-84 Plus CE), 49 bytes (45 tokens) (possibly non-competing)
0→Xmin
0→Ymin
8³→Xmax
Ans→Ymax
While 1
Input
{X,Y
Input
Ans-{X,Y
Disp √(sum(Ans²
Pause
End

-7 bytes with suggestions from kamoroso94
The user doesn't 'click' per se, but moves around a cursor on the graph screen with the arrow keys and hits enter to select a point, and the smallest movement is ~1.5 for x and ~2.4 for y.
Explanation:
0→Xmin                # 5 bytes
0→Ymin                # 5 bytes
8³→Xmax               # 6 bytes,
Ans→Ymax              # 5 bytes, Set up graph screen size (512x512)
While 1               # 3 bytes, Until interrupted with `on` button
Input                 # 2 bytes, Get user input as a point on the graph screen in X and Y
{X,Y                  # 5 bytes, store the list {X,Y} in Ans
Input                 # 2 bytes, Get second user input as a point on the graph screen in X and Y
Ans-{X,Y              # 7 bytes, store {X1-X2,Y1-Y2} in Ans
Disp √(sum(Ans²       # 6 bytes, Display the distance between the two points
Pause                 # 2 bytes, Let the user see it (press `enter` to continue)
End                   # 1 bytes, End while loop

Since the size only has to be at least 400, you can golf that constant to something like 8³ which is greater than 400 but one byte less.

Also you can reduce the Disp line by two bytes with {X-A,Y-B:Disp √(sum(Ans² (colon or newline works obviously).

@kamoroso94 My TI-BASIC is rusty but would't that be 8^2, the same number of bytes?

@ToddSewell no, 8^2 (8 squared) is 64 and less than 400.  I said 8³ (8 cubed) which is greater than 400 and uses two tokens, one byte each: 8 and ³.

Right, I meant 8^3. Is there a delegated ³ character in TI-BASIC?

@ToddSewell: There sure is (MATH→3).

JavaScript (ES6) + HTML, 58 bytes
The webpage itself serves as the "canvas" in question; I think it's quite safe to assume the browser window will be at least 400x400 pixels.

E=0,onclick=e=>(E&&alert(Math.hypot(E.x-e.x,E.y-e.y)),E=e)

JavaScript (ES6) + HTML, 51 bytes
We can save 7 bytes if we ignore the NaN output on the first click. (@Nate)

E=onclick=e=>alert(Math.hypot(E.x-e.x,E.y-e.y),E=e)

JavaScript (ES6) + HTML + CSS, 58 + 0 + 13 = 71 bytes
Edit: With an additional 13 bytes of CSS, we can ensure the scroll area will be sufficiently large enough to fit the 400x400 requirement.

E=0,onclick=e=>(E&&alert(Math.hypot(E.x-e.x,E.y-e.y)),E=e)
*{padding:9in

Processing/Java, 149 bytes
void setup(){size(400,400);}void draw(){}int a,b;void mousePressed(){if(mouseButton==LEFT){a=mouseX;b=mouseY;}else println(dist(a,b,mouseX,mouseY));}

Pretty straightforward, uses 2 global variables and 3 built-in functions to do everything.

Setup: just initializes the window to 400x400
Draw: empty, but must exist for Processing to be interactive for >1 frame
MousePressed: if left click, save the mouse coordinates into the integers a and b. If right click, measure the distance from point (a, b) to the current position, and print to the console.

Processing.org 126
float i,d,x,y;void setup(){fullScreen();}void draw(){}void mousePressed(){d=dist(x,y,x=mouseX,y=mouseY);print(i++%2<1?" ":d);}

Python 2, 144
Prints distance between last clicks (first one prints distance from 400,400).
import Tkinter as t,math
r=t.Tk()
p=[400]*2
r.minsize(*p)
def f(e):print math.hypot(p[0]-e.x,p[1]-e.y);p[:]=e.x,e.y
r.bind('<1>',f)
r.mainloop()

Python 2 (TigerJython), 125 123 bytes
from gturtle import*
n=0
def c(x,y):
 global n
 if n:print distance(x,y)
 else:setPos(x,y)
 n^=1
makeTurtle(mousePressed=c)

TigerJython comes with a default size of (800x, 600y) sized canvas.
This spawns a temporary turtle image for every 'begin' point clicked, which disappears after the next 'begin' point is selected. This behaviour is approved by the OP.

Autohotkey, 146 bytes
A=0
Gui,Add,Text,W400 H400 gC Border
Gui,Show
Return
C:
If A=0
MouseGetPos,A,B
Else{
MouseGetPos,C,D
Msgbox % Sqrt((A-C)**2+(B-D)**2)
A=0
}
Return

You'd think a language built specifically for capturing and simulating keyboard and mouse actions would be more efficient at this challenge...
This creates a window with a text box 400 x 400 pixels with a border to make it obvious. Without the border, there's a space around the edge that's in the window but outside the text box and you can't tell. Adding a border was the shortest way to differentiate them. The gC option make it run the subroutine C whenever you click on the text box. The command sequence is, therefore, Left Click followed by a different Left Click.
I found another solution that's 144 bytes but it allows clicks all over the screen instead of just in the "obvious canvas". It's also annoying to end because both left and right clicks are captured and it doesn't end when you close the GUI.
Gui,Add,Text,W400 H400 Border
Gui,Show
Return
LButton::
MouseGetPos,A,B
Return
RButton::
MouseGetPos,C,D
Msgbox % Sqrt((A-C)**2+(B-D)**2)
Return

SmileBASIC, 86 bytes
@L
TOUCH OUT F,X,Y
S=S-X
T=T-Y
IF!O*F*M THEN?SQR(S*S+T*T)
S=X
T=Y
M=M!=!O*F
O=F
GOTO@L

Uses touch screen for input.

Tcl/Tk, 94 104
wm ge . 400x400
bind . <1> {if [info ex x] {puts [expr hypot(%x-$x,%y-$y)]}
set x %x
set y %y}

Java 8, 228 bytes
interface A{static void main(String[]a){new java.awt.Frame(){{setSize(400,400);}int i,j,t;public boolean mouseDown(java.awt.Event e,int x,int y){if(t++%2==1)System.out.println(Math.hypot(x-i,y-j));i=x;j=y;return 1>0;}}.show();}}

Here's a Java solution that uses a deprecated AWT method mouseDown that you'd have to dig deep into the API to find. I only know of it because of the programming course I took as a high school sophomore, and one of the projects was to make a small paint program using that and similar methods. I never thought I'd have a good reason to use it until now.


text:
Find my polyphthongs!
For the purposes of this challenge, a polyphthong is defined as a contiguous slice of a String, that only contains vowels, and has length at least 2. Given a non-empty String as input, your task is to output all the polyphthongs it contains.
For example, "abeoic" has the following contiguous slices (space-separated):
a b e o i c ab be eo oi ic abe beo eoi oic abeo beoi eoic abeoi beoic abeoic

Removing those that contain anything other than vowels, or have length smaller than 2, we get our desired polyphthongs:
eo oi eoi

Your submissions must abide by the following rules:

You can choose either lowercase or uppercase for I/O, but the output case must match the input case.

The vowels are aeiou (for lowercase) and AEIOU (for uppercase). y / Y is not considered a vowel.

The input will only contain printable ASCII.

If a polyphthong appears multiple times, you may choose to output it only once or output all its occurrences.

Any reasonable I/O format and method is allowed (lists of characters are also fine, for both input and output).

Test Cases

Input  ->  Output (lowercase)

r67^^()*6536782!87                -> []
programming puzzles and code golf -> []
aaand... i won!                   -> ['aa', 'aa', 'aaa']
abeoic                            -> ['eo', 'oi', 'eoi']
yah eioo ala                      -> ['ei', 'io', 'oo', 'eio', 'ioo', 'eioo']
@yabeeeayio__e                    -> ['ee', 'ee', 'ea', 'io', 'eee', 'eea', 'eeea']
0ioen0aaiosnjksd                  -> ['io', 'oe', 'aa', 'ai', 'io', 'ioe', 'aai', 'aio', 'aaio']

Note that for test cases 3 and 6, you may output 'aa' and 'ee' respectively only once (See the fourth rule).
This is code-golf, the shortest submission in bytes in every language wins!

Note that this was originally posted as a CMC (Chat Mini Challenge) in The Nineteenth Byte, but Adám said that it is suitable for Main, so I ended up posting this.

I your third test case, 'aa' appears twice. Does one have to output the same string multiple times if it appears at various locations or can one only output unique polyphtongs?

@JonathanFrech Ok, I guess outputting the unique polyphtongs is fine. Will edit.

Does the order of output matter?

@ovs No, the order is irrelevant.

Shouldn't it be "polyphthong"? (note extra H)

As a (former) linguist, I feel the need to point out that ~phthong has to do specifically with the sounds of adjacent vowels blurring into one another within the same syllable, rather than how they're written. For example, the four vowels written at the end of "onomatopoeia" are just two monophthongs in hiatus.

@Xophmeister For the purposes of this challenge, a polyphthong is defined as - I know that's not the correct linguistic definition :-)

Python 2, 102 97 bytes
thanks to @JonathanFrech for -5 bytes
w=input();l=range(len(w)+1)
print{w[a:b]for a in l for b in l if b-a>1<set(w[a:b])<=set('aeiou')}

Try it online!
lowercase I/O

I think you do not need ...AEIOU', since you are allowed to only take lowercase letters as input.

97 bytes long Python 3 version.

@JonathanFrech print([w[a:b]for a in l for b in l[a+2:]if{*w[a:b]}<={*'aeiou'}]) works for 93.

@Lynn And your solution produces 96 Python 2 bytes.

Retina, 23 20 bytes
M!&`[aeiou]+
r!&`..+

Try it online!
This prints all occurrences of a polyphthong.
Explanation
Retina does have a way to get all overlapping matches, but what this really means is that it will look for one match from each position. So if there are multiple matches from the same position, this will only return one of them. The only way to really get all overlapping matches is to use this feature twice, once matching left to right and once right to left (so that we first get the longest possible match from each possible starting position, and then we also get all matches for the possible ending positions).
So the actual program:
M!&`[aeiou]+

Get all overlapping runs of vowels. What this really means is to get all suffixes of all vowel runs.
r!&`..+

Now get all prefixes which are at least of length 2, by matching from right to left. The M is implicit here, because it's the final line of the program.

Can you explain the code?

!&`[aeiou]{2,} is so close to correct, is there a way to get it greedier so it matches against io?

@Adám Added an explanation.

@AdmBorkBork My explanation sort of covers why that can't work. Retina doesn't fiddle with the actual regex engine, so the most & can do is to try for a match from each position, so you can't have multiple matches of different length from the same position. That's why I need a second stage.

Nice explanation, thanks.

JavaScript (ES6), 77 75 bytes
Expects input in lowercase. Outputs unique polyphthongs without repeating.
w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

Test cases

let f =

w=>(r=[],g=s=>w.match(s)&&[...'aeiou'].map(c=>g(s+c),s[1]&&r.push(s)))``&&r

console.log(JSON.stringify(f("r67^^()*6536782!87")))
console.log(JSON.stringify(f("programming puzzles and code golf")))
console.log(JSON.stringify(f("aaand... i won!")))
console.log(JSON.stringify(f("abeoic")))
console.log(JSON.stringify(f("yah eioo ala")))
console.log(JSON.stringify(f("@yabeeeayio__e")))
console.log(JSON.stringify(f("0ioen0aaiosnjksd")))

How?
We recursively build the tree of all possible polyphthongs, pruning branches as soon as the current node is not contained in the input anymore, and saving all matching nodes of at least 2 characters.
w => (                      // given the input w
  r = [],                   // r = array of results
  g = s =>                  // g = recursive function taking s
    w.match(s) &&           // if w contains s:
    [...'aeiou'].map(c =>   //   for each vowel c:
      g(s + c),             //     do a recursive call with s + c
      s[1] &&               //     if s is at least 2-character long:
      r.push(s)             //       push it into r
    )                       //   end of map()
)``                         // initial call to g() with s = ''
&& r                        // return r

QuadS, 20 + 1 = 21 bytes
⊃,/⍵
[aeiou]+
1↓,\⍵M

with the o flag
Try it online!
In order of things happening:
[aeiou]+ on each match of this PCRE
,\⍵M prefixes of the Match
1↓ drop the first one (which has one one vowel)
,/⍵ concatenate all the lists of prefixes
⊃ disclose (because reductions / enclose)

This is equivalent to the Dyalog APL tacit function:
{⊃,/⍵}'[aeiou]+'⎕S{1↓,\⍵.Match}⍠'OM'1

Try it online!

Mathematica, 92 bytes
Select[Join@@Partition[r,i,1]~Table~{i,2,Length[r=(S=Characters)@#]},SubsetQ[S@"aeiou",#]&]&

Try it online!

Java (OpenJDK 8), 138 135 134 bytes
s->{String e,x="";for(int i=0,j,y=s.length();i<=y;i++)for(j=y;j>i;x+=e.matches("[aeiou]{2,}")?e+" ":"")e=s.substring(i,j--);return x;}

Try it online!

i<y-1 can be i<=y and String#matches implicit checks the entire String, so you don't need the ^  and $. +1 for beating me to it, though. Was just about to post my own 138 byte answer (but with these changes I proposed yours is shorter). :)

J, 34 29 bytes
(*/@e.&'aeoui'*1<#)\\.#&,<\\.

Try it online!

Jelly, 9 bytes
ẆḟÐḟØcḊÐf

Try it online!
Explanation
ẆḟÐḟØcḊÐf  Main Link
Ẇ          Get all (contiguous) sublists
  Ðḟ       Filter; remove all elements where the result is truthy:
 ḟ  Øc     Filter; remove all vowels; if it's truthy, then it contains non-vowels
       Ðf  Filter; keep elements where the result is truthy:
      Ḋ    Dequeue; return all but the first element (truthy if the length was at least 2)

-4 bytes thanks to Mr. Xcoder

11 bytes by replacing L>1$$ with L’$.

Actually you can replace L’$ with Ḋ for 9 bytes. An equivalent would be ẆṫLḊḟÐḟØc.

R, 137 bytes
outgolfed by Mark!
function(S)(x=unlist(sapply((s=el(strsplit(S,"[^aeiou]")))[nchar(s)>1],function(x)substring(x,1:(n=nchar(x)),rep(n:1,e=n)))))[nchar(x)>1]

Try it online!
function(S){
 s <- el(strsplit(S,"[^aeiou]"))            # split on non-vowels
 s <- s[nchar(s)>1]                         # vowel groups of length at least 2
 p <- function(x){                          # generates all substrings of inputs
  n <- nchar(x)
  start <- 1:n
  stop <- rep(n:1, n)                       # this will generate dups
  substring(x, start, stop)
 }
 q <- unlist(sapply(s, p))                  # all substrings
 q <- q[nchar(q)>1]                         # all length-2 or more substrings
}

You do not need unique.

"Any reasonable I/O format and method is allowed (lists of characters are also fine, for both input and output)." I've not tried it out, but I suspect this could be quite a lot shorter if you use character lists from the start.

@user2390246 perhaps. I'm not convinced that it would help necessarily, but that's probably just because the approach to isolate runs of vowels would be quite different and I can't wrap my head around it right now.

C (gcc), 104 bytes (99 bytes with lowercase only or uppercase only)
Yeah, it leaks - so what?

#include<string.h>
a;f(char*s){*s&&f(s+1);for(a=strspn(s=strdup(s),"AEIOUaeiou");a>1;)s[a--]=0,puts(s);}

Try it online!

Seems to work without the #include, and you only need to handle one letter case, so you can shorten it to 80 bytes.

79 bytes

Perl 5, 53 +1 (-p)
/[aeiou]{2,}(?{$h{$&}++})(?!)/g;$_=join$",sort keys%h

Try It Online

PowerShell, 93 88 bytes
param($a)0..($b=$a.count-1)|%{($i=$_)..$b|%{-join$a[$i..$_]}}|?{$_-match'^[aeiou]{2,}$'}

Try it online!
Uses lowercase or uppercase I/O (or a mix!).
Borrows code from my answer on Exploded Substrings to get all the substrings, then pulls out those that regex -match against ^[aeiou]{2,}$ -- i.e., those that are at least two vowels in length and only vowels. Those strings are left on the pipeline and output is implicit.

05AB1E, 10 bytes
Œʒg≠}ʒžMм_

Try it online!
Explanations:
Œʒg≠}ʒžMм_
Œ            Push all substrings (abeoic => a, b, e, ..., eoi, eoc, ... abeioc)
 ʒ  }        Filter elements for which result is 1
  g≠            Push 1 if length is != 1, 0 otherwise
     ʒ       Filter elements for which result is 1
      žMм       Remove all occurences of 'aeiou' from element
         _      Negative bool: push 1 if length == 0, 0 otherwise

Nice answer! I had ŒʒžMм_}ʒg≠

@Mr.Xcoder Thanks. I also had ŒD1ùKʒžMм_ for 10 bytes. I'm trying to find a way to golf it down though

-1 byte by replacing ʒg≠} with ISK.

Haskell, 148 137 130 123 118 bytes
Thanks to @Laikoni for -11 bytes, further -7 bytes by pointing me to golfing tips, another -7 bytes, and yet another -5 bytes, for a total of whopping -30 bytes.
This looked like a good fit for Haskell but the result doesn't seem to agree. I guess Haskell was an OK-ish choice after all. I'm still annoyed by the way subsequences works though.
import Data.List
v=(`elem`"aeiou")
p s=nub$do x<-groupBy((.v).(&&).v)s;[y|y@(c:_:_)<-subsequences x,v c,y`isInfixOf`x]

Try it online!

This is a nice first answer :) Welcome to the site!

Welcome to Haskell golfing! You might be interested in our collection of golfing tips, the guide to golfing rules and Of Monads and Men, our Haskell chat room.

Some notes on your answer: Newlines have the same byte count as ;, but increase the readability of the code. You always use e together with v, so you can directly declare e=(elem"aeiou"). y!!0 is shorter than head y. There is concatMap instead of concat.map, but even shorter is (=<<) from the list monad wich has the same effect.

You can import Data.Lists instead of Data.List. The former has all functions of the latter, but also additional stuff like powerslice, which gives a list of all continuous subsequences.

@Laikoni Thanks for the tips! I expected to waste time on code golf but it seems I learned something new instead. Also, thanks for the welcome to both of you!

@nimi Sounds like it could save a few bytes. However, I seem to be having issues with getting the lists package and Data.Lists working on either TIO or my own machine, and quite frankly, I don't have much interest in fighting any more with the toolchain. Still, potentially useful advise for more productive coding, which I'm thankful for!

In the list comprehension, you can match on y@(h:_:_) to drop length y>1 and shorten v(y!!0) to v h.

@Laikoni Heh, at this rate, this might as well be your answer. I guess my relative inexperience with both Haskell and code golfing is showing. Anyway, thanks for the tip! It's pretty enlightening. Now I'm just wondering what possible optimization I missed this time.

I have two more aces up my sleeve: (1) (\x y->v x&&v y) can be shortened by converting to point-free, either manually using this tip or by using pointfree.io. (2) The list monad can also be used with the do notation, that is do x<-l;[...] is the same as l>>=(\x->[...]).
Btw, on TIO you can put your main into the header or footer field to have the byte count match the actual submission.

@Laikoni Heh, thanks again! I actually looked at (1) for a good while but couldn't figure out how to make it shorter. Didn't think of (2) though, even though it's clear what's happening there. That footer tip is really good! I actually figured out what header meant there but main didn't feel like it belonged there and I didn't look at footer. :P

Perl, 45 bytes
local $,=" ";print $_=~/(?=([AEIOU]{2,}))/ig;

Welcome to PPCG! Nice first post!

In case you're wondering about the downvote, that was automatically placed by the Community bot account because your post was edited. Sorry, nothing we can really do about it, it's dumb behaviour. Hopefully the upvotes should trigger automatic downvote retraction.

R, 120 bytes 110 bytes
function(x){k=nchar(x);i=k:1;e=expand.grid(i,i[-1]);grep("^[aeiou]+$",mapply(substr,x,e[,2],e[,2]+e[,1]),v=T)}

Try it online!
How it works
function(x){                  #initalize the anonymous function where input is stored in x
  k=nchar(x)                  #set k to the number of characters in x
  i=k:1                       #create vector of integers from k to 1
  e=expand.grid(i,i[-1])      #create matrix of full outer join on i
                              #except in the second column, limit i to being less than k
  grep("^[aeiou]+$",          #search for strings made of only vowels
       mapply(substr,         #map the substring function
              x,              #with x as the string to subset
              e[,2],          #start at the second column of the outer join
              e[,2]+e[,1]     #end at the sum of the sum of the first and second columns
       ),
       v=T                    #if a match is found, return it's value
  )
}                             #by default, R returns the last line of a function

105 bytes nice approach, I'll add a comment to my solution noting that you have outgolfed me :)

I'll be honest, I was very pleased that I was able to come up with an alternate solution to yours :) Normally you're already light years ahead of me or figuring out all the code I left on the table.

JavaScript (ES6), 105 bytes
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')

Probably has a lot of golfing left to do.

let f=
s=>eval('a=[];l=i=s.length;while(i--){j=l;while(j--)if(/^[aeiou]{2,}$/.test(t=s.slice(i,j)))a.push(t)}a')
console.log(JSON.stringify(f('r67^^()*6536782!87')))
console.log(JSON.stringify(f('programming puzzles and code golf')))
console.log(JSON.stringify(f('aaand... i won!')))
console.log(JSON.stringify(f('abeoic')))
console.log(JSON.stringify(f('yah eioo ala')))
console.log(JSON.stringify(f('@yabeeeayio__e')))
console.log(JSON.stringify(f('0ioen0aaiosnjksd')))

C, 119 bytes
f(char*s){*s&&f(s+1);char*t,*b=calloc(strlen(s),1);for(t=b;*s==65|*s==69|*s==73|*s==79|*s==85;b[1]&&puts(b))*t++=*s++;}

Try it online!

Perl 5, 44 + 1 (-n) = 45 bytes
map{say}/(?=([aeiou]{$.}))/g while$.++<y///c

Try it online!

C, 105 75 bytes

A function accepting a pointer to lowercase input, and producing space-separated strings on standard output:
i;f(char*p){for(i=strspn(p,"aeiou");i>1;)printf("%.*s ",i--,p);*p&&f(p+1);}

Test program
#include <stdio.h>

int main(int argc, char **argv)
{
    for (int i = 1;  i < argc;  ++i) {
        char *in = argv[i];
        printf("'%s' -> [ ", in);
        f(in);
        puts("]");
    }
}

Demo
'r67^^()*6536782!87' -> [ ]
'programming puzzles and code golf' -> [ ]
'aaand... i won!' -> [ aaa aa aa ]
'abeoic' -> [ eoi eo oi ]
'yah eioo ala' -> [ eioo eio ei ioo io oo ]
'@yabeeeayio__e' -> [ eeea eee ee eea ee ea io ]
'0ioen0aaiosnjksd' -> [ ioe io oe aaio aai aa aio ai io ]

Explanation
#include <string.h>
#include <stdio.h>

void find_polyphthongs(char *p)
{
    /* from longest polyphthong substring down to 2 */
    for (int i = strspn(p,"aeiou");  i >= 2;  --i) {
        /* print exactly [p .. p+i] */
        printf("%.*s ", i, p);
    }

    /* tail-recurse to next char */
    if (*p) {
        find_polyphthongs(p+1);
    }
}

Using GCC on Debian Linux, I seem to get away with the incompatible implicit declarations of strchr() and printf().  Other platforms may require <stdio.h> and <string.h> to be included.
Try it online (requires Javascript).

Can f(p)char*p; not be f(char*p)?

Quite right - I originally had output to caller-allocated storage: f(s,d)char*s,*d.

102 bytes.

APL (Dyalog), 53 bytes
This is a Dfn (direct function). Usage is p '<argument>'. Fair warning: this is not very efficient and times out for input > 8 characters on TIO, but works normally when given enough time.
p←{(G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵}

Try it online!
Thanks to @Adám for 16 bytes!
How it works:
This is easier to understand if we break the code in smaller portions:

Part 1 - G←⊃,/{(,v∘.,⊢)⍣⍵⊢v←'aeiou'}¨⍳≢1↓⍵:  This part of the function takes the length of the (right) argument and mixes the vector aeiou to itself that many times, yielding every possible combination of [2, length(right arg)] vowels.
Part 2 - (G∊⊃,/⌽,\∘⌽¨,\⌽⍵)/: This part checks which element(s) of G are members of the substrings of the input. This returns a boolean vector, with 1's at the indices of the vowel combinations that are present in the input and 0's where they're not. The resulting vector is then mapped (/) over G, returning the elements corresponding to the truthy values.

The whole thing is then assigned to p. p← is not included in the byte count because it's not necessary, it just makes using the function easier.

Golfed further. Also, you shouldn't use ⊆ to filter. Use /.

Haskell, 74 bytes
f[]=[]
f(h:t)=filter(all(`elem`"aeiou"))[h:take i t|i<-[1..length t]]++f t

Try it online!

Ruby 2.4, 100 bytes
(2..(b=(a=gets).size-1)).to_a.flat_map{|i|(0..(b-i)).to_a.map{|j|a[j,i]}}.select{|k|k=~/^[aeiou]+$/}

This is my first attempt at golfing, and I'm sure there are lots of ways to shorten this code.

Ruby, 80 bytes
->s{[*0..z=s.size-2].product([*2..z]).map{|v|s[*v][/[aeiou]{2,}/]}.uniq.compact}

Try it online!

.compact can be -[nil]

Pyth, 15 bytes
f&tT!-T"aeoi".:

Try it online!
Definitely golfable, I want to get it better before writing out explanation.

T-SQL (SQL Server 2014), 281 bytes
;with s as(select substring(@,1,1)C,stuff(@,1,1,'')D,1 R union all select substring(D,1,1),stuff(D,1,1,''),R+1from s where len(D)>0),c as(select R i,C w from s where C LIKE'[aeiou]'union all select R,w+C from c join s ON i+1=R where s.C LIKE'[aeiou]')select w from c where len(w)>1

Input give by
declare @ varchar(max) = 'abeoic'

Uses a common table expression s to blow the input apart into ordered individual letters, and then a second common table expression c to generate all ordered combinations, throwing out non vowels.
SQL Fiddle

PHP, 139 bytes
function y($s){$p=[];$l=strlen($s);for($i=2;$i<=$l;$i++)for($j=0;$j<=$l-$i;$j++)strspn($a=substr($s,$j,$i),'aeiou')==$i&&$p[]=$a;return$p;}

Online demo
function yreadable($s)
{
    $p = [];
    $l = strlen($s);
    for($i=2; $i<=$l; $i++)
        for($j=0; $j<=$l-$i; $j++)
            strspn($a=substr($s,$j,$i),'aeiou')==$i
            && $p[] = $a;
    return $p;
}

How it works
Select sub-strings (beginning with the length of 2) consisting of adjacent characters and move along string.
Collect any sub-strings that only contain vowels.  Repeat with longer sub-strings.
For string 'abcdef' these are the substrings generated and checked:
'ab','bc','cd','de','ef'
'abc','bcd','cde','def'
'abcd','bcde','cdef'
'abcde','bcdef',
'abcdef'

Vyxal 2.6.0pre1 , 6 bytes
K~Ḣ'AA

No TIO link yet.
K      # Substrings
 ~Ḣ    # Filtered by a[:1] exists (len(a) > 1)
   '   # Filtered by...
     A # All...
    A  # Are vowels.

Vyxal, 9 bytes
K'Ḣ;'kv↔=

Try it Online!
K         # Substrings
 ' ;      # Filtered by...
  Ḣ       # a[1:] is nonempty
    '     # Filter again by...
       ↔  # Removing everything but...
     kv   # Vowels
        = # Leaves it identical to the original.

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:
8 8's make 1000
Print the following output of a happy coincidence addition pattern:
   8
   8
   8
  88
+888
----
1000

Rules:

No leading spaces except the ones already present
There can be a trailing newline
+ sign needs to be displayed
Order of parcels needs to be the same

No winner. It is code-golf per language.

So, what exactly do you want us to print? 1000? 8+8+8+88+888=1000?

I think he wants the entire equation as-is.

@Okx: That is not valid. I want a vertical output ypsis verbis of what I posted.

Ah, I got confused by the lack of the tag [tag:kolmogorov-complexity]

I downvoted this challenge for the following reason: The output is far too short (in my opinion) for a KC challenge, and doesn't have a great pattern either. This doesn't leave too much place for clever compression, and hardcoding is most likely the golfiest way to solve it (in most languages).

I upvoted because with answers getting below the size of the plain output (34 bytes), there obviously are some "clever" ways.

PowerShell, 34 33 31 bytes
,'   8'*3+"  88
+888"+'-'*4+1e3

Try it online!
Five bytes shorter than printing the string as-is, but still not very golfy. now getting to be golfy.
Constructs an array of 3x '   8' (saving a byte), then array-concatenates the remaining items, with '-'*4 saving a byte. The other byte savings comes from using 1e3 in place of 1000.

You can replace all + on line breaks. This will not change the length. Only for fun.

Charcoal, 15 14 bytes
Ｇ↑↑↓↙³8←→⟦+⁴Ｉφ

Try it online! Link is to verbose version of code. Explanation:
Ｇ↑↑↓↙³          Draw a polygon implicitly closing the path
      8         Filled with the string 8
       ←        Move left one character
          +     Literal string +
           ⁴    Integer 4 (prints as ----)
             φ  Predefined variable 1000
            Ｉ   Cast to string
         ⟦      Wrap in array (implicit ⟧)
        →       Override ← print direction
                Implicitly print one per line

Bash, 35 bytes
printf %4s\\n {,,,8,+88}8 ---- 1000

Try It Online

Python 2, 40 bytes
print"   8\n"*3+"  88\n+888\n----\n1000"

Try it online!

+2 bytes if you make it Python 3 compatible, but otherwise you're absolutely right.

Python 3, 57 52 51 50 bytes
-5 bytes thanks to Mr. Xcoder.
-1 byte thanks to Dennis.
-1 byte again, thanks to Mr. Xcoder.
for i in 8,8,8,88,'+888','-'*4,1000:print('%4s'%i)

Try it online!

Ahum Hardcoded output is 49 bytes..

@KevinCruijssen Huh, that’s already my answer :-)

@Mr.Xcoder Oh, oops.. Didn't notice there was another Python answer. Yours is even shorter by using print"..." instead of print('...'), though. :) I'll delete my comment above in that case.

@KevinCruijssen because that was already posted for Py2 I didn’t want to steal it ;)  Besides, simply printing hard-coded is... boring?  Almost like a cop-out so I didn’t take that approach :)

@KevinCruijssen Keep in mind though that Python 2 and Python 3 are their own languages, in a sense, so there can be two different approaches :)

SOGL V0.12, 15 bytes
≥č*xi«∙tν↔β⁸‘4n

Try it Here! - simply    8   8   8  88+888----1000 compressed, then split to line lengths of 4
20 19 byte non-compression based method:
8³'E■888+⁰§o┌4*LM*⁰

Try it Here!
8                    push 8
 ³                   triplicate the 8
  'E                 push 88
    ■888+            push "888+"
         ⁰           wrap those in an array
          §          reverse horizontally, padding with spaces
           o         output that
            ┌4*      push "-"*4
               LM*   push 100*10
                  ⁰  wrap those two in an array, outputting both

05AB1E, 20 bytes
-1 byte thanks to Riley
8ÐÐ«D„8+«'-4×₄R).Bí»

Try it online!

8ÐÐ«D„8+«'-4×₄R).Bí» saves a byte

brainfuck, 107 bytes
++++++++[>+++++>+>+++++++>++++<<<<-]>+++++>++<<+++[->>>>...<.<.<<]>>>>..<..<.<--.>>...<.<++....>.<++++.-...

Try it online!
Explanation
++++++++[>+++++>+>+++++++>++++<<<<-]>+++++>++<<+++
TAPE:
>V_LOOP< C_DASH C_NL C_EIGHT C_SPACE
003      045    010  056     032

~~~OUTPUT SECTION~~~
V_LOOP TIMES DO                     [-
    PRINT C_SPACE x 3                 >>>> ...
    PRINT C_EIGHT                     <.
    PRINT C_NL                        <.
                                    <<]
PRINT C_SPACE x 2                   >>>>..
PRINT C_EIGHT x 2                   <..
PRINT C_NL                          <.
C_DASH = C_DASH MINUS 2 (PLUS SIGN) <--
PRINT PLUS SIGN                     .
PRINT C_EIGHT x 3                   >>...
PRINT C_NL                          <.
PRINT C_DASH x 4                    <++....
PRINT C_EIGHT                       >.
C_DASH = C_DASH PLUS 2 ('1')        <++++
PRINT '1'                           .
C_DASH = C_DASH MINUS 1 ('0')       -
PRINT '0' x 3                       ...

Bubblegum, 23 bytes
00000000: 5350 50b0 e042 262c 2cb8 b42d 8084 2e10  SPP..B&,,..-....
00000010: 7019 1a18 1800 00                        p......

Try it online!

V, 23 bytes
3o³ 8òÙhr8òR1³0-Ò-kr+

Try it online!

J, 37 bytes
  7 4 $'   8   8   8  88+888----1000'

Javascript 44 bytes

a=x=>`   8
`.repeat(3)+`  88
+888
----
1000`

console.log(a())

39 bytes

GNU sed, 37 bytes
s:$:   8:p;p
a\  88
a+888
a----
a1000

Try it online!
I use the a command to append text lines to output. For comparison, the trivial solution is to print the hardcoded text like below, 42 bytes. Reduction is 11.9 %.
c\   8\n   8\n   8\n  88\n+888\n----\n1000

///, 31 bytes
/!/   8
/!!!  88
+888
----
1000

Try it online!
A measly 3 bytes savings.

QBIC, 36 bytes
?@   8`?A?A?@  88`?@+888`?@----`?z^3

Java 8, 45 bytes
v->"   8\n   8\n   8\n  88\n+888\n----\n1000"

Boring hard-coded output, but this can't be done any shorter in Java. Just utilizing the repeated part "   8\n" is already 52 bytes..
v->"aaa  88\n+888\n----\n1000".replace("a","   8\n")
Try it here.

J, 28 27 bytes
|.|:'1-+','0-88888'$~3,4,:7

Try it online!
                                             0-8
          '0-88888'$~3,4,:7      Three rows: 0-88
                                             0-88888
    '1-+',                       "1-+" on top
|.|:                             Rotate counter-clockwise

LOLCODE, 66 bytes
HAI 1.3
VISIBLE "   8:)   8:)   8:)  88:)+888:)----:)1000"
KTHXBYE

Try it online!

R, 46 bytes41 bytes
cat('   8
   8
   8
  88
+888
----
1000')

Try it online!
Thanks to Dennis for golfing off 5 bytes.

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

Uses the same technique as this genius answer.

Tcl, 42 bytes
puts "   8
   8
   8
  88
+888
----
1000"

Try it online!

Failed outgolf: https://tio.run/##K0nO@f@/oLSkWEEpuji1RCFVQUlBQcGCSylWJVUlFciy4NK2ABK6QMBlaGBgoMT1/z8A

Another failed outgolf: https://tio.run/##K0nO@f@/oLSkWEFJIbo4tUQhFchQsFCK5VJQSQVjldQYCy5tCwsLLl0g4DI0MDBQ4vr/HwA

One more failure: https://tio.run/##K0nO@f@/JDM3VaG6oLSkWEFJQUHBQqlWwZgLxrWw4NK2ABK6QMBlaGBgoPT/PwA

Stax, 19 bytes
∩π╚nY╤¼æ♂ç♦d└tä♂&lò

Run and debug it
ASCII equivalent:
.-+]125E{'8*eN$m+MrVk+m

Build the 8s together with the line below by transposing the string representation of the array [-8,-88,-88888].

Befunge-93, 66 bytes
"0001"25*"-":::25*"888+"25*"88  "25*"8 "::25*"8 "::25*"8 "::>:#,_@

Try it online!

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


text:
Reverse user input
This is a pretty simple one. if the user enters "Hello World" your code should output "dlroW olleH"
I was inspired by the multiplication question recently posted. I know this is probably easy in bash.
As this is code-golf, least bytes wins.

Mathematica, 13 bytes
StringReverse

Try it online!


text:
Symmetric Ladybugs
Introduction:
When we think about Ladybugs, we usually think of a red or dark orange bug with black spots. Although this isn't necessary true, since there are also black with red/orange spotted ladybugs, or ladybugs without spots at all, we mainly picture ladybugs something like this Asian Ladybug:

Another thing to note is that the spots on the ladybugs are almost always symmetric. And that is where this challenge comes in.
Challenge:
Given an integer n (>= 0), output the following ASCII-art ladybug one or multiple times, with symmetric spots evenly divided between the two sides, as well as the two or more ladybugs.
Here is the default ladybug layout:
    _V_
  /(@I@)\
 /   |   \
|    |    |
 \   |   /
  ''-!-''

If n=0, we output the ladybug above as is.
When n is larger than zero, we either fill in the spaces of the ASCII-art bug with a lowercase o, or replace the | in the center with a capital O. The goal is to make n changes to the 'empty' ladybug(s), while still producing a symmetric output (per ladybug), and outputting as few ladybugs as possible.
So valid outputs for n=1 are:
    _V_
  /(@I@)\
 /   O   \
|    |    |
 \   |   /
  ''-!-''

    _V_
  /(@I@)\
 /   |   \
|    O    |
 \   |   /
  ''-!-''

    _V_
  /(@I@)\
 /   |   \
|    |    |
 \   O   /
  ''-!-''

But this would be invalid:
    _V_
  /(@I@)\
 /   |   \
| o  |    |
 \   |   /
  ''-!-''

Valid outputs for n=2 are:
    _V_
  /(@I@)\
 /   O   \
|    O    |
 \   |   /
  ''-!-''

    _V_
  /(@I@)\
 /   O   \
|    |    |
 \   O   /
  ''-!-''

    _V_
  /(@I@)\
 /  o|o  \
|    |    |
 \   |   /
  ''-!-''

    _V_
  /(@I@)\
 /   |   \
| o  |  o |
 \   |   /
  ''-!-''

etc. There are a lot of possible outputs.

The first n that isn't possible to fit into a single ladybug anymore is n=24. In which case you'll have to divide it as evenly as possible into two ladybugs (you can choose whether to output them next to each other, or under one another - with optionally one space or one new-line in between them). For example:
    _V_        _V_
  /(@I@)\    /(@I@)\
 /o o|o o\  /o o|o o\
|o o | o o||o o | o o|
 \o o|o o/  \o o|o o/
  ''-!-''    ''-!-''

OR:
    _V_
  /(@I@)\
 /ooo|ooo\
|    |    |
 \ooo|ooo/
  ''-!-''
    _V_
  /(@I@)\
 /ooo|ooo\
|    |    |
 \ooo|ooo/
  ''-!-''

Challenge rules:

n will be in the range of 0-1000.
You can choose to output to STDOUT, return as String or 2D-char array/list, etc. Your call.
Leading new-lines or unnecessary whitespaces aren't allowed. Trailing white-spaces and a single trailing new-line are allowed.
As mentioned above, when two or more ladybugs are necessary, you can choose whether to output them next to each other or below each other (or a mix of both..)
When two or more ladybugs are printed next to each other, a single optional space in between is allowed. When two or more ladybugs are printed down one another, a single optional new-line in between is allowed.
You can choose the layout of the ladybugs at any step during the sequence, as long as they are symmetric and equal to input n.
Since the goal is to have n changes AND as few ladybugs as possible, you will start using more than one ladybug when above n=23. The layout of these ladybugs doesn't necessary have to be the same. In fact, this isn't even possible for some inputs, like n=25 or n=50 to name two.
In addition, sometimes it isn't possible to evenly split the dots among two or more ladybugs. In that case you'll have to split them as evenly as possible, with at most a difference of 1 between them.

So for n=50, keeping the last two rules in mind, this would be a valid possible output (where the first bug has 16 spots, and the other two have 17):
    _V_        _V_        _V_
  /(@I@)\    /(@I@)\    /(@I@)\
 /oooOooo\  /   O   \  /o oOo o\
|ooooOoooo||ooooOoooo||o ooOoo o|
 \   |   /  \oooOooo/  \o oOo o/
  ''-!-''    ''-!-''    ''-!-''

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

What do you mean by "as few changes as possible" to the empty ladybug? When placing n (<24) letters o/O onto a single ladybug, you make n changes to it. Or do you mean changes from n-1 to n (so outputs vary by as little as possible when inputs vary by 1)?

@Heimdall Ah sorry for the confusion due to bad wording. This was when I had the idea to allow multiple characters to form one spot when I thought of this challenge, but I dropped this and just used o and O instead. I've changed the wording a bit.

For the n=50 example, I believe that you mean the first bug has 16 spots and the other two each have 17.

This is my favorite Jimi Hendrix album.

@iamnotmaynard Maybe I'm missing something obvious, or did you comment on the wrong challenge? I don't really see the link between Jimi Hendrix and ladybugs..

It was just a bad joke. A play on "Electric Ladyland". It seemed funny to me. Never mind.

Charcoal, 84 81 bytes
Ｎθ≔⌈∕∨θ¹¦²³ηＦη«≔⁺÷θη‹ι﹪θηζV_¶I@)↘²↙|/←''-↑!↑⎇›ζ²¹OO²§|OζＥ037×o⌊⟦⁻÷ζ²Ｉκ⁺³⁼κ3⟧↙»‖Ｂ←

Try it online! Link is to verbose version of code. Explanation:
Ｎθ

Input the total number of spots.
≔⌈∕∨θ¹¦²³η

Calculate the number of ladybirds needed.
Ｆη«

Loop over each ladybird.
≔⁺÷θη‹ι﹪θηζ

Calculate the number of spots to put on this ladybird.
V_¶I@)↘²↙|/←''-↑!

Print the head and right wing of the ladybird.
↑⎇›ζ²¹OO²

If there are more than 21 spots, print two spots, otherwise print the back.
§|Oζ

If the number of spots is odd print another spot otherwise print the rest of the back.
Ｅ037×o⌊⟦⁻÷ζ²Ｉκ⁺³⁼κ3⟧

Divide the number of spots by two, and distribute them among three rows of 3, 4, and 3 spots.
↙»

Move to the start of the next ladybird.
‖Ｂ←

Reflect the canvas to the left, keeping the back.

Python 2, 252 249 238 212 211 213 209 bytes
n=input()
x=(n+22)/23or 1
for i in range(x):b=n/x+(n%x>i);c=r"""    _V_
  /(@I@)\
 /361%s163\
|408717804|
 \5201025/
  ''-!-''"""%'|O'[b%2];i=0;exec"c=c.replace(`i%9`,' |oO'[i>9::2][i<b/2],2);i+=1;"*11;print c

Try it online!

Saved 9 bytes thanks to Kevin Cruijssen
Saved 18 bytes thanks to Mr. Xcoder
Saved 2 bytes thanks to Jonathan Frech

I think you can remove the .replace('A','|O'[b%2]) and use c="    _V_\n  /(@I@)\ \n /361"+'|O'[b%2]+"163\ \n|4087B7804|\n \\529B925/\n  ''-!-''" instead?

230 bytes by turning [' o','|O'][i>9] into ' |oO'[i>9::2] and using | instead of logical or. Also turning for i in range(11) to an exec statement saved 4 bytes.

And sorry for the comment clutter, but 218 bytes by mixing your list comprehension with the for loop, removing an unnecessary variable as well.

@Mr.Xcoder Thanks a lot :)

It's supposed to produce the fewest ladybugs possible, no? When I put in 24 through 46 on TIO, it gives 3 ladybugs instead of two.

@kundor Thanks, fixed :)

211 bytes.

JavaScript (ES6), 183 186 bytes
Uses the same formula as TFeld's answer to split the spots among the ladybugs.
n=>(g=k=>k--?`    _V_
  /(@I@)\\
 /3\\
|4|
 \\3/
  ''-!-''
`.replace(/\d/g,i=>(h=s=>i--?h((p=N?(N-=2,'o'):' ')+s+p):s)('|O'[N>2*i|N&1&&+!!N--]),N=(n%j>k)+n/j|0)+g(k):'')(j=n/23+.99|0||1)

Demo

let f =

n=>(g=k=>k--?`    _V_
  /(@I@)\\
 /3\\
|4|
 \\3/
  ''-!-''
`.replace(/\d/g,i=>(h=s=>i--?h((p=N?(N-=2,'o'):' ')+s+p):s)('|O'[N>2*i|N&1&&+!!N--]),N=(n%j>k)+n/j|0)+g(k):'')(j=n/23+.99|0||1)

console.log(f(0))
console.log(f(1))
console.log(f(9))
console.log(f(25))

Befunge, 292 279 bytes
#j07-00p&>::1-27*9+/\!!*:1+06pv-1_@#:<<g61$<<:
v"h"**95%2:+`g61%g60\/g60::p61<>-0g*+35*-,:!|
>\-30p2/:55+`:59**"g"\-40p-26pv^*84\!`"."::<<9
v\%+55+g62:%+55+4*g62:::-1<+55<>:"/n"$#->#<^#<
>`26g!+"O"*"Y"\-\-\5+0p:>#^_" 66<0<66// >,-"v
"n //>7OXO8k />'&%$%&'k !(*+)#)+*(! /k,-.$."<v

Try it online!
Explanation
The ASCII art for the ladybug is encoded in a single Befunge string, offset by 15, to allow the first 15 printable characters to be reserved for special purposes. The first two of these special characters represent the newline and the | character, both of which would otherwise not be printable. The third isn't used, because it's a ", which can't be used in a string. The next two represent the large spots in the centre. And the remaining ten are for the spots on the wings.
These special characters are translated into their final form via a lookup table, which is written over the first part of the first line.
To make it easier to explain, this is the code with the various component parts highlighted:

 We start by initialising the newline and | character in the lookup table, since these are constant.
 Next we read in the number of spots from stdin and calculate the number of ladybugs required.
 We can then start the outer loop for the set of bugs, calculating the number of spots for the next ladybug to be rendered.
 For each ladybug, we calculate whether the large centre spot needs to be shown (if spots%2 == 1), and write the appropriate value into the lookup table.
 Similarly, we calculate whether the other pair of large spots need to be shown (if spots/2 > 10), again updating the lookup table. We also calculate the remaining spots required on each wing.
 The final part of the lookup table initialization is a loop that calculates which of the small spots need to be displayed. Essentially the algorithm is: if (spotnum*spotcount+4)%10 > ((spotnum+1)*spotcount+4)%10, then the spot needs to be displayed.
 Next we push the encoded string representation of the ladybug onto the stack. This is essentially just a simple string, but it became a bit convoluted as I tried to squeeze it into the gaps in the code so the source would form a rectangle.
 At this point, we're ready to begin the output loop, processing the characters one by one, converting the special cases (the spots, line breaks, etc.) via the previously constructed lookup table.
 Finally we check whether we've displayed all the required ladybugs, otherwise continue back to the start the of the outer loop.

Nice, I really like the patterns your ladybugs have for each stage from 1-23. Quite different than some of the other answers. +1 from me. Would you mind adding an explanation (after you're perhaps done golfing it further)?

I'm glad you liked the patterns. I actually spent quite a lot of time trying out the different combinations to find an algorithm that looked good in as many of the stages as possible. Also added a bit of an explanation to my answer now.

Ruby, 203 193 190 bytes
f=->n{s=%q{    _V_
  /(@I@)\
 /137x731\
|0596x6950|
 \248x842/
  ''-!-''
}
n-=d=n>0?n/(1+~-n/23):0
s.gsub!(/\d/){$&.to_i<d/2??o:' '}
x=[d%2,d<=>21]*2
s.gsub!(?x){"|O|"[x.pop]}
n>0?s+f[n]:s}

Try it online!

Saved 10 bytes thanks to Jordan

{|m|m. can be replaced with {$&.; b=(n-1)/23+1 can be replaced with b=1+~-n/23; and x=[z=d>21,d%2>0,z]⏎s.gsub!(?x){x.pop ? ?O:?|} can be replaced with x=[d%2,d<=>21]*2⏎s.gsub!(?x){"|O|"[x.pop]}.

You can save another byte by using %q{XY} instead of 'X'+"Y" on the first eight lines and a couple more by doing d=n>0?n/(b=1+~-n/23):b=0 instead of n>0?d=n/(b=(n-1)/23+1):d=b=0.

@Jordan Wow, thank you.


text:
LaTeX truth tables
Write a program or a function that accepts the list of outputs from a logic function and outputs the LaTeX code for its truth table.
The inputs should be labeled as lowercase letters a-z, and the output should be labelled as F. The length of list of inputs will always be shorter than 2^25, which means that number of inputs will always be less than 25, so you can use letters from lowercase alphabet for input names.
Input
A number n of inputs and list of length 2^n of binary numbers which represents the outputs of a logical function.
Output
LaTeX code that produces the truth table for that function. Input and output values should be centered in rows.
There must be a line between table header and its values and between inputs and output, so the code should be similar to that below.
\begin{tabular}{c * <NUMBER OF INPUTS>|c}
<INPUTS>&F\\
\hline
<INPUT VECTOR i>&<OUTPUT>\\
\end{tabular}

Example
Input:
2
[0, 0, 0, 1]

Output:
\begin{tabular}{cc|c}
a & b & F \\
\hline
0 & 0 & 0 \\
0 & 1 & 0 \\
1 & 0 & 0 \\
1 & 1 & 1 \\
\end{tabular}

Which when displayed in LaTeX shows the following truth table

General rules

This is code-golf, so shortest answer in bytes wins.
Default Loopholes are forbidden.

Is this challenge require exactly same output or any output that may produce same thing in TeX?

Any output that produces the same thing in TeX

Can the list be input as a string of 2ⁿ binary digits e.g. 2, 0001?

Does the latex code need to produce the exact output formatting given? Can it have other lines?

@Neil, the output can be a string, xnor no, the format should not have other lines

Suggested test case: 3 and [1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0].

Something I find tricky here not knowing TeX that well is that there might be other shorter ways to write the table formatting TeX code, or even some other way (package?) to produce the table. Whatever language I use, TeX golf is part of the challenge. Is there an online interpreter for TeX for convenience, and perhaps to make unambiguous what the exact implementation is?

Tip: The TeX code seems to work with all spaces and newlines removed.

Anyone who doesn't know how to do it in LaTeX, follow the example output above. If n=5, simple put ccccc instead of cc, but leave |c alone... And yes, in this table, all spaces and newlines are optional, but I would avoid blank lines.

Are lines compulsory? Is TeX instead of LaTeX allowed?

Can we take the binary numbers as a list of characters?

@xnor Yes you can

Here's how to do it in TeX: \halign{\hfil#\hfil&\hfil#\hfil&\strut\vrule\hfil#\hfil\cr   \ a &\ b &\ F \cr   \noalign{\hrule}   0&0&0\cr   0&1&0\cr   1&0&0\cr    1&1&1\cr}. There are \cr instead of \\. Yes, I still prefer TeX from LaTeX, I feel more in control.

An alternative approach in TeX: \valign{\hbox to 1em {\strut\hfil#\hfil}\hrule&\hbox to 1em {\strut\hfil#\hfil}&\hbox to 1em {\strut\hfil#\hfil}&\hbox to 1em {\strut\hfil#\hfil}&\hbox to 1em {\strut\hfil#\hfil}\cr   a&0&0&1&1\cr   b&0&1&0&1\cr   \noalign{\vrule}   F&0&0&0&1\cr}. Looks worse, but with vertical alignment it may be easier because the first part (until the \noalign bit) is purely dependent on n and the second part (the last column) is just the &-delimited list of values.

Related question: Generate all combinations of given list of elements, sorted

Charcoal, 70 bytes
≔tabularζ\ζ{*θc|c}⸿⪫✂β⁰Ｉθ¹&⁰&F\\⸿\hline⸿Ｅη⁺⪫⁺⮌ＥＩθＩ﹪÷κＸ²λ²⟦ι⟧&¦\\⁰\endζ

Try it online! Link is to verbose version of code. Explanation:
≔tabularζ

Save this string in a variable to avoid duplication.
\ζ{*θc|c}⸿

Print the initial \tabular{*2c|c} line (2 or whatever value the first input q has).
⪫✂β⁰Ｉθ¹&⁰&F\\⸿\hline⸿

Get the first q letters from the predefined variable b and insert &s between them, then append the &F\\ and also print \hline on the next line.
Ｅη⁺⪫⁺⮌ＥＩθＩ﹪÷κＸ²λ²⟦ι⟧&¦\\

Loop over the characters in the second input. For each one, its index is converted to binary with length q, the character is concatenated, the result is joined with &s and \\ is appended. The resulting strings are implicitly printed on separate lines.
⁰\endζ

Print the \endtabular. (The ⁰ is just a separator as the deverbosifier forgots to insert a ¦.)

It's kinda impressive that Charcoal is currently the winner, given that this challenge isn't really what it's designed for.

Python 2, 153 bytes
lambda n,l:r'\tabular{*%dc|c}%s&F\\\hline%s\endtabular'%(n,q(map(chr,range(97,97+n))),r'\\'.join(q(bin(2**n+i)[3:]+x)for i,x in enumerate(l)))
q='&'.join

Try it online!
Outputs like
\tabular{*2c|c}a&b&F\\\hline0&0&0\\0&1&0\\1&0&0\\1&1&1\endtabular

\tabular and \endtabular are used as shorter \begin{tabular} and \end{tabular}, as per this LaTeX golf tip. The *2c is a shorthand to define 2 columns.

Haskell, 164 155 bytes
s%f=((:"&")=<<s)++f:"\\\\"
n#r=unlines$("\\tabular{"++('c'<$[1..n])++"|c}"):take n['a'..]%'F':"\\hline":zipWith(%)(mapM id$"01"<$[1..n])r++["\\endtabular"]

Try it online!
unlines                               -- take a list of strings and join it with NL.
                                      -- the strings are:
   "\\tabular{"++('c'<$[1..n])++"|c}" -- tabular definition with n times 'c'
   take n['a'..]%'F'                  -- table header
   "\\hline"                          -- hline
   zipWith(%)(mapM id$"01"<$[1..n])r  -- table content
   ["\\endtabular"]                   -- end of tabular definition

Table header and content are built via function '%'

s%f=                                  -- take a string 's' and a char 'f'
    ((:"&")=<<s)                      -- append a "&" to each char in 's'
    ++f:"\\\\"                        -- and append 'f' and two backslashes

Table header:

take n['a'..] % 'F'                   -- s: the first n letters from the alphabet
                                      -- f: char 'F'
Table content:

zipWith(%)                            -- apply '%' pairwise to
    mapM id$"01"<$[1..n]              -- all combinations of '0' and '1' of length n
    r                                 -- and the string 'r'

Edit: using \tabular instead of \begin{tabular} (stolen from @xnor's answer).

Python 2, 192 168 166 bytes
lambda n,l:r'\begin{tabular}{*%dc|c}%s\end{tabular}'%(n,r'\\'.join(map('&'.join,[map(chr,range(97,97+n))+[r'F\\\hline']]+[bin(2**n+i)[3:]+l[n]for i in range(2**n)])))

Try it online!
Pretty printed version:
Python 2, 234 229 218 209 205 203 bytes
n,l=input()
print'\\begin{tabular}{'+'c'*n+'|c}\n'+' & '.join(chr(i+97)for i in range(n)+[-27]),'\\\\\n\hline'
i=0
for r in l:print' & '.join(bin(i)[2:].rjust(n,'0')+`r`),r'\\';i+=1
print'\\end{tabular}'

Try it online!

Proton, 142 bytes
n=>x=>"\\tabular*#{n}c|c#{j(map(chr,97..97+n))}&F\\\\\hline"+'\\\\'.join(j(bin(i)[2to].zfill(n)+x[i])for i:0..len(x))+"\\endtabular"j="&".join

Try it online!
Output is in golfed LaTeX form; thanks to xnor for that trick!
This should be able to be golfed to shorter than xnor's Python answer because Proton should in theory never lose to Python lol (in practice I'm bad xD). I may steal some tricks from xnor ;P
Managed to now be shorter by making some things into variables, which I just noticed xnor also did :P
And there we go, -6 bytes by using some Proton golfing tricks.

R, 196 187 171 bytes
function(m,n){cat("\\tabular{*",n,"c|c}")
write(c(letters[1:n],"F\\\\\\hline",rbind(t(rev(expand.grid(rep(list(0:1),n)))),paste0(m,"\\\\")),"\\endtabular"),1,n+1,sep="&")}

Try it online!
Output similar to the Charcoal answer. expand.grid from this answer.
For the record, using xtable from the eponym package is not much shorter since one has to specify a lot of options to match the spec, in addition to including the package:
R, 187 bytes
function(m,n){u=rbind(apply(expand.grid(rep(list(0:1),n)),1,rev),m)
rownames(u)=c(letters[1:n],"F")
print(xtable(t(u),dig=0,align=c(rep("c",n+1),"|c}")),hl=0,include.r=F)}
library(xtable)

Try it online!


text:
RLE Brainfuck dialect
RLE Brainfuck
(related to BF-RLE)
The hypothetical RLE (Run-Length Encoding) dialect of Brainfuck accepts the symbols for the 8 commands and also accepts digits. The digits are used to represent the number of successive repetitions of a command, thus allowing run-length encoding of the source code.
8> is equal to >>>>>>>>.
The length is always on the left side of the command.
Your task is to write the shortest program/function that translates the input string (RLE Brainfuck fragment) into a regular Brainfuck program.
For example:
Input:
10+[>+>3+>7+>10+4<-]3>2+.>+.7+2.3+.2<2+.>15+.>.3+.6-.8-.2<+.<.

Ouptut:
++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++.>+.+++++++..+++.<<++.>+++++++++++++++.>.+++.------.--------.<<+.<.

The shortest code in byte count in each language will win.

I'm confused. Is the goal to output the fixed string corresponding to translating the given string?

Is the program given as input, or should we hardcode it?

Your task is to write the shortest program/function that translates the following RLE Brainfuck fragment into regular Brainfuck program - Should our  submissions work for any valid Brainfuck code or just that piece of code? You should also include the desired output by the way.

Although this is a valid challenge, it received 2 VTC (at the time of writing this comment) as unclear (up to the site's standard). You can try the Sandbox next time.

Hi, I edited the description. The program should work for any valid RLE BF code and display the translated program.

Hi, I downvoted this question because I feel that it's going to be dominated by one or two RLE-based regex algorithms that are then just copied to each language's individual regex formatting. There's very little room to golf anything here.

This looks a lot like a generic run-length decoding challenge. The difference here is that multidigit numbers are supported. I think it's still a dupe, but I won't hammer it.

@user202729 Thanks, I'll use it next time.

@AdmBorkBork Hi, Thanks for the feedback. Now I understand that my idea was stupid.

Hi, I added clarification that the shortest code in each language wins.

@xnor The other difference is that digits are not always present — this form of RLE guarantees far less structure, and IMO can lead to interesting techniques (compare my Python answer here with the one in the linked challenge!)

@GalenIvanov Can the input contain things like 0<?

@Lynn I haven't explicitly described this, but as is seen in the example, 1 is ommited; adding 0 doesn't make the string shorter, so the answer is no, no zeroes can prepend a command.

The other direction would be more interesting, I think (i.e. transform a brainfuck programm in the shortest equivalent RLE brainfuck program).

I kinda sorta implemented this language awhile ago if anyone's interested.

@PaŭloEbermann It'd be really difficult to prove that it was the shortest equivalent.  You'd need to recognize that, e.g., >+++<[>++++<-] is equivalent to 12+, but only if the second cell is 0 always 0 when the code is executed, which requires some serious static analysis if it appears inside any looping/branching structures.  And since in the general case, pretty much any interesting static analysis is going to reduce to the halting problem, it may actually be impossible to prove optimality. Converting to an equivalent RLE-BF program would be possible, though.

@Ray I meant some "weaker" form of equivalence, basically the one implemented by this challenge (i.e. two RLE brainfuck programs are equivalent if they expand to the same brainfuck program). Finding the shortest (or one of the shortest, as ++ and +2 have the same length) from such a family should be easily decidable. The general equivalence in the computer science meaning is non-decidable, of course.

Python 2, 62 61 bytes
lambda s:eval(re.sub('(\d*)(.)',r'+1*\1*1*"\2"',s))
import re

Try it online!
The regex substitution expands 3<2+- into the string:
+1*3*1*"<"+1*2*1*"+"+1**1*"-"

which is then evaled. (Note how when \1 is empty, we get 1**1 = 1.) The first + is a unary operator which binds to the first number, and the other +s are string concatenation. This beats the more obvious
lambda s:re.sub('(\d+)(.)',lambda m:int(m.group(1))*m.group(2),s)
import re

by 14 bytes. Ordinarily "\2" wouldn’t always work, but thankfully \ and " aren’t brainfuck commands.

xnor saved a byte, supplying the 1*\1*1 trick. Previously I had \1L in the regex, and defined L=1 as a lambda argument, which is also pretty cool: 3L is a long int literal and L is a variable.

That's a slick use of L to handle the empty string. There's a shorter way though, r'+1*\1*1*"\2"'.

...Why is import re below the lambda?

Putting the lambda first means I can use tio.run's Header/Footer feature to show off how the code is supposed to be invoked (I put f=\  in the Header — now the lambda has a name!)

Pyth, 2 bytes
r9

Try it here!
How it works

r9  - Full program receiving the String from STDIN.

r   - Pyth's set of extended string operations.
 9  - The ninth command of that set (run-length decode). This supports multi-digit numbers.

Darn, Jelly RLD borks :( :P

Necessary reminder: Stop upvoting trivial solutions (like this one).

It's not so trivial to know about that command, and to know it works when numbers are missing

@Mr.Xcoder Wait, what? Isn't the entire point of code golf to have the lowest byte count?

@Deacon It is, but trivial answers shouldn't be upvoted too much in my opinion, since they (might) discourage new users that don't know of these golfing languages.

@Deacon yes, but a golfed Python answer is usually a lot harder to make and more interesting than a 2-byte golflang answer.

@Mr.Xcoder People can certainly upvote if they wish.

@Stephen Yeah, but this doesn't have a popularity-contest tag, it has a code-golf tag.

@Deacon Upvoting isn't just about upvoting short solutions. Users are generally encouraged to upvote solutions that are interesting and creative as opposed to trivial short solutions in golfing languages.

Lua, 65 64 63 Bytes
Great ! For once, Lua beats Python !
Edit: Saved one byte thanks to @Jarhmander, thanks to him for the useful trick to force a single result
print(((...):gsub("(%d+)(.)",function(a,b)return b:rep(a)end)))

Try it online!
Explanations
print)((...):gsub(             -- iterate over the argument and replace the strings
            "(%d+)(.)",       -- matching this pattern (at least one digit and a non-digit)
            function(a,b)     -- capture the digit and non-digit parts in separate variables
              return b:rep(a) -- repeat the non-digit a times, a being the digit part
            end)))

Beat you! :)

@Lynn One byte down, 3 more to go!

You can save a byte by removing ,"" and enclosing in parens the entire print argument. Expressions enclosed in parens are adjusted to one value in Lua (see https://www.lua.org/manual/5.3/manual.html#3.4).

Scala, 73 69 bytes
"(\\d+)(.)".r.replaceSomeIn(_:String,m=>Some("$2"*m.group(1).toInt))

Try it online!

This is a nice answer! Welcome to the site. :)

Perl 5, 18 bytes
17 bytes code + 1 for -p.
s/\d+(.)/$1x$&/ge

Try it online!

RLE Brainfuck, 204 bytes
-3>,[[->+>+<<]>>47-3<10+<->[-<+4>->+<[>-]>[3<+<[-]4>->]5<]3>57+[-]+<<[>>-<<[3>+3<-]]3>[3<+3>-]<[>>+7<+[->11-<+[-<+]->>+[-<[->10+<]>>+]<[-4>.4<]4>[-]-3<-<+7>-7<[8>+8<-]]8>[8<+8>-]<[3<.3<[-]-6>-]7<--5>-]<,]

As I understand it the specs for the brainfuck environment aren't super well-defined. This program assumes that the cells in the tape allow arbitrarily large positive and negative integers, with no overflow. This code will transcribe non-command comments as well, but it will expand the run-length encoding of comments (eg "see 3b" → "see bbb"). The resulting program should run the same, so I'm not too concerned.
I'm pretty sure I could still golf a few bytes off this but I'm exhausted from working with it.
Here's the custom interpreter + tests I've been using to test it. If you pass it input in the Standard Input box it should run against that input instead of running the tests.
My messy ungolfed workpad:
->>>,
[
  [->+>+<<]>>  clone 2 into 3 and 4
  if read char is between zero and nine
  (num buffer | max | is_digit | original char | read | temp0 | temp1)
                                                   ^
  47-
  <<<10+  set max
  <->  handle gross 0 case
  [  while max
    -  max minus one
    <+  buffer plus one
    >>>>-  read minus one
    IF STATEMENT : if read is 0
    >+<
    [>-]>[<
      <<+  is_digit = 1
      <[-]>>>  max = 0
    >->]<<  back to read
    <<<     back to max
  ]

  >>>57+[-]  reset `read` (need to add first to avoid infinite negative)

  +<<  check is_digit flag
  ( end marker | 0 | is_digit | original char | temp0 | temp1 | temp2 | temp3)
  x[  IF READ WAS DIGIT
    CODE 1a
    >>temp0 -<<x
    [>>>temp1 +<<<x-]
  ]
  >>>temp1 [<<<x+>>>temp1 -]
  <temp0 [
    START CODE 2a
    >>temp2 +
    7<y+[  IF THERE IS A NUMBER PREFIX
      -
      START CODE 1b
      >11-  end marker is negativeone
      <   on smallest digit
      +[-<+]->  find largest digit
      >+[  sum digits until we hit the end marker negativeone
        -
        <[->10+<]>  h1 = ten * h0; h0 = 0
        >
        +
      ]  leave the negativeone at zero though
      num | 0 | 0 | 0 | original char
            ^
      <num
      [->>>>.<<<<]  print `original char` `num` times
      >>>>[-]-  set `char` to negativeone
      <<<- last ditch guess
      END CODE 1b
      <y+
      7>temp2 -
      7<y[8>temp3 +8<y-]
    ]
    8>temp3 [8<y+8>temp3 -]
    <temp2 [
      CODE 2b
      <<<.  print original char
      <<<[-]-  set num buffer to new left edge
      >>>>>>temp2 -
    ]
    7<y--

    END CODE 2a
    5>temp0 -
  ]
  <
  ,
]

Does the gross 0 case only refer to actual zero counts, or does it also happen when parsing, e.g. 10+?  The OP clarified in a comment that count will always be greater than 0, so you might be able to shave some bytes off if it's the former.

Gross 0 case is for parsing any 0. Since the while max loop always runs at least once, and I'm unconditionally upping the buffer where I store the digit's value in that loop, I need to start that buffer at -1. I wonder if I could save some bytes by leaving that buffer logically at value+1 though

vim, 29 25 23 22 16 bytes
:s/\D/a&<C-v><ESC>/g
D@"

<C-V> is 0x16, <ESC> is 0x1b.
It works by replacing each non-digit with a command that appends that character to the buffer.  The counts are left alone and modify those commands.  At this point, the buffer is a vimscript program that produces the desired Brainfuck program, so we pull it into a register and run it.
Try it online!
Edit: Size reductions thanks to suggestions: H.PWiz: 5, TheFamilyFroot: 5, DJMcMayhem: 1

TheFamilyFroot had a nice golfing tip: you don't need to use a capturing group, you can just use group 0 (& or \0) instead with no parentheses. Also, a tip from me, not TheFamilyFroot is that you could use D instead of dd for -1 byte.

Thanks for all the suggestions, H.PWiz, TheFamilyFroot, and DJMcMayhem.  That brought it below the 18 byte Perl solution and into second place.  Now we just need to find another 15 bytes we can get rid of and it'll beat the Pyth builtin. :-)

Stacked, 24 bytes
['(\d+)(.)'[\#~*]3/repl]

Try it online!
Explanation
['(\d+)(.)'[\#~*]3/repl]
[                      ]   anonymous function, taking string as argument
 '(\d+)(.)'                for all matches of this regex:
           [    ]3/repl      replace (stack = (whole match, digit, repetend))
            \#~              convert digit to number
               *             repeat the character by that digit

Retina, 28 23 bytes
thanks to @Leo for -5 bytes
\d+
$*
+`1(1\D)
$1$1
1

Try it online!

Can you use \b in the second regex to only match one 1 per run of 1s?

Or you could do something like this

TeX, 124 bytes
\newcount\n\def\b{\afterassignment\r\n0}\def\r#1{\ifx;#1\else\p#1\expandafter\b\fi
}\def\p#1{#1\ifnum\n>1\advance\n-1\p#1\fi}

(wrote in two lines to be visible, but the code can be written in one line)
This defines a macro \b that takes the input in the form \b<input>;, and prints the output wanted to the document.

Pyon, 66 bytes
print(re.sub("\d+.",lambda k:(int(k.group()[:-1])*k.group()[-1]),a

Try it online!
Pyon is pretty much just Python, but this is shorter because re is automatically imported when you use it, and a is automatically set to an argument or the input
-4 bytes thanks to Mr. Xcoder

You should change g[0] to g[:-1] (fails for the given test case or any number higher than 9).

Anyway why would you even need a lambda which actually wastes bytes? Golfed and corrected for 66 bytes

@Mr.Xcoder whoops, not sure what I was thinking... thanks

@Mr.Xcoder oh yeah I try to golf things a lot that end up being ungolfs xD

Python 2, 100 93 89 bytes
-7 with thanks to Mr.Xcoder
n=b=""
for y in input():
 if"/"<y<":":n+=y
 elif""==n:b+=y
 else:b+=y*int(n);n=""
print b

Try it online!

A few golfs for 93 bytes. It can be golfed further though.

Haskell, 60 bytes
f(a:b)|[(c,d:e)]<-reads$a:b=(<$)d[1..c]++f e|1<2=a:f b
f a=a

Try it online!

R, 121 106 90 bytes
function(s,a=strsplit)cat(rep(el(a(gsub("\\d","",s),"")),pmax(el(a(s,"\\D")),"1")),sep="")

Try it online!
Saved 15 bytes by realising that rep() will coerce to numeric.
Saved another 16 thanks to Giuseppe, mainly from the use of pmax to replace empty strings with 1
function(s) {
  x <- el(strsplit(s,"\\D")) # Split the string on anything that is not a digit...
  x <- pmax(x, "1")          # ... and replace any empty strings with 1. This gets us the numbers of repeats
  y <- gsub("\\d","",s)      # Remove all digits from the original string...
  y <- el(strsplit(y))       # ... and split into individual units. This gets us the symbols to repeat
  z <- rep(y, x)             # Implement the repeats. x is coerced to numeric
  cat(z, sep = "")           # Print without separators
}

very nice! I believe ifelse(x>"",x,1) is a byte shorter, and \\D is equivalent to [^\\d] and best of all, you don't need perl=T, so this is a sweet 99 bytes. I really didn't think this could be fewer than 100 bytes!

90 bytes with pmax

@Giuseppe Very clever use of pmax giving a nice big improvement - thanks!

replace "1" with 1 as pmax will coerce to character for the comparison.

85 bytes by changing the aliases

PowerShell, 66 62 bytes
-join("$args"-split'\b'|%{(,$(,$_[0]*$n+$_))[!!($n=$($_-1))]})

Try it online!
Breakdown
What a mess!
Starting from $args, which is a single element array containing the RLE string, I'm forcing into an actual string by wrapping it quotes.
Then split it by word boundary (\b in regex). That will give me an array of strings, where each element is either a number or the BF token(s) that come after the number. So in the example, the first 4 elements of this split array are 10,+]>+>,3,+> (all are string).
Next, I pipe that into ForEach-Object (%) to deal with each element.
The middle is a well-known PowerShell golfism, with a twist; it's essentially a DIY ternary operator, in which you create a 2 element array then index into it using the boolean expression you want to test, whereby a false result gives you element 0 and a true result gives you element 1.
In this case, I actually create a single element array with the unary comma , operator, because I don't want output in the true case.
First let's look at the indexer, even though it gets executed later.
The idea of this is that $_ (the current element) could either be a valid number, or some other string. If it's a number, I want $n to be the value of that number minus 1 (as a number, not a string). If it's not, I want $n to be false-y.
PowerShell usually tries to coerce the right-hand value to the type of the left side, but it can depend on the operation. For addition, "10"+5 would give you a new string, "105", whereas 10+"5" will give you an integer (15).
But strings can't be subtracted so instead PowerShell can infer the numeric value automatically with a string on the left side of subtraction, therefore "10"-5 gives 5.
SO, I start with $_-1, which will give me the number I want when $_ is actually a number, but when it's not I get nothing. On the surface, "nothing" is falsey, but the problem is that is stops execution of that assignment, so $n will retain its previous value; not what I want!
If I wrap it in a subexpression, then when it fails, I get my falsey value: $($_-1).
That all gets assigned to $n and since that assignment is itself wrapped in parentheses, the value that was assigned to $n also gets passed through to the pipeline.
Since I'm using it in the indexer, and I want 1 if the conversion succeeded, I use two boolean-not expressions !! to convert this value to boolean. A successful number conversion ends up as true, while the falsey nothingness gives us that sweet, sweet 0 that allows for returning the only element in that fake ternary array.
Getting back to that array, the element is this: $("$($_[0])"*$n*$_) $(,$_[0]*$n+$_)
"$($_[0])" - this is an annoyingly long way of getting the first character of the current element (let's say, getting + from +[>+), but as a string and not as a [char] object. I need it to be a string because I can multiply a string by a number to duplicate it, but I can't do that with a character.
Actually I managed to save 4 characters by using a [char] array instead of a string (by using another unary comma ,), so I was able to remove the quotes and extra sub-expression. I can multiply an array to duplicate its elements. And since the entire result of this iteration ends up being an array anyway and needs to be -joined, using an array here incurs no additional cost.
Then, I multiply that string array by $n, to duplicate it $n times. Recall that $n could be $null or it could be the value of the preceding digits minus one.
Then +$_ adds the current element onto the end of the duplicated first character of that element. That's why $n is minus one.
This way, 10+[>+ ends up with $n equal to 9, then we make 9 +'s and add that back to the +[>+ string to get the requisite 10, plus the other single elements along for the ride.
The element is wrapped in a subexpression $() because when $n is $null, the entire expression fails, so creating the array fails, so the indexer never runs, so $n never gets assigned.
The reason I used this ternary trick is because of one of its peculiarities: unlike a real ternary operator, the expressions that define the elements do get evaluated whether or not they are "selected", and first for that matter.
Since I need to assign and then use $n on separate iterations, this is helpful. The ternary array element value gets evaluated with the previous iteration's $n value, then the indexer re-assigns $n for the current iteration.
So the ForEach-Object loops ends up outputting everything its supposed to (a bunch of errors we ignore), but as an array of new strings.
So that whole thing is wrapped in parentheses and then preceded by unary -join to give the output string.

Great explanation, that alone warrants an upvote already.

Thanks @Mast, and because of your comment I looked over my answer again and realized how I could save 4 bytes.

QuadR, 17 bytes
\d+.
¯1((⍎↓)⍴↑)⍵M

Try it online!
Thanks to Adám for providing the correct version of the code.
How it works:
\d+.          ⍝ Regex to match any sequence of digits followed by a character.
¯1((⍎↓)⍴↑)⍵M  ⍝ Transformation line
¯1(      )⍵M  ⍝ Arguments: -1 and the matching expression
   ( ↓)       ⍝ 'Drop' the last item (-1) from the match (⍵M), yielding a string which is a sequence of digits.
    ⍎         ⍝ Execute. In this case, it transforms a string into a number.
        ↑     ⍝ 'Take' the last item (-1) from the match (⍵M), yielding a character.
       ⍴      ⍝ Reshape it. That will take the character resulting from the 'Take' operation and repeat it n times,
              ⍝ where n is the result from the 'Drop' and 'Execute' operations.

Equivalent to the APL function '\d+.'⎕R{¯1((⍎↓)⍴↑)⍵.Match}

Proton, 50 bytes
x=>/\d+./.sub(k=>int((e=k.group())[to-1])*e[-1],x)

Try it online!

Ruby, 35 bytes
->s{s.gsub(/(\d+)(.)/){$2*$1.to_i}}

Try it online!

Java 8, 148 bytes
s->{for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);!s.matches("\\D+");s=s.replaceAll("0(\\D)","$1$1"));return s.replaceAll("((.)+)\\2","$1");}

Gdamn Java regexes are so useless sometimes.. Last time it was lack of using the capture group "$1" for anything, now this.. I want to replace 3c with ccc or 000c with ccc as a one-liner, but unfortunately Java has no way of doing this without a loop. Ah well.
Explanation:
Try it here.
s->{                          // Method with String as both parameter and return-type
  for(s=s.format(s.replaceAll("(\\d+)","%1\\$0$1d"),0);
                              //  Replace every numbers of that many zeroes
                              //  (i.e. "3>2+" -> "000>00+")
      !s.matches("\\D+");     //  Loop as long as the String contains zeroes
    s=s.replaceAll("0(\\D)",  //   Replace every 0 followed by a non-0 character,
                   "$1$1")    //   with two times this captured non-0 character
  );                          //  End of loop
  return s.replaceAll("((.)+)\\2","$1");
                              //  Reduce every repeated character amount by 1,
                              //  and return this as result
}                             // End of method

Hi Kevin, good to see you here, dealing with puzzles other than twisty :)

@GalenIvanov Oh, hi! I had no idea you were active on PPCG as well.

I wasn't until recently :) I'm learning J and decided that this is a good opportunity to test my skills.

R, 151 bytes
Outgolfed by user2390246! This is now basically a garbage approach compared to that one, but I'll continue to improve it.
function(s,G=substr)for(i in el(strsplit(gsub("(\\d+.)","!\\1!",s),"!")))cat("if"(is.na(g<-as.double(G(i,1,(n=nchar(i))-1))),i,rep(G(i,n,n),g)),sep='')

Try it online!
Also outputs a bunch of warnings.
function(s){
s <- gsub("(\\d+.)","!\\1!",s)               # surround groups with !
X <- el(strsplit(s,"!"))                   # split to groups
for( i in X ){                             # iterate over groups
 n <- nchar(i)                             # length of group
 r <- substr(i,1,n-1)                      # potential number (first n-1 chars)
 d <- substr(i,n,n)                        # last character
 if( is.na(as.double(r)) ){                # if it's not a number
   cat(i)                                  # print out the whole string
  } else {
   cat(rep(d,as.double(r)),sep="")         # repeat d r times, and print with no separator
  }
 }
}
Next up, seeing if using a grep is more efficient than substr

A different approach

Haskell, 84 bytes
f s@(x:r)|(n:m,x:r)<-span(`elem`['0'..'9'])s=(x<$[1..read$n:m])++f r|1<3=x:f r
f e=e

Try it online!
Explanation:
span(`elem`['0'..'9'])s splits the given string s into a prefix of digits and the remainder. Matching on the result on the pattern (n:m,x:r) ensures that the digit prefix is non-empty and binds the character after the digits to x and the remainder to r. x<$[1..read$n:m] reads the string of digits n:m as number and repeats x that many times. The result is concatenated to the recursive treatment of the remaining string r.

JavaScript (ES6), 46 bytes
a=>a.replace(/(\d+)(.)/g,(_,n,b)=>b.repeat(n))

Pretty straightforward explanation:
a=>a.replace(/(\d+)(.)/g,                      // Match globally the following: a number N followed by a character
                         (_,n,b)=>b.repeat(n)) // Replace each occurrence by the matched character repeated N times

C++, 239 235 bytes
-4 bytes thanks to Zacharý
#include<regex>
using s=std::string;std::regex m("[0-9]*[<>+.,\\[\\]-]");s t(s r){s d,h;std::sregex_iterator i(r.begin(),r.end(),m),e;while(i!=e){h=(*i)[0];int g=std::strtol(h.data(),NULL,10);g+=!g;d+=s(g,h[h.size()-1]);++i;}return d;}

Can you change g=(g?g:1) to g+=!g? If that doesn't work, can't you remove the parentheses around g?g:1

208 bytes

Untyped Lambda Calculus, 452 bytes
(λp.λq.(λb.λg.(λi.(λp.λq.λb.p q b)(q(λq.λj.λl.j((λq.λj.qλq.λl.(λu.g i j(λp.u)(g j(λq.λg.q(b(p(λp.λq.p q))(p(λp.λq.p(p q)))q g))(λp.u)(λu.u qλq.λu.g j i q(b l(p(λp.λq.p(p(p(p q)))))q u))))λp.p(λp.λb.q p((λp.λq.l(λp.l)(λp.λq.p q)(λq.p j q)q)p b))λp.λp.p)l q))(λp.p)(λp.p(λp.λp.p)λp.λp.p)(λp.λq.p)))(b(p(λp.λp.p))(p(λp.λq.p(p q)))))(λp.λq.λb.p(q b))λp.λq.q(λp.λq.λb.p(λp.λb.b(p q))(λp.b)λp.p)p)λp.λq.λb.q(q(q(q(q(q(p q b))))))

Input and output comprise of right-fold lists of church encoded character codes, for example the character code of a newline is 10 so the church encoding would be λf.λx.f(f(f(f(f(f(f(f(f(f x))))))))). Converting "ABCD" to a list looks like λf.λx.f 65 (f 66 (f 67 (f 68 x))) but with the numbers church-encoded.
Applying an encoded string to the program and reducing it all the way should give you an encoded output string with the RLE applied.

Hello and welcome to the site! This looks like an interesting solution but we do expect languages to have a valid interpreter, do you have one of Untyped Lambda Calculus?

Also, what does the qλq notation mean? I've never seen that before.

Funky, 42 bytes
s=>s::gsub("(\\d+)(.)",(_,a,b)=>b::rep(a))

Try it online!

Stax, 24 bytes
▒tP☻↕╘`¼½ª√ΘBöQm>\%▒IïR}

Run and debug it
Regex replace and execute.

///, 114 bytes
/a/*l//b/l*//l/\/\///1/0a2/1a3/2a4/3a5/4a6/5a7/6a8/7a9/8a*0/9a0*/|l0l/|l/*>/>>b</<<b+/++b-/--b[/[[b]/]]b,/,,b./../

Try it online!
This is fairly trivial program as far as actual algorithm, it just happens that repeating characters is a strong suit of ///.
If you change the specification of the RLE, then its 106 bytes.
///, 106 bytes
/b/l*//a/*l//l/\/\///1/0a2/1a3/2a4/3a5/4a6/5a7/6a8/7a9/8a*0/9a0l/*>/>>b</<<b+/++b-/--b[/[[b]/]]b,/,,b./../

Try it online!
A 0 will never occur, and a 1 just adds a byte. 2 is the first number where anything is actually compressed, so it makes much more sense to start at that number. In other words, subtract 1 from each number. This is was the original program, just without the code to subtract one. It takes up so much space because there is an indeterminate amount of zeros at the beginning of each number, depending on the number of digits. If I just used /0*// to delete a zero and subtract one, it would delete one for each 0 instead. So it has to add another symbol like this /0*/|/, then remove that symbol /|//, then remove the 0s /0//.
Commented version

Dart, 78 bytes (with regex), 102 bytes (without regex)
With Regex:
(i)=>i.splitMapJoin(new RegExp(r"(\d+)(.)"),onMatch:(m)=>m[2]*int.parse(m[1]))

Without Regex:
(i,[n=0,d=0])=>i.codeUnits.map((c)=>i[d++]*((c-=48)>=0&&c<10?0*(n=n*10+c):n<1?1:(n=0*(c=n))+c)).join()

Both must be invoked like (<code here>)("input string").
Regex one is quite standard, but the regex-less one is quite special.
Regex-less abuses optional parameters to allocate local variables in "single return" function, otherwise you'd need to make a block and have the return keyword. For each code unit, if the code unit is between 0 and 9 it is accumulated to n and an empty string is returned. Otherwise, the the character is multiplied by the value of n (special cased if n == 0, in that case it will always emit 1 character) and n is set to 0. (n=0*(c=n))+c sets the char code argument to the value of n, multiplies n/c with 0, stores 0 to n, then adds c. This resets our n without being in a statement context.

Python3, 96 bytes
s,r=input(),""
while s:
 d=0
 while"/"<s[d]<":":d+=1
 r+=int(s[:d] or 1)*s[d];s=s[d+1:]
print(r)

I tried another implementation in Python, but i don't beat https://codegolf.stackexchange.com/a/146923/56846 :(