[Question]
  [
When I was a kid, there was a "really cool" shortcut to count to 100:
`1, 2, miss a few, 99, 100`
Output the exact string above, in the fewest characters possible, without using these characters: `0`, `1`, `2`, `9`
  
[Answer]
# JavaScript (ES6), 43 bytes
Browser only.
```
_=>atob`MSwgMiwgbWlzcyBhIGZldywgOTksIDEwMA`
```
[Try it online!](https://tio.run/##TcxNC4IwHIDxu5/ijxeVSisiqNBIipCQDgZBETl1W9ZysU3Fvry9nLw9l99zRxWSqchfalDwDLdI8QRckOB64JeEYGETwZ@mhB4YRh@MBEk8nRiWrXikRF5Q01poGnHbq@v9cBxGNQ3zmiZH9k4b/xZsTyxraro/PGSw3tThKm5TXkjOsM04NZ3zcDSeXRxbYalM0vlasAQ9KCrE8gwkL0WKdZiDHv0T9jvd0ron8iXtBw "JavaScript (Node.js) – Try It Online") (with a polyfill)
---
# JavaScript (ES6), 45 bytes
```
_=>[4-3,5-3,'miss a few',33*3,5*5*4].join`, `
```
[Try it online!](https://tio.run/##TYyxDoIwFEV3v@KlC4VAUYEBE3Q2Dg6MhEgDLSnBPtNW/PzaODnc5OQk5y5843Y06uUyjZPwsvGP5tyVWZFWYdFTWQscpPhEaVEkwSZVUvZsQaWHFAY/ora4CrbiTPNufzjWfc6csI5K5rB1RumZxjFcgFz1xlc1gcW3GQWBE5D2h3C/kXj3/yRD4r8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + coreutils, 40
```
tr 3-? /-:<<<"5, 6, miss a few, ==, 544"
```
[Try it online!](https://tio.run/##S0oszvj/v6RIwVjXXkFf18rGxkbJVEfBTEchN7O4WCFRIS21XEfB1lZHwdTEROn/fwA "Bash – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~43~~ 41 bytes
```
cat(T+F:T,"miss a few",3*33+F:T,sep=", ")
```
[Try it online!](https://tio.run/##K/r/PzmxRCNE280qREcpN7O4WCFRIS21XEnHWMvYGCxanFpgq6SjoKT5/z8A "R – Try It Online")
`T` and `F` are equal to `TRUE` and `FALSE`. They get coerced to integers `1` and `0` by the operators `+` and `:`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~54~~, ~~51~~, ~~47~~ 42 bytes
Saved **2 bytes** thanks to Digial Trauma's suggestion to replace `8*8+35 = 99` with `33*3 = 99`.
Saved **1 byte** by realizing that I could replace `8*8+36 = 100` with `4*5*5 = 100`.
Saved **4 bytes** thanks to dingledooper's suggestion to use `sep=', '` in the `print`!
Saved **5 bytes** thanks to ovs' suggestion to use `bytes` objects.
## New Answer
```
print(*b"","miss a few",*b"cd",sep=", ")
```
```
The b"" is equivalent to b"\1\2".
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQytJiZFJSUcpN7O4WCFRIS21XEkHKJacoqRTnFpgq6SjoKT5/z8A "Python 3 – Try It Online")
## Old Answer:
```
print(f"{4-3}, {6-4}, miss a few, {33*3}, {4*5*5}")
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EI02p2kTXuFZHodpM1wRI5WYWFyskKqSllgOFjI21wFImWqZaprVKmv//AwA "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 23 bytes
```
3Ṗ,³ṭ’¤j“¤mɗʂɠẉ⁾»W¤j⁾, 
```
[Try it online!](https://tio.run/##ATYAyf9qZWxsef//M@G5lizCs@G5reKAmcKkauKAnMKkbcmXyoLJoOG6ieKBvsK7V8KkauKBviwg//8 "Jelly – Try It Online")
## How it works
One thing to note: Jelly has the `Ṙ` atom, which prints a string Jelly representation of it's argument. Lists in Jelly do not use `[` and `]` as open/close markers, instead they consist of comma-separated values:
```
1,2,3,4,5Ṙ
```
prints `1,2,3,4,5`, unfortunately, without spaces.
```
3Ṗ,³ṭ’¤j“¤mɗʂɠẉ⁾»W¤j⁾,  - Main link. Takes no arguments
3                       - Yield 3;
 Ṗ                      - Pop from 3, yielding [1, 2]
      ¤                 - Group the previous links into a nilad:
   ³                    -   100
     ’                  -   Decrement; 99
    ṭ                   -   Tack; [99, 100]
  ,                     - Pair; [[1, 2], [99, 100]]
                  ¤     - Group the previous links into a nilad:
        “¤mɗʂɠẉ⁾»       -   The compressed string "miss a few"
                 W      -   Wrap; ["miss a few"]
       j                - Join; [1, 2, ["miss a few"], 99, 100]
                   j⁾,  - Join with ", "; "1, 2, miss a few, 99, 100"
```
[Answer]
# HTML + CSS, 118 bytes
```
<c>, <c>, miss a few, <d><d><c>, <c><style>c:before{content:counter(a);counter-increment:a}d{counter-increment:a 48}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
```
$><<[3/3,6/3,'miss a few',33*3,5*5*4]*", "
```
[Try it online!](https://tio.run/##KypNqvz/X8XOxibaWN9YxwyI1XMzi4sVEhXSUsvVdYyNtYx1TLVMtUxitZR0FJT@/wcA "Ruby – Try It Online")
-4 from Jonah. Borrows from Arnauld's answer.
# [Ruby](https://www.ruby-lang.org/), ~~46~~ 44 bytes
```
$><<"cd".bytes.insert(2,"miss a few")*", "
```
[Try it online!](https://tio.run/##KypNqvz/X8XOxkaJkSk5RUkvqbIktVgvM684tahEw0hHKTezuFghUSEttVxJU0tJR0Hp/38A "Ruby – Try It Online")
The three unprintables for codepoints 1, 2 and 3 are in the string containing "cd".
-2 from manatwork. [Other version with same bytecount](https://tio.run/##KypNqvz/v9hWiZGJOTlFSS@psiS1mKs42ijWVik3s7hYIVEhLbVciUvFzsamWEtJR0Hp/38A "Ruby – Try It Online")
[Answer]
# [Whispers v3](https://github.com/cairdcoinheringaahing/Whispers), ~~124..120~~ 114 bytes
```
>> Each 5 57
>> Then 7 3 6 3 4 3 54 3 8
> ", "
> "miss a few"
>> "L"
>> #3
>> #5
>> 53*6
>> #4
>> 8-7
>> Output 56
```
[Try it online!](https://tio.run/##HYwxDoAgFEN3T9HgZnQRPjqxuZm4eAFjMDBojEg8PvIZ@po3tJ/z4bZP6FMyBtO2OxBoqLKszl4YIKFzVA4xxspAtBBcpw8BGw77CR6IuVQtC4lJstHFFHPsyvES3zu@IJ3SDw)
**Explanation:**
I use the fact that each line with the line number \$x\$ can be called with \$x + k \cdot n \$, where \$k \in \mathbb{N} \$ and \$n\$ is total number of lines of code.
Example from code with 11 lines: the reference to line `1` can be replaced by `12`, `23`, `34`, and so on.
[Try the translated version online!](https://tio.run/##K8/ILC5ILSo2@v/fzk7BNTE5Q8FUwYgLyA7JSM1TMFcwVjADYhMgNjQAEhZcdgpKOgpKICo3s7hYIVEhLbVcCaRByQdMKRuDSVMQaallBuaYgEgLXXMQ5V9aUlBaomD4/z8A)
**Line by line:**
As always in Whispers, we run the last line first:
```
>> Output 56
```
This line outputs the result from line 56. Since the code does not have 56 lines it actually outputs line \$ 56 \mod 11 = 1\$:
```
>> Each 5 57
```
Applying the same trick again we can replace this line with:
```
>> Each 5 2
```
In line 5 we can expect a function and in line 2 an array. The function will be applied on each element of the array and it replaces the element with the result. Let us first look at line 5:
```
>> "L"
```
`L` is an argument from the `Each` statement in line 1. `L` is converted to a string.
Now line 2:
```
>> Then 7 3 6 3 4 3 54 3 8
```
`Then` creates an array with the arguments as its elements. If we would print this line we get the following array:
```
[1, ', ', 2, ', ', 'miss a few', ', ', 99, ', ', 100]
```
**Explanation of the arguments:**
Line 3 and 4: simple strings
Line 6: Returns the length of line 3, so we get `2`
Line 7: Returns the length of line 5, so we get a `1`
Line 8: Returns the result of line 53 (actually 9) raised to the power of the result of line 6, so we get `100`
Line 54 (actually 10): Subtracts result of line 8 with the result of line 7, so we get a `99`
[Answer]
# [PHP](https://php.net/), ~~57~~ ~~56~~ 53 bytes
```
printf('%c, %d, miss a few, %d, %o',7*7,5-3,33*3,64);
```
[Try it online!](https://tio.run/##K8go@G9jXwAkC4oy80rSNNRVk3UUVFN0FHIzi4sVEhXSUsshfNV8dR1zLXMdU11jHWNjLWMdMxNN6///AQ "PHP – Try It Online")
A `printf`, some spices, stir
EDIT: -1 byte thanks to Digital Trauma
EDIT 2: -3 bytes thanks to Michael Dorgan for octal, thought about 153 with `%x` for hex but it has a 1..
**Also, less fun but 2 bytes shorter by manatwork, improved by BadHorsie (it seems that `<?=` can also take multiple arguments with comas):**
# [PHP](https://php.net/), ~~51~~ 49 bytes
```
<?=5-4,', ',5-3,', miss a few, ',33*3,', ',5*5*4;
```
[Try it online!](https://tio.run/##K8go@P/fxt7WVNdER11HQV3HVNcYxMjNLC5WSFRISy0HCRobaxlDpbVMtUys//8HAA "PHP – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~54~~ 56 bytes
```
l(){printf("%c, %d, miss a few %d, %o",7*7,5-3,'c',64);}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpJqU1ySkpmvl2HHlZlXopCjoWkNZuQmZuZpaFaD@ApFqSWlRXkKBta1/4H86oIioII0DSXVZB0F1RQdhdzM4mKFRIW01HIwVzVfScdcy1zHVNdYRz1ZXcfMRBOo8T8A "C (gcc) – Try It Online")
Let's save a couple bytes using Octal for the 100. Thanks to Sheik Yerbouti for saving a byte and point out the no commas issue.
[Answer]
# [R](https://www.r-project.org/), 52 bytes
```
cat(chartr("@-K","/-:","B, C, miss a few, JJ, BAA"))
```
[Try it online!](https://tio.run/##K/r/PzmxRCM5I7GopEhDyUHXW0lHSV/XCkg66Sg46yjkZhYXKyQqpKWW6yh4eekoODk6Kmlq/v8PAA "R – Try It Online")
Encodes numbers as uppercase letters and then applies character range translation. Since we can't directly type `0-9`, we expand the range by 1 character in both directions resulting in `/-:`.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 146 bytes
```
-[----->+>+>+>++>++<<<<<]>>>--.-----.------------.<-.------.>.>+++++++.>+++.<++++++..<.>>--------.<<.>>+++++.-.<++++.<<.>.<<++++++..>.>.<+++++.-..
```
[Try it online!](https://tio.run/##NYtRCoBgCIMPFO4EsotEDxUEEfQQdH77pzlFnPvcnvW8j3e/Imw2iVOV2qWFpBkyrPkL3h7EoFO5wH8Dh56bl6vACsnTGI1TrglEfA "brainfuck – Try It Online")
A fairly straightforward 255/5=51 loop giving ASCII 51 and ASCII 102 as `333ff` in 5 consecutive cells, followed by hunt and peck strategy.
[Answer]
# [Perl 5](https://www.perl.org/), 42 bytes
```
$,=", ";say!!3,5-3,"miss a few",3*33,4*5*5
```
Sets the record separator, and prints a few numbers and a string.
[Try it online!](https://tio.run/##K0gtyjH9/19Fx1ZJR0HJujixUlHRWMdU11hHKTezuFghUSEttVxJx1jL2FjHRMtUC6j2X35BSWZ@XvF/XV9TPQNDAwA "Perl 5 – Try It Online")
# [Perl 5](https://www.perl.org/), 43 bytes
```
say"C, D, miss a few, KK, CBB"=~y,A-L,/-:,r
```
Translates B-K to 0-9 (extended by one more ASCII code on each side of the range) and prints.
[Try it online!](https://tio.run/##K0gtyjH9/784sVLJWUfBRUchN7O4WCFRIS21XEfB21tHwdnJScm2rlLHUddHR1/XSqfo//9/@QUlmfl5xf91fU31DAwNAA "Perl 5 – Try It Online")
# [Perl 5](https://www.perl.org/), 44 bytes
```
$,=", ";say unpack"c3/acc","
miss a fewcd"
```
Sets the record separator, and unpacks values to be printed.
[Try it online!](https://tio.run/##K0gtyjH9/19Fx1ZJR0HJujixUqE0ryAxOVsp2Vg/MTlZSUeJkYkrN7O4WCFRIS21PDlF6f//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 – Try It Online")
[Answer]
# [Julia](http://julialang.org/), 41 bytes
```
()->join([b"";"miss a few";b"cd"],", ")
```
[Try it online!](https://tio.run/##yyrNyUw0rPifZvtfQ1PXLis/M08jOkmJkUnJWik3s7hYIVEhLbVcyTpJKTlFKVZHSUdBSfN/QVFmXolGmoam5n8A "Julia 1.0 – Try It Online")
the first string is `"\1\2"` which is allowed if I understand the challenge correctly
`b"str"` converts the string in an array of the value of each character so `b"\1\2" => [1,2]` and `b"cd" => [99,100]`
[Answer]
# [Husk](https://github.com/barbuz/Husk), 31 bytes
```
mȯ←←←"4/#5/#plvv#d#ihz/#<</#433
```
[Try it online!](https://tio.run/##yygtzv7/P/fE@kdtEyBIyURf2VRfuSCnrEw5RTkzo0pf2cZGX9nE2Pj/fwA "Husk – Try It Online")
Explanation:
```
m                                 Map the function...
 ȯ←←←                             Decrement character 3 times
      "4/#5/#plvv#d#ihz/#<</#433  desired string "ASCII-shifted" by 3
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
³ḊĖ.ịṚj“¤mɗʂɠẉ⁾»W¤j⁾, 
```
A full program that prints the result.
**[Try it online!](https://tio.run/##ATUAyv9qZWxsef//wrPhuIrEli7hu4vhuZpq4oCcwqRtyZfKgsmg4bqJ4oG@wrtXwqRq4oG@LCD//w "Jelly – Try It Online")**
### How?
```
³ḊĖ.ịṚj“¤mɗʂɠẉ⁾»W¤j⁾,  - Link: no arguments
³                      - 100
 Ḋ                     - dequeue -> [2,3,...,99,100]
  Ė                    - enumerate -> [[1,2],[2,3],...,[98,99],[99,100]]
   .                   - 0.5
    ị                  - index into -> [[99,100],[1,2]]
     Ṛ                 - reverse
                 ¤     - nilad followed by links as a nilad:
       “¤mɗʂɠẉ⁾»       -   dictionary compression of "miss a few"
                W      -   wrap in a list  -> ["miss a few"]
      j                - join              -> [1,2,"miss a few",99,100]
                   ⁾,  - ", "
                  j    - join              -> [1,", ",2,", ","miss a few",", ",99,", ",100]
                       - implicit print    -> `1, 2, miss a few, 99, 100`
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 16 bytes
I don't think this would be shorter with `0`, `1`, `2` and `9`.
```
XY…š§€…†Óт<т„, ý
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/IvJRw7KjCw8tf9S0Bsh61LDg8OSLTTYXmx41zNNROLz3/38A "05AB1E – Try It Online")
```
X                # push 1
 Y               # push 2
  …š§€…†Ó        # push compressed dictionary string "miss a few"
         т<      # push 100-1
           т     # push 100
            „,   # push string ", "
               ý # join the stack with this string
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 20 19 17 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
saved 2 bytes thanks to Razetime
```
ü←φr5╧wL'•↔♦$▒ò╠‼
```
[Run and debug it](https://staxlang.xyz/#p=811bed7235cf774c27071d0424b195cc13&i=)  
  
  
Original brain-dead solution for reference purposes only:
# [Stax](https://github.com/tomtheisen/stax), 22 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü2Φÿßbÿ»f╙m¡6¿₧|░╘;┬u»
```
[Run and debug it](https://staxlang.xyz/#p=8132e898e16298af66d36dad36a89e7cb0d43bc275af&i=)
[Answer]
# C++, 56 bytes
```
[]{for(int x:"4/#5/#plvv#d#ihz/#<</#433"s)putchar(x-3);}
```
Inspired by a [comment](https://codegolf.stackexchange.com/questions/219495/1-2-miss-a-few-99-100#comment511335_219544).
Usage:
```
#include <string>
#include <stdio.h>
using namespace std;
int main() {
    auto k = [](){for(int x:"4/#5/#plvv#d#ihz/#<</#433"s)putchar(x-3);};
    k();
    return 0;
}
```
[Try it online!](http://cpp.sh/3lefr)
[Answer]
# [Barrel](https://www.github.com/LorenDB/barrel), 31 34 bytes
```
+n, +n, 'miss a few, '#44+#45+n, +n
```
This is my own esolang, follow the link for more info.
Increments the accumulator, prints it, implicitly prints some strings (`,` and `miss a few,` are implicitly printed), does a loop on accumulator incrementation, and finishes as it started.
Edit: I realized that "97" used a "9". *smacks forehead*
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 32 bytes
```
B, C, miss a few, JJ, BAA
T`L`d
```
[Try it online!](https://tio.run/##K0otycxL/P@fy0lHwVlHITezuFghUSEttVxHwctLR8HJ0ZErJMEnIeX/fwA "Retina 0.8.2 – Try It Online") Explantion:
```
B, C, miss a few, JJ, BAA
```
Replace the empty input with the literal string.
```
T`L`d
```
Transliterate upper case letters to digits.
[Answer]
# [PowerShell (ASCII answer)](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 128 bytes
```
$k=3-3;((@(46+3),@(53-3),@('miss a few'),@(57,57),@((46+3),48,48))|%{$k++;if($k-eq3){$_}else{($_|%{[char]$_})-join''}})-join', '
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyXb1ljX2FpDw0HDxEzbWFPHQcMUKACi1XMzi4sVEhXSUsvVweLmOqbmIAZUpYkFEGlq1qhWq2Rra1tnpmmoZOumFhprVqvE16bmFKdWa6jEA2WjkzMSi2KBYpq6WfmZeerqtTCWjoL6//8A "PowerShell – Try It Online")
# [PowerShell (Base64 one)](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 135 bytes
```
[Text.Encoding]::Unicode.GetString([Convert]::FromBase64string('MQAsACAAMgAsACAAbQBpAHMAcwAgAGEAIABmAGUAdwAsACAAOQA5ACwAIAAxADAAMAA='))
```
[Try it online!](https://tio.run/##JYuxCsIwFEU/p3bppA4Fh5tYo0OQoJ2Kg7aPWmiTkgTTv4@BTPdwDnc1gaz70jzH2D1p81WjezNMenzVdaunxFQJ8g9vk9t13OgfWZ/ixZqFvR0d9y63Qio4cECOeT@KrbhK9AEjRIMb2ALRYgi53xUO4CF5bDinH3AqyjLGPw "PowerShell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 23 bytes
```
“×ƤṪ5Ġpṃ:Ƒ5ṫȷØJkxXp⁺¥ġ»
```
[Try it online!](https://tio.run/##ATMAzP9qZWxsef//4oCcw5fGpOG5qjXEoHDhuYM6xpE14bmryLfDmEpreFhw4oG6wqXEocK7//8 "Jelly – Try It Online")
Same length as caird's answer, much more boring.
[Answer]
# [Python 2](https://docs.python.org/2/), 59 bytes
```
print ', '.join(map(str,(4-3,5-3,'miss a few',33*3,5*5*4)))
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EQV1HQV0vKz8zTyM3sUCjuKRIR8NE11jHFIjVczOLixUSFdJSy9V1jI21gKJaplommpqa//8DAA "Python 2 – Try It Online")
Thanks to @arnauld for js answer
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 29 bytes
```
j+\,d[=hZhZ"miss a few"t=*TTT
```
[Try it online!](https://tio.run/##K6gsyfj/P0s7Ricl2jYjKiNKKTezuFghUSEttVypxFYrJCTk/38A "Pyth – Try It Online")
---
Python 3.8 translation:
```
Z=0
T=10
print(", ".join(map(str,[(Z:=Z+1),Z+1,"miss a few",(T:=T*T)-1,T])))
```
[Answer]
# [PHP](https://php.net/), 48 bytes
```
<?=join(', ',[!'',~-3,'miss a few',33*3,45^73]);
```
[Try it online!](https://tio.run/##K8go@P/fxt42Kz8zT0NdR0FdJ1pRXV2nTtdYRz03s7hYIVEhLbVcXcfYWMtYx8Q0ztw4VtP6/38A "PHP – Try It Online")
[Answer]
# Vim, 37 keystrokes
```
i3, 3, miss a few, 8, <esc>|<C-x><C-x>l.l<C-a>ylp$pp<C-a>
```
[Answer]
# PHP, 58 54 bytes
```
<?=join(', ',[$i=3/3,++$i,'miss a few',$i=33*3,++$i]);
```
PHP doesnt really want to be typed short, but I liked coming up with this :)
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~21~~ ~~20~~ 19 bytes
```
3ɽ÷«eeȮǒḋp«₁‹₁W‛, j
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=3%C9%BD%C3%B7%C2%ABee%C8%AE%C7%92%E1%B8%8Bp%C2%AB%E2%82%81%E2%80%B9%E2%82%81W%E2%80%9B%2C%20j&inputs=&header=&footer=)
## Explained
```
3ɽ÷      # stack = [1, 2]
«eeȮǒḋp« # stack = [1, 2, "miss a few"] 
₁‹₁      # stack = [1, 2, "miss a few", 99, 100]
W‛, j    # join stack on ", "
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 45 bytes
```
say join ", ",5-4,5-3,"miss a few",3*33,4*5*5
```
[Try it online!](https://tio.run/##K0gtyjH7/784sVIhKz8zT0FJB4hMdU2A2FhHKTezuFghUSEttVxJx1jL2FjHRMtUy/T/fwA "Perl 6 – Try It Online")
]