# Print this maximally long URL

## Python 3, ^{86 \$\cdots\$ 81} 77 bytes

Saved 3 bytes thanks to mypetlion!!!

Saved 4 bytes thanks to Shieru Asakoto!!!

```
print(f"http://{'.'.join(chr(i+97)*int(1+.7**-i/120)for i in range(26))}.me")
```

Try it online!

Uses Shieru Asakoto's 0-based formula.

## APL (Dyalog), ~~41~~ 38 bytes

*-3 bytes thanks to Bubbler*

```
2⌽'mehttp://',∊'.',¨⍨⎕A⍴¨⍨⌊1+62×.7*⍒⎕A
```

Try it online!

Outputs the URL with the letters capitalised. Uses the 0 indexed formula \$ \lfloor 1 + 62 \times 0.7^{25-x} \rfloor \$, since \$ (\frac{10}{7})^{x-25} = ((\frac{7}{10})^{-1})^{x-25} = (\frac{7}{10})^{25-x}\$

### Explanation:

```
2⌽ ⍝ Rotate by two places (moving the 'me' to the end)
'mehttp://' ⍝ The start string
, ⍝ Followed by
∊ ⍝ The flattened string of
'.' ⍝ A period
,⍨¨ ⍝ Appended to the end of each of
⎕A ⍝ The uppercase alphabet
⍴¨⍨ ⍝ Where each letter is repeated by
⌊ ⍝ The floor of
1+ ⍝ 1 plus
62× ⍝ 62 times
.7* ⍝ 0.7 to the power of
⍒⎕A ⍝ The range 26 to 1
```

## 05AB1E, ~~25~~ ~~24~~ ~~23~~ 21 bytes

```
žXAS.7Ƶ-t∞-m>×….me¬ýJ
```

-1 byte thanks to *@Neil*'s analysis that `*(10/7)**`

is the same as `/.7**`

.

-3 bytes thanks to *@Grimmy* using a different formula and ingenious use of `ý`

!

Try it online.

**Explanation:**

The formula used to get the correct amount of characters of the alphabet, where \$n\$ is the 1-based index of the alphabetic letter:

\$a(n) = \left\lfloor0.7^{(\sqrt{208}-n)}+1\right\rfloor\$

```
žX # Push builtin "http://"
Ƶ- # Push compressed 208
t # Take the square-root of that: 14.422...
∞ # Push an infinite list of positive integers: [1,2,3,...]
- # Subtract each from the 14.422...: [13.442...,12.442...,...]
.7 m # Take 0.7 to the power of each of these: [0.008...,0.011...,...]
> # Increase each by 1: [1.008...,1.011...,...]
AS # Push the lowercase alphabet as list of characters,
× # and repeat each the calculated values amount of times as string
# (which implicitly truncates the floats to integers, and ignores
# the floats beyond the length of the alphabet)
….me # Push ".me"
¬ # Push its head (the "."), without popping the ".me" itself
ý # Join with delimiter. Normally it will use the top value as
# delimiter and joins the top-1'th list. In this case however, the
# top-1'th item is a string, so instead it will join the entire stack
# together. BUT, because the stack contains a list, it will instead
# only join all lists on the stacks by the "." delimiter
J # And finally join the three strings on the stack together
# (after which this result is output implicitly)
```

See this 05AB1E tip of mine (section *How to compress large integers?*) to understand why `Ƶ-`

is `208`

.