title: Put together a Senate majority

text:
# Question
Title: Put together a Senate majority
There are one hundred members of the United States Senate. Assuming that nobody filibusters and that the Vice President isn't cooperating, at least fifty-one members are necessary to pass a bill. But some members work together better than others, entropy-wise.

Your task: Output the last names of at least 51 of the US senators at the time this question was posted in 2017. *Any* 51 are acceptable; put together a Cruz-Sanders coalition if you'd like. The names may be output in any order.

The full list is as follows (note that Van Hollen is one person):

> Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker, Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey, Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto, Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst, Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham, Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono, Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar, Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell, Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul, Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders, Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange, Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner, Warren, Whitehouse, Wicker, Wyden, Young

Querying Wolfram Alpha (or any other database of senators) is specifically disallowed. Anything else is fair game; use gzip as a language if you'd like.

# Answer
# Bubblegum, ~~165~~ ~~164~~ ~~163~~ ~~162~~ ~~161~~ 160 bytes

```
00000000: 1dc6 410a 0231 0c00 c0bf b50a c22a 880a  ..A..1.......*..
00000010: e231 b4c1 0697 6449 5aa5 bede c4cb 303b  .1....dIZ.....0;
00000020: 2046 5bc2 5b1b 0ead 2b59 5a07 f72c 5eb6   F[.[...+YZ..,^.
00000030: bdb2 f9c5 c75f 4ac8 8c7d 09eb cc60 1818  ....._J..}...`..
00000040: c5b5 12bb 1bea a964 886f d425 2b6c cef8  .......d.o.%+l..
00000050: 5e4b 83ee 4aef 49e5 c3d9 23ae f20c 5fa8  ^K..J.I...#..._.
00000060: f759 9193 4894 4a08 ca7f 15f9 e092 1d04  .Y..H.J.........
00000070: df71 3370 7b69 572f 5ec8 625c 51ed 8c3d  .q3p{iW/^.b\Q..=
00000080: 84b1 ded0 bc59 4a53 e093 0443 1566 727d  .....YJS...C.fr}
00000090: 5b9b 4784 0017 e2e7 05b1 3e64 789c 6a3f  [.G.......>dx.j?

```

Try it online!

### Output

> DainesKaineThuneTillisBluntCollinsErnstCoonsEnziBennetKennedyCaseyCassidyCardinCarperMcCainCapitoCrapoCruzSchatzScottBrownCottonCornynCorkerWydenBookerWickerWarnerWarrenHarrisHoevenHassanHatchSasseRischSandersPetersPaulTesterCochranMoranMurrayBurrMurphyLeahyLeeKingReedYoungRounds

### How I generated this

Previous versions were generated by simulated annealing, but now I’ve switched strategies to late acceptance hill-climbing. I’m not sure whether it’s fundamentally better or I just got luckier this time, but I do appreciate that LAHC has fewer parameters to tweak to get good results.

```
from __future__ import print_function
import random
import zlib

try: range = xrange
except NameError: pass

senators = b'Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker, Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey, Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto, Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst, Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham, Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono, Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar, Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell, Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul, Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders, Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange, Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner, Warren, Whitehouse, Wicker, Wyden, Young'.split(b', ')
assert len(senators) == 100

random.shuffle(senators)
score = 9999
best = score
recent = 65536 * [score]
recent_index = 0

while True:
    old_score = score
    step = random.randrange(2)
    if step == 0:
        i, j = 100, 100
        while i >= 51 and j >= 51:
            i, j = random.sample(range(100), 2)
        senators[i], senators[j] = senators[j], senators[i]
    else:
        i, j, k = 100, 100, 100
        while i >= 51:
            i, j, k = sorted(random.sample(range(101), 3))
        senators[i:k] = senators[j:k] + senators[i:j]

    bound = max(old_score, recent[recent_index])

    z = zlib.compressobj(9, zlib.DEFLATED, -zlib.MAX_WBITS, 9)
    sin = b''.join(senators[:51])
    sout = bytearray(z.compress(sin) + z.flush())
    score = len(sout) * 8
    if score - 7 <= bound:
        for bit in range(7):
            sout[-1] ^= 128 >> bit
            try:
                if zlib.decompress(bytes(sout), -zlib.MAX_WBITS) == sin:
                    score -= 1
                else:
                    break
            except zlib.error:
                break

    if score > bound:
        if step == 0:
            senators[i], senators[j] = senators[j], senators[i]
        else:
            j = i + k - j
            senators[i:k] = senators[j:k] + senators[i:j]
        score = old_score
    elif score < recent[recent_index]:
        recent[recent_index] = score
        if score < best:
            best = score
            print(score, b''.join(senators[:51]).decode())
    recent_index = (recent_index + 1) % len(recent)

```
> 32 votes

# Answer
# Jelly, 128 bytes

```
“¡e:©*ḲṣṛḷYx½NḢṀPtU9'*KṪmbpƊæ n¥×Ƭḥ0mṀC%kçaḶw'øȤ€ðzṬ¢Ỵi⁷ṅọTṛỵṙḳAf"Zƙ~^RỊṙ.Jþ°ọṄ2l+ṇ=×ıƓ:ẊƒmJJḂs}ẹ~ɗƲ³£ɓȤɗƘṪruzṂµẈ+Ç9ḋ4^(ḤạFƑỤʠ>»

```

A niladic link returning a list of characters - the names (with spaces between since it's shorter):

```
Alexander Baldwin Bennet Blunt Booker Brown Burr Cardin Carper Casey Cochran Corker Cotton Crapo Cruz Durbin Ernst Fischer Flake Gardner Graham Harris Hatch Heinrich Heller Johnson Kennedy King Lee McCain McCaskill McConnell Moran Murphy Murray Nelson Paul Perdue Portman Reed Sanders Sasse Scott Shelby Strange Sullivan Tester Udall Warner Warren Whitehouse

```

**Try it online!**

### How?

Boring - 53 of the names are dictionary entries (the unused ones here being `Wicker` and `Young`), so all of the code is a single compressed string using those dictionary entries. Maybe something clever could make for less bytes, but probably not (`brownlee` is in the dictionary, but manipulating the result to capitalise the `L` & add the space to keep format will cost more that the saving of 2 bytes).
> 15 votes

# Answer
# SOGL V0.12, ~~118~~ 117 bytes

```
│▲S⁹@^V'/¾Π;○ccΠæ▒¡$λ‼⌠Æķ□~─┼∑>°⅔′κļ    ≥Y#⁄◄‰Νļ┘Υp\¹øDK%◄ρhpš,ιPΖοh≠wΜø⅞ƨω6Η√⁶┌B∞žΤΟ⅜Γ\=M»⁶»□⁽ø⁴┌¦nč+ÆB(k° Π→→∙Æ═'x¹ξ‘ū

```

Note that that code has tabs, so Try it Here!

I was *extremely* lucky that in the SOGL english dictionary *exactly* 51 names existed :o

The program is almost all (`.....‘`) a compressed string, and as SOGLs dictionary only has lowercase words, ū uppercases each words first letter.

-1 byte by rearranging the names
> 13 votes

# Answer
# ;#, 28571 bytes

```
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

```

Try it online!

Everyone's favourite antigolfing language! As ;# is a subset of ;#+, the TIO can be used.
> 11 votes

# Answer
# Bash, 277 bytes

```
echo LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds

```

Just a simple solution to get things started :)

Try it online!
> 9 votes

# Answer
# Bubblegum, 194 193 bytes

```
0000000: 1d4e cb4e c330 10fc b7b8 05a3 36a8 4a41  .N.N.0......6.JA
0000010: 88e3 361e 6aab 6636 5adb 20f7 eb71 b9cc  ..6.j.f6Z. ..q..
0000020: 61de 4760 6a66 ceda 7dcf 7b3a 245e 4fd2  a.G`jf..}.{:$^O.
0000030: f202 8429 37d6 c9f4 974e 0aba 5365 7126  ...)7....N..Seq&
0000040: 9bee 8da5 3e65 b9c1 4b5d e341 1271 84c4  ....>e..K].A.q..
0000050: 3eab 0997 54d6 b8b4 4bd2 b394 82f3 aab5  >...T...K.......
0000060: bec5 46bc 07c9 f9a3 07f0 531b af13 48d4  ..F.......S...H.
0000070: 49f5 0673 b2a5 aa4e 2ca4 3166 db60 d46e  I..s...N,.1f.`.n
0000080: ffc8 4e37 1a94 bbc7 4cd9 35bb 243e 9b44  ..N7....L.5.$>.D
0000090: f9f6 6296 8a47 ceb0 5986 bffb 644a 5d46  ..b..G..Y...dJ]F
00000a0: 7d28 73b3 6d5c 5add c8bd 30ea 174e b0d0  }(s.m\Z...0..N..
00000b0: 0656 d843 35e9 7e3c 147a c50f f88a 5c94  .V.C5.~<.z....\.
00000c0: 7f                                       .

```

Try it online!

This answer currently works, but I will likely post a shorter version later seeing as I currently have a Python script running to generate these.

### Python Script (using 3<sup>rd</sup> party library `hexdump`)

```
from itertools import permutations
from hexdump import hexdump
import zlib

senators = ['Lee', 'Burr', 'Cruz', 'Enzi', 'King', 'Paul', 'Reed', 'Blunt', 'Brown', 'Casey', 'Coons', 'Crapo', 'Ernst', 'Flake', 'Hatch', 'Kaine', 'Leahy', 'Moran', 'Risch', 'Rubio', 'Sasse', 'Scott', 'Thune', 'Udall', 'Wyden', 'Young', 'Bennet', 'Booker', 'Capito', 'Cardin', 'Carper', 'Corker', 'Cornyn', 'Cotton', 'Daines', 'Durbin', 'Graham', 'Harris', 'Hassan', 'Heller', 'Hirono', 'Hoeven', 'Inhofe', 'Markey', 'McCain', 'Murphy', 'Murray', 'Nelson', 'Perdue', 'Peters', 'Rounds']
min_length = 1000
for perm in permutations(senators):
    z = zlib.compressobj(level=9, wbits=-15)
    z.compress("".join(perm).encode())
    compressed = z.flush()
    length = len(compressed)
    if length < min_length:
         min_length = length
         best = compressed
         hexdump(best)
         print("Length:", length)
         file = open("bub_out.txt", "bw")
         file.write(best)
         file.close()

print(best)

```
> 7 votes

# Answer
# Python 2, ~~329~~ 279 bytes

-50 bytes Thanks @caird coinheringaahing: \[avoid the delimiter-spaces\]

```
print'LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds'

```

Try it online!

### String Generated by this program(get list from the data string, sort the strings by length, take first 51 elements, join)

```
a='Alexander, Baldwin, Barrasso, Bennet, Blumenthal, Blunt, Booker, Boozman, Brown, Burr, Cantwell, Capito, Cardin, Carper, Casey, Cassidy, Cochran, Collins, Coons, Corker, Cornyn, Cortez Masto, Cotton, Crapo, Cruz, Daines, Donnelly, Duckworth, Durbin, Enzi, Ernst, Feinstein, Fischer, Flake, Franken, Gardner, Gillibrand, Graham, Grassley, Harris, Hassan, Hatch, Heinrich, Heitkamp, Heller, Hirono, Hoeven, Inhofe, Isakson, Johnson, Kaine, Kennedy, King, Klobuchar, Lankford, Leahy, Lee, Manchin, Markey, McCain, McCaskill, McConnell, Menendez, Merkley, Moran, Murkowski, Murphy, Murray, Nelson, Paul, Perdue, Peters, Portman, Reed, Risch, Roberts, Rounds, Rubio, Sanders, Sasse, Schatz, Schumer, Scott, Shaheen, Shelby, Stabenow, Strange, Sullivan, Tester, Thune, Tillis, Toomey, Udall, Van Hollen, Warner, Warren, Whitehouse, Wicker, Wyden, Young'.split(', ')
a.sort(key=lambda x:len(x))
print(''.join(a[:51]))

```

Try it online!
> 3 votes

# Answer
# PHP, 270 bytes

```
<?=strtr(K3gLeeBurrC5d3C5p0Co7sCruzEnziHat6He40Ka3eM163Mor1PaulReedRis6Uda4W5n0W5r2Wyd2B2netBluntBook0BrownCaseyCo6r1Co43sCork0Cott7CrapoDa3esDurb3ErnstFis60FlakeFr1k2G5dn0H5risHass1Hir7oHoev2LeahyM5keyMcCa3Nels7P0duePet0sRubioS1d0sSasseS6atz,[er,an,en,in,ll,ar,ch,on]);

```

Try it online!

# PHP, 270 bytes

```
<?=strtr(H02K4gLeeS0eBurrC6d4C6p1Co8sCruzEnziHat7He51Ka4eM274Mor2PaulReedRis7Uda5W6n1W6r3Wyd3B6r0oB3netBluntBook1BrownCaseyC0idyCo7r2Co54sCork1Cott8CrapoDa4esDurb4ErnstFis71FlakeFr2k3G6dn1H6risHir8oHoev3LeahyM6keyMcCa4Nels8P1duePet1sRubio,[ass,er,an,en,in,ll,ar,ch,on]);

```

Try it online!
> 3 votes

# Answer
# Add++, 2131 bytes

```
+76
&
+25
&
&
-57
&
-12
&
+34
&
+51
&
-3
&
&
-70
&
-12
&
+35
&
+47
&
+3
&
+5
&
-78
&
-12
&
+37
&
+41
&
+12
&
-17
&
-61
&
-12
&
+43
&
+30
&
+5
&
-7
&
-59
&
-12
&
+48
&
+17
&
+20
&
-9
&
-64
&
-12
&
+50
&
+19
&
&
-1
&
-56
&
-12
&
+34
&
+42
&
+9
&
-7
&
+6
&
-72
&
-12
&
+34
&
+48
&
-3
&
+8
&
-9
&
-66
&
-12
&
+35
&
+30
&
+18
&
-14
&
+20
&
-77
&
-12
&
+35
&
+44
&
&
-1
&
+5
&
-71
&
-12
&
+35
&
+47
&
-17
&
+15
&
-1
&
-67
&
-12
&
+37
&
+45
&
-4
&
+5
&
+1
&
-72
&
-12
&
+38
&
+38
&
-11
&
+10
&
-6
&
-57
&
-12
&
+40
&
+25
&
+19
&
-17
&
+5
&
-60
&
-12
&
+43
&
+22
&
+8
&
+5
&
-9
&
-57
&
-12
&
+44
&
+25
&
-4
&
+7
&
+17
&
-77
&
-12
&
+45
&
+34
&
+3
&
-17
&
+13
&
-66
&
-12
&
+50
&
+23
&
+10
&
-16
&
+5
&
-60
&
-12
&
+50
&
+35
&
-19
&
+7
&
+6
&
-67
&
-12
&
+51
&
+14
&
+18
&
&
-14
&
-57
&
-12
&
+51
&
+16
&
+12
&
+5
&
&
-72
&
-12
&
+52
&
+20
&
+13
&
-7
&
-9
&
-57
&
-12
&
+53
&
+15
&
-3
&
+11
&
&
-64
&
-12
&
+55
&
+34
&
-21
&
+1
&
+9
&
-66
&
-12
&
+57
&
+22
&
+6
&
-7
&
-7
&
-59
&
-12
&
+34
&
+35
&
+9
&
&
-9
&
+15
&
-72
&
-12
&
+34
&
+45
&
&
-4
&
-6
&
+13
&
-70
&
-12
&
+35
&
+30
&
+15
&
-7
&
+11
&
-5
&
-67
&
-12
&
+35
&
+30
&
+17
&
-14
&
+5
&
+5
&
-66
&
-12
&
+35
&
+30
&
+17
&
-2
&
-11
&
+13
&
-70
&
-12
&
+35
&
+44
&
+3
&
-7
&
-6
&
+13
&
-70
&
-12
&
+35
&
+44
&
+3
&
-4
&
+11
&
-11
&
-66
&
-12
&
+35
&
+44
&
+5
&
&
-5
&
-1
&
-66
&
-12
&
+36
&
+29
&
+8
&
+5
&
-9
&
+14
&
-71
&
-12
&
+36
&
+49
&
-3
&
-16
&
+7
&
+5
&
-66
&
-12
&
+39
&
+43
&
-17
&
+7
&
-7
&
+12
&
-65
&
-12
&
+40
&
+25
&
+17
&
&
-9
&
+10
&
-71
&
-12
&
+40
&
+25
&
+18
&
&
-18
&
+13
&
-66
&
-12
&
+40
&
+29
&
+7
&
&
-7
&
+13
&
-70
&
-12
&
+40
&
+33
&
+9
&
-3
&
-1
&
+1
&
-67
&
-12
&
+40
&
+39
&
-10
&
+17
&
-17
&
+9
&
-66
&
-12
&
+41
&
+37
&
-6
&
+7
&
-9
&
-1
&
-57
&
-12
&
+45
&
+20
&
+17
&
-7
&
-6
&
+20
&
-77
&
-12
&
+45
&
+22
&
-32
&
+30
&
+8
&
+5
&
-66
&
-12
&
+45
&
+40
&
-3
&
-2
&
-8
&
+17
&
-77
&
-12
&
+45
&
+40
&
-3
&
&
-17
&
+24
&
-77
&
-12
&
+46
&
+23
&
+7
&
+7
&
-4
&
-1
&
-66
&
-12
&
+48
&
+21
&
+13
&
-14
&
+17
&
-16
&
-57
&
-12
&
+48
&
+21
&
+15
&
-15
&
+13
&
+1
&
-71
&
-12
&
+50
&
+29
&
+6
&
-7
&
-10
&
+15
&
-71
&
-12
&
+51
&
+16
&
+5
&
-7
&
+19
&
+6
&
P

```

Try it online!

I love hardcoding these! They are so fun!

Each line is either `[+-]\d+`, `&` or `P`.

* `&` adds the char in the accumulator to the output string, without outputting.
* `P` prints the output string
* Numbers add or subtract that value from the accumulator
> 1 votes

# Answer
# 05AB1E, 455 bytes (all 100, I misread)

Im more excited about this challenge now and will indeed fix this in time.

```
.•вÏ–lāä˜(~Îíˆ^ÅËð3µpñ»ú¶›;β›vGĀ½W PToÚ+ćLöт'Ç@qu¿>ßH3^eoèL«Oт©zβü)Åëîƶ¿n77¯Þ»øδëΩŽÐ∊ÿ–R9ÑÄÿÂMD∊Ê'Ƶ~°Aº≠₄›Š∞"Óн=Üg2Ua‘èǝʒ·ªd±{-wγrWÉ₃§¯Ωnι“âÝvγ+ŸõÊ×|Ù¨LòΛÍ_Ð®\‡,–Ç+Q^ú€ÉƵÙD“≠ŒC½ŒÉÃ₅Ç^þ:†ÆÜãôвΩæĀîAìëƵôÄê“¬{/¯ÐaĆXõ₅ñγÃµ¶P\¹oÓΣθºõ®5ù@ïwÛ-þoÅÇóÌ»"ηÆ!PÑ₅§₆úñ©C½[RV7Y#:ìÎmÓžĆº´aΩ. ªƶтñΔo
H!®àrα¤´¢gËZLβθŽ#§ƶl¸±0ª©öδgYÃÀQ1œuYÎ₂Ä¾éï¶çÉsžÏT®é®§šŒE[7èœ~Õм-4UÃн₄Î^Rs›k€’(∞S₃˜\‘½ÊÀsΣǝP¶²Ï4oÍ‘Δýε¿(†Û)ŽαΔ…p§¼móe,k£í¥‡8(ÖöÍDÒ₆OÅÇ0vÆÖΩ¼ì>^ŸćrʒðĆтÄε%D™¶ÞZ®=4¦?µ×•'q¡„, ý™

```

Try it online!

---

Here's a boring answer, but base compression and complex methods in 05AB1E won't cut it for how random this is... I tried a more scientific approach:

```
[['j', 1], ['x', 1], [' ', 2], ['v', 3], ['f', 6], ['z', 6], ['g', 7], ['p', 9], ['w', 11], ['y', 15], ['b', 16], ['k', 18], ['d', 19], ['m', 19], ['u', 20], ['t', 28], ['h', 31], ['c', 33], ['i', 33], ['l', 37], ['s', 43], ['o', 44], ['a', 53], ['r', 59], ['n', 65], ['e', 69], [',', 99]]

```

Calculated the frequencies of the letters; but I can't really get lower because I'm only able to easily use 8-bit replacements of the... well 8-bit equivalents. If there was an easier way to do binary compression in 05AB1E, maybe?

```
'MJP1MOCPNQAMJC8IOQAMNNMKKLQAPOOPFQAJEDPOFGMJQAJEOFQALLBPNQALL5DMOQANL8OQAENNQHMOF8PJJQHM7IFLQHMNCIOQHMN7PNQHMKP9QHMKKIC9QHLHGNMOQHLJJIOKQHLLOKQHLNBPNQHLNO9OQHLNFP52DMKFLQHLFFLOQHNM7LQHNE5QCMIOPKQCLOOPJJ9QCEHB8LNFGQCENAIOQPO5IQPNOKFQ4PIOKFPIOQ4IKHGPNQ4JMBPQ4NMOBPOQ6MNCOPNQ6IJJIANMOCQ6NMGMDQ6NMKKJP9QGMNNIKQGMKKMOQGMFHGQGPIONIHGQGPIFBMD7QGPJJPNQGINLOLQGLP3POQIOGL4PQIKMBKLOQ0LGOKLOQBMIOPQBPOOPC9QBIO6QBJLAEHGMNQJMOB4LNCQJPMG9QJPPQDMOHGIOQDMNBP9QDHHMIOQDHHMKBIJJQDHHLOOPJJQDPOPOCP5QDPNBJP9QDLNMOQDENBL8KBIQDEN7G9QDENNM9QOPJKLOQ7MEJQ7PNCEPQ7PFPNKQ7LNFDMOQNPPCQNIKHGQNLAPNFKQNLEOCKQNEAILQKMOCPNKQKMKKPQKHGMF5QKHGEDPNQKHLFFQKGMGPPOQKGPJA9QKFMAPOL8QKFNMO6PQKEJJI3MOQFPKFPNQFGEOPQFIJJIKQFLLDP9QECMJJQ3MO2GLJJPOQ8MNOPNQ8MNNPOQ8GIFPGLEKPQ8IHBPNQ89CPOQ9LEO6'

```

Ended up with that, which was worse.
> 1 votes

# Answer
# Bubblegum, ~~195~~ 193 bytes

```
00000000: 05c1 514e eb30 1404 d0bd c5ed 7b41 6d50  ..QN.0......{AmP
00000010: 9482 109f b7c9 505b 3173 a3b1 0d72 57cf  ......P[1s...rW.
00000020: 3957 6001 b633 9f69 b696 2f89 8fa0 f61c  9W`..3.i../.....
00000030: 9af4 2fdb 8ea5 dd93 5f2c 11c1 0afa 6df5  ../....._,....m.
00000040: 5a27 97f1 0a8b fd2c 96fa d137 f02d 3662  Z'.....,...7.-6b
00000050: 90ff f2d3 1b1f a3d5 3506 7796 f7cd 721e  ........5.w...r.
00000060: 7263 0db2 c397 54d6 78b3 5210 ec48 d567  rc....T.x.R..H.g
00000070: 686b 3835 dd13 27d3 8e3e 5a29 c631 c9e9  hk85..'..>Z).1..
00000080: afc8 c539 adc1 1283 e980 46e4 0c05 d70e  ...9......F.....
00000090: 8d8e 1f70 3429 9501 24ea d424 ebc1 b425  ...p4)..$..$...%
000000a0: be30 fa17 82d7 ea0c 2e76 9e2c 11e5 bf2c  .0.......v.,...,
000000b0: daf7 e0be 4353 d311 fbe2 8d5b 9951 a1f2  ....CS.....[.Q..
000000c0: 07                                       .

```

Try it online!
> 1 votes

# Answer
# MAWP, 5624 bytes

```
88WM;269WW;1689MWA;358WW;1277WWA;19M29MW;455WW;1689MWA;67W89WM;159WA;48W;288WM;1277WWA;269WW;455WW;789MW;357WW;19M29MW;159WA;48W;288WM;1277WWA;67W89WM;67W89WM;1277WWA;2949MWA;2949MWA;1278WWA;159WA;48W;288WM;1689MWA;19M29MW;19M29MW;1689MWA;1949MWA;159WA;48W;288WM;269WW;949MW;1269WWM;1689MWA;19M29MW;1949MWA;849MW;1277WWA;269WW;159WA;48W;288WM;269WW;949MW;19M29MW;1949MWA;159WA;48W;288WM;1278WWA;1278WWA;1269WWA;1689MWA;67W89WM;159WA;48W;288WM;1278WWA;1278WWA;2279WAW;1269WWM;1277WWA;19M29MW;159WA;48W;288WM;67W89WM;1278WWA;789MW;19M29MW;159WA;48W;288WM;949MW;67W89WM;67W89WM;159WA;48W;388WM;1277WWA;19M29MW;1949MWA;789MW;1689MWA;269WW;269WW;159WA;48W;388WM;1277WWA;278WW;357WW;1949MWA;1278WWA;159WA;48W;388WM;1277WWA;67W89WM;455WW;357WW;19M29MW;159WA;48W;388WM;1277WWA;67W89WM;278WW;1689MWA;67W89WM;159WA;48W;388WM;1277WWA;2949MWA;1689MWA;1358WWM;159WA;48W;388WM;1277WWA;2949MWA;2949MWA;357WW;455WW;1358WWM;159WA;48W;388WM;1278WWA;929MW;849MW;67W89WM;1277WWA;19M29MW;159WA;48W;388WM;1278WWA;269WW;269WW;357WW;19M29MW;2949MWA;159WA;48W;388WM;1278WWA;1278WWA;19M29MW;2949MWA;159WA;48W;388WM;1278WWA;67W89WM;1269WWA;1689MWA;67W89WM;159WA;48W;388WM;1278WWA;67W89WM;19M29MW;1358WWM;19M29MW;159WA;48W;388WM;1278WWA;67W89WM;1949MWA;1689MWA;2279WAW;48W;499WA;1277WWA;2949MWA;1949MWA;1278WWA;159WA;48W;388WM;1278WWA;1949MWA;1949MWA;1278WWA;19M29MW;159WA;48W;388WM;67W89WM;1277WWA;278WW;1278WWA;159WA;48W;388WM;67W89WM;949MW;2279WAW;159WA;48W;488WM;1277WWA;357WW;19M29MW;1689MWA;2949MWA;159WA;48W;488WM;1278WWA;19M29MW;19M29MW;1689MWA;269WW;269WW;1358WWM;159WA;48W;488WM;949MW;929MW;1269WWA;789MW;1278WWA;67W89WM;1949MWA;849MW;159WA;48W;488WM;949MW;67W89WM;277WW;357WW;19M29MW;159WA;48W;389WA;19M29MW;2279WAW;357WW;159WA;48W;389WA;67W89WM;19M29MW;2949MWA;1949MWA;159WA;48W;257WW;1689MWA;357WW;19M29MW;2949MWA;1949MWA;1689MWA;357WW;19M29MW;159WA;48W;257WW;357WW;2949MWA;929MW;849MW;1689MWA;67W89WM;159WA;48W;257WW;269WW;1277WWA;1269WWA;1689MWA;159WA;48W;257WW;67W89WM;1277WWA;19M29MW;1269WWA;1689MWA;19M29MW;159WA;48W;189WA;1277WWA;67W89WM;455WW;19M29MW;1689MWA;67W89WM;159WA;48W;189WA;357WW;269WW;269WW;357WW;277WW;67W89WM;1277WWA;19M29MW;455WW;159WA;48W;189WA;67W89WM;1277WWA;849MW;1277WWA;1269WWM;159WA;48W;189WA;67W89WM;1277WWA;2949MWA;2949MWA;269WW;1689MWA;1358WWM;159WA;48W;89W;1277WWA;67W89WM;67W89WM;357WW;2949MWA;159WA;48W;89W;1277WWA;2949MWA;2949MWA;1277WWA;19M29MW;159WA;48W;89W;1277WWA;1949MWA;929MW;849MW;159WA;48W;89W;1689MWA;357WW;19M29MW;67W89WM;357WW;929MW;849MW;159WA;48W;89W;1689MWA;357WW;1949MWA;1269WWA;1277WWA;1269WWM;278WW;159WA;48W;89W;1689MWA;269WW;269WW;1689MWA;67W89WM;159WA;48W;89W;357WW;67W89WM;1278WWA;19M29MW;1278WWA;159WA;48W;89W;1278WWA;1689MWA;1949MWM;1689MWA;19M29MW;159WA;48W;189WM;19M29MW;849MW;1278WWA;689MW;1689MWA;159WA;48W;189WM;2949MWA;1277WWA;1269WWA;2949MWA;1278WWA;19M29MW;159WA;48W;289WM;1278WWA;849MW;19M29MW;2949MWA;1278WWA;19M29MW;159WA;48W;355WW;1277WWA;357WW;19M29MW;1689MWA;159WA;48W;355WW;1689MWA;19M29MW;19M29MW;1689MWA;455WW;1358WWM;159WA;48W;355WW;357WW;19M29MW;1849MWA;159WA;48W;355WW;269WW;1278WWA;277WW;949MW;929MW;849MW;1277WWA;67W89WM;159WA;48W;489WM;1277WWA;19M29MW;1269WWA;689MW;1278WWA;67W89WM;455WW;159WA;48W;489WM;1689MWA;1277WWA;849MW;1358WWM;159WA;48W;489WM;1689MWA;1689MWA;159WA;48W;499WA;1277WWA;19M29MW;929MW;849MW;357WW;19M29MW;159WA;48W;499WA;1277WWA;67W89WM;1269WWA;1689MWA;1358WWM;159WA;48W;499WA;929MW;388WM;1277WWA;357WW;19M29MW;159WA;48W;499WA;929MW;388WM;1277WWA;2949MWA;1269WWA;357WW;269WW;269WW;159WA;48W;499WA;929MW;388WM;1278WWA;19M29MW;19M29MW;1689MWA;269WW;269WW;159WA;48W;499WA;1689MWA;19M29MW;1689MWA;19M29MW;455WW;1689MWA;2279WAW;159WA;48W;499WA;1689MWA;67W89WM;1269WWA;269WW;1689MWA;1358WWM;159WA;48W;499WA;1278WWA;67W89WM;1277WWA;19M29MW;159WA;48W;499WA;949MW;67W89WM;1269WWA;1278WWA;789MW;2949MWA;1269WWA;357WW;159WA;48W;499WA;949MW;67W89WM;278WW;849MW;1358WWM;159WA;48W;499WA;949MW;67W89WM;67W89WM;1277WWA;1358WWM;159WA;48W;399WA;1689MWA;269WW;2949MWA;1278WWA;19M29MW;159WA;48W;199WA;1277WWA;949MW;269WW;159WA;48W;199WA;1689MWA;67W89WM;455WW;949MW;1689MWA;159WA;48W;199WA;1689MWA;1949MWA;1689MWA;67W89WM;2949MWA;159WA;48W;199WA;1278WWA;67W89WM;1949MWA;1269WWM;1277WWA;19M29MW;159WA;48W;199WM;1689MWA;1689MWA;455WW;159WA;48W;199WM;357WW;2949MWA;929MW;849MW;159WA;48W;199WM;1278WWA;277WW;1689MWA;67W89WM;1949MWA;2949MWA;159WA;48W;199WM;1278WWA;949MW;19M29MW;455WW;2949MWA;159WA;48W;199WM;949MW;277WW;357WW;1278WWA;159WA;48W;299WM;1277WWA;19M29MW;455WW;1689MWA;67W89WM;2949MWA;159WA;48W;299WM;1277WWA;2949MWA;2949MWA;1689MWA;159WA;48W;299WM;929MW;849MW;1277WWA;1949MWA;2279WAW;159WA;48W;299WM;929MW;849MW;949MW;1269WWM;1689MWA;67W89WM;159WA;48W;299WM;929MW;1278WWA;1949MWA;1949MWA;159WA;48W;299WM;849MW;1277WWA;849MW;1689MWA;1689MWA;19M29MW;159WA;48W;299WM;849MW;1689MWA;269WW;277WW;1358WWM;159WA;48W;299WM;1949MWA;1277WWA;277WW;1689MWA;19M29MW;1278WWA;789MW;159WA;48W;299WM;1949MWA;67W89WM;1277WWA;19M29MW;1849MWA;1689MWA;159WA;48W;299WM;949MW;269WW;269WW;357WW;1949MWM;1277WWA;19M29MW;159WA;48W;267WW;1689MWA;2949MWA;1949MWA;1689MWA;67W89WM;159WA;48W;267WW;849MW;949MW;19M29MW;1689MWA;159WA;48W;267WW;357WW;269WW;269WW;357WW;2949MWA;159WA;48W;267WW;1278WWA;1278WWA;1269WWM;1689MWA;1358WWM;159WA;48W;499WM;455WW;1277WWA;269WW;269WW;159WA;48W;599WM;1277WWA;19M29MW;48W;89W;1278WWA;269WW;269WW;1689MWA;19M29MW;159WA;48W;699WM;1277WWA;67W89WM;19M29MW;1689MWA;67W89WM;159WA;48W;699WM;1277WWA;67W89WM;67W89WM;1689MWA;19M29MW;159WA;48W;699WM;849MW;357WW;1949MWA;1689MWA;849MW;1278WWA;949MW;2949MWA;1689MWA;159WA;48W;699WM;357WW;929MW;1269WWA;1689MWA;67W89WM;159WA;48W;699WM;1358WWM;455WW;1689MWA;19M29MW;159WA;48W;899WM;1278WWA;949MW;19M29MW;1849MWA;

```

Try it!

Made using Arnauld's MAWP string printer. Somehow it's not the biggest solution in here.
> 1 votes

# Answer
# Javascript, 275 bytes

```
alert`LeeBurrCruzEnziKingPaulReedBluntBrownCaseyCoonsCrapoErnstFlakeHatchKaineLeahyMoranRischRubioSasseScottThuneUdallWydenYoungBennetBookerCapitoCardinCarperCorkerCornynCottonDainesDurbinGrahamHarrisHassanHellerHironoHoevenInhofeMarkeyMcCainMurphyMurrayNelsonPerduePetersRounds`

```

Trivial Answer.
> 0 votes

# Answer
# 05AB1E, ~~234~~ ~~192~~ 191 bytes

```
.•–¯¼‡=/–nhVηÕÞ·×üΣA₁OúÝá=‘Î¦δk∍˜§ýz†ÂËt@ä‹A‡4)нW¯/kΓoʒÇ4ùŽY„¥₂2Æ²FƒtāË¹kyØ¢øÏ‹Õ.γbÓÄ
₃%‡íéZ'Oδ{)©»Õ¡Ôº₃j
Qyù+íw¬uÂ®ÃÑ3ô₂вÊîv/˜āø¡м¨Z{4∞ä”ôsó×JËP¹pWǝŽèñÇdb]qÀS¼ª†šвε:Ω¢ùÉfΣS€…Ÿ>и²%É(A90þ’8ˆ•™

```

Try it online!

Outputs: `Bennet Blunt Booker Brown Burr Capito Cardin Carper Casey Coons Corker Cornyn Cotton Crapo Cruz Daines Durbin Enzi Ernst Flake Graham Harris Hassan Hatch Heller Hirono Hoeven Inhofe Kaine King Leahy Lee Markey Moran Murphy Murray Nelson Paul Perdue Peters Reed Risch Rounds Rubio Sasse Scott Thune Udall Wyden Young`
> 0 votes

---
Tags: code-golf, kolmogorov-complexity, open-ended-function
---


title: Substandard deviation

text:
# Question
Title: Substandard deviation
The mean of a population \\$(x\_1,\dots,x\_n)\\$ is defined as \\$\bar x=\frac1n\sum\_{i=1}^n x\_i\\$. The (uncorrected) standard deviation of the population is defined as \\$\sqrt{\frac1n\sum (x\_i-\bar x)^2}\\$. It measures how dispersed the population is: a large standard deviation indicates that the values are far apart; a low standard deviation indicates that they are close. If all values are identical, the standard deviation is 0.

Write a program or function which takes as input a (non-empty) list of non-negative integers, and outputs its standard deviation. But check the scoring rule, as **this is not code golf**!

## Input/Output

Input/Output is flexible. Your answer must be accurate to at least 2 decimal places (either rounding or truncating). The input is guaranteed to contain only integers between 0 and 255, and to not be empty.

## Scoring

To compute your score, convert your code to integer code points (using ASCII or whatever code page is standard for your language) and compute the standard deviation. Your score is the number of bytes in your code multiplied by the standard deviation. Lower score is better. You should therefore aim for code which at the same time (a) is short and (b) uses characters with close codepoints.

Here is an online calculator to compute your score (assuming you use ASCII).

## Test cases

```
Input              | Output
77 67 77 67        | 5
82                 | 0
73 73 73           | 0
83 116  97 116 115 | 13.336

```

A word of caution about built-ins: if your language has a built-in, that's fine (and good for you if it only uses one character!). But make sure that it uses \\$n\\$ and not \\$n-1\\$ as the denominator in the formula, or else your answer won't be valid.

# Answer
> 10 votes
# MATL, score 65.30697

```
tYmhZs

```

Try it online! Or verify all test cases.

### How it works

The built-in function `Zs` with its default arity (1 input, 1 output) computes the *corrected* standard deviation:

\\$\sqrt{\frac 1 {n-1}\sum (x\_i-\bar x)^2}\\$

The uncorrected standard deviation can be obtained with the 2-input version of `Zs`: `1&Zs`, where `1` as second input means uncorrected. `l` or `T` could be used instead of `1` to reduce the score, but `&` is very far from the other characters. `2$` or `H$` could be used instead of `&`, but `$` is even farther.

So it is better to use the default version of `Zs` (corrected standard deviation) on the input *with its mean appended*. This increases the input length by `1` and contributes `0` in the numerator, which causes the corrected standard deviation to become uncorrected.

```
t     % Implicit input: numeric vector. Duplicate
Ym    % Mean
h     % Concatenate the input vector with its mean
Zs    % Corrected standard deviation

```

# Answer
> 8 votes
# , 19 bytes, Score 119.8249

*-~1 thanks to Bubbler*

Tries to have most characters between 0x23 and 0x2F `#$%&'()*+,-./`, with `:` being a bit further away.

```
(+/%$)&.:*:&(-+/%#)

```

Try it online!

### How it works

```
(+/%$)&.:*:&(-+/%#)
            (-+/%#) x - sum divided by length
         *:&        and squared
(+/%$)&.:           mean of that
      &.:*:         reverse square -> square root

```

# Answer
> 6 votes
## Google Sheets, Score 142.6885

```
=STDEVP(F:F

```

Google Sheets automatically closes parentheses, and using `F` as the input column minimizes the standard deviation. This saves one byte over Excel's uncorrected standard deviation, since Excel uses `STDEV.P` instead of `STDEVP`

# Answer
> 4 votes
# Wolfram Language (Mathematica), Score 537.0884

```
A@((#-A@#)^2)^.5&;A=Mean

```

Try it online!

@att saved 17.6142 points

# Answer
> 4 votes
# , ~~34 bytes~~ 24 bytes, score ~~789.5923~~ ~~723.4687~~ 722.6112

```
sd(c(scan()->J,mean(J)))

```

Try it online!

*Edit: switched to a shorter formula to calculate the population sd (which I found here), which now only benefits from selecting the best variable name among the golfs outlined below for the previous version.*

*Edit2: score reduced by 0.8575 thanks to Robin Ryder*

The (previous) ungolfed code ~~is~~ was: `x=scan();sqrt(mean((x-mean(x))^2))` (which would have a score of 1104.484)

From this, sequential score-improving golfs are:

* `x=scan();`?`=mean;sqrt(?(x-?x)^2)` = re-define `mean()` as a single character unary operator (score 983.8933)
* `x=scan();`?`=mean;(?(x-?x)^2)^.5` = exchange `sqrt()` for `()^.5` (score 918.6686)
* `H=scan();`?`=mean;(?(H-?H)^2)^.5` = exchange `x` for `H` which is the closest codepoint value to the mean of the program, thereby reducing the standard deviation (score 801.4687)
* `I=scan();`?`=mean;I=I-?I;(?I^2)^.5` = first calculate `x-mean(x)` separately, to reduce number of parentheses (which are at the far end of the ASCII range, and so increase the standard deviation), and re-adjust the variable name to `I`. Although this increases the code length by 2 characters, it reduces the score to 789.5923.

---

# \+ multicon, 15 bytes, score 273.5032

```
multicon::popsd

```

Trivial solution using built-in `popsd` function from `multicon` library.
Not installed at TIO, but you can try it at rdrr.io by copy-pasting this code:

```
x=c(67,77,67,77)  # data
multicon::popsd(x)

```

# Answer
> 3 votes
# Python 3, Score 680.5175

Where the golfiest solution is not the best. I doubt any non-builtin could be better but I might be wrong.

```
import statistics;statistics.pstdev

```

Try it online!

### Python 3, Score 733.6818

```
from statistics import*;pstdev

```

### Python 3, Score 798.5587

```
__import__('statistics').pstdev

```

# Answer
> 3 votes
# JavaScript (ES7), Score  ~~1359 1228~~  1156.077

*Saved 72 points thanks to @edc65*

```
D=>D[F='map'](C=>B-=(C+E/A)**2/A,D[F](C=>E+=--A?C:9,A=B=E=0))&&B**.5

```

Try it online!

### Character breakdown

```
 char. | code | count
-------+------+-------
   0   |  48  |   1
   2   |  50  |   1
   5   |  53  |   1
   9   |  57  |   1
   &   |  38  |   2
   '   |  39  |   2
   (   |  40  |   3
   )   |  41  |   3
   *   |  42  |   4
   +   |  43  |   2
   ,   |  44  |   2
   -   |  45  |   3
   .   |  46  |   1
   /   |  47  |   2
   :   |  58  |   1   <-- mean ≈ 59.43
   =   |  61  |   9
   >   |  62  |   3
   ?   |  63  |   1
   A   |  65  |   4
   B   |  66  |   3
   C   |  67  |   4
   D   |  68  |   3
   E   |  69  |   3
   F   |  70  |   2
   [   |  91  |   2
   ]   |  93  |   2
   a   |  97  |   1
   m   | 109  |   1
   p   | 112  |   1

```

# Answer
> 3 votes
# 05AB1E, Score: ~~531.168~~ ~~431.516~~ 360.278 (~~10~~ ~~15~~ 14 bytes)

```
Osg/nsn-Osg/(t

```

Uses the 05AB1E coding page. The characters used have the codepoints `[79,73,103,47,110,73,110,45,68,79,73,103,47,40,116]`.

Try it online or verify all test cases.

**Explanation:**

```
                # Get the arithmetic mean of the (implicit) input-list by:
O               #  Summing the (implicit) input-list
 I              #  Push input-list again
  g             #  Pop and push its length
   /            #  Divide the sum by this length
                #  (which gives a better score than the builtin `ÅA`)
    n           # Square it
     I          # Push the input again (better score than `s` or `¹`)
      n         # Square each value in the input as well
       -        # Subtract each from the squared mean
                # Take the arithmetic mean of that list again by:
        O       #  Summing it
         Ig     #  Push the input-list again, and pop and push its length
           /    #  Divide the sum by this length
            (   # Negate it
             t  # And take its square-root
                # (after which the result is output implicitly)

```

# Answer
> 3 votes
# Arn, score = ~~925.3172~~ ~~655.6836~~ ~~602.7985~~ 123.2274

```
sdev:s

```

Uses the builtin standard deviation function. Go to the old answer for a more interesting one

# Old Answer

I don't compress it because Standard Deviation would be way higher. I have updated this answer, since I found a much shorter method (sitting at 14 bytes). Link here (this is the program the score refers to). I will leave the original program for posterity's sake

```
:/(+v{:*v-(:s.mean}\)/((:s)#

```

Try it!

# Explained

$$\large\sqrt {\frac1n \sum(x\_i-\bar x)^2}$$ Just made use of the formula. `:/` is the sqrt prefix, `:*` is the square prefix, `+v{:*v-(:s.mean}\` Folds with `+` (addition) after mapping with the block `v{:*v-(:s.mean}`. `v` is current entry, `:s` splits on space (no variable is provided, so it assumes the variable `_`, which is STDIN). Then it just divides by the length (`#` suffix).

# Answer
> 2 votes
# Io, score = 1454.7164672196433912

-19.58295474318379 thanks to @ManishKundu

```
method(:,:map(Z,(Z- :average)squared)average sqrt)

```

Try it online!

# Answer
> 2 votes
# Jelly, (14 bytes), score 218.314

(218.31399405443526)

```
+/÷LN+*2+/÷L*.

```

**Try it online!** Or see a self-evaluation.

Bytecode: `2b 2f 1c 4c 4e 2b 2a 32 2b 2f 1c 4c 2a 2e`

### How?

A naive program would be `_Æm²Æm½`for 348.47 (subtract the mean from each, square each, take the mean of that and then square root it).

We know that to get rid of the two byte monad `Æm` whose code-points are quite far apart (`0x0d` and `0x6d`) we need to either:

* divide using `÷` (`0x1c`), or
* multiply, `×` (`0x11`), and invert, `İ` (`0xc6`)

But the latter bytes are also fairly far apart, so this answer attempts to use bytes close to `÷` (`0x1c`).

```
+/÷LN+*2+/÷L*. - Link: list of numbers, A
 /             - reduce (A) by:
+              -   addition             -> sum(A)
   L           - length (A)
  ÷            - divide                 -> mean(A)
    N          - negate
     +         - add (to A, vectorised) -> [mean(A)-v for v in A]
       2       - two
      *        - exponentiate           -> [(mean(A)-v)² for v in A]
         /     - reduce by:
        +      -   addition             -> sum((mean(A)-v)² for v in A)
           L   - length (A)
          ÷    - divide                 -> sum((mean(A)-v)² for v in A)/n
             . - a half
            *  - exponentiate           -> √(sum((mean(A)-v)² for v in A)/n)

```

# Answer
> 2 votes
# Wolfram Language (Mathematica), 31 bytes, score 478.3451

```
a[a_]=RootMeanSquare[a-Mean[a]]

```

Try it online!

# Answer
> 1 votes
# Charcoal, 15 bytes, stddev 46.741654, score 701.12481

```
Ｉ₂∕ΣＸ⁻θ∕ΣθＬθ²Ｌθ

```

Try it online! Link is to verbose version of code. Link test case is the byte values in the Charcoal code page of the code. Explanation:

```
         θ      Input `x`
        Σ       Summed
       ∕  Ｌθ    Divided by `n`
     ⁻θ         Vectorised subtracted from `x`
    Ｘ       ²   Squared
   Σ            Summed
  ∕          Ｌθ Divided by `n`
 ₂              Square rooted
Ｉ               Cast to string
                Implicitly printed

```

Note that the alternative formula for the standard deviation, \\$ \sqrt{\bar{x^2}-\bar x^2} \\$, while having a slightly smaller standard deviation, takes 17 bytes, and therefore results in a higher score of 755.6.

# Answer
> 1 votes
# C (gcc), ~~107~~ ~~104~~ 99 bytes, stddev ~~25.25~~ \\$\cdots\\$~~25.32~~ 25.00, score ~~2702.01~~ \\$\cdots\\$ ~~2634.27~~ 2475.426270

Saved 3 bytes and 46.95288 points thanks to ceilingcat!!!
Saved 5 bytes and 158.848632 points thanks to att!!!

```
E;float D,G,H;float F(F,C)int*C;{E=F;for(H=G=0;E>-F;0>E?G+=D*D:(H+=*C++))D=H/F-C[--E];G=sqrt(G/F);}

```

Try it online!

# Answer
> 1 votes
## Setanta, score: 2728.508

```
gniomh(g){f:=0h:=0e:=fad@g le i idir(0,e){d:=g[i]f+=d h+=d*d}toradh freamh@mata((h-f*f/e)/e)}

```

Try it here!

# Answer
> 1 votes
# MATLAB/Octave, 12 bytes, score 336.32

*(changed according to guidance by Giuseppe to conform with rules)*

```
@(A)std(A,1)

```

Argument with name `A` provides the lowest deviation for score, output to standard output variable `Ans` and actually written to command window.
Try it online!

`std` is a built-in function. By default it uses \\$N-1\\$ as demoninator but by passing `1` as second argument it's changed to \\$N\\$.

---
Tags: math, code-challenge, self-referential
---


title: Word Length-Sum Multiples

text:
# Question
Title: Word Length-Sum Multiples
A port of my other question: Double Prime Words

Consider a word/string of `n` alphanumeric characters with sum of the characters, `s`, using their numeric position in the alphabet (`a=1, B=2, c=3,` etc.) or numeric value (0,1, 2, 3 - 9). Numeric characters should be taken at individual value. (`66` is two `6` characters for a sum of `12`)

A word is a Length-Sum Multiple if and only if `s` is a multiple of `n`, specifically `s/n` is a positive integer `{1,2,3,4...}`. In the case of `s=0`, and `n={0,00,000,...}`, 0 is a multiple of any `n` but it does not yield a positive integer. Hence an input of `{0,00,000,...}` is False.

Input can be any combination of numbers and upper or lower case alphabetic characters, as there is no numeric difference between `a` or `A`. Handling empty input, `n=s=0`, is not required.

Output is any appropriate logical format related to your language. i.e. True or False, T or F, 1 or 0, positive for truthy and 0 for falsy, etc. Specifying what format your output will appear is highly appreciated, but not required. (Output need not include n or s, but I include them below as demonstration and example)

Winning condition: In as few bytes as possible, write a function that is able to determine if a string is a Length-Sum Multiple.

### Examples

```
Input -> Output (n,s)

hello -> False (5, 52)
MuLtIpLe -> False (8, 108)
Junct10n -> False (8, 83)
Order66 -> False (7, 72)
CodeGolf -> False (8, 67)
SUM -> False (3, 53)
ID -> False (2, 13)

25 -> False (2, 7)
0 -> False (1, 0) 0/1 = 0 which is not a positive integer
10 -> False (2, 1)

hello2 -> True (6, 54)
5um -> True (3, 39)
length -> True (6, 66)
Order64 -> True (7, 70)
Covid19 -> True (7, 63)
Word -> True (4, 60)
APPLE -> True (5, 50)
lawYER -> True (6, 84)
abc123 -> True (6, 12)
is -> True (2, 28)
television -> True (10, 130)
19 -> True (2, 10)
234 -> True (3, 9)

a -> True (1, 1)
b -> True (1, 2)
C -> True (1, 3)
Z -> True (1, 26)
1 -> True (1, 1)
9 -> True (1, 9)

```

# Answer
> 4 votes
# 05AB1E, ~~16~~ 15 bytes

```
þIáÇ32%«ODXgÖ*Ā

```

Input as a list of characters.

-1 byte implicitly thanks to *@ovs*.

Try it online or verify all test cases.

**Explanation:**

```
þ                # Only leave the digits of the (implicit) input-list
 Iá              # Push the input-list again, and only leave its letters
   Ç             # Convert each letter to its codepoint integer
    32%          # Take modulo-32 on each codepoint
       «         # Merge it to the list of digits
        O        # Sum this list
         D       # Duplicate this sum
          Ig     # Push the input-list again, and pop and push its length
            Ö    # Check if the sum is divisible by this length
             *   # Multiply it by the duplicated sum
              Ā  # And check that this is NOT 0
                 # (after which the result is output implicitly)

```

3 bytes (`D*Ā`) are used for edge-cases `0`/`00`/`000`/etc.

# Answer
> 4 votes
# C (gcc), ~~73~~ \\$\cdots\\$ ~~63~~ 61 bytes

Saved ~~a~~ 3 bytes thanks to ceilingcat!!!

```
n;u;f(char*s){for(n=u=0;*s;++n)u+=*s&15+*s++/64*16;u*=u%n<1;}

```

Try it online!

Inputs a string and returns a truthy if it's a Length-Sum Multiple or a falsey otherwise.

# Answer
> 4 votes
# Jelly,  ~~12~~  11 bytes

```
ŒlO%48Sȯ.%L

```

A monadic Link accepting a list of characters which yields zero (falsey) if the string is a *length-sum-multiple* or a non-zero number (truthy) if not.

**Try it online!** Or see the test-suite.

### How?

```
ŒlO%48Sȯ.%L - Link: list of characters, w  e.g. "ID"       "10"     "19"     "0...0"
Œl          - lower-case (w)                    "id"       "10"     "19"     "0...0"
  O         - ordinals                          [105,100]  [49,48]  [49,57]  [48,...,48]
    48      - forty-eight                       48         48       48       48
   %        - modulo                            [9,4]      [1,0]    [1,9]    [0,...,0]
      S     - sum                               13         1        10       0
        .   - a half                            0.5        0.5      0.5      0.5
       ȯ    - logical OR                        13         1        10       0.5
         L  - length (w)                        2          2        2        length(w)
        %   - modulo                            1          1        0        0.5
                                               (nope       nope     yep!     nope)

```

# Answer
> 4 votes
# , 29 24 bytes

```
#(|=0=])1#.48|64|96|3&u:

```

Try it online!

*-5 bytes thanks to xash*

Inspired by Neil's answer -- be sure to upvote him.

* `3&u:` turns the string into ascii codes
* `96|` mods the lowercase letters into the range 1-26
* `64|` mods the uppercase letters into the range 1-26
* `48|` mods the digits into the range 0-9
* `1#.` sum of all those converted digits
* `#` (on the far left) length of string
* `(|=0=])` First we check if the sum is zero `0=]` -- this will return `1` when it is and `0` otherwise. Then we check if sum mod the length `|` is equal to *that*. Thus for the entire phrase to return true it must be the case that the sum is *both* evenly divisible its length and nonzero.

*Why can't you just use a single 32 mod instead of doing a 96 followed by a 64?*

With 32, you'd be affecting the values 0-9 as well. With 96/64, you fix the letters without touching the digits, and now, since the letters are all 26 and under, when you fix the digits the already-fixed letters are unaffected.

# Answer
> 3 votes
# , ~~63~~ ~~62~~ ~~57~~ 56 bytes

*Edit: saved 1 byte thanks to Jonah*

```
function(s)!sum(i<-utf8ToInt(s)%%96%%64%%48)%%nchar(s)&i

```

Try it online!

Output is Truthy list of one-or-more TRUEs, or Falsy list of one-or-more FALSEs.

# Answer
> 3 votes
# Scala, ~~71~~ ~~62~~ 46 bytes

```
s=>{val x=(0/:s)(_+_%96%64%48);x>0&x%s.size<1}

```

Try it online

## 32 bytes if zero weren't falsey

```
s=>(0/:s)(_+_%96%64%48)%s.size<1

```

Try it online

# Answer
> 3 votes
# Java ~~79~~ ~~77~~ ~~68~~ ~~66~~ 64 bytes

```
s->{int u=0;for(int c:s)u+=c%96%64%48;return u>0&u%s.length<1;};

```

Try it here!

My first ever answer! The "0" test case messed me up, without it I could have had 51, (I wanted to try challenge the C answer, from which I've borrowed the char-to-number conversion). Now pretty much a port of the C answer.

```
s->s.chars().map(c->c%96%64%48).sum()%s.length()<1;

```

Still fairly proud of beating out some of current answers in languages like Python and JavaScript using the 'oh so verbose' Java.

Thanks to @user for a few extra bytes saved

@ceilingcat for a few more

@dominic-van-essen for 2 more using @xash's idea

# Answer
> 3 votes
# Python 3, 54 bytes

```
lambda s:(sum(ord(c)%48for c in s.lower())or.5)%len(s)

```

An unnamed function accepting a string which returns zero (falsey) if the string is a length-sum-multiple or a non-zero number (truthy) if not.

**Try it online!** Or see the test-suite.

# Answer
> 2 votes
# Python 3.8, 59 bytes

```
lambda d:1>(x:=sum(int(c,36)-9*(c>'9')for c in d))%len(d)<x

```

Try it online!

# Answer
> 2 votes
# Charcoal, 18 bytes

```
≔ΣＥ↧θ﹪℅ι⁴⁸η∧η¬﹪ηＬθ

```

Try it online! Link is to verbose version of code. Output is a Charcoal boolean, i.e. `-` for a multiple, nothing if not. Explanation:

```
≔ΣＥ↧θ﹪℅ι⁴⁸η

```

Convert the string to lower case, take the code points of all the characters, reduce them modulo 48, then take the sum.

```
∧η¬﹪ηＬθ

```

Check that the sum is a non-zero multiple of the length of the string.

# Answer
> 2 votes
# Perl 5 \+ `-plF`, 32 bytes

-7 bytes thanks to @Nahuel Fouilleul!

```
$s+=ord(lc)%48for@F;$_&&=1>$s%@F

```

Try it online!

# Answer
> 1 votes
# Japt, ~~22~~ ~~17~~ 15 bytes

Input is an array of characters.

Or 13 bytes, without having to special-case `0`.

```
xÈv c u48
©vNÎl

```

Try it

```
;x@ÒBbXu)ªX\n©vNÎl     :Implicit input of character array U
 x                     :Reduce by addition
  @                    :After passing each X through the following function
   Ò                   :  Negate the bitwise NOT of
;   B                  :  Uppercase alphabet
     b                 :  0-based index of
      Xu               :    Uppercase X
        )              :  End indexing
         ªX            :  Logical OR with X, which gets coerced to an integer
           \n          :Reassign to U
             ©         :Logical AND with
              v        :  Is divisible by
               N       :  Array of all inputs
                Î      :  First element (i.e., the original U)
                 l     :  Length

```

# Answer
> 1 votes
# Python 3, ~~101~~ 96 bytes

```
def f(s):x=sum([i-[48,96][i>96]for i in map(ord,s.lower())]);return not(x%len(s))and x//len(s)>0

```

Try it online!

# Answer
> 1 votes
# Jelly, 23 bytes

```
ØWiⱮ_³e€ØD¤%26Sµ;ọ³L¤$Ȧ

```

Try it online!

Golfed 1 byte and also made the program actually work (third time's a charm? it was still broken)

## Explanation

```
ØWiⱮ_³e€ØD¤%26Sµ;ọ³L¤$Ȧ  Main Link
   Ɱ                     For each character in the input
  i                      find its index in
ØW                       "ABC...XYZabc...xyz0123456789_"
    _                    and subtract from each element
     ³e€ØD¤              the corresponding value, which is
     ³                   if the original character
      e€                 is a member of
        ØD               the digits (this is to fix the one-off offset of the digits)
                         (the above nilad gets a list of 0 and 1 for if each character is a digit, and since Jelly's subtraction `_` is vectorized, this works as subtracting the corresponding element)
           %26           modulo 26
              Sµ         take the sum; begin a new link with this value
                ;    $   append
                 ọ       the number of times the sum is divisible by (just plain "divisible by?" has the arguments in the opposite order which would take 1 extra byte to flip)
                  ³L¤    the length of the input
                      Ȧ  any and all - are both values truthy; that is, is the sum divisible and non-zero?

```

# Answer
> 1 votes
# JavaScript (Node.js),  ~~54~~  53 bytes

Returns **0** or **1**.

```
s=>Buffer(s).map(c=>t+=++k&&c%96%64%48,k=t=0)|t%k<!!t

```

Try it online!

# Answer
> 0 votes
Python 2 & Python 3 -- 69 Bytes

```
lambda a:0==sum(ord(s.upper())-[64,48][s.isdigit()]for s in a)%len(a)

```

Assuming the input as string on variable a, one can get down to 60 Bytes

```
0==sum(ord(s.upper())-[64,48][s.isdigit()]for s in a)%len(a)

```

# Answer
> 0 votes
# JavaScript, 107 bytes

```
a=>(b=a.toLowerCase().split('').reduce((c,d)=>c+(+(isNaN(d)?d.charCodeAt(0)-96:d)),0)/a.length,!(b?b%1:!b))

```

Try it online!

# Answer
> 0 votes
# MATL, ~~12~~ 11 bytes

```
k48\stGn\~*

```

Output is `0` if the input is length-sum multiple, or a positive number otherwise.

Try it online! Or verify all test cases.

### How it works

```
k     % Implicit input. Convert to lowercase
48    % Push 48
\     % Modulus. Each character is first converted to its code-point
s     % Sum. This gives "s"
t     % Duplicate (*)
G     % Push input again
n     % Number of elements. This gives "n"
\     % Modulus
~     % Negate. This gives true if s mod n equals 0, or false otherwise (**)
*     % Multiply (*) and (**)
      % Implicit display. True and false are displayed as 1 and 0 respectively

```

# Answer
> 0 votes
# Retina 0.8.2, 63 bytes

```
^
$.'$*1;
T`L`l
[j-z]
55$&
[t-z]
55$&
T`_l`ddd
\d
$*
^(1+);\1+$

```

Try it online! Link includes test cases. Explanation:

```
^
$.'$*1;

```

Prefix the input with a unary copy of itself.

```
T`L`l

```

Convert it to lower case.

```
[j-z]
55$&
[t-z]
55$&
T`_l`ddd

```

Convert the letters to digits with the same digital sum.

```
\d
$*

```

Take the digital sum.

```
^(1+);\1+$

```

Check that it is a non-zero multiple of the length.

# Answer
> 0 votes
# MAWP, 78 bytes

```
%|0/[!843WWP843WWWA/]~[!88WP88WWA/]~[!86WP86WWA/]_1A![1A~M~]%!~!~/P\WA{0:.}?1:

```

Try it!

Waiting for answer in 1+...

Uses the modulus method from Jonah's J answer.

# Answer
> 0 votes
# Wolfram Language (Mathematica), 54 bytes

```
Tr[a=FromDigits/@#/.a_/;a>9:>a-9]~Mod~Tr[1^#]==0<Tr@a&

```

Try it online! Pure function. Takes a list of characters as input and returns `True` or `False` as output. The bulk of the work is done by `FromDigits`, which converts the characters 0-9, A-Z to the numbers 0-35.

---
Tags: code-golf, decision-problem
---


# Question
Title: Concatenations of powers and their squares
At time of writing, my reputation is \\$16,256\\$. As I noted in chat,

> Oh cool my rep is the concatenation of two powers of 2: 16,256
>
> Or even the concatenation of a power of 2 and its square, which is much more interesting

which then spawned a CMC about checking if a number has this property.

---

Given an integer \\$n \> 0\\$, considered a decimal integer, and a power \\$r \> 1\\$, return two distinct values which determine whether \\$n\\$ can be expressed as the concatenation of a power of \\$r\\$ and its square or not. For example, \\$n = 16256\\$ and \\$r = 2\\$ returns true (the concatenation of \\$2^4\\$ and \\$(2^4)^2\\$), while \\$n = 39\\$ and \\$r = 2\\$ does not. Note however that \\$n = 39\\$, \\$r = 3\\$ *is* true. The power of \\$r\\$ may be \\$0\\$, meaning that \\$n = 11\\$ is true for all \\$r\\$

The power of \\$r\\$ will always come "before" its square, so \\$n = 62525, r = 5\\$ is false.

You will never get an input \\$n\\$ where its validity depends on ignoring leading \\$0\\$s or not (for example \\$101\\$ is true for all \\$r\\$ if ignoring leading \\$0\\$s and false otherwise). However, you may still get inputs with the digit \\$0\\$ in (e.g. \\$n = 1024, r = 2\\$) where leading \\$0\\$s have no bearing on the validity of \\$n\\$ being such a concatenation.

Input and output may be in any accepted method and this is so the shortest code in bytes wins.

## Test cases

```
    n    r    1
   39    3    1
  525    5    1
  864    8    1
16256    2    1
   11    r    1
  416    7    0
   39    2    0
   15    5    0
 1024    4    0
62525    5    0

```

Feel free to suggest more test cases.

# Answer
> 9 votes
# APL (Dyalog Unicode), 21 bytes (SBCS)

Anonymous infix lambda, taking \\$r\\$ as left argument and \\$n\\$ as right argument. Requires `⎕IO←0` (zero-based indexing).

```
{⍵∊(⊢⍎⍤,⍥⍕¨×⍨)⍺*⍳⌊⍟⍵}

```

Try it online! (Dyalog Extended as polyfill for version 18.0)

`{``}` "dfn",  is \\$r\\$ and  is \\$n\\$:

`⍟⍵` natural log of \\$n\\$ (to avoid overflow)

round that down

**ɩ**ntegers zero through one less than that

`⍺*` raise \\$r\\$ to those powers

`(``)` apply the following monadic function to that:

`×⍨` multiply those with themselves (i.e. square them)

`¨` for each unmodified argument and its corresponding square:

`⍥⍕`… stringify the argument and its square before

`⍤,` concatenating them, and then

evaluating the result

`⍵∊` is the original argument a member of that?

# Answer
> 8 votes
# 05AB1E, 9 bytes

```
ÝmεDn«}¹å

```

Try it online! This is a *little* inefficient, so don't try the larger falsey test cases.

**Commented:**

```
           # implicit input, n first, r second
Ý          # inclusive range from 0 to n
 m         # raise r to all of these powers
  ε   }    # map over the powers ...
   D       #   duplicate power
    n      #   square it
     «     #   and concatenate
       ¹   # push the first input (n)
        å  # is this in the list?

```

# Answer
> 8 votes
# Python 3, <sup>~~63~~ \\$\cdots\\$ ~~56~~</sup> 54 bytes

Saved 4 bytes thanks to ovs!!!
Saved a byte porting Arnauld's golf of Shaggy's JavaScript answer!!!
Saved 2 bytes thanks to pxeger!!!

```
f=lambda n,r,p=1:p>n or(n-int(f'{p}{p*p}'))*f(n,r,r*p)

```

Try it online!

Returns a falsey if \\$n\\$ can be expressed as the concatenation of a power of \\$r\\$ and its square or truthy otherwise.

# Answer
> 6 votes
# Brachylog, 9 bytes

Takes `r` as input and `n` as output. Unifies if truthy, otherwise fails.

```
;A^gj^₂ᵗc

```

Try it online!

### How it works

```
;A^gj^₂ᵗc with implicit r as input
;A^       r^some number
   gj     [r^some number, r^some number]
     ^₂ᵗ  [r^some number, r^some number^2]
        c concatenated is the output n

```

# Answer
> 6 votes
# \+ pryr, ~~43~~ 39 bytes

*Edit: -4 bytes thanks to pajonk*

Or **, 43 bytes**

```
pryr::f(any(n==paste0(s<-r^(0:n),s^2)))

```

Try it online!

A nice function that is naturally short thanks to 's vectorization.

`s<-r^(0:n)` generates a vector of all powers-of-`r` from 0..`n` (the `<-` here is an  assignment operator, similar to `=`),

`paste0(s,s^2)` generates a character vector of all these powers `paste`d onto their squares (the `0` in `paste0` instructs the function not to use a space in the concatenation),

`any(n==...)` finally checks to see whether `n` is equal to any of the elements of the vector, conveniently coercing `n` into character form to do this.

`pryr::f(...)` is a shorter way to express `function(n,r)` (from the `pryr` library), that 'guesses' the arguments using the body of the function definition (presumably by the order-of-appearance of unassigned variables: I can't actually find any explanation in the manual page, but anyway it seems to work...!).

# Answer
> 4 votes
# JavaScript, ~~47~~ ~~44~~ 38 bytes

```
n=>g=(r,x=1)=>x<n&&[x]+x*x==n|g(r,x*r)

```

-6 bytes thanks to Arnauld.

Try it online!

# Answer
> 3 votes
# Javascript (V8), ~~63~~ ~~60~~ ~~59~~ ~~53~~ ~~51~~ 43 bytes

*-3 from Neil*

*-2 and -8 from Shaggy*

```
n=>r=>[...n+n].some((_,i)=>[p=r**i]+p*p==n)

```

Takes input via currying: `f("16256")(2)`. Works quickly and for all values within the safe integer limit (\\$2^{52}-1\\$). Returns `true` or `false`.

### Old

```
n=>r=>[...n+n].map((a,i)=>[s=r**i]+s*s).indexOf(n)

```

```
n=>r=>[...Array(+n)].map((a,i)=>""+(p=r**i)+p*p).indexOf(n)

```

# Answer
> 3 votes
# Japt `-x`, 11 bytes

```
ÆVpXÃ£¥X+²s

```

Try it

```
ÆVpXÃ£¥X+²s     :Implicit input of integers U=n and V=r
Æ               :Map each X in the range [0,U)
 VpX            :  Raise V to the power of X
    Ã           :End map
     £          :Map each X
      ¥         :  Test U for equality with
       X+       :  X appended with
         ²      :  X squared
          s     :  Converted to a string
                :Implicit output of sum of resulting array

```

# Answer
> 3 votes
# Wolfram Language (Mathematica), 52 bytes

```
#^2+10^IntegerLength[#^2]#&[#2^0~Range~#]~MemberQ~#&

```

Try it online!

# Answer
> 3 votes
# PHP, 63 bytes

```
function($n,$r){while($n>$b=($a=$r**$x++).$a*$a);return$n==$b;}

```

Try it online!

Or... put another way...

### PHP, 63 bytes

```
function($n,$r){while(0<$b=$n<=>($a=$r**$x++).$a*$a);return$b;}

```

Try it online!

Can't seem to get away from this number...

### PHP, 63 bytes

```
function($n,$r){while($n>$a=$r**$x.$r**($x++*2));return$n==$a;}

```

Try it online!

# Answer
> 3 votes
# Rust, ~~72~~ 70 bytes

```
|n,r|(0..n).any(|i|format!("{}{}",r.pow(i),r.pow(2*i))==n.to_string())

```

Try it online!

A port of ovs's 05AB1E answer. Thanks to ovs for helping save 2 bytes!

# Answer
> 2 votes
# SNOBOL4 (CSNOBOL4), 96 bytes

```
	N =INPUT
	R =INPUT
N	Z =R ^ X
	Y =EQ(N,Z Z ^ 2) 1	:S(O)
	X =LE(Z,N) X + 1	:S(N)
O	OUTPUT =Y
END

```

Try it online!

Prints 1 for Truthy, and an empty line for Falsey.

```
	N =INPUT			;* Input n
	R =INPUT			;* input R
N	Z =R ^ X			;* set Z = R^X (X starts as "" or 0)
	Y =EQ(N,Z Z ^ 2) 1	:S(O)	;* If N = Z concatenated to Z^2, set Y = 1 and goto O
	X =LE(Z,N) X + 1	:S(N)	;* If Z <= N, increment X and goto N, else:
O	OUTPUT =Y			;* print Y, which is '' unless N == Z Z^2
END

```

# Answer
> 2 votes
# MathGolf, 11 bytes

```
r#mÆ‼░²░+l╧

```

Try it online. (The two test cases with the largest \\$n\\$ are timing out.)

**Explanation**

```
r            # Push a list in the range [0, (implicit) input `n`)
 #           # Take (implicit) input `r` to the power of each value in this list
  m          # Map over this list,
   Æ         # Using the following five commands:
    ‼        #  Apply the following two commands on the stack separately:
     ░       #   Convert the value to a string
      ²      #   Square the value
       ░     #  Convert the squared value to a string a well
        +    #  Concatenate the two strings together
         l   # After the map: push the first input `r` as string
          ╧  # And check if this string is in the list
             # (after which the entire stack joined together is output implicitly)

```

# Answer
> 2 votes
# Jelly, ~~10~~ 9 bytes

```
Ḷ*@ż²$Vi⁸

```

Try it online!

*-1 thanks to Jonathan Allan*

Elided the two larger test cases for the sake of being able to run.

Adapted from my own answer to the CMC. I've also attempted to adapt one of HyperNeutrino's cleverer answers, but it comes out to the same length on account of needing  to handle the `[11, r]`:

# Jelly, ~~10~~ 9 bytes

```
ḶżḤ$*@Vi⁸

```

Try it online!

I save on an `@` and an  by reversing the arguments, but then it takes 2 bytes to handle an exponent of 0, taking it right back up to ~~10~~ 9:

# Jelly, ~~10~~ 9 bytes

```
*Ɱ;1ż²$Vi

```

Try it online!

# Answer
> 2 votes
# Jelly, 9 bytes

Uses the evaluation (`V`) trick from Unrelated String's answer \- go give an upvote!

```
*⁹ŻżḤ$¤Vċ

```

A dyadic Link accepting an integer \\$r\>1\\$ on the left and an integer \\$n\>0\\$ on the right which yields `1` if \\$n\\$ can be expressed as the concatenation of a power of \\$r\\$ and its square, or `0` if not.

**Try it online!** Or see the test-suite (large \\$n\\$ excluded due to speed).

### How?

```
*⁹ŻżḤ$¤Vċ - Link: r; n
      ¤   - nilad followed by link(s) as a nilad:
 ⁹        -   chain's right argument, n
  Ż       -   zero-range -> [0,1,2,...,n]
     $    -   last two links as a monad:
    Ḥ     -     double -> [0,2,4,...,2n]
   ż      -     zip -> [[0,0],[1,2],[2,4],...,[n,2n]]
*         - (r) exponentiate (that) (vectorises)
       V  - evaluate (e.g. [9,81] -> 981) (vectorises)
        ċ - count occurrences (of n)

```

# Answer
> 2 votes
# Rockstar, 129 bytes

```
listen to N
listen to R
X's0
O's0
while N-X
let X be+1
P's1
Y's0
while X-Y
let P be*R-0
let Y be+1

let O be+P+""+P*P is N

say O

```

Try it here (Code will need to be pasted in, with `n` on the first line of input and `r` on the second)

---
Tags: code-golf, decision-problem, arithmetic
---


title: Tips for golfing in Octave

text:
# Question
Title: Tips for golfing in Octave
What general tips do you have for golfing in Octave? I'm looking for ideas that can be applied to code golf problems in general that are at least somewhat specific to Octave (e.g. "remove comments" is not an answer). Please post one tip per answer.

# Answer
1. Once you know, that `a` is free of zero values, using `nnz(a)` spares you 2 chars compared to `numel(a)`.
2. Prefer `a(a==0)` to `a(find(a==0))`.
3. `~t` is shorter than `t==0` , and even `~~t` is shorter than `t!=0`.
4. `0*(1:n)` is shorter than `zeros(1,n)`
5. Generally, `||` and `&&` , unlike many other operators, scalarize the result when the first argument is a scalar. For matrices, only non-empty matrices without elements equal to zero have the logical value of *true*.

Hence, we can do `0||m` instead of `all(all(m))` for any matrix.

Try with `0||[1 1;1 0]` and `0||[1 1;1 1]` to convince yourself.
6. When you are using a builtin a number of times, do a function handle to spare characters eg. `f=@find` . For short function names at least 3 occurrences justify this, for long ones - even with two occurrences.
7. When a function is a single statement, prefer `f=@(n)dosomething(n)` notation to `function r=f(n)r=dosomething(n);end` one.
8. Unfortunately, global variables have to be declared both in global scope and in each function using them. But there is an exception: anonymous `@(n)...` functions "see" all variables from the scope where they are called from.
9. It's possible to do `f(a=0,b=0)` instead of `a=0;b=0;f(a,b)`.
10. This seems undocumented feature, but the order of evaluation is from left to right (checked at v. 3.8.1), you can do `zeros(a=n,b=a*a)` to both create a n x n^2 matrix and store it's row and column number in `a` and `b` variables.
11. The operator precedence table is your friend. Don't do `b=(a==0)` since `b=a==0` is the same.
> 11 votes

# Answer
# Using argument list:

Octave is capable to get default arguments so expressions can be evaluated in the argument list.

This feature is useful when we want to compute an expression and use it multiple times:

```
f = @(x,a=sort(x))a(a>.5);

```

One use case is when we use an indexed assignment to modify part of an array and we want to use the array:

```
a=[1 2 3 4]
a(2)=5;

```

But the expression `(a(2)=5)` returns `a(2)`, or the expression `(a([1 3])=4)` returns a two elements array. Neither returns the whole array. We can use the argument list:

```
f=@(a=[1 2 3 4],b=a(2)=5)a;

```

Here the result of the indexed assignment is stored into a dummy variable `b` and the function returns the array.
> 9 votes

# Answer
I do not remember in what challenge I saw it someone use (please tell us=), but I found this a neat trick:

Usually if you add matrices you have to have the same size, but for one dimensional (1xn and nx1) matrices there is a shortcut (that does not work in Matlab):

```
z = (1:5)+(6:10)';

```

produces the same effect as

```
[x,y]=meshgrid(1:5,6:10);
z = x+y;

```

Then something that pawel.boczarski already mentioned: In Octave you can (while you cannot in Matlab) define auxiliary variables within function handles, AND a variable assignment itself has the value of the assignment so you can really shorten code (well this is an useless example but you'll get the trick):

```
f=@(n)(z=n+1)*z; %returns (n+1)^2

```

Then another trick (also applicable in Matlab) is abusing strings for storing (hardcoded) numbers (this neat trick is stolen from feersum), you just need something that interprets the string as number, which is as easy as e.g. adding zero:

```
a = 'abc';
a+0 %returns
[97 98 99]

```

Or

```
sum('abc') == 294

```
> 7 votes

# Answer
-In Octave it is possible to apply indexing on a temporary expression, a feature that prohibited in MATLAB and this feature is very useful for golfing. example:

Octave: `[1 23 4 5 7](3:4)` and its MATLAB equivalent: `a=[1 23 4 5 7];a(3:4)`
Octave: `hilb(4)(4:5,4:5)` and its MATLAB equivalent: `h=hilb(4);h(4:5,4:5)`
Octave: `{1,4,{4 5 6},[7 ;3]}{3}` and its MATLAB equivalent: `a={1,4,{4 5 6},[7 ;3]};a{3}`
Octave: `num2cell([1 2 3 4]){:}` for creation of comma separated list
Octave: `a'(:)'`

-Sometimes in an anonymous function as of a normal function we require to evaluate multiple expressions,that include assignment, One approach is that we can place each expression in a cell(since cell can contain object of multiple types ) and when we need the value of each expression we can use indexing to extract that element.

`{1,4,{4 5 6},[7 ;3]}{3}`
or

`{a=1,b=4,c={4 5 6},[b ;3]}{4}`
> 6 votes

# Answer
**Skip semicolons!**

I'll use this answer to illustrate the point.

The original code was:

```
function f(x);if~movefile('f.m',x);disp("+-+\n| |\n+-+");end

```

After removing semicolons, it could be reduced to the following, saving three bytes:

```
function f(x)if~movefile('f.m',x)disp("+-+\n| |\n+-+")end

```

This can be used quite a few places, and stuff you don't even try because it looks like a syntax error often works.
> 6 votes

# Answer
This is a simple, but useful one.

In Octave, but not MATLAB, you can do as in C++:

```
x = 0  ->  x = 0
x++    ->  ans = 0
x      ->  x = 1
++x    ->  ans = 2
x      ->  x = 2

```
> 3 votes

# Answer
## Use the `e` function instead of `ones` or `zeros`

Octave has an `e` function, which I don't think is very well known. It's like `ones`or `zeros`, but it produces copies of the number *e*. And it's *shorter*. This function can be useful sometimes:

* Instead of `ones(m,n)` you can use `~~e(m,n)` if you can get away with having `true` instead of `1`. Or even use `e(m,n)` directly if all you need is a nonzero value, not specifically `1` (for example if you are going to convert to `logical` later).
* Instead of `zeros(m,n)` you can use `~e(m,n)` if `false` is acceptable instead of `0`; or `+~e(m,n)` to produce actual zeros.
> 3 votes

# Answer
Another simple, but useful one (not possible in MATLAB):

Assign the same value to several variables:

```
a=b=c=0;

```
> 2 votes

# Answer
Use `rows(a)` instead of `size(a,1)`
> 2 votes

# Answer
**Use `eval`!**

Inspired by Luis Mendo's answer here.

---

Anonymous functions are in most cases shorter than creating a script that needs one or more calls to `input('')`. The downside is that loops and variable modifications (such as swapping two elements in a matrix) is ~~impossible~~ cumbersome.

With `eval`, you can fetch the input as you do with a normal anonymous function, and run the script as you do with a normal script:

Consider this:

```
c=(i=@input)('');N=i('');A=i('');for C=c,A(flip(k))=A(k=[x=find(A==C),N^2+1-x]);end,A

```

Compared to this:

```
@(c,N,A)eval('for C=c,A(flip(k))=A(k=[x=find(A==C),N^2+1-x]);end,A')

```

The code is identical, but the input section is much shorter.

---

This can also be used to modify input variables, like this (credit to Luis Mendo for this!):

```
f(x)eval('x([1,4])=x([4,1])`;

```
> 2 votes

# Answer
Related, but not identical tips for MATLAB.

A little known and little used feature of Octave is that most builtin functions can be called without parentheses, in which case they will treat whatever follows it as a string (as long as it doesn't contain spaces). If it contains spaces you need quotation marks. This can frequently be used to save a byte or two when using `disp`. All the following work, and gives the same result:

```
disp('Hello')
disp Hello
disp"Hello"

```

If you have spaces, then you *must* have the quotation marks:

```
disp('Hello, World!')
disp"Hello, World!"

```

Other, less useful examples include:

```
nnz PPCG
ans = 4

size PPCG
ans = 1  4

str2num 12
ans = 12

```
> 1 votes

---
Tags: code-golf, tips, octave
---