text:
There, I broke it (with scissors)
Challenge
Given a string describing a cutting rule and another string, cut parts out of the second string using the rule described by the first string.
Both strings will consist of letters a-z or A-Z, whichever one you choose (they don't have to be represented the same way). The way the second string is to be modified is described below:
Algorithm
Take the first string and imagine filling in the gaps between non-adjacent (increasing) letters with =; for example, abcfg => abc==fg. Then, line up the two strings and return all characters from the first string that aren't above an equal sign. For example, given abcfg and qrstuvw as inputs:
qrstuvw - Modify
abc==fg - Modifier

qrs--vw -> qrsvw

If the modifier is shorter after filling with equal signs, all trailing characters in the second string should be included. If the modifier is longer, the trailing characters are ignored.
The modifier isn't guaranteed to be sorted.
Test Cases
abcfg, qrstuvw -> qrsvw
abqrs, qwertyuiopasdfghjklzxcvbnm -> qwjklzxcvbnm
za, qr -> qr
azazaz, qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq -> qmn

Reference Implementation (used to generate test cases) -> TIO
Rules

Standard Loopholes Apply
You may take input as two strings, two lists of characters, a matrix of characters, etc. (any other reasonable format is acceptable)
You may output as a string or a list of characters (or some other standard format for strings)
This is code-golf, so the shortest answer in bytes in each language is declared the winner for its language. No answer will be accepted.
Either string may be empty.

Happy Golfing!
Inspired by Kevin Cruijssen's recent two challenges, "There, I fixed it (with tape/rope)"

There, I fixed it (with tape), There, I fixed it (with rope)

very common trend im seeing here

@L_Church challenges sometimes follow trends. two related challenges were posted so I decided to continue along the trend :D I was going to post another "I fixed it" challenge but a) I like breaking things better 2) I can't think of another creative and distinct enough "fixed it" idea :P

Next challenge: There, I blew it up (with a segfault)

@MagicOctopusUrn Someone beat you to it :(

cut the part where is taped in the "fix with tape"?

Lower case, English alphabet letters only in the modifier?

@fishinear Both strings will consist of letters a-z or A-Z, whichever one you choose

@HyperNeutrino Ah, sorry, did not see that.

JavaScript (ES6), 81 80 bytes
Takes input in currying syntax (modify)(modifier).
s=>g=([c,...a],d=i=0,x=s[k=parseInt(c,36),i+=c?d&&(k-d+26)%26:1])=>x?x+g(a,k):''

Try it online!
Commented
s =>                       // outer function, taking the string s to modify
  g = (                    // recursive inner function g(), taking:
    [c, ...a],             //   c = current modifier character; a[] = remaining characters
    d = i = 0,             //   d = code of previous modifier character; i = pointer in s
    x = s[                 //   x = i-th character of s
      k = parseInt(c, 36), //     k = code of the current modifier character in [10..35]
      i += c ?             //     update i; if c is defined:
        d &&               //       if d = 0, let i unchanged
        (k - d + 26) % 26  //       otherwise, add the difference between k and d (mod 26)
      :                    //     else:
        1                  //       just pick the next character by adding 1
    ]                      //   end of character lookup in s
  ) =>                     //
    x ?                    // if x is defined:
      x + g(a, k)          //   append x and do a recursive call to g()
    :                      // else:
      ''                   //   stop recursion

Python 3, 99 bytes
lambda a,b:[x for x,y in zip(a,''.join(d+(ord(c)+~ord(d))%26*'='for c,d in zip(b[1:],b))+a)if'='<y]

Try it online!

05AB1E, 20 17 bytes
ćsv¹Ç¥Nè<yú«}SðÊÏ

Try it online!

Calculates the ASCII distance between each char, prepending that many spaces if it's positive. Negative distance results in appending 0 spaces, as per the spec. After that, I push all characters at the same indices in string 2 as the spaces in the first manipulated string.

Input: [azaz,qwertyuiopasdfghjklzxcvbnm]
--------------------------------------------------------------------------------

ćs                # Remove head, swap                           | [a, zaz]
  v               # Iterate...                                  | ............
   ¹Ç¥            # Push deltas between each char of string 1   | [a,[25,-25,25,-25]]
      Nè          # Push delta at index...                      | [a, 25]
        <         # Decrement (for 1-indexed answer)            | [a, 24]
         y        # Push current char in iteration...           | [a, 24, z]
          ú       # Append b spaces to a...                     | [a, '(spaces)z']
           «      # Concat                                      | [a(spaces)z]
            }     # End loop.                                   | [a(spaces)za(spaces)z]
             SðÊ  # Split, push 1 for non-space elements.       | [Long array of 1/0]
                Ï # Push chars from 2 that aren't spaces in 1.  | ['qmn']

90% sure I can lose another 2-3 bytes by not using spaces, but pushing the char at index N. Still working on this variant at the moment... What my "better idea" ended up as:
05AB1E, 18 bytes
Ç¥ε1‚Z}ηO0¸ìʒ²g‹}è

Try it online!
I feel like I'm missing something, if you see improvements on ε1‚Z}, ʒ²g‹} or 0¸ì lmk...
Ç¥ε1‚Z}ηO0¸ìè was 13, but it wraps when n > |input_2| to input_2[n%|input_2|]...

Your second version could be Ç¥ε1M}.¥ʒ²g‹}è, but none of the three versions seem to work for these inputs.

The version above could be fixed by adding IgÅ1«, but maybe there's a better way?

APL (Dyalog Classic), 35 34 32 bytes
{⍵∩⍨⊃¨↓∘⍵¨+\0,1⌈(-2-/⎕ucs⍺),=⍨⍵}

Try it online!

K (ngn/k), 27 24 25 bytes
{y[+\0,1|1_-':x,!#y]^" "}

Try it online!
{y[+\0,1|1_-':x,!#y]^" "}

{                       } function with x and y as arguments
                 #y       the length of y
                !#y       0 1 2 ... (#y)-1
              x,          x concatenated with
           -':            differences between pairs
         1_               rm extra leading item
       1|                 max between 1 and
     0,                   prepend 0
   +\                     partial sums
 y[                ]      index y with that
                    ^" "  rm spaces due to out-of-bounds indexing

Stax, 15 bytes
Ç«|¢Äα•è@╟╣i`vF

Run and debug it
This is the ascii representation.
:-Z+{v0|Mt|cB]pFp

Get pairwise differences.
Prepend a zero.
Foreach difference, repeat

Subtract 1, and take maximum with zero.
Remove that many characters from the beginning of string.
Stop if the string is empty.

Print the rest of the string.

I like how the code says ╟╣i

Jelly, 14 bytes
OI’R¬⁸żFḣL}aḟ0

A dyadic link accepting the modifier as a list of characters on the left and the list of characters to modify on the right returning a lists of characters.
Try it online!
How?
OI’R¬⁸żFḣL}aḟ0 - Link list of characters Modifier, list of characters InStr
               -                       e.g.  ['a','c','g','a'], ['n','m','l','k','j']
O              - ordinals of Modifier        [97,99,103,97]
 I             - incremental differences     [2,4,-6]
  ’            - decrement                   [1,3,-7]
   R           - range                       [[1],[1,2,3],[]]
    ¬          - NOT (vectorises)            [[0],[0,0,0],[]]
     ⁸         - chain's left argument, Modifier
      ż        - zip together                [['a',[0]],['c',[0,0,0]],['g',[]],['a']]
       F       - flatten                     ['a',0,'c',0,0,0,'g','a']
         L}    - length of right (InStr)     5
        ḣ      - head to index               ['a',0,'c',0,0] (if shorter or equal, no effect)
           a   - AND with InStr (vectorises) ['n',0,'l',0,0]
            ḟ0 - filter out zeros            ['n','l']

Used the ¬ trick in my answer. :) (we technically have the same algorithm, but you did shorter, well done!)

Oh yeah, I was gonna comment about ¬, but forgot when I did a mobile phone fat-finger post of a not-yet-ready 13 byte attempt.

JavaScript (ES6), 79 bytes
f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

Uses the same algorithm for calculating distance between letters as my last answer.
Test cases:

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

console.log(f('abcfg','qrstuvw')) // -> qrsvw
console.log(f('abqrs','qwertyuiopasdfghjklzxcvbnm')) // -> qwjklzxcvbnm
console.log(f('za','qr')) // -> qr
console.log(f('azazaz','qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq')) // -> qmn

Haskell, 49 bytes
(x:r)#(y:n:s)=x:drop(length[y..n]-2)r#(n:s)
r#_=r

Try it online!

Perl 5, 45 bytes
s/./v0.$;x(ord($')-1-ord$&)/eg;$_|=<>;s/\W//g

Try it online!

Charcoal, 29 28 bytes
⭆η×ιＩ§⁺⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1⭆η1κ

Try it online! Link is to verbose version of code. Based on my answer to There, I fixed it with tape. Explanation:
       ⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1        Fix it with tape, but map to 1s and 0s
      ⁺                 ⭆η1     Append extra 1s just in case
⭆η                              Map over the second string
     §                     κ    Get the character from the fixed string
    Ｉ                           Cast to integer
  ×ι                            Repeat the current character that many times
                                Implicitly print

Note: This should be 28 bytes, but And is broken at time of writing.

Ruby, 68 64 bytes
->m,z,i=1{z[i,[0,m[i].ord+~m[i-1].ord].max]&&='';m[i+=1]?redo:z}

Try it online!

Java 8, 117 bytes
a->b->{for(int i=0,j;++i<a.length;b=j>0&b.length()>=i+j?b.substring(0,i)+b.substring(i+j):b)j=a[i]+~a[i-1];return b;}

Explanation:
Try it online.
a->b->{                   // Method with char-array + String parameters and String return
  for(int i=0,j;++i<a.length;
                          //  Loop `i` in range [1; length_of_array)
      b=                  //    After every iteration: change the String-input to:
        j>0               //     If `j` is larger than 0,
        &b.length()>=i+j? //     and the length of `b` is larger or equal to `i+j`:
         b.substring(0,i) //      Take the substring [0; i)
         +b.substring(i+j)//      + the substring [i+j; end_of_string]
        :                 //     Else:
         b)               //      Leave `b` the same
    j=a[i]+~a[i-1];       //   Set `j` to the difference between two adjacent chars - 1
  return b;}              //  Return the modified input-String


text:
Sum of squares on GPU
Write a program or function that:

Takes as input a list or array of 128 numbers.
Sends that array to a GPU
Performs a calculation on the GPU to square each element of the array and then sum them
Gets the answer from the GPU, and returns or displays it

So your program will simply return the sum of the squares of its input array, but it will perform the calculation on a GPU.
The input numbers should be sent to the GPU in the form of signed or unsigned integer types or floats, of 32 or more bits in size.
You may make any assumptions you like about hardware, e.g. you may assume a CUDA or OpenCl capable card is present without checking for it.
This is code-golf. The smallest code (in bytes) will be considered the winner for each language.

Sandbox (deleted)

that would be +/×⍨ in apl with https://github.com/Co-dfns/Co-dfns :)

@ngn I'm curious why you didn't post that as an answer - is there a reason?

it would take me a long time to apply for a dyalog licence, install a recent version of dyalog, then download and compile co-dfns, and make sure it works on my 10-year-old laptop

...and there's always danger that the co-dfns compiler might decide that using the gpu is not worth it for arrays of size <1000000 :) - I haven't been following the trends there for a while

@ngn Your 10-year-old laptop has a discreet GPU?

@Adám it looks like it's integrated, lspci shows: 00:02.0 VGA compatible controller: Intel Corporation Mobile 945GSE Express Integrated Graphics Controller (rev 03)

The sum of the squares of 128 32-bit integers may very well overflow the 32-bit integer type. May we assume it won't?

@Adám yes, you may assume that.

APL (Dyalog Unicode) with Co-dfns, 7 bytesSBCS
Anonymous prefix lambda. I have verified with the author of Co-dfns that the code will indeed run according to the required spec.
{+.×⍨⍵}

Try it online! (equivalent code, but TIO doesn't provide GPU access)
{…} compilable dfn; ⍵ is the argument vector
 +.× dot-product of
 ⍨ itself ("selfie")
 ⍵ using the argument as data

Processing.org 392 bytes
392 counting the shader and function
It's possible to reduce the number of characters by putting the shader program in a separate file.
String[] f={"uniform float x[128];void main(){float s;for(int i=0;i<128;i++)s+=x[i]*x[i];int b=floatBitsToInt(s);gl_FragColor=vec4(b>>16&255,b>>8&255,b&255,b>>24&255)/255.;}"},v={"uniform mat4 transform;in vec4 vertex;void main(){gl_Position=transform*vertex;}"};PShader p;void s(float[]i){p=new PShader(this,v,f);p.set("x",i,1);filter(p);loadPixels();print(Float.intBitsToFloat(pixels[0]));}
void setup(){
size(1,1,P2D);
float[] input = new float[128];
for(int i=0;i<128;i++)input[i]=(float)i;
s(input); // prints 690880.0
}

source: Stack Exchange

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

sort: votes


text:
Create an "H" from smaller "H"s
Challenge
Create a function or program that, when given an integer size, does the following:
If size is equal to 1, output
H H
HHH
H H

If size is greater than 1, output
X X
XXX
X X

where X is the output of the program/function for size - 1
(If you prefer, you may have the base case correspond to 0, so long as you specify in your answer)
Any of the following output formats are acceptable, whichever is more convenient for you:

A string of the required structure with any two distinct characters corresponding to H and space

A two-dimensional array with the required structure, with any two distinct values corresponding to H and space

An array/list of strings, with one line of the output in each string, with any two distinct values corresponding to H and space

Leading spaces are allowed, as long as there is a constant amount of leading spaces on each line. The two distinct output characters can be dependent on anything you choose, as long as they are different.
Specify what output format your code is returning.
Test Cases
1
H H
HHH
H H

2
H H   H H
HHH   HHH
H H   H H
H HH HH H
HHHHHHHHH
H HH HH H
H H   H H
HHH   HHH
H H   H H

3
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

This is code-golf, so the lowest byte count for each language wins!

Perfect for Charcoal probably... lol. Also welcome to PPCG! :D

Welcome to PPCG. Nice first challenge!

May we use 0 based sizes?

@Adám that is acceptable

Forgot to check your acceptable outputs before I submitted, but would an array of strings be acceptable instead of a two-dimensional array? This is for languages where a string is not formally an array of characters, but its own data structure.

@ValueInk That's fine

related

Can I print the desired output instead of returning it? Can I give a program that instead of a function?

Are leading spaces (or whatever the chosen background character is) allowed ?

Possible duplicate of ABAA/ABBB: Generate this recursive 2D pattern

@LuisMendo apologies, there are no restrictions on the two output characters so long as they are different. You can have them depend on whatever you want.

@Titus that's fine

@TonHospel Leading/trailing spaces are allowed so long as they are consistent across all lines (so the structure of the H remains)

I'd call this a "Sierpinski H"

I made a dot plot, but I don't think that qualifies: https://repl.it/repls/ShockedAgitatedKeygenerator

I just found a piece of paper from 2008 where I did exactly this! I was 8 at that time and very interested in fractals (meaning: even more than now). It's the fourth iteration. Photo: https://drive.google.com/open?id=1Ww7_i2phDWGwUNUZCte0Nr4YrKz_Mlxg

Apparently a I can't do Math. I was 12 in 2008, not 8. +2, not -2.

Wolfram Language (Mathematica), 46 bytes
Nest[ArrayFlatten@{r={#,0,#},{#,#,#},r}&,1,#]&

Returns a 2d array of 0s and 1s.
Try it online!

what the heck of course Mathematica has a built-in for recursive nested arrays lol. +1

@HyperNeutrino well obviously

@HyperNeutrino How is this considered a built-in? Just Nest (repeatedly) the function multiple times. Like any other submissions (Jelly?) The ArrayFlatten is... well, built-in, but it behaves somewhat just like a Flatten[#,{{1,3},{2,4}}] in this case. (didn't test)

There is a built-in for this, but longer. Mathematica has long function names.

How could it not, given its triumph at the upgoat challenge?

Canvas, 14 12 bytes
H；［⌐⌐∔＊×∔；３＊＋

Try it here!
Explanation:
Code    |Instruction                                                         |Stack
--------+--------------------------------------------------------------------+-------------------------
        |Push input to stack (implicit)                                      |I
H       |Push "H" to stack                                                   |I,"H"
；      |Swap the top two stack items                                        |"H",I
［      |The following ToS (input) times:                                    |X
    ⌐⌐  |Duplicate ToS (result from last loop ("H" if first loop)) four times|X,X,X,X,X
    ∔   |Join vertically                                                     |X,X,X,X\nX
    ×   |Prepend                                                             |X,X,XX\nX
    ∔   |Join vertically                                                     |X,X\nXX\nX
    ；  |Swap top two stack items                                            |X\nXX\nX,X
    ３＊|Repeat three times vertically                                       |X\nXX\nX,X\nX\nX
    ＋  |Join horizontally                                                   |X<space>X\nXXX\nX<space>X
        |End loop (implicit)                                                 |X
        |Print ToS (implicit)                                                |

Where I is the input, X is the pattern generated by the previous loop ("H" for the first loop), and <space> is the empty space on the first and third row of the pattern, added implicitly by ＋.
-2 bytes thanks to dzaima!

Amazingly short answer :O

MATL, 12 11 bytes
t:"[ACA]BX*

Given input n,  this outputs a matrix containing 0 and n.
Try it online!
To convert this into a character matrix of Hand space add g72*c in the header. Try it online too!
Or add ]1YC to see the matrix displayed graphically. Try it at MATL Online!
Explanation
t          % Input (implicit): n. Duplicate
:          % Range. Gives the array [ 1 2 ... n]
"          % For each (that is, do n times)
  [ACA]    %   Push the array [5 7 5]
  B        %   Convert to binary. Gives the 3×3 matrix [1 0 1; 1 1 1; 1 0 1]
  X*       %   Kronecker product
           % End (implicit). Display (implicit)

Stax, 16 15 bytes
╛c_mê║6{│◙ÖmπV"

Run and debug it
This is the ascii representation of the program with comments.  This program builds up the H sideways, and then transposes once at the end.
'H]                 ["H"]
   {         },*    repeat block specified number of times
    c               copy the matrix
     {3*m           triplicate each row
         |S         surround; prepend and append like b + a + b
           |C       horizontally center rows with spaces
                M   transpose back to original orientation
                 m  output each row

Bonus 14 byte program - uses its input as the output character.  Theoretically, this would not produce the right shape at 10, since it has 2 digits, but attempting to run that crashes my browser.

Ruby, 72 bytes
Output is a list of strings, one string per line.
f=->n{n<1?[?H]:[*a=(x=f[n-1]).map{|i|i+' '*i.size+i},*x.map{|i|i*3},*a]}

Try it online!

Well done! The output looks wrong on tio at first, but it's fine when zoomed out.

APL (Dyalog Classic), 14 bytes
×/¨∘.≥⍨2|,⍳⎕⍴3

Try it online!
⎕ evaluated input n
,⍳⎕⍴3 all n-tuples with elements from 0 1 2
2| mod 2
×/¨∘.≥⍨ form a matrix by comparing every pair of tuples a and b - if all elements of a are ≥ the corresponding elements of b, it's a 1, otherwise 0

Haskell, 50 bytes
f 0=[[1]]
f n=[x++map(*c)x++x|c<-[0,1,0],x<-f$n-1]

Try it online!
Makes a grid of 0's and 1's. One character longer for spaces and H's.
Haskell, 51 bytes
f 0=["H"]
f n=[x++map(min c)x++x|c<-" H ",x<-f$n-1]

Try it online!

Jelly, 17 16 15 bytes
381B«€s3Z€ẎF€µ¡

This is a full program that prints a 2D array of 1's and 0's.
Try it online! or see the output with H's and spaces.

Java (JDK), 126 bytes
n->{int s=1,H[][]=new int[n+=Math.pow(3,n)-n][n],x;for(;s<n;s*=3)for(x=n*n;x-->0;)H[x/n][x%n]|=~(x/n/s%3)&x%n/s%3&1;return H;}

Try it online!
Returns an int[][] with 0 for H and 1 for space. This actually "carves" a wall of H's instead of "piling" H's.
Explanations
n->{                        // An int to int[][] lambda function
  int s=1,                  //  size of the carvings.
      H[][]=new int[n+=Math.pow(3,n)-n][n],
                            //  change n to 3^n, through +=...-n to avoid an explicit cast
                            //  and create the 2D array to return, filled with 0s
      x;                    //  counter for the 2D array
  for(;s<n;s*=3)            //  for each size
    for(x=n*n;x-->0;)       //   for each cell
      H[x/n][x%n] |=        //     assign 1 to a cell of the array if...
        ~(x/n/s%3)          //      it is located in the "holes" of the H
        &x%n/s%3            //
        &1;                 //
  return H;                 //  return the array
}                           // end the lambda

Credits

-9 bytes thanks to ceilingcat.

save 5 bytes by adding a static import for Math.pow

@Selim the static import is required in the byte count. So I would lose...  19 bytes.

SOGL V0.12, 13 bytes
┌.{³2∙⁴┼+;3∙┼

Try it Here!

R, 64 bytes
function(n)Reduce(`%x%`,rep(list(matrix(c(1,1,1,0,1,0),3,3)),n))

Try it online!
Reduces by Kronecker product, as a shameless port of Luis Mendo's answer.
The footer prints the result nicely, but this is an anonymous function which returns a matrix of 1 for H and 0 for space.

V, 22 bytes
éHÀñäLgvr PGï3PkyHGpH

Try it online!
Hexdump:
00000000: e948 c0f1 e416 4c67 7672 2050 47ef 3350  .H....Lgvr PG.3P
00000010: 6b79 4847 7048                           kyHGpH

This is basically the exact same approach as the Sierpinski carpet and The Fractal Plus on Anarchy Golf.

Is that French?

Python 2, 70 bytes
f=lambda r:-r*'H'or[x+[x,' '*3**r][b]+x for b in 1,0,1for x in f(r-1)]

Try it online!
Function outputs a list of strings.

Python 2, 84 bytes
r=input()
for i in range(3**r):x,s=' H';exec"s+=[x,s][i%3%2]+s;x*=3;i/=3;"*r;print s

Try it online!
Uses the same template as other 3*3 fractal patterns:

Sierpinski
carpet
Fractal
X
Fractal plus.

Vim - 66 56 54 bytes
A
@
c
H
esc
"
r
d
^
q
c
{
ctrl-v
}
"
a
y
g
v
r
space
g
v
d
"
a
P
P
"
a
P
V
G
"
b
y
P
g
v
ctrl-v
$
d
"
a
P
.
.
G
"
b
p
q
@
r
The input is taken as a number in the buffer.

What do I have to type, starting from a bash prompt, assuming I have vim installed, to see the result?

Type vim, press enter, type the input number (e.g. 3) in the buffer then, from normal mode, press the sequence of keys from the post.

Make sure to use vanilla vim

There was a typo in the code. Just fixed it.

Works! I is a capital i, not ell. :set nowrap to see the result, for 4 and more.

@Fabien an i works as well, so I changed it to be more clear

J, 25 22 bytes
,./^:2@(*/#:@5 7 5)^:]

Try it online!
        */               multiply by
          #:@5 7 5       the binary matrix shaped like H
,./^:2                   assemble the 4-dimensional result into a matrix
                   ^:]   do it input times

Haskell, 73 67 64 55 bytes
g#f=g<>f<>g
w=map.(id#)
(iterate(w(>>" ")#w id)["H"]!!)

This works only with the latest version of Prelude, because it exports <> from Data.Semigroup. To run it on TIO, add an import as done here: Try it online!
g#f=              -- function # takes two functions g and f and a list s
                  -- and returns
   g <> f <> g    -- g(s), followed by f(s) and another g(s)

w=                -- w takes a function and a list of lists
                  -- (both as unnamed parameters, because of pointfree style,
                  -- so let's call them f and l)
  map.(id#)       -- return map(id#f)l, i.e. apply (id#f) to every element of l

  w(>>" ")#w id   -- this partial application of # is a function that
                  -- takes the missing list (here a list of lists)
                  -- remember: (>>" ") is the function that replaces every element
                  -- of a list with a single space

iterate(   )["H"] -- starting with a singleton list of the string "H"
                  -- which itself is a singleton list of the char 'H'
                  -- repeatedly apply the above function
              !!  -- and pick the nth iteration

Example for ["H H", "HHH", "H H"], i.e.

   H H
   HHH
   H H

call the iterated function:
                    ( w(>>" ")         # w id       ) ["H H","HHH","H H"]

expand w:           ( map(id#(>>" "))  # map(id#id) ) ["H H","HHH","H H"]

expand outermost #: map(id#(>>" "))["H H","HHH","H H"] ++
                    map(id#id)     ["H H","HHH","H H"] ++
                    map(id#(>>" "))["H H","HHH","H H"]

expand map:         [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"] ++
                    [(id#id)     "H H",   (id#id)     "HHH",   (id#id)     "H H"] ++
                    [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"]

expand other #:     ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"] ++
                    ["H H"++"H H"++"H H", "HHH"++"HHH"++"HHH", "H H"++"H H"++"H H"] ++
                    ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"]

collaps ++:         ["H H   H H", "HHH   HHH", "H H   H H",
                     "H HH HH H", "HHHHHHHHH", "H HH HH H",
                     "H H   H H", "HHH   HHH", "H H   H H"]

which is printed line by line:

  H H   H H
  HHH   HHH
  H H   H H
  H HH HH H
  HHHHHHHHH
  H HH HH H
  H H   H H
  HHH   HHH
  H H   H H

Edit: -9 bytes thanks to @Potato44.

You should be able to golf (#) down to g#f=g<>f<>g if you use GHC 8.4. This is because Semigroup is now in the prelude.

@Potato44: I'm pretty sure this will help in a lot of challenges. Thanks!

Perl 5, 46 44 43 41 40 bytes
1 based counting. Uses 0 and 1 for H and space, has a leading 1 (space)
say//,map/$'/^1,@;for@;=glob"{A,.,A}"x<>

Based on a classic idea by mtve.
Try it online!

Output for n ≥ 3 isn't quite right.

@primo The program was correct but TIO uses the UTF-8 version of the special characters. I fixed the link to use escapes instead, but the program still works if you use the actual literal characters

I have no idea why \321 is necessary, any character seems to work. // and $' can also replace //g and `$``, but I'm not sure it leads to an improvement.

@primo Thanks! I was still working from code derived from the old mtve solution where \321 was the bit complement of . (used to generate another fractal pattern). But I dropped the bit-complement so of course I don't need that anymore. I used //g and $ so I can easily test the code from the commandline (//and$'don't lead to a gain I can see, the gained byte is wasted with a space or!` again)

Python 2, 143 bytes
def g(a,x,y,s):
	if s:s/=3;[g(a,x+k/3*s,y+k%3*s,s)for k in 0,2,3,4,5,6,8]
	else:a[x][y]=1
def f(s):s=3**s;a=eval("s*[0],"*s);g(a,0,0,s);print a

Try it online!
-30 bytes thanks to recursive
wrapper code is for nice formatting. it works fine if you remove it

A few golfs

APL (Dyalog Unicode), 38 34 bytesSBCS
({(⍵,(0×⍵),⍵){⍺⍪⍵⍪⍺}⍵,⍵,⍵}⍣⎕)1 1⍴1

Output is a 2-dimensional array with 1 representing H and 0 representing space.
Try it online!

Welcome to PPCG! You can omit f← and count chars as 1 byte each: https://codegolf.meta.stackexchange.com/questions/9428/when-can-apl-characters-be-counted-as-1-byte-each It's also considered legal to take input from ⎕, i.e. replace ⍣⍵ with ⍣⎕ and drop the outer dfn's braces.

Thanks! I've never actually formally golfed APL before so these should help.

1 1⍴1 can be written as ⍪1 and then the parens around the operator become unnecessary. If you're familiar with trains - they can help a lot here.

Also, ⍨ is your friend: (⍵,(0×⍵),⍵) => (⍵,⍵,⍨0×⍵)

Charcoal, 30 29 bytes
HＦＥＮＸ³ι«Ｊ⁰¦⁰Ｃ⁰ιＣιιＴ⊗ι⊗ι‖ＯＯ→↓ι

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

Print the original H.
ＦＥＮＸ³ι«

Loop over the first size powers of 3.
Ｊ⁰¦⁰

Move the cursor back to the origin. Trim needs this, as both the original printing of the H and the reflection below move the cursor.
Ｃ⁰ι

Copy the previous iteration downwards, creating a domino.
Ｃιι

Copy the result down and right, creating a tetromino.
Ｔ⊗ι⊗ι

Trim the canvas down to an L shape triomino.
‖ＯＯ→↓ι

Reflect the canvas horizontally and vertically with overlap, completing the iteration.
Charcoal is better at some fractals than others. Here's a similar idea, but in almost half the size:
HＦＮ«⟲Ｃ²⁶‖ＯＯLＸ³ι

Try it online! Link is to verbose version of code.

PHP 7, 125 109 bytes
a different approach: Instead of nesting and flattening the result recursively, this just loops through the rows and columns and uses a 3rd loop to find out if to print H or _.
Edit: Saved a lot by combining the row/column loops to one, though it took a bit to get the decrease for the inner loop correct. Requires PHP 7 for the power operator.
Try them online!

for($z=3**$argn;$z*$z>$q=$p;print$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;

prints the result. Run as pipe with -nR.
qualified function, 147 130 bytes
function r($n){for($z=3**$n;$z*$z>$q=$p;$r.=$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;return$r;}

returns a single string. Run with default config (no php.ini).

%3==1 can be replaced with %3&1.

T-SQL, 267 261 bytes
DECLARE @N INT=3DECLARE @ TABLE(I INT,H VARCHAR(MAX))INSERT @ VALUES(1,'H H'),(2,'HHH'),(3,'H H');WITH
T AS(SELECT 1 A,3 P,I J,H S FROM @ UNION ALL SELECT A+1,P*3,J*P+I,REPLACE(REPLACE(S,' ','   '),'H',H)FROM @,T
WHERE A<@N)SELECT S FROM T WHERE A=@N ORDER BY J

This is my first answer on Code Golf, so please help me if I made any mistakes. Also, my preferred language is Transact-SQL, which is not very suitable for short code.

Welcome to PPCG and nice first post! For tips about golfing in T-SQL, make sure to check out this post!

I tried adding a sqlfiddle, but it doesn't work well with table variables. If I use normal tables, it's even 1 byte shorter: http://sqlfiddle.com/#!18/eb14e/2. However, the output is not formatted correctly by sqlfiddle, but it works fine in SSMS.

You should be able to get this down to 259 by removing some unnecessary whitespace and linefeeds

I only got to 261. What am I missing?

Jelly, 25 bytes
,’b3U×"3S_4A1e
3*çþ`ị⁾ HY

Try it online!

Although this is longer than the existing Jelly submission, it tries to generate each character independently just from the coordinate.
In particular, if the coordinate is (x,y) (1-indexing), the first link returns 0 and 1 corresponds to H and   respectively.

,                Pair. Get (x,y)
 ’               Decrement. Get (x,y) (0-indexing)
  b3             Convert to base 3 digits.
    U            Upend. So next operations can pair the corresponding digits.
     ×"3         Multiply the first element (list) by 3.
        S        Sum (corresponding digit together). Let the sum be s.
         _4A1e   Check if any of abs(s-4) is 1. Equivalently, check
                 if there is any 3 or 5 in the list of s.

Also, the 5 bytes ị⁾ HY are used for formatting, so this program (20 bytes) is also valid (but the output doesn't look as nice):
,’b3U×"3S_4A1e
3*çþ`

PHP 7, 153 bytes
    function p($n){$r=["H H",HHH,"H H"];if(--$n)foreach(p($n)as$s){$r[+$i]=$r[$i+6*$p=3**$n]=str_pad($s,2*$p).$s;$r[3*$p+$i++]=$s.$s.$s;}ksort($r);return$r;}

Run with default config (no php.ini) or try it online.

Perl, 64 bytes
//;$_ x=3,$.=s|.+|$&@{[$$_++/$.&1?$&:$"x$.]}$&|g for($_=H.$/)x$'

Requires -p, input is taken from stdin. Output is an H of Hs.
Try it online!

Counting on this site has changed, you don't need to count -p anymore (I think it is too  lenient for perl, but that's how it is now)

PHP (5.6+), 94 bytes
<?for(;$H>$e*=3or$e=($i+=$e&&print"$s
")<${$s=H}=3**$argn;)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

Used with -F command line option. Assumes interpreter defaults (-n). Will not work on versions previous to 5.6, due to the power operator.
Sample usage
$ echo 3|php -nF h-carpet.php
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

Try it online!

You can save one byte: $s.$s.$s instead of $s.=$s.$s. And you don´t need <? with -R instead of -F.

Thanks for the byte. Regarding -R, can you show me the complete usage?

Just like -nF: echo <input> | php -nR '<code>'. -r is almost the same: php -nr '<code>' <arguments>.

Maybe I'm just too stupid to get it working :/ https://i.stack.imgur.com/jqpmk.png

Errm no, sorry. The mix of quotation marks ruins it. You probably could work around that with a ~ for the preg-replacement; but that would render your code pretty unreadable - for gaining a single byte.

But: why preg_filter and not simply $s=($s=$s.$s).sprintf("%$i.s$s",$$i++/$i&1?$s:"");? And have you tried $s.str_pad($$i++/$i&1?$s:"",$i).$s instead of the sprintf? (I have not)

preg_filter is to iterate each line while preserving newlines, roughly equivalent to join("\n",array_map(function(){...},split("\n",$s.$s.$s))), but significantly less verbose. I initially had str_pad but changed to sprintf because it's one byte shorter: '"\0".str_pad($$i++/$i&1?"\0":"",$i)."\0"'

CJam - 103 97 87 76 bytes
{H{ae_,S*}%}:Il~a:A];{A_W={)(a9*+:A;[[HIH][HHH][HIH]]{z~}%}{);:A;"H"}?}:H~N*

This program does a quite verbose "handcoded" recursion. No smart matrix multiplications. Throughout the recursion, on top of the stack there is an array gathering the output gained from the parent calls. Right after each set of recursive calls the output of the recursive calls needs to be zipped together, to make sure the output is correct when the stack is printed linearly at the end of the program. The stack of arguments being passed down the recursion is kept in the variable A.
Try online

K (ngn/k), 18 bytes
{~|/a<\:'a:1=!x#3}

Try it online!

Japt, 23 bytes
_·£[X³XX³]Ãy c ·û}gQq)y

Try it online!
Unpacked & How it works
Z{ZqR mXYZ{[Xp3 XXp3]} y c qR û}gQq)y

Z{    Declare a function that accepts a string...
  ZqR   Split by newline...
  mXYZ{   and map each row into...
    [Xp3 XXp3]  an array of [X.repeat(3), X, X.repeat(3)]
  }
  y   Transpose the resulting 2D array
  c   Flatten
  qR  Join with newline
  û   Center-pad each row to the longest
}
gQq)  Apply the above function to '"' recursively
y     Transpose the resulting 2D string

Using the transposed pattern
III
 I
III

is far easier to handle than the original H pattern, at least in Japt where the I can be done with string repeat and center-padding.

C++11 - 138 bytes
Not sure if this answer has a valid syntax here however.
#define A a?1:0
template<int N>struct H{H<N-1>h[9];H(int a):h{A,0,A,A,A,A,A,0,A}{}};template<>struct H<0>{char h;H(int a):h{a?'H':' '}{}};

Ungolfed with working code
#include <iostream>

#define A a?1:0

template<int N>
struct H
{
  H<N-1> h[9];

  H(int a) : h{A,0,A,A,A,A,A,0,A}
  {}
};

template<>
struct H<0>
{
  char h;

  H(int a) : h{a?'H':' '}
  {}
};

int pow(int a, int b)
{
  int res=1;

  for (int i=1; i<=b; ++i)
    res *= a;

  return res;
}

template<int N>
char getHvalue(int i, int j, H<N> &hn)
{
  int n3=pow(3, N-1);

//std::cout << N << " " << i << " " << j << std::endl;

  return getHvalue(i%n3, j%n3, hn.h[i/n3*3+j/n3]);
}

template<>
char getHvalue<0>(int, int, H<0> &hn)
{
  return hn.h;
}

int main()
{
  H<0> h0(1);

  std::cout << getHvalue(0, 0, h0) << std::endl;

  std::cout << "\n====================\n" << std::endl;

  H<1> h1(1);

  for (int i=0; i<3; ++i) {
    for (int j=0; j<3; ++j)
      std::cout << getHvalue(i, j, h1);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<2> h2(1);

  for (int i=0; i<9; ++i) {
    for (int j=0; j<9; ++j)
      std::cout << getHvalue(i, j, h2);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<3> h3(1);

  for (int i=0; i<27; ++i) {
    for (int j=0; j<27; ++j)
      std::cout << getHvalue(i, j, h3);
    std::cout << std::endl;
  }

  return 0;
}

all_licenses: 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/


text:
EASY to memorize numbers
Numbers that are easy to remember yet theoretically not easily made
Your challenge is to make a program/function in any language that generates uniformly random numbers that fit these criteria:

Length is 5 digits

There are two separate repeated digit pairs

One set of repeated digits is at the beginning or end and the digits
are next to each other

The odd number out is surrounded by the other pair of digits

The two digit pairs and the other number should all be unique

Your program may support numbers with leading zeroes or not, at your discretion. If leading zeroes are supported, they must be included in the output: 06088, not 6088. If leading zeroes are not supported, then numbers like 06088 should not be generated at all.

Test Cases
Accepted Outputs:

55373
55494
67611
61633
09033
99757
95944
22808
65622
22161

Not accepted outputs:

55555
77787
85855
12345
99233
12131
abcde
5033

More acceptable test cases can be found at this pastebin link.
These were made with this python program:

import random
for i in range(100):

    if random.randint(0,100) >= 50: #Put pair touching at beginning if true
        temp = []                      #working array
        temp.append(random.randint(0,9))  #append random digit
        temp.append(temp[0])              #append the same digit again

        x = random.randint(0,9)
        while x == temp[0]:
            x = random.randint(0,9)
        temp.append(x)                    #append another unique digit

        y = random.randint(0,9)
        while y == temp[0] or y == temp[2]:
            y = random.randint(0,9)
        temp.append(y)                  #append another unique digit, and the previous unique digit
        temp.append(x)

    else:  #Put touching pair at end
        temp = []                      #working array
        temp.append(random.randint(0,9))  #append random digit

        #While not unique, try again
        x = random.randint(0,9)
        while x == temp[0]:
            x = random.randint(0,9)
        temp.append(x)                    #append another unique digit

        temp.append(temp[0])              #append the same 0th digit again

        y = random.randint(0,9)
        while y == temp[0] or y == temp[1]:
            y = random.randint(0,9)
        temp.append(y)                  #append another unique digit twice
        temp.append(y)

    tempstr = ""
    for i in temp:
        tempstr += str(i)
    print tempstr

This is code-golf, so shortest answer in bytes wins!

Does every possible easy to memorize number have to be able to appear as output? Should the random choice be uniform?

@JonathanFrech Yes and yes

I suggest "Possible outputs (probability>0)" and "Not possible outputs (probability=0)" rather than "Truthy" and "Falsy"—this seems more in line with what I think you're asking (and with the Python).

Do we have to print an output like 09033 with a leading zero?

If the probability is uniform, can you specify that in the question. By default, random does not mean uniformly so

maybe add 99233, for conveniewnce to understand

Welcome to PPCG! Nice first challenge.

@xnor, since some languages will most likely need to use numbers instead of arrays of numbers, you can decide whether or not you output numbers with leading zeroes. But do not output any numbers that are 4 or 3 in length because the zero(es) was/were chopped off

@Downvoter what can I improve?

"Outputs that have a pair of zeroes are not required to output the leading zero, but if omitted, make sure that you do not output something like 6088, chopping the first zero off." ... um, what?

@DLosc Yeah I'm sorry, I'm not quite sure how to word it. Your interpretation is correct. Please feel free to edit your alternate explanation in.

@DLosc looks great, thanks

It’s 0118-999-881-999-119-725......3

05AB1E, 11 bytes
žh.r3£ûÁÂ)Ω

Try it online!
Explanation
žh            # push "0123456789"
  .r          # random shuffle
    3£        # take the first 3
              # EX: 152
      û       # palendromize
              # EX: 15251
       Á      # rotate right
              # EX: 11525
        Â)    # pair with its reverse
              # EX: [11525, 52511]
          Ω   # pick one at random

I wonder if Emigna ha... sees top answer +1.

Perl 5, 81 63 56 bytes
Cut 7 bytes with inspiration from @DomHastings
Constructing the number from the appropriate pattern.
@q{0..9}++;say+(keys%q)[.5>rand?(2,2,0,1,0):(0,1,0,2,2)]

Try it online!

Perl 5, 89 bytes
Picks random 5 digit numbers until it finds one that meets the criteria.

$_=sprintf'%05d',0|rand 1E5until(/(.)\1(.)(.)\2/||/(.)(.)\1(.)\3/)&&$1-$2&$2-$3&$1-$3;say

Try it online!

Nice trick using the hash keys for randomness! I think this is equivalent for -8, although I might have missed an edge case... Try it online!

Hash randomization. Brilliant! shorter

The question is whether or not time%2 is sufficiently random, since it is, in a sense, under the control of the user.

@Xcali It seems to be consensus that it is fine as long as you only use it once so I think you should be good.

CJam (16 bytes)
YmrG*98+ZbA,mrf=

Online demo
Note: I've assumed that by "unique" OP really means "distinct".
Also for 16 bytes:
98ZbA,mrf=W2mr#%
98ZbA,mrf=_W%]mR

Dissection
Ymr    e# Select a random number from [0 1]
G*98+  e# Multiply by 16 and add 98 to get 98 or 114
Zb     e# Base conversion in base 3 to get [1 0 1 2 2] or [1 1 0 2 0]
A,mr   e# Shuffle the numbers from 0 to 9
f=     e# Map "select the item at this index"

The other variants generate using [1 0 1 2 2] and then select either the result or its reverse.

Python 2, 80 bytes
from random import*
a,b,c=sample(range(10),3)
print[a,a,b,c,b][::choice((-1,1))]

Try it online!
Outputs a list of digits.
Python 2, 83 bytes
from random import*
a,b,c=sample('0123456789',3)
print(a*2+b+c+b)[::choice((-1,1))]

Try it online!
Output is a number.

If non-uniform randomness is allowed by default (the question doesn't specify), you can save bytes by sampling the reversedness as well: Try it online! Edit: Never mind, I see uniformity was edited into the spec. I wonder if this approach can still be salvaged.

APL (Dyalog Unicode), 22 21 20 18 17 bytes
(3∨?2)⌽1↓,∘⌽⍨3?10

Try it online!
If it's acceptable to output the numbers always in the same format, this can be shortened to 12 bytes, either 1⌽1↓,∘⌽⍨3?10 or 3⌽1↓,∘⌽⍨3?10.
Saved a byte by removing the unnecessary ∘.
Saved a byte thanks to H.PWiz, and then 2 more bytes due to their tip.
Saved a byte thanks to ngn.
The function assumes ⎕IO←0 (Index Origin).

How?
(3∨?2)⌽1↓,∘⌽⍨3?10 ⍝ Anonymous function.
              3?10  ⍝ Deal 3 (distinct) random numbers from 0 to 9. (Assume 1 2 3)
             ⍨     ⍝ Use that as both arguments for:
          ,∘⌽      ⍝ Rotate (⌽), then concatenate (,).
                   ⍝ Yields 3 2 1 1 2 3.
        1↓         ⍝ Drop the first element. Our vector is now 2 1 1 2 3
      ⌽            ⍝ Rotate the vector to the left using as argument:
(  ?2)             ⍝ Roll 0 or 1 and...
 3∨                ⍝ Do the GCD between 3 and the result. (3∨0=3; 3∨1=1.)
                   ⍝ This yields either 1 1 2 3 2 or 2 3 2 1 1.

Input cannot be given

@drham there is no input to the function. In this case, the TIO field Input is used to call the function g. Also, the g← is not counted in the byte count because it's not necessary, it's only being used to call the function.

The fact that g is called in the input section is just a quirk of how APL is set to run on TIO

(4∨?2) saves a byte over 1 4[?2]

You can also save bytes by not assigning to f and using a train. I'll leave that to you though :)

@H.PWiz got it :) Thanks for the tip.

OK that works I guess

(1↓⌽,⊢) -> 1↓,∘⌽⍨

typo: GDC -> GCD

Java 8, 145 136 125 119 bytes
v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}

-9 bytes thanks to @OlivierGrégoire.
-11 bytes thanks to @RickHitchcock.
-6 bytes thanks to @Nevay.
Explanation:
Try it online.
v->{            // Method with empty unused parameter and String return-type
  String r;     //  Result-String
  for(;!(r=(int)(Math.random()*1e5)+"")
                //  Generate a random number in the range [0; 100000) and set it to `r`
        .matches("(.).*\\1(.).*\\2")
                //   And continue doing this as long as it doesn't match the regex above,
       |r.chars().distinct().count()<3;);
                //   or doesn't have three distinct digits
  return r;}    //  Return the result

136 bytes

@OlivierGrégoire Did you post this at the correct challenge?.. :S It does look familiar, but it's certainly not this challenge..

The bitly thingy broke my link... Anyways, here's the golf: v->{String r="";for(;!r.matches("(.)\\1(.).\\2|(.).\\3(.)\\4")|r.chars().distinct().count()!=3;r=(int)(Math.random()*1e5)+"");return r;}

@OlivierGrégoire Ah oops, the regex golf (except for || to |) I had already done locally, but after I fixed some things I forgot to post it.. Thanks for the 1e5 and | golf!

I think your regex can be shortened to (.).*\\1(.).*\\2, saving 11 bytes.

119 bytes: v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}

Jelly, 23 bytes
⁵Ḷṗ3⁼Q$ÐfXµḢ;`;ŒBW;U$µX

Try it online!

Nice, I would upvote, but I can't

@drham :) thanks. you should be able to soon, once most active members wake up your question will probably get a lot of upvotes. good first challenge and welcome to PPCG by the way!

Jelly, 12 11 bytes
ØDẊ⁽0yṃ,U$X

Try it online!

Explanation

ØDẊ⁽0yṃ,U$X    Niladic link, generate a random string.
ØD             List of digits, ['0','1','2',...,'9'].
  Ẋ            Random shuffle.
   ⁽0y         Number 13122.
      ṃ        Base decompression. (*)
       ,U$     Pair with its upend (reverse).
          X    Choose one (it or its reversed) randomly.

(*) The right argument of ṃ is the list ['0','1','2',...,'9'], randomly shuffled, have 10 elements. So the number 13122 will be converted to bijective base 10 ([1,3,1,2,2]) and index into the list (so if the list is l, the return value of the atom is [l[1],l[3],l[1],l[2],l[2]], where Jelly uses 1-based indexing)

(same idea as the 05AB1E answer, came up with independently)

... 05AB1E get 6 upvotes because of being able to tie Jelly, Jelly only get 2 upvotes because of being unable to win 05AB1E?

i upvoted your answer. --> SPEECH 100 <---

JavaScript (ES6), 79 bytes
f=([,,d,a,b,c]=[...Math.random()+f])=>a-b&&a-c&&b-c?d&1?a+a+b+c+b:b+c+b+a+a:f()

Try it online!
How?
Math.random() gives a random float in [0..1). We use +f to force coercion to a string. We ignore the leading zero and the decimal point by doing [,, (destructuring assignment of the first two characters to nothing) and collect the first 4 decimal digits into d, a, b, and c.
If a, b and c are 3 distinct integers, we build the final output in either AABCB or BCBAA format (using the parity of d to decide). Otherwise, we try again until they are.
In the highly improbable event of Math.random() returning a value without enough decimal places, at least c will be set to a non-digit character, forcing the test to fail and the recursive call to occur. If a, b and c are valid integers then d is guaranteed to be a valid integer as well, so this one doesn't need to be tested.

Both && can be &. Also, how does [,,a,b,c,d] work? I've never seen an input like [,, before.

@KevinCruijssen A bitwise AND would fail for instance for a=4, b=2, c=1 because 4-2&4-1&2-1 == 2&3&1 == 0. I've added a short explanation about the variable assignment.

Ah of course. I just tried && to & in TIO and it gave correct outputs, so I assumed it was possible. Didn't realize & instead of && would filter out otherwise valid outputs. And thanks for the added explanation about the destructuring assignment, never seen it before.

This is just awesome +1

Perl 6, 42 bytes
[~] (^10).pick(3)[0,|(<0 2 1>,<1 0 2>).pick,2]

Try it online!

Dirty, 33 bytes
Uses the --numeric-output flag so it's readable, otherwise it would output a string of control characters with code-points corresponding to the digits.
10⭧[1w#%D⅋№3⤱≠1ẅ&]1wẂ⭿⭣1u∅#1∧◌ŪW‼

Try it online!
Explained:
10⭧              put 10 on the right stack
[1w#%D⅋№3⤱≠1ẅ&] loop until there are 3 distinct positive numbers below 10 in the top stack
1wẂ              clean-up the right and top stacks
⭿               copy the top and bottom of the top stack to each-other
⭣                swap the first two elements of the top stack
1u               rotate the top stack by 1
∅#1∧◌ŪW          reverse the top stack half of the time
‼                print the top stack

Ruby,  60 59 bytes
->{a,b,c=[*0..9].sample 3;[[a,a,b,c,b],[b,c,b,a,a]].sample}

Try it online!
It returns a list of digits.

PHP, 73 72 66 bytes
<?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));

Edit: 66 bytes thanks to @David 's suggestion.
Try it online!

You can get it to 65 with this: <?=strtr(rand()%2?AABCB:BCBAA,ABC,rand(0,9).rand(0,9).rand(0,9));

@David Unfortunately your solution violates rule 5. It could be like rand(0,3).rand(4,6).rand(7,9), but then again is not "uniformly random". Btw. I wasn't familiar with rand()%2, so your comment helped me to slightly improve my solution anyway.

ah, yes, you're right. I didn't see that rule. I've got one that works now, at 66 bytes: <?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));. You can test that the array_rand's second parameter only returns unique results here (tested over 10000 iterations).

@David thanks, just updated my post!

Charcoal, 34 bytes
≔‽χθ≔‽Φχ⁻ιθη↑Ｉ⟦θθη‽Φχ×⁻ιθ⁻ιηη⟧¿‽²‖

Try it online! Link is to verbose version of code. Explanation:
  χ                                 Predefined variable 10
 ‽                                  Random element from implicit range
≔  θ                                Assign to variable `q`
       χ                            Predefined variable 10
      Φ                             Filter on implicit range
         ι                          Current value
          θ                         Variable `q`
        ⁻                           Subtract
     ‽                              Random element
    ≔      η                        Assign to variable `h`
                    χ               Predefined variable 10
                   Φ                Filter on implicit range
                       ι  ι         Current value
                        θ           Variable `q`
                           η        Variable `h`
                      ⁻  ⁻          Subtract
                     ×              Multiply
                  ‽                 Random element
               θθ                   Variable `q`
                 η          η       Variable `h`
              ⟦              ⟧      Wrap 5 values into array
             Ｉ                      Cast array elements to string
            ↑                       Make array print horizontally
                                ²   Literal 2
                               ‽    Random element from implicit range
                              ¿     If
                                 ‖  Reflect

Retina, 40 bytes

10*
Y`w`d
V?`
Lv$7`.(.)
$1$<'$'
O?`...?

Try it online!
Can print strings with leading zeros.
Explanation

10*

Initialise the string to 10 underscores.
Y`w`d

Cyclically transliterate word characters to digits. This is a bit weird. The w and d are short for the following strings, respectively:
w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

Cyclic transliteration means that first, both strings are repeated to the length of the their LCM:
_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

Since the string lengths 53 and 10 are coprime, each copy of _ is paired with a different digit. And now cyclic transliteration will replace the ith copy of _ with the ith pairing in that expanded list. So we end up with the following string:
0369258147

All of that to save a single byte over the literal string 0369258147, so yay I guess? :D
Anyway, we've got a string of all 10 digits now.
V?`

This shuffles the digits. So the first three digits will be a uniformly random selection of three distinct digits.
Lv$7`.(.)
$1$<'$'

We match the string ...ABC and turn it into BABCC. The way we do this is kinda crazy though and again saves only one byte compared to a more straightforward approach. We first match all overlapping (v) pairs of characters, capturing the second one (.(.)). Then we retain only the 8th match (7, zero-based) which is AB in ...ABC. Then we replace ($) it with: B ($1), ABC ($<' which is the suffix of the match-separator left of the match), C ($' which is the suffix of the match itself).
O?`...?

Finally, we match either 3 or 2 characters and shuffle the matches, giving us either BABCC or CCBAB at random.

R, 78 bytes
z=sample(0:9,3)[c(2,1:3,3)];cat(paste(`if`(runif(1)>.5,z,rev(z)),collapse=''))

Try it online!
sample picks 3 random values from 0:9, which are placed in a vector like so: a b a c c. Now we have a 50/50 chance to reverse this vector, and then concatenate and print.

Very nice! 62 bytes; looks like you're a little out of practice ;)

I looked at using rt, but for some reason I thought it was longer....

And the ( as no-op is a good find :)

@Giuseppe your asnwer can be golfed further to 55 bytes... TIO

Wolfram Language (Mathematica), 59 bytes
{{#,##,#2},{#2,##,#3}}~r~1&@@(r=RandomSample)[0~Range~9,3]&

Try it online!

C (gcc), 126 119 bytes
-6 bytes from @ceilingcat
#define R time(0)%10
b,n,m,k;f(){b=R^8;for(n=R;m==n|k==m|k==n;m=R,k=R);printf("%d%d%d%d%d",b?n:m,b?n:k,m,b?k:n,b?m:n);}

Try it online!

Python 3 +numpy, 69 bytes
from pylab import*
r=choice
i=r(2)
print(r(10,3,0)[[1-i,0,1,2,-1-i]])

Explanation
from pylab import*
r=choice               # `choice` takes a range, number of samples, and wether repetition is allowed
i=r(2)                 # Single value in [0,1] to specify if repeated digits come on right or left
print(r(10,3,0)[[1-i,0,1,2,-1-i]])    # Construct output using index list and 3 random integers

Red, 147, 146 125 bytes
func[][b: copy[]d:[1 1 2 3 2]if 1 = random 2[d: reverse d]while[4 > length? b][alter b(random 10)- 1]foreach a d[prin b/(a)]]

Try it online!
Ungolfed:
f: func[] [                       function with no arguments
    b: copy []                    an empty list
    d: [1 1 2 3 2]                preset digits at positons
    if 1 = random 2 [             generate 1 or 2
        d: reverse d]             based on this choose to reverse the positions list
    while [4 > length? b] [       while we haven't chosen 3 different digits
        alter b (random 10) - 1   pick a random digit, if it's not in the list already
                                  append it to the list, otherwise remove it
    ]
    foreach a d [                 for each position
       prin b/(a)]                print the corresponding digit
]

J, 35 bytes
[:u:48+[:|.^:(?&2:)2 2 1 0 1{3?10"_

Try it online!
I'm sure it can be golfed much further.
Explanation:
  3?10             - generates 3 different digits
7 0 3

  2 2 1 0 1{       - constructs a list using digits positions 0, 1 and 2

  2 2 1 0 1{3?10
3 3 0 7 0

  |.^:(?&2:)       - generates 0 or 1 and if 1, reverses the list

  |.^:(?&2:)2 2 1 0 1{3?10
0 7 0 3 3

   u:48+              - converts to char by adding 48 to each digit
   u:48+|.^:(?&2:)2 2 1 0 1{3?10
07033


text:
Left Hand vs. Right Hand — Typists Challenge
Your task is to pit each side of the keyboard against each other and build two programs, in the same language, one using only keys on the left-hand side of a standard keyboard that outputs Pollinium milk; plump pumpkin; lollipop?, and one using the keys on the right that outputs Weatherheaded sweetheart haberdasheress!.
Rules
The exact keys allowed for the left-hand program are:
123456!@#$%^QWERTYqwertyasdfghASDFGH`zxcvb~ZXCVB

and for the right-hand program:
7890-=&*()_+uiop[]UIOP{}jkl;'\JKL:"|nm,./NM<>?

There are four free keys Esc (\x1b), Tab (\x09), Space (\x20) and Enter(\x0a and/or \x0d) which can be used in either, neither, or both solutions.
Your score will be the total byte count for both programs. Whilst I've used the term program, your submissions can either be full programs, or functions as usual, and both can be different types (eg. one full program, and one function).
Your result must include the desired text, any amount of leading and trailing whitespace is fine, as long as the exact text appears within it.
Standard loopholes are forbidden.
The shortest solutions in each language win.

Why H is left hand?

@tsh I wanted to split the keyboard 6/6 (or as close to that as possible) just to try and keep more even number of symbols for each "hand".

// Maybe i should learn whitespace and back later...

@tsh, I guess a whitespace answer is inevitable! Not sure how competitive it would be though! Perhaps I should have addressed that, too late now!

Is it OK if the program has other (non-whitespace) output too, as long as it includes the requested texts?

@GrzegorzOledzki I don't think any other output is acceptable, but I'm intrigued on what the output would be in your proposed solution!

@DomHastings, I am wondering if I can throw() or raise() some exception, etc.

@GrzegorzOledzki you can exit via error, but in a full program the result must be on STDOUT. Hope that helps!

Perl 5, 261 = 88 + 173 bytes
This is an example where "language options don't count" is a problem. The rigt side solution uses -p, the left side doesn't. So does it count as the same language or not? And should the options come from the left/right character set ?
Left 88
use -M5.10.0 (or -E from the commandline) to activate say Again arguable if this option should count as code and should come from the left side or if it falls under "options to set language version don't count"
say eYYYYZYEYWYYYYYWQYEYQWQEYQYYZYWYYYYYQYQW^q%565504004w4052bw!504!w!04!204bw56550!6!h%

Try it online!
Right 173
Run with the -p option (which also consists of right characters)
}{*_=\(uuuuuuuuuuuuuiuuuuuuuuuuiuuuuuuuuuuuuuui&Uiipjipjiijij0puiipjiipp0jijipjipjipipp7|Ouiujujjuiuuu0kouuujuiju0jijujuikjujukk7&"7oulio7iouloli77ooliou7liiu7o7lu7io7o77i")

This can almost certainly be improved, but for now it was hard enough to get something working. Not having access to print, say, $_ and sub{} makes output tricky
Try it online!

Not concerned about flags at all, I'm happy that this is valid. A much shorter solution than what I've been tinkering with as I called eval via &{(u&I.._)[9-7].O.(P|'"'&_).("U::u"&"o::o").("&"|p).(uo&il).(u&i.._)[9-8].("{|o"&"}uu").(j..u)[9]}!

Whitespace, 1175 1143 655 645 638 632 639 578 (293 + 285) bytes
It had to be done.. ;p
Can definitely be golfed by filling the stack reversed and printing it all at the end in some kind of loop, but this is only my second Whitespace program ever, so I've yet to figure it out.. EDIT: Golfed.
+7 bytes because I misspelled pumpkin as pumkin.. (Thanks for noticing, @fəˈnɛtɪk.)
Letters S (space), T (tab) and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Left-sided Pollinium milk; plump pumpkin; lollipop?:
[S S T  T   S T T   T   T   N
_Push_-47_?][S S S T    S N
_Push_2_p][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_p][S S T  T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_l][S S T  T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   T   N
_Push_-3_k][S S S T S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S S T  S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S S T    S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S N
_Push_-2_l][S S S T S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S T  T   T   N
_Push_-3_k][S S T   T   S N
_Push_-2_l][S S T   T   S T N
_Push_-5_i][S S T   T   N
_Push_-1_m][S S T   T   S S T   T   T   S N
_Push_-78_space][S S T  T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S T N
_Push_-5_i][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S S T    T   T   T   T   S N
_Push_-30_P][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   S N
_Push_110][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Try it online (with raw spaces, tabs and new-lines only).
Right-sided Weatherheaded sweetheart haberdasheress!:
[S S T  T   S S S T S S N
_Push_-68_!][S S S T    T   T   S N
_Push_14_s][S N
S _Duplicate_14_s][S S S N
_Push_0_e][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   S N
_Push_14_s][S S T   T   S S N
_Push_-4_a][S S T   T   N
_Push_-1_d][S S S T T   S T N
_Push_13_r][S S S N
_Push_0_e][S S T    T   T   N
_Push_-3_b][S S T   T   S S N
_Push_-4_a][S S S T T   N
_Push_3_h][S S T    T   S S S T S T N
_Push_-69_space][S S S T    T   T   T   N
_Push_15_t][S S S T T   S T N
_Push_13_r][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S S N
_Push_0_e][S N
S _Duplicate_0_e][S S S T   S S T   S N
_Push_18_w][S S S T T   T   S N
_Push_14_s][S S T   T   S S S T S T N
_Push_-69_space][S S T  T   N
_Push_-1_d][S S S N
_Push_0_e][S S T    T   N
_Push_-1_d][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S T    T   T   T   S N
_Push_-14_W][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S T N
_Push_101][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Try it online (with raw spaces, tabs and new-lines only).

Explanation:
It first build the stack reversed. Pushing a number is done as follows:

S at the start: Enable Stack Manipulation
S: Push what follows as number to the stack
S/T: Sign bit where S is positive and T is negative
Some T and S followed by an N: Put number as binary to the stack (T=1 and S=0).

Then it will loop over the stack reversed and print everything as characters. It does this as follows:

Push 0 (SSSN)
Push all numbers indicating the characters reversed as explained above
Create a Label_0 (NSSN)

Duplicate the top of the stack (SNS)
If this value is 0: Jump to Label_1 (NTSTN)
Else: Pop and print the top of the stack as character (TNSS)
Jump to Label_0 (NSNN)

Create Label_1 (NSSTN)

This above is the default layout for both programs. Here is the change-log for this default layout which lowered the byte-count even further:

All numbers are lowered by the same amount (100 110 in the first program, and 102 101 in the second) to decrease the binary digits used for the now lower numbers, and between step 3.2 and 3.3 the following two sub-steps are added:

Push 110 (SSSTTSTTTSN) in program 1, or 101 (SSSTTSSTSTN) in program 2
Pop and add the top two values of the stack with each other, and the result is the new top of the stack (TSSS)

I've also used SNS in some cases to duplicate the top of the stack, which is used to golf the ll, ll, ee and ss.
In addition, step 4 (create Label_1) was removed completely. It will exit with an error, but will still output everything correctly (which is allowed according to the meta).
It's possible to copy an n'th value from the top of the stack (with STS + 0-indexed n), which is shorter than creating a new number in some cases.
In the first program I've done this for: the second p in pop (STSSTN (copy 1st) is shorter than SSSTTSSN (create number for 'p')), the second l in lol (STSSTN (copy 1st) is shorter than SSSTSSSN (create number for 'l')), the second p in p p (STSSTN (copy 1st) is shorter than SSSTTSSN (create number for 'p')), the second p in pumlp (STSSTTN (copy 3rd) is shorter than SSSTTSSN (create number for 'p')), the second p in pmup (STSSTSN (copy 2nd) is shorter than SSSTTSSN (create number for 'p')), the second m in m m (STSSTN (copy 1st) is shorter than SSSTSSTN (create number for 'm')), the second i in ini (STSSTN (copy 1st) is shorter than SSSTSTN (create number for 'i')).
In the second program this isn't done for any. The distance between some is pretty short, like ere or ded, but creating the number for 'e' (SSTTN) or 'd' (SSTTSN) are both shorter or of equal length as copy 1st (STSSTN), so I couldn't apply this trick in the second program to save bytes. NOTE: After golf-step 7, not all of these apply anymore.
In both programs I've changed step 1 of the loop from SSSN (Push 0) to SSN (Push error_value), and removed the steps 3.1 (SNS Duplicate) and 3.2 (NTSTN If 0: Exit). Now it will simply exit with an error that SSN is an unknown value as soon as it's tries to access it.
Removed the SSN(error_value) completely in both programs. It will now stop with the error "Can't do Infix Plus" when it tries to do the Add-function with nothing left on the stack.
Changed the constant values of 100 and 102 to 110 and 101 respectively. Here the Java program used to generate the 110 constant; and here the Java program used to generate the 101 constant. Note that there are now less Copy used than described at point 4 above, because the new values are in many cases shorter than the copies, so re-pushing them is shorter.

The ST stuff is just push the number as binary, with space as 0, tab as 1. Output is the TNSS, so you have an extra two spaces at the beginning of each program.
It also probably save bytes to duplicate and then add/subtract for each character and loop over the values at the end.

You misspelt pumpkin.

@fəˈnɛtɪk Whoops lol.. Should be fixed now, thanks for noticing.

Lenguage, this many bytes
The left-hand side is 65721878296123796350462639500449228197646164622176218219262161264085219054330862921130017235140285847450697804123168755463678390611789188813352602373675420824698785508893489685489807676509031860196742608788337382365939621331808044899882497347443262020486908162559376082705672994569868 repetitions of the a character, which is equivalent to the following Brainfuck program:
-[--->+<]>-----.[--->+<]>-.---..---.+++++.-----.++++++++++++.--------.[->+++++<]>-.+[----->+<]>.----.+++.-.--[->+++<]>.+[-->+<]>++.[-->+++++++<]>.----.+++++++++.--------.+++.[------->++<]>.[-->+++++++<]>.+++++.--------.+++.-----.--.+++++.[-->+<]>++++.+[-->+<]>++.++[--->++<]>.+++.---..---.+++++++.-.+.[--->++++<]>-.

Try it online!
The right-hand side is 636605880289050800007960838028215177632402180834140124157618258152393860687206680356620669530585999501769442445842690365640523699585001167392310123764258380235064746704898152544431842440556280249638840374132783257375880144623575829131522611446544303839106505176776161206935275549421170646618266717893044911373119804737614528140 repetitions of the p character, which is equivalent to the following Brainfuck program:
+[--->++<]>+.++[->++++<]>+.----.--[--->+<]>-.------------.---.+++++++++++++.----------.---.----.+++.+.-.-[--->+<]>-.---[->++++<]>-.++++.[->+++<]>..[--->+<]>---.------------.---.----.--[--->+<]>---.++.[---->+<]>+++.-[--->++<]>--.-------.+.+++.+++++++++++++.--------------.---.--[--->+<]>--.-----------.---.+++++++++++++.-------------.[--->+<]>----..+[-->+++++<]>-.

Try it online!

CJam, 128 + 192 = 320 bytes
64G^c111c111Z^cT$111c6^111X^c1$116X^c111Y^c32c1$6$Y3#$111c4^56Z^c32c112c13$A$A$3$5$1$4$4$4$12$22$22$14$32c13$111c1$T$7$A$4$1$63c

Try it online!
'U))'i(((('_))'u('i('i(((('p))'i('i(((('_))'_)))))'i(((('_)))))'&(((((('u(('u))'i(((('i(((('u('i('i(((('_))'p))'u('&(((((('i('_))'_)))'i(((('p))'_)))))'_))'u(('i('i(((('p))'i(((('u(('u(('&(((((

Try it online!

Fission, 958 + 752 = 1710 bytes
._.
Left
D
z
^@$$$$$$$$$$$$$$$$$$$@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~@!!@~~~@!@$$$$$@!@~~~~~@!@$$$$$$$$$$$$@!@~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$@!@~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$$$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~@!@~~@!@$$$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$@!@~~~@!!@~~~@!@$$$$$$$@!@~@!@$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!V

Try it online!
Right
                                           } \} \    } \      } \    } \   } \   } \    } \   } \       } \    } \   } \ } \       } \   } \                                           } \   } \    } \    } \   } \   } \   } \} \      } \    } \    } \                                           } \ } \ } \   } \    } \   } \   } \    } \   } \   } \   } \    } \      } \
O________________________________________I'/O\/O\__u'/O\____i'/O\++p'/O\___/O\_i'/O\__u'/O\___/O\_____i'/O\++p'/O\+++/O\+/O\_______/O\_i'/O\_________________________________________I'/O\_u'/O\++p'/O\____/O\___/O\_i'/O\_u'/O\/O\____i'/O\++u'/O\__u'/O\_________________________________________I'/O\_/O\+/O\+++/O\____/O\___/O\_i'/O\++p'/O\___/O\_i'/O\_u'/O\____/O\____i'/O\+++++++P'L

Try it online!
OK, here we are with plain luck, actually ._.
First cool feature of Fission is that it has 4 commands to create command pointers, AKA atoms: RLDU, so I have two commands for left and right groups.
Second lucky charm is 2 commands for output ! and O, which occurs in different groups.
Third time the charm. Both outputting comands output ASCII equivalent of atoms' mass. So I need to change it some how. Lucky me! Both + (+1 mass) and _ (-1 mass) are in one group and all needed three $ (+1 energy), ~ (-1 energy), @ (swap mass and energy) are in other group.

 Also there are mirrors to control atoms in both groups! But I didn't use them in first program

So there is nothing to stop me, but it can't be compact, setting masses step-by-step.
First program
First program consists of only Dz^@$~!V
D   create atom, going down
z   set its mass to ASCII code of 'z'
^   split atom in 2, dividing their mass. One goes left, second - right

Start can be simplier (just R), but using divide saves some bytes for first letter.
Atom, that goes left wraps around and encounters V, which makes him going down and wrapping indefinitely, doing nothing.
Second atom goes rigth and will encounter bunch of repeated patterns @...@! for each letter to output.
@   swap atom's mass and energy
... increament or decrement energy until it would match desired ASCII code
@   swap again
!   print character by atoms mass

Eventually it will encounter V and share fate of first atom.  There is no way to destroy them or halt with left part of keyboard.
Second program
Second comes with its ups and downs. I've got comands to change mass directly, but output command O destroys atoms, so I need to preserve them somehow.
Program starts on the right from L with atom going left.
Repeated pattern:
} \
/O\...X'

' puts next encoutered char's ASCII code in atoms' mass, so code of some X is stored first, than mass is changed by _ and + to exact value.
Sometimes X' is skipped, if it is shorter to use just _ and +.
Atom comes from the left, mirrors two times and hits } from left. In this case } works like cloner, sending two identical atoms up and down. Down atom reflects by mirror and goes left. Up atom wraps, hits same mirror but from below and so reflects right, encountering O and printing.
At the end last atom meets final O to be destructed.


text:
Extract filename from path
Given a printable ASCII string representing a path to a file on a POSIX-compliant system, return just the filename, i.e. remove everything until and including the last slash (/):
/full/path/file.name.ext → file.name.ext
nopath.here → nopath.here
dir/.hidden → .hidden
/dirs.can/have.exts/file → file
./here → here
don't\do this → don't\do this

I‘m just curious to see how this is done in a variety of languages...ie whether there‘s any jumping through hoops or if is built-in. Can you suggest a better way to find that out?

There is this challenge, although not exactly a dupe.

Now, I doubt that there is any difference between this and the "what's the file extension" challenge, as they're just "shortest substring after a <'.' or '/', depends on the challenge".

@user202729 Right, I'm kind of awaiting it to be re-opened so I can dupe-hammer it.

QuadR, 4 bytes
Retina, 4 bytes
.*/

Try QuadR online!
Try Retina online!
Replace as many characters as possible, followed by a slash, with nothing.
Equivalent to the 9-byte Dyalog APL function '.*/'⎕R''.

Also works in Retina.

@Emigna Thanks, added.

Python 2, 41 27 25 bytes
lambda s:s.split('/')[-1]

Try it online!

05AB1E, 4 bytes
'/¡θ

Try it online!

Java (OpenJDK 9), 25 bytes
s->s.replaceAll(".*/","")

Try it online!
Honorable mention
26 bytes:
s->("/"+s).split(".*/")[1]

Red, 24 bytes
func[s][last split s"/"]

Try it online!
Red has a built-in split-path but it needs a path agrument and not a string.
f: func[p][last split-path to-file p]

Stax, 4 bytes
'//H

Run and debug online!
Explanation
Split on "/", take last part.

Wolfram Language (Mathematica), 12 bytes
A built-in.
FileNameTake

Try it online!

Haskell, 29 bytes
r.fst.span(/='/').r
r=reverse

Try it online!

Coconut, 19 bytes
n->n.split('/')[-1]

Try it online!


text:
Golf the Chinese 9*9 multiple table
Output the following table:
一一得一
一二得二 二二得四
一三得三 二三得六 三三得九
一四得四 二四得八 三四十二 四四十六
一五得五 二五一十 三五十五 四五二十 五五二十五
一六得六 二六十二 三六十八 四六二十四 五六三十 六六三十六
一七得七 二七十四 三七二十一 四七二十八 五七三十五 六七四十二 七七四十九
一八得八 二八十六 三八二十四 四八三十二 五八四十 六八四十八 七八五十六 八八六十四
一九得九 二九十八 三九二十七 四九三十六 五九四十五 六九五十四 七九六十三 八九七十二 九九八十一

Or you can use the first three letters in its English word, in case that some languages don't support Chinese characters:
OneOneGetOne
OneTwoGetTwo TwoTwoGetFou
OneThrGetThr TwoThrGetSix ThrThrGetNin
OneFouGetFou TwoFouGetEig ThrFouTenTwo FouFouTenSix
OneFivGetFiv TwoFivOneTen ThrFivTenFiv FouFivTwoTen FivFivTwoTenFiv
OneSixGetSix TwoSixTenTwo ThrSixTenEig FouSixTwoTenFou FivSixThrTen SixSixThrTenSix
OneSevGetSev TwoSevTenFou ThrSevTwoTenOne FouSevTwoTenEig FivSevThrTenFiv SixSevFouTenTwo SevSevFouTenNin
OneEigGetEig TwoEigTenSix ThrEigTwoTenFou FouEigThrTenTwo FivEigFouTen SixEigFouTenEig SevEigFivTenSix EigEigSixTenFou
OneNinGetNin TwoNinTenEig ThrNinTwoTenSev FouNinThrTenSix FivNinFouTenFiv SixNinFivTenFou SevNinSixTenThr EigNinSevTenTwo NinNinEigTenOne

You can output in any reasonable format, e.g. plain text separated with space/comma/tab and newline, 2D array where empty places are empty or don't exist (The 2*1 place is empty so there shouldn't be anything in the array).
Code golf, shortest code in bytes win. GBK encoding is allowed, where each Chinese character use 2 bytes.
Converting Table:

Character
Number

一
One

二
Two

三
Thr

四
Fou

五
Fiv

六
Six

七
Sev

八
Eig

九
Nin

十
Ten

得
Get

The rest seems fairly intuitive, but could you at least explain how 十 and 得 work?

得 is only used when the product is smaller than 10

ahhh, so if it is greater that 10 instead 得 we are supposed to use 十?

@LuisfelipeDejesusMunoz and [11,19] are special with a bare 十.

我能确认这是正确的。(Translation: I can confirm that this is correct)

It seems unfair to require a three-byte Roman string (four if you need a null terminator) in place of a two-byte Chinese character.

@David Richerby The roman output is a bit more expensive to fairten languages that are optimized for letters

Seems someone say "二五得十", and that's right but worse than "二五一十". Here "二五一十" is required

Why I learned 三五一十五 / 二八一十六 at school. I must attend a fake school. // Anyway, I can't recite it until maybe 4th grade. I just try to do a mental arithmetic adding, when I was asked to recite this....

I say "一五五 二五一十 三五十五 四五二十 五五廿五" all the "x十" is expressed with a single syllable when something followed

@tsh Same, I learned it that way as well.

Stax, 66 characters
9mYF"得一二三四五六七八九"cacy*~@ny@\p;11AH:b!n;A/X@]z?px'十z?p,A%sn@]z?' +qD

Number of bytes depends on the encoding used for Chinese characters.
Run and debug online!
Explanation
9mYF...D    Loop `n` times and print a newline after each loop, `n`=1..9

"..."cay*~@ny@\p
"..."c              Push the string and duplicate it
      ay            Fetch the outer loop variable
        *           Multiply with the inner loop variable
         ~          Move the product to input stack for later use
          @         Take character at the index specified by inner loop variable
           ny@      Take character at the index specified by outer loop variable
              \p    Print the two characters

;11AH:b!n;A/X@]z?p
;11AH:b!        ?p    Is the product not in range [11,20)?
                      Output (*) if true, (**) if false.
        n;A/X@        Character at the index of the "ten" digit of product
              ]       Convert character to string (*)
               z      Empty string (**)

x'十z?p,A%sn@]z?' +q
x'十z?p                Print "十" if the "ten" digit is non-zero, nothing otherwise
       ,A%sn@]z?       Get the character specified by the last digit if that digit is non-zero, empty string otherwise
                ' +q   Append a space and print

Alternative version (Stax 1.0.6), 59 bytes (by @recursive)
This uses a feature that is inspired by this challenge and is only included in Stax 1.0.6 which postdates the challenge.
éz░╖▐5à{│`9[mLùÜ•ëO╞îπl▼Γ─§╥|▒╛Δ◙Φµ'r╠eƒÿQ╫s♪Ω]£ï♪D3╚F◙δÿ%‼

The ASCII version is
9mX{x\_x*YA/]yA-y20<*!*+y9>A*+yA%]0-+"NT|,,t.%,p&()(!'^pq kzi !X6"!s@mJ

This version constructs the index array and then uses it to index the string of Chinese characters to avoid redundant stack operations (c,a,n) and multiple @s.
Explanation
9mX{...m    Loop `n` times and map `1..n` to a list of strings, `n`=1..9
        J   Join the strings with space and print with a newline

x\_x*YA/]yA-y20<*!*+y9>A*+yA%]0-+"..."!s@
x\                                           A pair: (inner loop variable, outer loop variable)
  _x*Y                                       Product of inner and outer loop variable
      A/                                     floor(product/10)
        ]                                    [floor(product/10)]
         yA-                                 Product does not equal 10
            y20<                             Product is less than 20
                *!                           `Nand` of them
                                             This is true (1) if the product is in the range {10}U[20,81]
                  *                          Repeat [floor(product/10)] this many times
                                             This results in itself if the predicate above is true, or empty array if it is false
                   +                         Add it to the list of [inner loop var, outer loop var]
                                             This list will be used to index the string "得一二三四五六七八九十"
                    y9>A*                    Evaluates to 10 if the product is larger than 9, 0 otherwise
                                             When indexed, they become "十" and "得", respectively
                         +                   Append to the list of indices
                          yA%                Product modulo 10
                             ]0-             [Product modulo 10] if that value is not zero, empty array otherwise
                                +            Append to the list of index
                                 "..."!      "得一二三四五六七八九十"
                                       s@    Index with constructed array

Stax 1.0.6 can do it in 59, but it postdates the challenge, so it isn't qualified IMO.

Worth mentioning anyway. It also obviously uses some optimization that is also available before 1.0.6.

I suspect there's still a decent amount of optimization room left in it, but I'm going to leave it alone for now.

@recursive Nowadays, newer programming languages that are not made purposefully for a question do not have to be marked ‘non competing’ (somebody link the meta post)

@StanStrum Here's the meta post

Python 3, 151 149 146 bytes
-3 bytes thanks to Rod.
l=" 一二三四五六七八九"
for i in range(1,10):print([l[j//i]+l[i]+('得',l[j//10][10<j<20:]+'十')[j>9]+l[j%10]for j in range(i,i*i+1,i)])

Try it online!

Just a small note, you could use zero-width space '\u200b' (+2 bytes) instead space for an exact output

Javascript, 190 bytes
(_="得一二三四五六七八九十")=>{for(i=1;i<10;i++){for(t="",v=0;v<i;t+=_[++v]+_[i]+[...(v*i+'')].map((a,b,c) => c.length>1&&b==0?(a>1?_[a]+'十':'十'):b==0?'得'+_[a]:_[a]).join``+' ');console.log(t)}}

a=(_=" 一二三四五六七八九")=>{for(i=1;i<10;i++){for(t="",v=0;v<i;t+=_[++v]+_[i]+[...(v*i+'')].map((a,b,c) => c.length>1&&b==0?(a>1||c[1]==0?_[a]+'十':'十'):b==0?'得'+_[a]:_[a]).join``+' ');console.log(t)}}
a()

@l4m2 Yes, i did not notice the difference when using 得

@FrownyFrog when is 10 is 一十 but when is 15 or 16 or any other number we omit 一?

@FrownyFrog Can you take a look now?

All fine, well done.

Try (_="得一二三四五六七八九十")=>eval("for(i=1;i<10;i++){for(t='',v=0;v<i;t+=_[++v]+_[i]+[...(v*i+'')].map((a,b,c)=>c.length>1&&b==0?(a>1?_[a]+'十':'十'):b==0?'得'+_[a]:_[a]).join\`+' ');t")`. I haven't looked too closely, but there are definitely some other things that you can golf.

Yabasic, 250 242 238 bytes
A basic answer with unicode characters?! What?
An anonymous function and declared helper function, c(n) that takes no input and outputs to STDOUT
For r=1To 9
For c=1To r
c(c)
c(r)
If!r*c>9Then?"得";Fi
c(r*c)
?" ";
Next
?
Next
Sub c(n)
s$="一二三四五六七八九"
If n>19Then?Mid$(s$,Int(n/10)*3-2,3);Fi
If n=10Then?"一";Fi
If n>9Then?"十";Fi
?Mid$(s$,Mod(n,10)*3-2,3);
End Sub

Try it online!

Ruby, 166 bytes
->{(1..9).map{|a|(1..a).map{|b|p=a*b;([b,a]+(p<10?[0,p]:p<11?[1,10]:p<20?[10,p%10]:[p/10,10]+(p%10<1?[]:[p%10]))).map{|d|"得一二三四五六七八九十"[d]}*""}}}

Try it online!
A lambda returning a 2D array of strings.
->{
  (1..9).map{|b|                  # b is the multiplier
    (1..b).map{|a|                # a is the multiplicand
      p=a*b;                      # p is the product
      (                           # We will build an array of indexes into a ref string:
        [a,b] + (                 #   The first two indexes will be a and b
        p<10 ? [0,p] :            #   Case 1: abGp (single digit sums)
        p<11 ? [1,10] :           #   Case 2: 251X (only happens once)
        p<20 ? [10,p%10] :        #   Case 3: abXd (12-18, d is the ones digit)
        [p/10,10]+(               #   (Cases 4 and 5 share a prefix)
          p%10<1 ? [] :           #   Case 4: abcX (20, 30, 40, c is the tens digit)
          [p%10]))                #   Case 5: abcXd (two-digit product, p = 10*c+d)
      ).map{|d|
        "得一二三四五六七八九十"[d] # Fetch the character for each index
      }*""                        # Join the characters into words
    }
  }
}

Python 3, 142 bytes
Structure is similar to ovs's 146 byte answer, but the middle terms work in a different way.
n=" 一二三四五六七八九"
for x in range(1,10):print([n[y//x]+n[x]+n[y//10][20>y!=10:]+'得十'[y>9]+n[y%10]for y in range(x,x*x+1,x)])

Try it online!
Explanation
The most interesting term is the term for the number of tens:
n[y//10][20>y!=10:]

Note that 20>y!=10 means 20 > y and y != 10, which is False when the number of tens should be included and True otherwise.
False has an integer value of 0 and True has an integer value of 1, so whereas n[y//10] is always one character long, the subscript [20>y!=10:] is equivalent to [0:1] (i.e. "the character") when the number of tens should be included and [1:1] (i.e. "no characters") otherwise.
The following term,
'得十'[y>9]

is easier to understand; note that:

The output for every result <= 9 should contain 得
The output for every result > 9 should contain 十
得 can be handled after the 'tens' term because the 'tens' term always evaluates to an empty string when there is a 得

Note on trailing spaces
The trailing spaces for multiples of ten stretch the specification slightly - as mentioned by rod, this could be made visually perfect by using a zero-width space, but then you would also have to unpack the arrays using print(*[...]) as the zero-width space is represented as a literal "\u200b" when printed in an array.

APL (Dyalog), 75 100 characters, 97 122 bytes
k t←' 一二三四五六七八九得十'10
∘.{⍺<⍵:''⋄(s=10)∨19<s←⍺×⍵:k[1+⍵⍺(⌊s÷t)11,t|s]⋄9<s:k[1+⍵⍺,11,t|s]⋄k[⍵⍺t s+1]}⍨⍳9

Try it online!

I'd love to improve it if the downvoter would tell what's wrong with it.

Oh, right, so for 11 to 19 inclusive the output should be 4 characters, with no 一

@FrownyFrog fixed

Python 3, 196 bytes
lambda c=' 一二三四五六七八九':[[c[j]+c[i]+[('得'+c[(i*j%10)]),((c[(int(i*j/10))]*((i*j>19)or(i*j==10)))+'十'+(c[i*j%10])*(i*j%10!=0))][i*j>9]for j in range(1,i+1)]for i in range(1,10)]

Try it online!

二五一十九 二六一十二 two kinds of wrong

@FrownyFrog fixed...

c[(i*j%10)] => c[i*j%10]?

Retina, 100 characters, 122 bytes

9*
_
$`_$n
_
$%`_$.%=
(_+)(.)
$.1,$2,$.($.1*$2*)
\B.
:$&
:0
:
1:\b
:
,(. )
,0$1
T`,d:`_得一二三四五六七八九十

Try it online! Explanation:

9*

Insert nine _s.
_
$`_$n

Expand to 9 rows of 1 to 9 _s.
_
$%`_$.%=

(note trailing space) Expand to 9 rows of 1 to i _s plus i as a digit.
(_+)(.)
$.1,$2,$.($.1*$2*)

Convert the _s to decimal and multiply by i.
\B.
:$&

Insert a : if the answer has two digits. This will become the ten character.
:0
:

Delete zero units.
1:\b
:

Delete the 1 from 1: unless it's 1:0 which had its zero removed.
,(. )
,0$1

Inser a 0 for single-digit answers; this will become the get character.
T`,d:`_得一二三四五六七八九十

Fix up all the characters.

JavaScript (Node.js), 141/130 bytes
(s=[...'得一二三四五六七八九'])=>s.map((A,i)=>s.map((B,j)=>i<j|!j?'':B+A+[s[(q=i*j)/10|-(q>11&q<19)]]+(q>9?'十':'')+[s[q%10||s]]))

Try it online!

Could you please remove the "UTF8" from header? It isn't necessary, but it tricks leaderboard scripts, making them think this answer is only 8 bytes long.

JavaScript, 190 bytes
(s="得一二三四五六七八九十",o="")=>eval(`for(i=1;i<10;i++){for(j=1;j<=i;j++){o+=s[j]+s[i]+(i*j<10?s[0]:i*j<11?s[1]+s[10]:i*j<20?s[10]:s[i*j/10|0]+s[10])+(i*j%10?s[i*j%10]:"")+" "}o+="\\n"}`)

I will try to golf this later.

Ruby, 136 bytes
Byte count in UTF-8, should be 128 bytes with Han characters counted as 2 instead of 3.
1.upto(9){|x|p (1..x).map{|y|[y,x,x*y/10,?X,x*y%10].join.sub(/(?<=0)X|1(?=X[1-9])|0$/,'').tr"0-9X","得一二三四五六七八九十"}}

Try it online!

Construct the strings from multipliers' and products' digits with
the latter separated by X as a placeholder for 十.
Do some regex fun to drop X for products <10, leading ones for "-teen" products, and trailing zeroes.
Translate digits and X to Han characters.

///, 301 bytes (GBK*)
/*/\/\///1/一*2/二*3/三*4/四*5/五*6/六*7/七*8/八*9/九*0/十*=/得*I/
1*t/ 2*T/ 3/11=1I2=2t2=4I3=3t3=6T3=9I4=4t4=8T402 4406I5=5t510T505 4520 55205I6=6t602T608 46204 5630 66306I7=7t704T7201 47208 57305 67402 77409I8=8t806T8204 48302 5840 68408 78506 88604I9=9t908T9207 49306 59405 69504 79603 89702 99801

Try it online!
*Spec explicitly allows GBK → Unicode conversion.

Pyth, 49 characters, 71 bytes
J" 一二三四五六七八九"jmj;m+s@LJkr6>3+\得j\十@LJj*FkT,RdSdS9

Uses UTF-8 encoding. Try it online here.
In the following explanation, the ? characters are substitutes for the correct Chinese characters - I'm too lazy to make everything line up properly...
J" ?????????"jmj;m+s@LJkr6>3+\?j\?@LJj*FkT,RdSdS9
J" ?????????"                                       Assign space + glyphs for 1-9 to J
                                               S9   [1-9]
              m                                     Map each element, as d, using:
                                             Sd       [1-d]
                                          ,Rd         Pair each element of the above with d
                                                        e.g. for d=3, yields [[1,3],[2,3],[3,3]]
                 m                                    Map each element, as k, using:
                                      *Fk               Get the product of the pair
                                     j   T              Get decimal digits of the above (convert to base 10)
                                  @LJ                   Map each digit to its index in J
                               j\?                      Join the above on ? ("Ten")
                            +\?                         Prepend ? ("Get")
                          >3                            Take the last 3 characters of the above
                        r6                              Strip whitespace
                  +                                     Prepend to the above...
                   s@LJk                                Concatenated digits of k in lookup string
               j;                                     Join result on spaces
             j                                      Join result on newlines, implicit print

Deadfish~, 5210 bytes
{{i}dd}dc{iii}ic{d}ic{dd}ddc{iii}ic{d}ic{ddd}c{iii}c{i}iiiiic{dddd}iiic{iii}ic{d}ic{{d}i}dc{{i}ddd}dc{iii}ic{d}ic{dd}iiic{iii}iiiiic{d}iic{dddd}c{iii}c{i}iiiiic{ddd}ddc{iii}iiiiic{d}iic{{d}ii}ic{iiiii}iic{iii}iiiiic{d}iic{ddd}iiic{iii}iiiiic{d}iic{dddd}c{iii}c{i}iiiiic{dddd}ddddddc{iiii}iciiiiiic{{d}}{d}iiic{{i}ddd}dc{iii}ic{d}ic{dd}iiic{ii}c{i}c{dddd}dddc{iii}c{i}iiiiic{ddd}ddc{ii}c{i}c{{d}ii}ddc{iiiii}iic{iii}iiiiic{d}iic{ddd}iiic{ii}c{i}c{dddd}dddc{iii}c{i}iiiiic{ddd}dddc{ii}iic{i}iiiiic{{d}i}iic{iiiii}iic{ii}c{i}c{ddd}c{ii}c{i}c{dddd}dddc{iii}c{i}iiiiic{dddd}iic{iii}dddciiiiic{{d}}c{{i}ddd}dc{iii}ic{d}ic{ddd}dc{iiii}iciiiiiic{dddd}ddddddc{iii}c{i}iiiiic{dddd}ddddddc{iiii}iciiiiiic{{d}ii}dddddc{iiiii}iic{iii}iiiiic{d}iic{dddd}dc{iiii}iciiiiiic{dddd}ddddddc{iii}c{i}iiiiic{ddddd}iiic{iii}iiiiiicddc{{d}iii}dc{iiiii}iic{ii}c{i}c{dddd}ddddc{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{dd}ddddddc{iii}iiiiic{d}iic{{d}ii}ic{iiii}ddc{iiii}iciiiiiic{ddddd}iiic{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{ddd}iiic{ii}iic{i}iiiiic{{d}}{d}c{{i}ddd}dc{iii}ic{d}ic{ddd}dc{iii}iiiiic{i}iiic{ddddd}iiic{iii}c{i}iiiiic{dddd}ddddddc{iii}iiiiic{i}iiic{{d}ii}ddddddc{iiiii}iic{iii}iiiiic{d}iic{dddd}dc{iii}iiiiic{i}iiic{dddd}ic{iii}ic{d}ic{dd}iiic{ii}dddc{i}dc{{d}ii}iic{iiiii}iic{ii}c{i}c{dddd}ddddc{iii}iiiiic{i}iiic{ddd}ddddc{ii}dddc{i}dc{dddd}c{iii}iiiiic{i}iiic{{d}ii}ddddddc{iiii}ddc{iiii}iciiiiiic{ddddd}iiic{iii}iiiiic{i}iiic{ddd}ddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{{d}ii}iic{iiii}ddc{iii}iiiiic{i}iiic{ddddd}iic{iii}iiiiic{i}iiic{ddd}ddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{dddd}c{iii}iiiiic{i}iiic{{d}}{d}iic{{i}ddd}dc{iii}ic{d}ic{dd}iic{ii}iic{i}iiiiic{ddddd}ic{iii}c{i}iiiiic{ddd}dddc{ii}iic{i}iiiiic{{d}i}iic{iiiii}iic{iii}iiiiic{d}iic{ddd}iic{ii}iic{i}iiiiic{ddd}ddddddc{ii}dddc{i}dc{dd}ddddddc{iii}iiiiic{d}iic{{d}ii}ic{iiiii}iic{ii}c{i}c{ddd}dc{ii}iic{i}iiiiic{ddd}ddddddc{ii}dddc{i}dc{dddd}dc{iii}iiiiiicddc{{d}iii}dc{iiii}ddc{iiii}iciiiiiic{ddd}ddddc{ii}iic{i}iiiiic{ddd}ddddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{dddd}c{iiii}iciiiiiic{{d}ii}dddddc{iiii}ddc{iii}iiiiic{i}iiic{ddd}dddddc{ii}iic{i}iiiiic{ddd}ddddddc{ii}c{i}c{ddd}c{ii}dddc{i}dc{{d}ii}iic{iiiii}ic{ii}iic{i}iiiiic{dddd}iiic{ii}iic{i}iiiiic{ddd}ddddddc{ii}c{i}c{ddd}c{ii}dddc{i}dc{ddd}iiic{ii}iic{i}iiiiic{{d}}{d}c{{i}ddd}dc{iii}ic{d}ic{dd}iic{ii}ddc{ii}dddc{ddddd}iiic{iii}c{i}iiiiic{ddd}dddc{ii}ddc{ii}dddc{{d}ii}ddddddc{iiiii}iic{iii}iiiiic{d}iic{ddd}iic{ii}ddc{ii}dddc{ddd}ddddc{ii}dddc{i}dc{dddd}c{iiii}iciiiiiic{{d}ii}dddddc{iiiii}iic{ii}c{i}c{ddd}dc{ii}ddc{ii}dddc{ddd}ddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{ddd}dc{iii}ic{d}ic{{d}iii}ic{iiii}ddc{iiii}iciiiiiic{ddd}ddddc{ii}ddc{ii}dddc{ddd}ddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{dddd}dc{iii}iiiiiicddc{{d}iii}dc{iiii}ddc{iii}iiiiic{i}iiic{ddd}dddddc{ii}ddc{ii}dddc{ddd}ddddc{ii}c{i}c{ddd}c{ii}dddc{i}dc{dddd}c{iii}iiiiic{i}iiic{{d}ii}ddddddc{iiiii}ic{ii}iic{i}iiiiic{dddd}iiic{ii}ddc{ii}dddc{ddddd}iic{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{dd}ddddddc{iii}iiiiic{d}iic{{d}ii}ic{iiiii}ic{ii}ddc{ii}dddc{ddd}dddddc{ii}ddc{ii}dddc{ddddd}iic{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{ddd}ddc{iii}dddciiiiic{{d}}c{{i}ddd}dc{iii}ic{d}ic{ddd}ddc{iii}iiiiiicddc{ddd}ddc{iii}c{i}iiiiic{ddddd}iiic{iii}iiiiiicddc{{d}iii}dc{iiiii}iic{iii}iiiiic{d}iic{dddd}ddc{iii}iiiiiicddc{dd}ic{ii}dddc{i}dc{ddd}iiic{ii}iic{i}iiiiic{{d}i}iic{iiiii}iic{ii}c{i}c{dddd}dddddc{iii}iiiiiicddc{dd}ic{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{dddd}c{iiii}iciiiiiic{{d}ii}dddddc{iiii}ddc{iiii}iciiiiiic{ddddd}iic{iii}iiiiiicddc{dd}ic{ii}c{i}c{ddd}c{ii}dddc{i}dc{dd}ddddddc{iii}iiiiic{d}iic{{d}ii}ic{iiii}ddc{iii}iiiiic{i}iiic{ddddd}ic{iii}iiiiiicddc{ddd}dddc{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{{d}ii}iic{iiiii}ic{ii}iic{i}iiiiic{ddddd}dc{iii}iiiiiicddc{ddd}dddc{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{dddd}dc{iii}iiiiiicddc{{d}iii}dc{iiiii}ic{ii}ddc{ii}dddc{ddddd}ic{iii}iiiiiicddc{ddd}dddc{iii}iiiiic{i}iiic{ddd}ddddc{ii}dddc{i}dc{ddd}iiic{ii}iic{i}iiiiic{{d}i}iic{iiii}dddc{iii}iiiiiicddc{ddd}ddddc{iii}iiiiiicddc{dd}c{ii}iic{i}iiiiic{ddd}ddddddc{ii}dddc{i}dc{dddd}c{iiii}iciiiiiic{{d}}{d}iiic{{i}ddd}dc{iii}ic{d}ic{dd}dddc{iii}dddciiiiic{dddd}ic{iii}c{i}iiiiic{dddd}iic{iii}dddciiiiic{{d}ii}iic{iiiii}iic{iii}iiiiic{d}iic{ddd}dddc{iii}dddciiiiic{dd}ddddddc{ii}dddc{i}dc{dddd}dc{iii}iiiiiicddc{{d}iii}dc{iiiii}iic{ii}c{i}c{ddd}ddddddc{iii}dddciiiiic{dd}ddddddc{iii}iiiiic{d}iic{ddd}iiic{ii}dddc{i}dc{ddd}iiic{ii}ddc{ii}dddc{{d}ii}ddddddc{iiii}ddc{iiii}iciiiiiic{dddd}ic{iii}dddciiiiic{dd}ddddddc{ii}c{i}c{ddd}c{ii}dddc{i}dc{ddd}iiic{ii}iic{i}iiiiic{{d}i}iic{iiii}ddc{iii}iiiiic{i}iiic{dddd}c{iii}dddciiiiic{dddd}c{iiii}iciiiiiic{ddd}dddc{ii}dddc{i}dc{dddd}c{iii}iiiiic{i}iiic{{d}ii}ddddddc{iiiii}ic{ii}iic{i}iiiiic{dddd}ddc{iii}dddciiiiic{dddd}c{iii}iiiiic{i}iiic{ddd}ddddc{ii}dddc{i}dc{dddd}c{iiii}iciiiiiic{{d}ii}dddddc{iiiii}ic{ii}ddc{ii}dddc{dddd}c{iii}dddciiiiic{ddd}iiic{ii}iic{i}iiiiic{ddd}ddddddc{ii}dddc{i}dc{dd}ddddddc{ii}c{i}c{{d}ii}ddc{iiii}dddc{iii}iiiiiicddc{dd}dddddc{iii}dddciiiiic{ddd}iiic{ii}ddc{ii}dddc{ddd}ddddc{ii}dddc{i}dc{dd}ddddddc{iii}iiiiic{d}iic{{d}ii}ic{iiii}iiiiiic{iii}dddciiiiic{ddd}ddc{iii}dddciiiiic{dddd}dc{iii}iiiiiicddc{dd}ic{ii}dddc{i}dc{ddd}dc{iii}ic{d}ic{{d}i}dc

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