text:
Phony fractions
Context
If a0 and b0 are two decimal numbers, with a and b representing the decimal expansion of all digits but the least significant one, then we know that
$$\frac{a0}{b0} = \frac{a{\not\mathrel0}}{b{\not\mathrel0}}= \frac{a}{b}$$
Phony fraction
A phony fraction is a fraction where the numerator and denominator share a digit (other than a 0 in the units place) and, when that digit is erased from both numerator and denominator, the simplified fraction happens to be equal to the original one.
Example
\$16/64\$ is a phony fraction because if we remove the \$6\$, we get \$16/64 = 1{\not\mathrel6}/{\not\mathrel6}4 = 1/4\$, even though the intermediate step of removing both sixes is wrong.
Task
Given a fraction, determine if it is phony or not.
Note
Notice that 10/20 is not a phony fraction. Even though 10/20 = 1/2, the simplification here was mathematically sound, you divided numerator and denominator by 10, which amounts to "crossing out a 0 on the num. and the den.".
On the other hand, 102/204 = 12/24 is a phony fraction, because supposedly we can't cross out the 0s.
Because of this, when the input fraction is such that crossing out 0 gives an equivalent fraction to the original, the behaviour is unspecified.
Input
The fraction we care about, with positive numerator and denominator, in any sensible format. Some examples of sensible formats include:

a list [num, den] or [den, num]
a string of the form "num/den"
the exact fraction, if your language supports it
two different arguments to your function

Assume both are greater than 9. You can also assume the denominator is strictly larger than the numerator.
Output
A Truthy value if the fraction is phony and a Falsy value if it is not.
Test cases
(Please keep an eye out for the comments, as some people have really nice test case suggestions! I'll edit them in, but sometimes I don't do it immediately.)
Truthy
69/690 = 9/90
99/396 = 9/36
394/985 = 34/85
176/275 = 16/25
85/850 = 5/50
59/295 = 5/25
76/760 = 6/60
253/550 = 23/50
52/520 = 2/20
796/995 = 76/95
199/796 = 19/76
88/583 = 8/53
306/765 = 30/75
193/965 = 13/65
62/620 = 2/20
363/561 = 33/51
396/891 = 36/81
275/770 = 25/70
591/985 = 51/85
165/264 = 15/24
176/671 = 16/61
385/781 = 35/71
88/484 = 8/44
298/596 = 28/56
737/938 = 77/98
495/594 = 45/54
693/990 = 63/90
363/462 = 33/42
197/985 = 17/85
462/660 = 42/60
154/451 = 14/41
176/374 = 16/34
297/990 = 27/90
187/682 = 17/62
195/975 = 15/75
176/473 = 16/43
77/671 = 7/61
1130/4181 = 130/481

Falsy
478/674
333/531
309/461
162/882
122/763
536/616
132/570
397/509
579/689
809/912
160/387
190/388
117/980
245/246
54/991
749/892
70/311
344/735
584/790
123/809
227/913
107/295
225/325
345/614
506/994
161/323
530/994
589/863
171/480
74/89
251/732
55/80
439/864
278/293
514/838
47/771
378/627
561/671
43/946
1025/1312

You can check this reference implementation that I used to generate some phony fractions by brute-force.

This is code-golf so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!

Possible duplicate of How NOT to reduce fractions

The linked challenge is about removing a common substring. This is about removing a common digit. I think the difference is significant enough to make it non-dupe

May we accept lists of digits?

Is 11/11 a phony fraction?

@JonathanFrech yes it is. Just not a very interesting one, I would say.

@JonathanAllan yes, you may accept lists of digits.

J, 22 bytes
%&".e.=/#&,%/&(1".\.])

Try it online!
quick explanation for now:

take the input as strings
%/&(1".\.]) creates a function table %/ whose axes are the integer ". lists formed by the 1-outfixes \. (remove 1 digit at a time) of both args, and whose cells are the quotients of those numbers
=/ forms a corresponding function table of the same shape, which acts as a boolean mask which is only 1 when corresponding "removed" digits are equal
#&, Flattens , both function tables into lists and uses the boolean mask to filter # the quotients, since cancelling is only valid when the digits are equal
%&". the true quotient of the inputs after converting to ints
e. is that true quotient an element of the filtered list from step 4.

Really nice! +1 I have no idea what is going on but it is passing all test cases... So it can't be that wrong :p

Python 3, 86 bytes
lambda a,b:g(a)&g(b)
g=lambda s:{(int(s[:i]+s[i+1:])/int(s),x)for i,x in enumerate(s)}

Try it online!
-8 bytes thanks to ovs
Making use of the fact that the boolean value for a0/b0==a/b is equivalent to a0/a==b0/b. The helper function g generates all ratios a0/a and keeps track of the removed digit. Then it does the same for b0/b. The main function determines the intersection of the two sets.
Returns a non-empty set (boolean True in Python) if a match is found, and an empty set (boolean False in Python) otherwise.

Looking good! +1 for your good work :D

114 bytes with enumerate.

05AB1E, 26 23 22 bytes
€æ`âεR*Ë9ÝºIJySõ.;å*}à

-3 bytes thanks to @Grimmy.
Input as a pair [numerator, denominator].
Try it online or verify all test cases.
Explanation:
€æ         # Get the powerset of each number in the (implicit) input-pair
  `        # Push both lists separated to the stack
   â       # Create all possible pairs by taking the cartesian product
ε          # Map each pair to:
 R         #  Reverse the pair
  *        #  Multiply it by the (implicit) input-pair
   Ë       #  Check if both values are the same
 9Ý        #  Push a list in the range [0,9]
   º       #  Mirror each horizontally: [00,11,22,33,44,55,66,77,88,99]
 IJ        #  Push the input, joined together
   y       #  Push the pair we're mapping again
    S      #  Convert it to a flattened list of digits
     õ.;   #  Remove the first occurrence of those digits in the joined input,
           #  by replacing each first occurrence with an empty string
 å         #  Check if what remains is in the list of doubled digits
        *  #  And check if both that and the earlier check are truthy
}à         # After the map: check if any where truthy by taking the maximum
           # (after which this is output implicitly as result)

The R*Ë checks with input-pair \$[a,b]\$ and potentially reduced pair \$[c,d]\$ whether \$a×d=b×c\$ (source).

24 with €æ`âʒ9Ý2×IJySõ.;å}εR*Ë}à. (Use €æ`âʒ9Ý2×®JySõ.;å}εR®*Ë}à to "verify all test cases".)

Down to 23 with €æ`âεR*Ë9Ý2×IJySõ.;å*}à (€æ`âεR®*Ë9Ý2×®JySõ.;å*}à to verify all).

@Grimmy Thanks. And an additional -1 with º instead of 2×, since it apparently vectorizes with lists. :)

Good catch with º. I had missed the other than a 0 part of the spec, so that 9Ý might need to be changed to 9L (pending confirmation from RGS).

Really good job! +1 sorry for taking so long, but I have tried to make the 0 rule more clear. 10/20 is not a phony fraction because the simplification 10/20 = 1/2 by crossing out the digits is mathematically sound.

Jelly,  18  17 bytes
DḌ-Ƥż$€÷þ/Ẏċ÷/,1Ɗ

A monadic Link accepting a list, [numerator, denominator] which yields zero (falsey) if not reducible, or a positive integer (truthy) if reducible.
Try it online! Or see the test-suite.
How?
DḌ-Ƥż$€÷þ/Ẏċ÷/,1Ɗ - Link: [n, d]
D                 - decimal digits (vectorises)
     $€           - last two links as a monad for each:
  -Ƥ              -   for overlapping 1-outfixes (i.e. less 1 digit):
 Ḍ                -     un-decimal
    ż             -   zip (with digits - these are in the same order)
         /        - reduce by:
        þ         -   outer-product with:
       ÷          -     division -> [outfixesDivided, digitsDivided]
          Ẏ       - tighten (to a list of pairs)
                Ɗ - last three links as a monad:
             /    -   reduce ([n, d]) by:
            ÷     -     division
               1  -   one
              ,   -   pair -> [n÷d, 1]  i.e. digitsDivided must be 1
           ċ      - count occurrences

Unfortunately enumerate, Ė, given a number, n, yields [[1, n]] not simply the first pair [1, n], which would save a byte with ...ċ÷/Ė$.

Really short answer! +1 Jelly with some nice submissions here

T-SQL, 192 bytes
Returns -1 for true, 0 for false
WITH x as(SELECT substring(@n,number,1)b,substring(@,number,1)a,number
n FROM spt_values)SELECT~(1/~count(*))FROM x,x y
WHERE x.b=y.a AND x.b>0and 1*stuff(@,x.n,1,'')*@n=@*1*stuff(@n,y.n,1,'')

Try it online

Uh, really interesting submission! +1 thanks for your work!

JavaScript (ES6),  100  93 bytes
Saved 7 bytes by using @Jitse's method
Takes input as ('numerator')('denominator'). Returns a Boolean value.
n=>d=>(g=n=>[...n].map((x,i)=>x+-(n.slice(0,i)+n.slice(i+1))/n))(n).some(v=>g(d).includes(v))

Try it online!

Great job! +1 i don't know if you think it helps, but you may want to consider reducing the test case results into a single boolean? Using .reduce((a,b)=>a&&b,true) and .reduce((a,b)=>a||b,false) instead of the .join :) I'm leaving this here for your consideration!

Perl 6, 58 bytes
{[(&)] .map:{m:g/./>>.&{(.prematch~.postmatch)/.orig~$_}}}

Try it online!
Same approach as in Jitse's Python answer.
Alternative, 75 bytes
{?grep {[==] $_ Z*$^m[(3,4),(0,2)]>>.join},m:ex/^(.*)(.)(.*)\s(.*)$1(.*)$/}

Try it online!
Same regex-based approach as in Neil's Retina answer.

Cool submission! Thanks for your work +1

Jelly, 22 bytes
DżḌ-Ƥ$€ŒpḢ€E$Ƈ÷/€F=÷/Ẹ

Try it online!
A monadic link taking a list of [num, den] and returning 1 for phony and 0 for non-phony.
Explanation
D                      | Convert to decimal digits
     $€                | For each list of decimal digits:
 ż                     | - Zip with:
  Ḍ-Ƥ                  | - A list of lists of digits each one with 1 removed, that has then been converted back to a list of integers
       Œp              | Cartesian product
            $Ƈ         | Keep those where the following is true:
         Ḣ€            | - The heads of each list (which will be the removed digits)
           E           | - Are equal
              ÷/€      | Reduce each by dividing
                 F     | Flatten (to remove the nested lists)
                  =÷/  | Equal to the original argument reduced by division
                     Ẹ | Any

Cool submission! I'll be wanting to give this a very good look +1

Ruby, 109 86 81 78 bytes
->n,d{g=->n,d{w=1;n.digits.map{|s|[s,d*(n%w+w*(n/w*=10))]}};g[n,d]&g[d,n]!=[]}

Try it online!
Saved some bytes by using multiplication instead of division: if a/b==a0/b0, then a*b0==a0*b.
Then stole some ideas from Jitse's excellent Python answer (upvote him!) to trim a couple of bytes off the corners.

Great minds copy, genius minds steal. A friend of mine says this a lot. Haven't figured out if it makes sense, but your paragraph reminded me of it +1

C (gcc), 128 126 124 bytes

Thanks to ceilingcat for saving two four bytes.

P,h,o,n,_=10;i(e,s){for(n=P=1;e/P;P*=_)for(h=1;s/h;h*=_)e/P%_&&e/P%_==s/h%_&&(o=s/h/_*h+s%h,n*=!o|(e/P/_*P+e%P)*s-e*o);e=n;}

Try it online!

Thanks for your submission! +1 what are the weird numbers next to the Falsy test cases?

@RGS Those are (not) truthy values; i's output.

Nice variable naming.

Phonies........

@ceilingcat Thank you.

Excel (Ver. 1911), 64 Bytes
Fraction entered as a row literal of 2 strings e.x. ={"16","64"}
A1    'Input: row literal of 2 strings -> ={num,den}
C1:D9 {=SUBSTITUTE(A$1#,ROW(),,1)} 'Array formula (entered with <C-S-Enter>)
E1    =SUM((C1:C9/D1:D9=A1/B1)*(A1#<>C1#)) 'Output (truthy/falsy int)

Test Sample

Cool submission! Thanks :D +1

Retina, 69 bytes
L$w`(.)(.*)/(.*)\1
$($`$2)*$($3$1$')*_/$($`$1$2)*$($3$')*
\b(_+)/\1\b

Try it online! Link includes test suite. Outputs the number of phony pairs of digit cancellations. Explanation:
L$w`(.)(.*)/(.*)\1

List all matching pairs of digits in the numerator and denominator, including overlaps.
$($`$2)*$($3$1$')*_/$($`$1$2)*$($3$')*

Cross-multiply each value with the digit removed from the other value.
\b(_+)/\1\b

Count how many times this results in the same answer, indicating that this digit cancellation was a phony fraction.

And here it is, Retina again! +1 keep up the interesting work!

Charcoal, 27 bytes
⊙θ⊙η∧⁼ιλ⁼×ＩΦη⁻ξμＩθ×ＩΦθ⁻ξκＩη

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, i.e. - for phony, nothing otherwise. Explanation:
 θ                          First input as a string
⊙                           Any character satisfies
   η                        Second input as a string
  ⊙                         Any character satisfies
      ι                     First character
     ⁼                      Equals
       λ                    Second character
    ∧                       Logical And
            η               Second input
           Φ                Filtered by
              ξ             Inner index
             ⁻              Minus (i.e. not equal to)
               μ            Second index
          Ｉ                 Cast to integer
         ×                  Multiplied by
                 θ          First input
                Ｉ           Cast to integer
        ⁼                   Equals
                     θ      First input
                    Φ       Filtered by
                       ξ    Inner index
                      ⁻     Minus (i.e. not equal to)
                        κ   First index
                   Ｉ        Cast to integer
                  ×         Multiplied by
                          η Second input
                         Ｉ  Cast to integer
                            Implicitly print

Thanks for your submission! +1


text:
How many unique one sided polyominos
Context
From Wikipedia:
A polyomino is a plane geometric figure formed by joining one or more equal squares edge to edge.
one-sided polyominoes are distinct when none is a translation or rotation of another (pieces that cannot be flipped over). Translating or rotating a one-sided polyomino does not change its shape.
In other words, a one sided polyomino reflected across its x or y axis is not the same as the original polyomino, but a one sided polyomino that is rotated is still considered the same polyomino
Task
Given a number n, find how many different unique one sided
polyominos can be created using n number of blocks
Input
Take integer n as input for the number of blocks that exist in the polyomino
Output
An integer of the amount of unique one sided polyominos that can be generated
Examples
in -> out
4 -> 7
5 -> 18
6 -> 60
7 -> 196
More test cases can be found on the Wikipedia page and OEIS

https://oeis.org/A000988

@Anush what do you think I should change it to? This is my first question here so I'm still trying to figure this out. Edit: nvm misspelling, I'll correct it

Related, related.

It took me a while to figure out what one-sided means here (and I'm stilk not sure). Can you clarify in the challenge text?

What is a "one sided" polyomino?

@RGS I interpret that as: you cannot flip it upside down (and that's why the two orange ones here are not the same)

Sorry for the confusion, I improved the explanation a little better, but I am open to suggestions for improvement

Jelly,  39  37 bytes
Soon to be crushed by MATL and, quite possibly, APL
p`œc⁸ḣ1ạ§ỊẸʋƇ@;QɗƬƊṪṢƊƑƇŒṬZṚŒṪƲƬṂ$€QL

Try it online! (It's pretty slow - a(6) took ~30 minutes locally!)
To see them instead try this (L -> ŒṬ€G€j⁾¶¶).
How?
Builds all index lists, where each represents the locations of 1s on a grid of 1s and 0s, up to those for a square of side n, filters for those that have their 1s fully connected, then selects the "minimal" of each after any amount of rotation + vertical translation, and finally de-duplicates and yields the length.
   p`œc⁸ḣ1ạ§ỊẸʋƇ@;QɗƬƊṪṢƊƑƇŒṬZṚŒṪƲƬṂ$€QL - Link: integer, n
   A....B..................C............ - break down below

A: p`œc⁸ - Get all ways to have n 1s on an n*n grid as multidimensional indices
    `    - use n as both arguments of:
   p     -   Cartesian product -> all pairs of [1..n] - these are in sorted order
       ⁸ - chain's left argument, n
  œc     - combinations (no replacement) - ...and so each of these are in sorted order

B: ḣ1ạ§ỊẸʋƇ@;QɗƬƊṪṢƊƑƇ - Keep only the fully-connected ones (call input "All")
                     Ƈ - filter keep those for which:
                    Ƒ  -   is invariant under:
                   Ɗ   -     last three links as a monad:
                Ɗ      -       last three links as a monad:
    1                  -         one
   ḣ                   -         head to index - i.e. [firstPair] (initial "Current")
               Ƭ       -         collect up while distinct, applying:
              ɗ        -           last three links as a dyad - i.e. f(Current, All):
           @           -             with swapped arguments - i.e. f(All, Current):
          Ƈ            -               filter keep those (of All) for which:
         ʋ             -                 last four links as a dyad - i.e. f(All, Current):
     ạ                 -                   absolute difference (vectorises)
      §                -                   sum each
       Ị               -                   insignificant? (effectively "in (0,1)?")
        Ẹ              -                   any? - i.e. any are neighbours/same?
            ;          -             concatenate (the result with Current)
             Q         -             deduplicate (-> Current for the next Ƭ-loop)
                 Ṫ     -       tail
                  Ṣ    -       sort

C: ŒṬZṚŒṪƲƬṂ$€QL - Count the distinct results
             €   - for each:
            $    - last two links as a monad:
          Ƭ      -   collect up while distinct, applying:
         Ʋ       -     last four links as a monad:
   ŒṬ            -       2d array from multidimensional indices
     Z           -       transpose
      Ṛ          -       reverse (transpose + reverse = rotate 1/4 anti-clockwise)
       ŒṪ        -       truthy multidimensional indices
           Ṃ     -   minimum
              Q  - de-duplicate
               L - length

How did you code this in such a short amount of time..??

@RGS Because Jonathan is good with Jelly and golfing in general, and his answer was posted 3 hours after the challenge was posted, so plenty of time for him. I'm pretty sure writing his explanation above took most of the time. ;p

Woah, visualizing nominos procedurally in under 50 bytes is insane

@KevinCruijssen that seems plausible indeed

Well, you know a challenge is going to be a doozy when the Jelly answer is 39 bytes!

@RGS - the thinking & coding did actually take me more than an hour, maybe even two - I saw the question within 8 minutes of it being posted, posted a solution 2.5h later, and didn't immediately start writing the code-breakdown (see history "Forgive the lack of code-breakdown - I need a break!").

@JonathanAllan either way, great job :) do you think you'll be able to golf it further? As in, is this a working algorithm and maybe you can find some shortcuts, or has this been already quite golfed?

@RGS I feel that the method employed is fairly well golfed while it's possible that there's a byte or two to find (I think I may have just spotted a save actually!). A change of method might find a more terse solution too.

@JonathanAllan thanks, and good job on the save!

JavaScript (Node.js),  269 ... 243  239 bytes
Rather slow for \$n\ge7\$, but it does find \$a(8)=704\$ in a bit more than 2 minutes on my laptop.
f=(n,m=[...o=Array(w=n)],i=c=0)=>n?m.map((r,y)=>m.map((_,x,[...m])=>!i|1<<x&~r&(m[y+1]|r/2|r*2)&&f(n-1,m,m[y]|=1<<x)))|c:[0,0,0,0].some(_=>o[M=(m=m.map(a=(_,y)=>m.map(b=(v,x)=>a|=b|=(v>>y&1)<<w+~x)|b)).flatMap(v=>v/(a&-a)||[])])?0:o[M]=++c

Try it online!
How?
Building the \$n\$-polyominos
We store the polyomino in an array \$m[\:]\$ of \$n\$ bitmasks and build all possible shapes recursively. At each iteration, a new cell adjacent to an existing cell is added.
m.map((r, y) =>            // for each bitmask r at position y:
  m.map((_, x, [...m]) =>  //   for each position x, using a copy of m[]:
    !i |                   //     always set this cell if this is the 1st iteration
    1 << x &               //     otherwise, the x-th bit
    ~r &                   //     must not be already set in the current row
    (                      //     and one of the following conditions must be met:
      m[y + 1] |           //       - the x-th bit is set in the next row
      r / 2 |              //       - the (x+1)-th bit is set in the current row
      r * 2                //       - the (x-1)-th bit is set in the current row
    ) &&                   //     if truthy:
      f(                   //       do a recursive call:
        n - 1,             //         decrement n
        m,                 //         pass the copy of m[]
        m[y] |= 1 << x     //         set the bit at (x, y)
      )                    //       end of recursive call
  )                        //   end of inner map()
)                          // end of outer map()

Applying the rotations and translations
When we have enough cells, we apply all 4 possible rotations to \$m[\:]\$, discard the empty rows and translate it horizontally so that it's 'right-justified'. We store the encountered shapes in the object \$o\$ and the number of distinct shapes in \$c\$.
[0, 0, 0, 0].some(_ =>     // repeat 4 times:
  o[                       //   we will ultimately test this entry in o
    M = (                  //     save the final matrix in M[]
                           //     1) rotate
      m = m.map(a =        //       starting with a zero'ish,
      (_, y) =>            //       for 0 <= y < w:
        m.map(b =          //         starting with b zero'ish,
        (v, x) =>          //         for each bitmask v at position x in m[]:
          a |=             //           update the global bitmask:
            b |=           //             update the row bitmask:
              (v >> y & 1) //               extract the y-th bit from v
              << w + ~x    //               and set the (w-x-1)-th bit in b accordingly
        ) | b              //         end of inner map(); yield b
      )                    //       end of outer map()
    )                      //     2) translate and crop
    .flatMap(v =>          //       for each bitmask v in m[]:
      v / (a & -a)         //         right-shift v by the position of the LSB of a
      || []                //         discard this row if it's empty
    )                      //       end of flatMap()
  ]                        //   end of lookup
) ?                        // if at least one shape was already encountered:
  0                        //   do nothing
:                          // else:
  o[M] = ++c               //   save the new shape in o and increment c

a(6) in 3-4s is "rather slow" - mine takes ~ half an hour :p

R, 180 168 bytes
f=\(n,o={},v=0,u=0,`:`=c,`~`=sort,`?`=diff){for(j in u)F=F+`if`(length(p<-~j:o)<n,f(n,p,v,setdiff(c(u=u[-1],j+-1:1i:1:-1i),v<-j:v)),2^(-any(?p-~-p)-any(?p-~p*1i))/n);F}

Attempt This Online!
How about a golfy implementation of a more or less real world algorithm of counting polyominoes?
This code is a variation of Redelmeier's method published back in 1981 (link). Obviously, here lots of speed optimizations have been sacrificed in favor of golf, but it still manages to calculate all \$n\$ up to 9 in about 17 s on TIO (and even finishes \$n = 10\$ when run alone), yet allowing for a quite nice byte count.
Explanation
The method works by performing a recursive depth-first search up to the indicated length \$n\$. The key point is that we never store the list of found polyominoes. Instead, we check for symmetries, and if the current polyomino is symmetric, add only a fraction of the score, so that the total of all polyominoes having the same unique shape would add up to 1.
The algorithm starts by initializing the parent polyomino \$o\$ as empty (NULL), the set of visited cells \$v\$, and untried cells \$u\$ containing only the origin. The coordinates of the cells are represented by complex numbers.
for(j in u) - Iterate through the untried set. At each iteration, the current cell is \$j\$.
u<-u[-1] - Remove the current cell from the untried set.
v<-c(j, v) - Add it to the visited set.
p<-sort(c(j, o)) - Grow the current polyomino \$p\$ by adding \$j\$ to the parent \$o\$. Sort for later use.
if(length(p)<n) - If the polyomino has not yet reached the maximum length,
f(n,p,v,...) - Invoke the recursive call with modified arguments. The new untried set (...) is constructed as follows.
Add new neighbors to the untried set. When we are at the origin, the next iteration will involve the cells labeled 1-4 in the scheme below. However, the new neighbors exclude already visited cells, therefore when enumerating neighbors for cell 1, only the cells 5-7 will be added, as the origin had already been visited.
. . . . . . .
. . 6 2 . . .
. 5 1 0 3 . .
. . 7 4 . . .
. . . . . . .

So, the new untried set is defined as \$u \cup\ \{j-1,j+i,j+1,j-i\} \setminus v\$.
If the length \$n\$ has already been reached, count the polyomino and return.
2^(-any(diff(p-sort(-p)))-any(diff(p-sort(p*1i))))/n - This is our symmetry evaluation.
As we are interested in one-sided polyominoes, luckily, only two checks corresponding to 90 and 180 degree rotations are needed, no reflections involved. The rotations with complex numbers are very simple (\$ \times i\$ for 90 degrees, and \$ \times -1\$ for 180 degrees), but then we need to align the shapes to compare them. For this purpose, we sort the polyomino cells, and subtract one from another. If both represent the same shape under different translations from the origin, the resulting vector will consist of identical entries, so that all diff will be zero.
Now, if a polyomino is invariant under 180 degree rotation, we will encounter this shape twice, so that gains a multipler of \$1/2\$.
If it is also invariant under 90 degree rotation, we will find it 4 times, and the multiplier becomes \$1/4\$.
In Redelmeier's work, there are additional restrictions disallowing inclusion of certain cells, in order to guarantee that each different rotation ("fixed" polyomino) we be counted exactly once. But these checks take precious bytes, so we skip them. In our case, each fixed polyomino is counted \$n\$ times - once for every possible starting point. So, we can handle this simply by dividing the result by \$n\$.
Finally, we make use of heavy operator overloading to turn the code into a lunatic mess for some rather modest byte savings.

Ruby, 216 214 204 bytes
->n{*h=1,1i,-1,-1i;z=[[0i]];(r,*z=z;r.map{|c|h.map{|v|(r!=k=r|[c+v])&&(w=h.map{|y|(x=k.map{|v|v*y}).map{|g|g-x.map(&:real).min-1i*x.map(&:imag).min}.sort_by &:rect})-z==w&&z<<w[0]}})until z[0][-n];z.size}

Try it online!
5.5 seconds for n=8 on TIO.
Update: 41 seconds for n=9 on TIO
Harder Better Faster Shorter: 36 seconds for n=9 on TIO
Still golf-in-progress, the explanation refers to a previous version, the concept is still the same.
How (more or less):
->n{z=[[0+0i]]

This initializes the list of polyominos. Instead of a matrix, I will use a list of complex numbers (with integer real and imaginary part). The first entry is the monomino (0,0)
(r,*z=z;

The main loop: get a single n-omino from the list and build all possible (n+1)ominos from there:
4.times{|v|r.map{|c|

We need to iterate on all squares of r 4 times (add a new square on all sides)
(k=[*r,e=c+1i**v])==k|[]&&

First check: if we have duplicate squares, we can discard this piece. Otherwise, continue.
(w=4.times.map{|y|

Check all possible rotations
(x=k.map{|v|v*1i**y})

To rotate a piece 90 degrees, multiply all squares by i
.map{|g|g-x.map(&:real).min-1i*x.map(&:imag).min}

Then translate it so that it starts from (0,0).
.sort_by(&:rect)})-z==w&&

Sort the squares inside all 4 rotations, check if at least one is already contained in z
z<<w[0]}})

If not, add the first rotation to z
until z[0][-n]

Repeat until the first piece in the list has size n
;z.size}

The size of z is the final result.

I don't know Ruby, but love the method!

Wolfram Language (Mathematica), 632 bytes
Finds    a(9)=2500  in 30 seconds
J=Length;Q=First;s@n_:=(p=m@{{0,0}};Do[p=S[Flatten[m@#&/@p,1]],n-2];If[n<3,1,J@p]);m@b_:=(A=B={};Do[(A=If[(X=MemberQ)[b,b[[i]]+#],A,(H=Append)[A,b[[i]]+#]])&/@{{0,1},{1,0},{-1,0},{0,-1}},{i,J@b}];A=Complement@A;Table[B=H[B,H[b,A[[j]]]],{j,J@A}];B);S@q_:=Module[{s,b,u,L,V,U,f},f={};Do[s=q[[j]];b=g[q[[j]]];u=Sort[(#-Q@b)&/@q[[j]]];{L,V,U}=v@u;f=If[Or@@(X[f,#]&/@{u,Sort[(#-Q@g@L)&/@L],Sort[(#-Q@g@V)&/@V],Sort[(#-Q@g@U)&/@U]}),f,H[f,u]],{j,J@q-1}];f];g@h_:=(o=(W=Select)[h,Last@#==(Min[Last@#&/@h])&];W[o,Q@#==(Min[Q@#1&/@o])&]);v@p_:=(x=y=z={};Do[x=H[x,{T=Last[p[[i]]],-(R=Q[p[[i]]])}];y=H[y,-{R,T}];z=H[z,{-T,R}],{i,J@p}];{x,y,z})

Try it online!

05AB1E, 75 72 bytes
Should have been 1 byte less by replacing })}€ê with }){}, but the many nested maps/loops cause a bug in 05AB1E here (})ê} and })}€{ also doesn't work strangely enough..)
1ÝInãʒOQiyƶIô©Δ2Fø0δ.ø}2Fø€ü3}®Ā*εεÅsyøÅsM}}}˜Ùg<]εIô2Føʒà}}4FDíø})}€êÙg

Extremely slow brute-force, so is only able to output up to \$a(4)\$ on TIO.
Try it online or verify the first few results.
Explanation:
Step 1: Create all possible \$n^2\$-sized list using 0s and 1s, consisting of \$n\$ amount of 1s:
1Ý          # Push pair [0,1]
  In        # Push the squared input
    ã       # Cartesian power
ʒ           # Filter this list of lists by:
   i        #  If
 O          #  the sum of the current list
  Q         #  is equal to the (implicit) input-integer:
            #   Continue with the check in step 2 below
            #  (implicit else: implicitly use the implicit input for the filter;
            #   this is only truthy for edge case n=1, which fails step 2 due to the `ü3`)

Try just this first step online (without trailing i).
Step 2: Filter it further to only keep single polynominos, using a flood-fill approach:
 y          #   Push the current list again
  ƶ         #   Multiply each value by its 1-based index
   Iô       #   Convert the list to an input-by-input block
     ©      #   Store this block in variable `®` (without popping)
 Δ          #   Loop until the result no longer changes to flood-fill the matrix:
  2Fø0δ.ø}  #    Add a border of 0s around the matrix:
  2F     }  #     Loop 2 times:
    ø       #      Zip/transpose; swapping rows/columns
      δ     #      Map over each row:
     0 .ø   #       Add a leading/trailing 0
  2Fø€ü3}   #    Convert it into overlapping 3x3 blocks:
  2F    }   #     Loop 2 times again:
    ø       #      Zip/transpose; swapping rows/columns
     €      #      Map over each inner list:
      ü3    #       Convert it to a list of overlapping triplets
  ®Ā        #    Push matrix `®` and convert all its positive values back to 1s
    *       #    Multiply each 3x3 block by this matrix of 0s/1s (so 0s will remain 0s)
  εεÅsyøÅsM #    Get the largest value from the horizontal/vertical cross of each 3x3 block:
  εε        #     Nested map over each 3x3 block:
    Ås      #       Pop and push its middle row
      y     #       Push the 3x3 block again
       ø    #       Zip/transpose; swapping rows/columns
        Ås  #       Pop and push its middle rows as well (the middle column)
          M #       Push the flattened maximum of the entire (scoped) stack,
            #       which is the flattened maximum of the cross of the current 3x3 block
  }}        #     Close the nested map
 }˜         #   After the flood-fill loop: flatten the block to a list
   Ù        #   Uniquify its values
    g       #   Pop and push its length
     <      #   Decrease it by 1 to account for the 0s
            #   (only 1 is truthy in 05AB1E, so only single islands remain)
]           # Close both the if-statement and filter

Try just the first two steps online.
Step 3: Convert each valid lists to matrices, and slash of any rows/columns of 0s to have the actual polynominos:
ε           # Map over each inner list
 Iô         #  Convert it to an n-by-n block
   2F       #  Inner loop 2 times:
     ø      #   Zip/transpose; swapping rows/columns
      ʒ     #   Filter this list of rows by:
       à    #    Get the maximum of the row (so if it only contains 0s, it'll be removed)
      }     #   Close the filter
    }       #  Close the inner loop

Try just the first three steps online.
Step 4: Remove all duplicated rotations, by converting each polynomino to a quartet of its four sorted rotations, and then uniquify that list of quartets.
 4F         #  Inner loop 4 times:
   D        #   Duplicate the current polynomino-matrix
    íø      #   Rotate it 90 degrees counterclockwise:
    í       #    Reverse each inner row
     ø      #    Zip/transpose the matrix; swapping rows/columns
  })        #  After the loop: wrap the four rotations on the stack into a list

            # Explanation if the 05AB1E bug mentioned at the top wasn't present:
    {       #  Sort the quartet of rotations
}Ù          # After the map: uniquify the list of polynomino-rotations

            # Actual explanation with bug:
}€          # After the map: open a new map:
  ê         #  Sort and uniquify each quartet
   Ù        # After the map: uniquify the list of distinct polynomino-orientations

Try just the first four steps online.
Step 5: Get the amount of unique polynominos left, and output it as result:
g           # Pop and push the length
            # (which is output implicitly as result)

Python, 396 319 bytes
saved 77 bytes thanks to @Deadcode
Modified from @Kirill L.'s answer.
The golfed version, Try it online!
import numpy as np
def f(n,o=[],v=[0],u=[0]):
    F=0
    for j in u:
        p=sorted(o+[j])
        if len(p)<n:u=u[1:];v=[j]+v;F+=f(n,p,v,list(set(u).union(set(np.array(j)+np.array([-1,1j,1,-1j]))-set(v))))
        else:F+=(2**(-any(np.diff(np.array(p)-np.sort(-np.array(p))))-any(np.diff(np.array(p)-np.sort(np.array(p)*1j))))/n)
    return F

The ungolfed version:
import numpy as np

def f(n, o=None, v=None, u=None):
    if o is None:
        o = []
    if v is None:
        v = [0]
    if u is None:
        u = [0]
    F = 0
    for j in u:
        p = sorted(o + [j])
        if len(p) < n:
            u = u[1:]
            v = [j] + v
            F += f(
                n,
                p,
                v,
                list(set(u).union(set(np.array(j) + np.array([-1, 1j, 1, -1j])) - set(v)))
            )
        else:
            var1 = any(np.diff(np.array(p) - np.sort(-np.array(p))))
            var2 = any(np.diff(np.array(p) - np.sort(np.array(p) * 1j)))
            F += (2 ** (-var1 - var2) / n)
    return F

expected = []
for n in range(1, 10):
    expected.append(round(f(n)))
print(expected)

Golfing the whitespace makes it 319 bytes: Try it online!

source: Stack Exchange

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

sort: votes


text:
ASCII art is ready for take-off
Task
Given a positive integer n, draw the corresponding rocket.
Examples
From n = 1 to 4 the rockets are below. For your program's output, the trailing newline after a rocket is optional.
  |
 / \
*---*
| o |
| o |
*---*
 /_\

   |
  / \
 /   \
*-----*
| o o |
| o o |
| o o |
| o o |
*-----*
 /___\

    |
   / \
  /   \
 /     \
*-------*
| o o o |
| o o o |
| o o o |
| o o o |
| o o o |
| o o o |
*-------*
 /_____\

     |
    / \
   /   \
  /     \
 /       \
*---------*
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
*---------*
 /_______\

You can check this reference implementation (ungolfed).

This is code-golf so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!

related challenges here and here

Also related.

Is it Musk's latest design of the Starship? :)

@Arnauld nope, he wish! This fabulous design is mine. The final product of countless hours spent refactoring the whole thing, redrawing bits time after time... Finding the fine balance between elegance and efficiency...

Could I make this challenge in PETSCII rather than ASCII (i.e., for TheC64 etc...)

@ShaunBebbers what does that mean?

@RGS = Is an alternative codepage encoding acceptable as output?

Yes, basically for computers that might not do extended ASCII by default -> here is the specifics of PETSCII on the C64/128 and VIC-20 https://sta.c64.org/cbm64pet.html

@ShaunBebbers I don't mind the codepoints being different. If you want to use something weird (weird is good!) that doesn't support ascii and you can still make a rocket similar to the one shown, go for it! I don't mind

@Arnauld It can't be Musk's design, if it only has one engine :-)

This is the very first non-trivial programming task I ever accomplished; I think I was seven. I did not own a computer; I worked out the program to draw the rockets on paper and then typed it in to the Commodore PET in the school library after school. What a charming question!

@EricLippert You've wrote exactly 7 answers ...

PowerShell, 131 117 bytes
param($n)' '*$n+" |"
$n..1|%{" "*$_+"/$(' '*++$i)\";$x="*-$('-'*++$i)*"}
$x
,("| $('o '*$n)|")*$i
$x
" /$('_'*--$i)\"

Try it online!
Line breaks added for clarity, but they could just as easily be ; (it's the same byte count either way).
We're basically brute-force building the rocket one line at a time. We start by taking input $n, then construct a string of $n spaces and the nose antenna. We then loop from $n down to 1, using a triangular number trick with $i to get the appropriate number of middle spaces for the nose cone. Including the construction of the joiner into the loop allows us to re-use ++$i to both create the joiner and increment for our triangular number, saved into $x for later use.
We then use array-multiplication with the comma operator to construct the body of the rocket, then $x onto the pipeline again for the bottom. Finally we output the engine part with the appropriate _ in between.
All of those strings are left on the pipeline, and default implicit output gives us newlines for free.
-14 bytes thanks to VisualMelon.

Dammit, I was working on this approximately this exact answer.

Quite cool! +1 for this one :D

You can trade the quoted addition for raw text: ' '*($n+1)+"|" -> ' '*$n+" |"? Also, I think you can shave quite a handful of bytes by switching to inlined expressions in some of the strings, e.g. ($x=''+'-'++$i+'')->($x="$('-'++$i)") ($(stuff)is cheaper than the"+stuff+"). Inlining the extra '-'there also means you can use$iinstead of2*$n, and --$iinstead of($i-2)later on. You can also assign$x` in the loop to save 2 bytes.

Adding 3 bytes so that $i is initialised (param($n,$i)) I get 120 bytes: https://tio.run/##LYxBCsMgFAX3nkIev6jfmNJuQ29SCKEIDaQa7KKBmrNbDd3ODLPGj0/vp18W94jJl7JOaXppCh3NRknFFCxkhqDQ95d8@kKCabQ4k27a2trdMdB2A7vK3J8xdkGb6DSyrDgeK5NhmOYmINthVOzccSilXH8

@VisualMelon $i is perfectly happy being created and set with ++$i See here with it removed

@Veskah yeah, but it assumes that $i is left uninitialized, or initialised to 0 explicitly, and I'd personally rather not make that assumption ;)   (if you run the script twice from the same session, it will produce incorrect results)

@VisualMelon Thanks for the golfs - rolling $x into the loop is pretty clever. Given that this is a "full program", every time you execute it with .\rocket-ship.ps1 (or whatever), the $i is reset to uninitialized so that can be golfed off, too.

@AdmBorkBork I wonder if that is version specific, because a script on my machine is editing the environment's $i.

Charcoal, 38 bytes
ＮθＰ×θ_←↗¹Ｐθ←²↑*↑⊗θ↘*ＵＯ⊕θ⊗θo ↑Ｐ⊕θ↑↗θ|‖Ｂ

Try it online! Link is to verbose version of code. Works by drawing the left half of the rocket and reflecting it. Explanation:
Ｎθ

Input the size of the rocket.
Ｐ×θ_

Print the _s at the base of the rocket.
←↗¹

Move left and print the / at the left of the base.
Ｐθ←²

Print the -s on the second layer.
↑*↑⊗θ↘*

Print the left side of the rocket, and leave the cursor inside the body.
ＵＯ⊕θ⊗θo ↑

Fill the rocket with os and move the cursor up.
Ｐ⊕θ↑

Print the top row of -s and move the cursor up.
↗θ|‖Ｂ

Print the nose cone and reflect to complete the rocket.
Alternate solution, also 38 bytes:
Ｎθ×θ_↖¹Ｐ←θ²↑*Ｆ⊗θ←⪫|¶… o⊕θＰ←⁺²θ↖*↖θ|‖Ｂ←

Try it online! Link is to verbose version of code. Works by drawing the right half of the rocket and reflecting it. Explanation:
Ｎθ

Input the size of the rocket.
×θ_↖¹

Print the base of the rocket.
Ｐ←θ²↑*

Print the second layer.
Ｆ⊗θ←⪫|¶… o

Print the body of the rocket.
⊕θＰ←⁺²θ↖*

Print the top of the rocket.
↖θ|‖Ｂ←

Print the nose cone and reflect to complete the rocket.

+1 charcoal answers to ASCII art challenges are really nice!

The fact that this sequence can even be described uniquely in 38 bytes is mind boggling

@Cruncher uniquely? But I did it in two different ways...

And they both uniquely describe the sequence lol. As in, unambiguously. Anything that's a solution to this problem uniquely describes the sequence

Python 2, 165 154 bytes
i=input()
m=["*-"+"--"*i+"*"]
print"\n".join([" "*i+" |"]+[" "*(i-x)+"/ "+"  "*x+"\\"for x in range(i)]+m+["|"+" o"*i+" |"]*2*i+m+[" /"+"_"*(i*2-1)+"\\"])

Try it online!
-11 with thanks to @wilkben for some great hints
Nothing very exciting here. Just builds each line in a list and then prints with '\n'.join().

Thanks for your submission, even if not very exciting! +1

154 bytes, 151 bytes that works locally but not on TIO (uses ASCII backspace)

153 that only works in python 3.8+ with assignment expressions Not yet supported by TIO

@Cruncher TIO can do assignment expressions. You just have to switch your language to "Python 3.8 (pre-release)"

T-SQL, 265 bytes
DECLARE @n INT=0,@o varchar(max)=''z:SELECT
@o+=space(@-@n)+'/'+replicate(' ',@n*2)+' \
',@n+=1IF @n<@ GOTO z
PRINT space(@)+' |
'+@o+stuff(replicate('*'+replicate('-',@*2+1)+'*
',2),5+2*@,0,replicate('|'+replicate(' o',@)+' |
',2*@))+' /'+replicate('_',@*2-1)+'\'

Try it online

Yet another surprising SQL submission! Thanks for your work +1

IBM/Lotus Notes Formula Language, 262 246 236 bytes
L:=@NewLine;M:="*"+@Repeat("-";i*2+1)+"*"+L;N:=@Repeat(" ";i+1)+"|"+L;
@For(x:=0;x<i;x:=x+1;@Set("N";N+@Repeat(" ";i-x)+"/"+@Repeat(" ";x*2+1)+"\\"+L));
@Set("N";N+M+@Repeat("|"+@Repeat(" o";i)+" |"+L;2*i)+M+" /"+@Repeat("_";i*2-1)+"\\");

Basically a port of my Python 2 answer. Newlines in the code added for readability. They are not required by the interpreter. The formula takes it's input from i which is a numeric field on the same form.
There is no online interpreter for Notes formula so here is a screen shot of the output from 1 to 4:

This looks nice :) good job! +1

Thanks. Haven't done an ASCII art challenge for a while. They are usually quite fun to port to Formula mainly to see if I can still remember how to use it :)

What's 0? I've tested almost all of these and some are pretty funny.

@S.S.Anne 0 is basically a pile of rubble which is what you would expect as 0 is not a positive integer. How the output renders depends on the font. The above is using Default Monospace. You can have hours of harmless fun trying it with different fonts :)

Yeah, but the rubble is different for every answer. Mine is like Python's but it has an extra | | in the base.

05AB1E, 52 50 47 45 43 bytes
'|'/ILúí`©„ oI>∍'|ìI·иI>'-×'*ì.ø`®ð'_:».º.c

-2 bytes thanks to @Grimmy.
Try it online or verify some more test cases.
Explanation:
'|           '# Push a "|"
  IL          # Push a list in the range [1,input]
'/  ú        '# Push a "/" with that many leading spaces
     í        # And reverse each string so the spaces become trailing
      `       # And push all strings in this list to the stack
       ©      # Store the last one in variable `®` (without popping)
„ o           # Push string "o "
   I>         # Push the input+1
     ∍        # Extend the string to that size
      '|ì    '# And prepend a "|"
         I·   # Push the input doubled
           и  # And repeat the string that many times as list
I>            # Push the input+1 again
  '-×        '# And create a string with that many "-"
     '*ì     '# And prepend a "*"
        .ø    # Then surround the earlier created list with this string
          `   # And push all separated to the stack
®             # Push the string from variable `®` again
 ð'_:        '# And replace all its spaces with "_"
»             # Now join every string on the stack by newlines
 .º           # Mirror it intersected horizontally
   .c         # And centralize each line (which adds leading spaces where necessary)
              # (after which the result is output implicitly)

+1 thanks for your submission! 05AB1E usually does well in ascii art, right? Also, completely off-topic but I'm in The Netherlands for a (very little...) holiday :)

@RGS Overall it does pretty good indeed, due to its mirror, centralize, and Canvas buitlins. I have the feeling this can be shorter, though.. And where in The Netherlands will you visit? Enjoy your holiday. :)

If that position in The Netherlands is exactly where Kevin Cruijssen lives in ... ;)

@a'_' I highly doubt it, since I live in a village with just 900 residence outside of the tourist parts of The Netherlands. We do have a Bed & Breakfast near where I live though, so who knows. xD

'oI>и'|šðý2äн => „ oÞI>£'|šJ for -2.

@Grimmy Thanks. And 2 more by changing it to „ oI>∍'|ì :)

C (gcc), 248 bytes
i;f(n){char d[i=2*n+4],o[i];d[i]=o[--i]=!memset(d,45,i);o[--i]=*o='|';*d=d[i]=42;for(i=1+n;i;)printf(--i-n?"%*s/%2$*s\\\n":"%*s|\n",i,"",~i-2*~n-i);for(puts(d);i<=4*n;)i++<=2*n?o[i]="o "[i&1]:puts(o);printf("%s\n /%.*s\\",d,--n,memset(o,95,n+=n));}

This is surprisingly hard to get right, especially with off-by-one errors. I still might be overflowing the stack...
I fixed the bug I mentioned with n=23 and onwards; turns out that i was being decremented in the wrong place, so o was being overwritten and one byte of it was left uninitialized. Luckily, fixing this didn't cost me anything.
I've added a testcase for n=50 and a fun one for n=0.
-11 bytes thanks to ceilingcat!
Try it online!
Also, here's your rocket at n=0:
 |
*-*
*-*
 /| |\

Looks more like space junk to me... Ungolfed and an explanation (plus this weird corner case):
int i;
void f(int n)
{
    char d[i=2*n+4], // holds the *---* line; 2*n+1 dashes plus an extra 3 for the asterisks and the null byte
         o[i];       // holds the | o | line; 2*n+1 for the 'o ' and extra 3 for pipes and null byte

    d[i]=o[--i]=!memset(d,45,i); // null-terminate d and o; set d to dashes starting at d + 1 and ending at d+i-2

    o[--i]=*o='|'; // set the first and last bytes of o to the pipe
    *d=d[i]=42; // set the first and last bytes of d to asterisks

    for(i=1+n;i;) // print top of rocket
        printf(--i-n?"%*s/%2$*s\\\n":"%*s|\n",i,"",~i-2*~n-i); // on first iteration, print the tip and the correct number of spaces; the * before s pads the empty string with a variable number of spaces
// after that, print the cone; use 2$*s to use the second argument to save a byte

// if anyone can figure out how to remove the need for newlines, that would be appreciated

        // print the dashed line
    for(puts(d);i<=4*n;) // generate and print the tube
        i++<=2*n? // first half of loop
          o[i]="o "[i&1] // generate ' o '
          :puts(o); // print the line
    // n+=n here doubles n for the correct number of underscores
    printf("%s\n /%.*s\\",d,--n,memset(o,95,n+=n)); // print the last dashed line and then generate the underscores and print in one go
    // it's shorter doing a sized print than null-terminating o
}

And for the explanation of the corner case: the leading and terminating | are set as well as one character (the ) but never printed because there is only one iteration (as 0 <= 0 and 0 <= 2 * 0). Because n is 0, d is not set by memset, and is printed as | |. The rest should be pretty self-explanatory; the middle is not printed because the loop terminates before it can begin and neither is the cone for pretty much the same reason. There's only one - in *-* because n is 0 (in 2n+1).

Suggest n-~n-i-i instead of ~i-2*~n-i

Ruby, 130 bytes
->n{["%#{n+2}s"%?|,*(1..n).map{|x|"%#{n-x+2}s%#{x*2}s"%[?/,?\\]},k="*-"+"--"*n+?*,[[?|,*[?o]*n,?|]*" "]*n*2,k," /#{?_*n+=n-1}\\"]}

Try it online!

Thanks for your Ruby submission! +1

Batch, 700 614 573 538 498 452 bytes
Notes:

Must be started from cmd.exe's command line using: Echo(rockets n|cmd /V:On, where n is an integer.
Program builds the Nth rocket on a line by line basis, incrementing the values used to repeat characters using the N value
If the file is run without a parameter, it will output rocket n 1 by default.
lines 1 and 7 have trailing spaces

filename: rockets.bat
@ECHO OFF&Set $=Set
!$!}=ECHO(&!$!F=For /L %%A in (1,1,&!$!D=)Do &!$!P=^|&!$!/A _=]=W=1,H=O=2,L=3
%F:1,1=2,1%,%1%D%!$!/A W+=1,O+=1,H+=2,_+=2,L+=2
!$!.=!P!&!$![=!W!&%F%!O!%D%!$!.= !.!
%}%!.!&%F%!W!%D%(!$!.=/
%F:A=B%![!%D%!$!.= !.!
%F:A=C%!]!%D%!$!.=!.!
!$!.=!.!\&%}%!.!&!$!/A [-=1,]+=2)
!$!*=*&%F%!L!%D%!$!*=!*!-
!$!*=!*!*&%}%!*!&!$!.=!P!
%F%!W!%D%!$!.=!.!o
!$!.=!.!!P!&%F%!H!%D%%}%!.!
%}%!*!&!$!.= /&%F%!_!%D%!$!.=!.!_
!$!.=!.!\&%}%!.!

The ungolfed version [1131 bytes]

Hey there! Thanks for your submission! I'm assuming there is no TIO link you can provide?

I did take a look over on the TIO website, however batch is not a supported language - I also  tied searching cmd, dos, and msdos as possible alternate language names with no luck.

Does your code take input, though? I'm not sure I understand what is going on, so I don't know if your code works for any n or just the first few ones.

works for any n

JavaScript (ES6),  158  156 bytes
This implements the straightforward repeat everything approach.
n=>` `[N=n*2,R='repeat'](n+1)+`|
${(g=k=>k?` `[R](k)+`/${' '[R](N-k---k)}\\
`+g(k):s=`*${'-'[R](N+1)}*
`)(n)+`|${' o'[R](n)} |
`[R](N)+s} /${'_'[R](N-1)}\\`

Try it online!

JavaScript (ES6),  164  162 bytes
This one builds the rocket recursively.
f=(n,x=y=0,w=2*++n)=>y<w+n?`/\\ |*-o
`[(x>w?x=~!++y:(y?y-n&&~y+3*n?y>n?x&1?2:x%w?6:3:x+y-n&&x-y-n&&2:x%w?5:4:x-n?2:3)||x>n)&7]+f(n,x+1,w):` /${'_'.repeat(w-3)}\\`

Try it online!
Commented
f = (                            // f is a recursive function taking:
  n,                             //   n = size of the rocket
  x = y = 0,                     //   (x, y) = current coordinates
  w = 2 * ++n                    //   w = width of the rocket - 1; increment n
) =>                             //
  y < w + n ?                    // if this is not the last row:
    `/\\ |*-o\n`[                //   pick the next character from this string
      ( x > w ?                  //     if this is the end of the row:
          x = ~!++y              //       increment y and set x to -1
        :                        //     else:
          ( y ?                  //       if this is not the first row:
              y - n &&           //         if this is neither the top
              ~y + 3 * n ?       //         nor the bottom of the tank:
                y > n ?          //           if this is not the fairing:
                  x & 1 ?        //             if x is odd:
                    2            //               append a space
                  :              //             else:
                    x % w ? 6    //               append either a 'o'
                          : 3    //               or a '|' on the borders
                :                //           else (fairing):
                  x + y - n &&   //             append a '/' if we're located on
                  x - y - n && 2 //             a border, or a space otherwise
              :                  //         else (top or bottom of the tank):
                x % w ? 5        //           append either a '-'
                      : 4        //           or a '*' on the borders
            :                    //       else (first row):
              x - n ? 2          //         append either a space
                    : 3          //         or a '|' in the middle
          )                      //
          || x > n               //       turn '/' into '\' if we're in the right side
      ) & 7                      //     turn -1 into 7, false into 0, true into 1
    ] + f(n, x + 1, w)           //   end of character lookup; recursive call with x+1
  :                              // else:
    ` /${'_'.repeat(w - 3)}\\`   //   append the nozzle and stop the recursion

Thanks for your submission! What do you mean by "recursively"? Your function f, that I see is being called at the end of the code, is it building different parts of the rocket, depending on its second argument?

@RGS Each call to f draws exactly one character, except the last call that draws the whole last row at once.

ah ok, I understand now! Thanks

Wren, 156 bytes
I am very surprised that Arnauld is so easy to outgolf ...
Fn.new{|n|" "*(n+1)+"|
"+(n..1).map{|i|" "*i+"/%(" "*(1+2*(n-i)))\\
"}.join()+"*%("-"*(1+2*n))*
"+"| %("o "*n)|
"*2*n+"*%("-"*(1+2*n))*
 /%("_"*(2*n-1))\\"}

Try it online!

I think the real challenge is outgolfing Arnauld in JS :) +1 for your submission

Python 2, 126 bytes
p=n=input()
s="_ |"+"  \/"*n+"--**"+" o||"*2*n+"--**__\/"
while s:p+=s>"^";print' '*p+s[3]+s[:2]*(n-p)+s[:4:2];s=s[4:];p-=p>0

Try it online!
Includes some trailing whitespace, which I hope is allowed. One of them is the first character of s, a DEL character.
The main idea is to store the design of each line of the rocket in a big template string s. It's a bit easier to see in this slightly less golfed version, where the template for each line is given in a list:
134 bytes
n=input()
p=n+2
w="*--*"
for a,b,c,d in["|   "]+["/  \\"]*n+[w]+["| o|"]*2*n+[w,"/__\\"]:p-=p>0;p+=c=="_";print' '*p+a+(b+c)*(n-p)+b+d

Try it online!
Each line of the rocket is drawn from a template like this with four characters a,b,c,d specified for each line:
  abcbcbcbcbd

It's an a followed by alternating b's and c's followed by a d. The number of leading spaces, which also governs the number of repetitions of bc, is given by p, and is updated with each new line.
I'm aware that Python 3's f-strings and walrus operator could probably shorten many things, but I like Python 2 for golfing ASCII art because it means finding hacks to do things like that instead.

It looks like a nice submission +1! I'll try to make it a bit shorter :)

Clojure (307 bytes)
Great challenge, because it let me crank up Def Leppard's "Rocket" and Elton John's "Rocket Man" while coding. Always a plus! :-)
Golfed:
(defn r[n s](apply str(repeat n s)))(defn b[n](r n \ ))(defn p[s](println s))(defn k[n](let[t(str \*(r(inc (* n 2))\-)\*)](p(str(b(inc n))\|))(doseq[l(range 0 n)](p(str(b(- n l))\/(b(inc(* 2 l)))\\)))(p t)(doseq[l(range 1 (inc(* n 2)))](p(str "| "(r n "o ")\|)))(p t)(p(str " /"(r(inc(* 2(dec n)))\_)\\))))

Try it online!
Ungolfed:
(defn repeat-str [n s]
  (apply str (repeat n s)))

(defn blanks [n]
   (repeat-str n \ ))

(defn rocket [n]
  (let [ top-bottom  (str \* (repeat-str (inc (* n 2)) \-) \*) ]
    (println (str (blanks (inc n)) \|))
    (doseq [ l  (range 0 n) ]
      (println (str (blanks (- n l)) \/ (blanks (inc (* 2 l))) \\)))
    (println top-bottom)
    (doseq [ l  (range 1 (inc (* n 2))) ]
      (println (str "| " (repeat-str n "o ") "|")))
    (println top-bottom)
    (println (str " /"  (repeat-str (inc (* 2 (dec n))) \_) \\))))

GUITAR..! DRUMS..!

Thanks for your submission! +1 I'm glad you enjoyed the challenge!

C# (Visual C# Interactive Compiler), 292 289 257 bytes
Thanks to @mypronounismonicareinstate -32B
n=>{dynamic r="",t="*",i=n,j;for(;i-->0;)r+=" ";r+=" |\n";for(;++i<n;){for(j=0;j<n+i+2;++j)r+=n-i-j==0?"/":" ";r+=@"\
";}for(;i-->0;)t+="--";t+="-*\n";r+=t;for(;++i<n*2;){r+="|";for(j=0;j++<n;)r+=" o";r+=" |\n";};r+=t+" /";for(;i-->1;)r+="_";return r+"\\";}

Try it online!

Thanks for your submission! +1 for your work :D

271, a bunch of golfs

@mypronounismonicareinstate I like your solution. It took me while to understand the the part while(i-->1) I was trying to find what operator is this --> :D Then I found that it is like while(--i>0)

@JirkaPicek Ugh... What is the "-->" operator in C++? (spoiler alert: it's i-- > 1)

245 bytes

Perl 5, 150 +1 (-p) = 151 bytes
$x=($n=$_)*2;map{$r.=$"x($n-$_).'/'.$"x(2*$_+1).'\
'}0..$n-1;$s='*'.'-'x$x."-*
";$l='|'.' o'x$n." |
";$_=$"x$n.$"."|
$r$s".$l x$x."$s /".'_'x--$x.'\
'

Run with -p, provide input to stdin.  Started with basically the reference implementation, and just golfed it down, though there might be better ways.
I could save a byte by leaving off the final newline, but I like it better with it in.
Try it online!

Thanks for your Perl submission! +1 I also like the trailing newline

GolfScript, 95 bytes
v1.0.2, my goal is to get this sub-60, which I think is actually doable.
:i)" ":s*"|"n i,{:j i\-s*"/ "2s*j*"l"n}%"*-""--"i*"*"n+++:q{"| ""o "i*"|"n}2i**q" /""__"i*);"l"

This program uses miniscule L instead of backslash since I spent like four hours today trying to find a way for GS to print ONE backslash and couldn't get it to work. It's ridiculous. Temporary patchfix, looks acceptable in TIO.
WANNA SEE A GROSS PROGRAM?
Okay, so this is obviously a disaster, so we're going to need to go through it very carefully to see why it works. Let's break this into chunks.
:i)" ":s*"|"n                 #Top Needle
i,{:j i\-s*"/ "2s*j*"l"n}%    #Roof
"*-""--"i*"*"n+++:q           #First star-dash line
{"| ""o "i*"|"n}2i**          #Cabin
q                             #Second star-dash line
" /""__"i*);"l"               #Rocket cone

So, that's mildly more digestible for my format. Work is slow today, so enjoy this overly arduous explanation.
Before we start this, I'm clarifying one thing. Input is from the header, slotted right into the stack, and our output is let on the stack, printed out when the program finishes.
:i)" ":s*"|"n     #Print the top needle
:i                #Set our input to i; we'll call it INDEX.
  )               #Increment the INDEX on the stack by 1 (not the variable)
   " ":s          #Put a space on the stack, and make s remember it. We'll call it SPACE.
        *         #Multiply this space by INPUT+1
         "|"      #Needle!
            n     #Newline

So, our stack now looks something like "     ""|""/n", which is concatenated all together on output. Every future chunk ends with n characters, and we never back up further in the stack, so we never touch this again.
i,{:j i\-s*"/ "2s*j*"l"n}%    #Print the roof
i,                            #Make an array of size INDEX, from 0 to i-1
  {                     }%    #Block notation. On every element in this array, perform this
  {:j                   }%    #Remember our index as J
  {   i\-               }%    #Subtract J from INDEX
  {      s*             }%    #Make that many spaces
  {        "/ "         }%    #Make a slash then a space
  {            2s*j*    }%    #Make 2*j spaces
  {                 "l" }%    #lmao backslash no work
  {                    n}%    #Add a newline

Which is for what we're looking, for every line. Done INDEX times, we have our roof!. Next!
"*-""--"i*"*"n+++:q   #Print the star-line.
"*-"                  #First two characters.
    "--"              #Next two.
        i*            #We want a number of those double-dashes equal to INDEX.
          "*"         #Last asterisk
             n        #Newline
              +++     #Concatenate that all together. We haven't done this before, but...
                 :q   #We're remembering this entire line in Q, which saves us a TON

Next we have the o-cabin. Surprisingly the easiest part of the program.
{"| ""o "i*"|"n}2i**   #Build the cabin
                2i*    #Double INDEX
{              }   *   #Perform the block 2*INDEX times
{"| "          }   *   #First two characters
{    "o "      }   *   #You know the drill. Combination of the two prev tactics.
{        i*    }   *   #Make that many windows this row
{          "|" }   *   #East wall
{             n}   *   #Newline, as always.

Now comes the trickiest part of the entire program
q      #Print the second star line
q      #Print Q, as established above

And the bottom of the rocket.
" /""__"i*);"l"     #Bottom of the rocket
" /"                #So, how's your day been? Mine's been pretty slow.
    "__"            #Slow enough that I had time to write this whole post.
        i*          #Boss isn't even watching. Maybe I'll do another later.
          );        #Remove the last _, since we've one too many.
            "l"     #lmao backslashes

And that's everything! Why don't you check my work by trying it out online? 78 is the max size you can get before it starts to linebreak on TIO on my monitor, try to find yours!

This looks great! Good job! +1

Ping me when it's sub 60 :)

I found this on Stack Overflow: https://stackoverflow.com/questions/60342178/how-do-you-add-a-single-backslash-to-a-string-in-golfscript (no answers, though) (and it's by you)

Vyxal, 65 bytes
›ð*\|+,(⁰nε\/꘍nd›\\꘍+,)×⁰d›-×+:,⁰d(\|‛ o⁰*ð\|+++,),‛ /\_⁰d‹*\\++,

Try it Online!
Slowly constructs the string bit by bit.

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


text:
Find self-locating strings in a number
Based on this Numberphile video
A self-locating string is a number (or set of numbers) in a decimal expansion which corresponds to its location, from the start of the decimal.
For example, take the number:
.2734126393112

Here, we can identify certain items quickly, e.g:
.27 _3_ _4_ 1263 _9_ 3112

There are a few more complex cases in here though, too. For instance, the numbers 11 and 12 both appear starting in their respective positions:
.2734126393112
 123456789ABCD
           ^
           11

            ^
            12

So the list of self-locating strings in this case would be [3, 4, 9, 11, 12], as even though some of them overlap, they both start in the correct places. If we sum these up, we get 39, or the self-reference index (SRI) of this terminating decimal.
Input
A terminating decimal, either an array of digits (after the point) or a decimal type with 0. at the start/..
Output
The SRI of the input number.
Rules

In the case that there are no self-referential numbers, the SRI is 0. This must be returned/printed, as opposed to exiting or returning undefined.
The decimal expansion can be assumed to terminate, and will be no more than 128 digits in length.
The counting of the indexes should be 1-based, e.g the first decimal is at position 1, etc.
Standard I/O rules + standard loopholes apply.
This is code-golf, so shortest answer in bytes wins

Test cases
0.1207641728 -> 3
.12345678910 -> 55
0.1234567890112 -> 68
.0 -> 0
0.654321 -> 0
.54321 -> 3

@JonathanAllan regarding your second comment, thanks; fixed. With your first one, the point is that your program should know to start counting after the decimal point: it needs to have a way of detecting it, the same way that when doing it with Pi you'd start counting after the three. All decimal numbers need something at the start before the point, so to make it truly general it should accept any number of digits before it.

@JonathanAllan Yes

My answer is the only one which allows there to be leading zeros in a self-locating string. The spec is not clear on this matter at present. I'd suggest allowing either handling (i.e. 0.440036 -> 6 or 9)

^ EDIT was the only, I now have golfed it and it no longer does, but I still recommend allowing either.

Is there an implicit zero at the end? I.e. would 0.0000000001 count as 10?

I think I understand the goal. I don't get this explanation, though : "Here, we can identify certain items quickly, e.g: .27 _3_ _4_ 1263 _9_ 3112 ".

@EricDuminil in this example, the highlighted digits 3, 4, and 9, are clearly in the 3rd, 4th, and 9th positions

@Laikoni No, because we're trying to keep the decimals terminating. If I allow that there'd probably be a number of other such cases to, so I'd like to just keep it to exactly the input.

@retnikt aaah. It's supposed to be highlighting, not a placeholder for other digits. Thanks.

Jelly,  9  8 bytes
ṫJw"Jẹ1S

A monadic Link accepting a list of the digits after the decimal point which yields an integer.
Try it online!
How?
ṫJw"Jẹ1S - Link: list of digits, A        e.g. [3,2,1,0,5]
 J       - range of length (of A)              [1,2,3,4,5]
ṫ        - tail from index (vectorises)        [[3,2,1,0,5],[2,1,0,5],[1,0,5],[0,5],[5]]
    J    - range of length (of A)              [1,2,3,4,5]
   "     - zip with:
  w      -   first index of substring or 0     [3,1,0,0,1]
               Note: w has implicit decimalisation of its right argument,
                    so [7,6,5,4]w65 is equivalent to [7,6,5,4]w[6,5] = 2
      1  - literal one                         1
     ẹ   - indexes of                          [2,5]
       S - sum                                 7

APL (Dyalog Extended), 16 bytes
+/⍬∘⍋(⍸⊣⊃¨⍕⍛⍷¨)⊂

Try it online!
Takes a string of digits.
How it works
+/⍬∘⍋(⍸⊣⊃¨⍕⍛⍷¨)⊂  ⍝ Input: character vector of digits
  ⍬∘⍋             ⍝ X←Array of 1-based indices
     (    ⍕⍛ ¨)   ⍝ Stringify each of X
     (      ⍷¨)⊂  ⍝ And for each of above, build a boolean array where
                  ⍝   substring matches are marked as 1
                  ⍝ e.g. '10'⍷'10428104' is [1 0 0 0 0 1 0 0]
       ⊣⊃¨        ⍝ Extract X-th indices from each of above
      ⍸           ⍝ Convert ones to its 1-based locations
+/                ⍝ Sum

05AB1E, 9 bytes
āʒ.$yÅ?}O

Try it online!

Didn't know you could vote on deleted answers. And comment.

@ouflak I really don't think you can, actually.

9 bytes if you use the same input style as this answer?

Python 2, 112 \$\cdots\$ 52 51 bytes
Saved 9 bytes thanks to ElPedro!!!
Saved a byte thanks to Jonathan Allan!!!
Saved 3 4 bytes thanks to Poon Levi!!!
f=lambda s,i=0:s>s[:i]and(s[:i]+`i`in s)*i+f(s,i+1)

Try it online!
Takes a number in the form .abc... as string input and returns its SRI.

You can simplify a bit now since input restriction has been relaxed.

@JonathanAllan Well done, that floating decimal point was costly! :-)

Save 1: sum(i*(s.find(\i`,i)==i)for...`

@JonathanAllan Oh, lovely - thanks! :-)

-3: sum(i*(s[:i]+\i`in s)...`

@PoonLevi That's diabolical ! And it can't match further on in s because it starts with the decimal point - thanks! :-)

You can further shave off 1 byte by doing s>s[:i] instead of i<len(s)

@PoonLevi You're the devil incarnate - thanks! :-)

JavaScript (ES6),  50  48 bytes
Takes input as a string. A recursive approach.
f=(s,n=1)=>s?+s.match('^'+n)+f(s.slice(1),n+1):0

Try it online!
s.match('^'+n) is either null or a singleton array holding \$n\$ as a string. By applying the unary +, these values are coerced to \$0\$ or \$n\$ respectively.

JavaScript (ES6), 52 bytes
Takes input as a string.
s=>[...s].reduce(t=>t+!(i-s.indexOf(i+1,i))*++i,i=0)

Try it online!

PowerShell, 60 56 bytes
param($n)1..128|%{$o+=$_*($_-eq$n.indexOf("$_",$_))};+$o

Try it online!
Takes input $n as a string (else you'll get floating point inaccuracies), then constructs a range from 1 to 128. We then loop through those numbers (the |%{...}) and each iteration we're accumulating into $o the current number times if the current number $_ is -equal to the .indexOf the current number "$_" starting at position $_ in the input string $n. In other words, if the current number matches the first index starting at that position, the current number is added to our output. After the loop, we tack on a + at the front to account for the zero case (i.e., no numbers in the collection). That result is left on the pipeline and output is implicit.
-4 bytes thanks to inspiration from ElPedro.

Very nice. I'm trying to learn Powershell at the moment. Guess I won't be allowed to write stuff like this at work ;)

@ElPedro No. Do not. lol Just like any good golfing answer, people on Code Review would have a heart attack. https://codegolf.stackexchange.com/questions/191/tips-for-golfing-in-powershell/80674#comment239529_80674

If Powershell had been around in the really early days of Windows we would have  to do this kinda thing with only 64k of memory available but then, who would ever need more than 64k? :) Guess I'm showing my age now.

@ElPedro lol, thanks for the inspiration! Reminding me of that trick saved 4 bytes here.

and of course I misquoted. Should have been 640k but in todays terms there's not much difference.

@mazzy That doesn't perform the summation, which is the required output.

R, 1̶0̶2̶, 99 bytes
Thanks to @Giuseppe for 99 bytes
U=`[`
`[`=Map
sum(which(paste0[U[list(x<-scan()),`+`[(L=seq(x))-1,seq[nchar(L)]]],collapse=""]==L))

Try it online!
Few bytes can be saved if there is a second 2-byte 3-argument operator like [. First time messing with [, it is fun.

99 bytes from your original; it took forever to unpack to see if there was a different golf for operator aliasing, and I still came up basically empty.

I'm not sure your latest edit works, since it doesn't do the sum?

@Giuseppe I broke it. Fixed now. My head hurts reading this code.

mine too, if that's any consolation!

74 bytes doing a string-manipulation approach; I think there are some bytes to shave off of that too...

@Giuseppe There is a slight indexing error there causing it to not work on the test case, can change the input format to save a few more. You should post a new answer: 66 bytes

J, 30 29 bytes
1#.#\(=#])(<:,:#@":)@#\".;.0,

Try it online!

Ruby, 46 44 bytes
->n{r=0;n.chars.sum{n[r+=1,r]=~/^#{r}/?r:0}}

Try it online!
Thanks Value Ink, as usual, for -2 bytes.

With the power of sheer insanity-- uh I mean boredly checking if I could make the first argument of a slice use += without throwing a syntax error, I have found a 44 byte solution

Perl 5 -pl, 27 bytes
Requires input to be in the format .####...:
$\+=++$a*/\G$a/ while/./g}{

Try it online!
Original version below handles input with or without a leading 0.
Perl 5 -pal, 34 bytes
s/^0//;$\+=++$a*/\G$a/ while/./g}{

Try it online!

Perl 6, 31 30 bytes
{sum m:ex/\d+<!{$/-$/.from}>/}

Try it online!
Explanation:
{                            }   # Anonymous code block returning
 sum                             # The sum of
     m:ex/                  /    # All possible matches
          \d+                    # Of numbers
             <!{$/-       }>     # That are equal
                   $/.from       # To their position in the string

Python 2, 64 60 bytes
lambda i:sum(x for x in range(len(i))if`x`==i[x:x+len(`x`)])

Try it online!
The 0 result works because an empty list in Python is equivalent to False which is equivalent to 0 and when you sum(0) you very conveniently get 0.

You can use find now, I've been shown another way.

@Noodle9 Thanks but I'll probably leave it as it is now.

Retina 0.8.2, 29 bytes

¶$.`$.`$*;$'¶
Gm`^(.+);+\1
;

Try it online! Link includes test cases. Assumes input begins with the decimal point. Explanation:

¶$.`$.`$*;$'¶

For each offset in the string, list the offset in decimal, then again in unary, then the suffix starting at that offset, wrapping the whole thing in newlines so that the characters in the input string don't contaminate the data.
Gm`^(.+);+\1

Keep only the lines where the suffix starts with the offset.
;

Take the total of the matching unary offsets.

Charcoal, 18 bytes
ＩΣＥＬθ×ι⁼Ｉι✂θι⁺ιＬＩι

Try it online! Link is to verbose version of code. Assumes input begins with the decimal point. Explanation:
    θ               Input string
   Ｌ                Length
  Ｅ                 Map over implicit range
                 ι  Current index
                Ｉ   Cast to string
               Ｌ    Length
              ι     Current index
             ⁺      Added
            ι       Current index
           θ        Input string
          ✂         Sliced
         ι          Current index
        Ｉ           Cast to string
       ⁼            Equals
      ι             Current index
     ×              Multiplied
 Σ                  Take the sum
Ｉ                   Cast to string for implicit print

Python 2, 53 bytes
f=lambda s,i=0:s>''and(s.find(`i`)==0)*i+f(s[1:],i+1)

A recursive version of a previous version of Noodle9's Python 2 answer.
Try it online!

I've taken a leaf out of your book and gone recusive with a new devilish test unleashed by @PoonLevi!

PowerShell, 49 bytes
[Double] has 15 to 17 significant decimal digits precision, so we can consider a finite number of digits
param($n)1..99|%{$s+=$_*($n-match"^.{$_}$_")}
+$s

Try it online!

PowerShell, 54 bytes
any string representation of decimal number
param($n)$n|% t*y|%{$s+=++$i*($n-match"^.{$i}$i")}
+$s

Try it online!

Haskell, 71 bytes
import Data.List
f l=sum[i|(i,x)<-zip[0..]$tails l,show i`isPrefixOf`x]

Try it online!

Java 8, 86 bytes
s->{int r=0,i=0;for(;i<s.length();)r+=s.substring(i++).startsWith(i+"")?i:0;return r;}

To the point approach. Will see if I can find something shorter later on. Also, this is probably the first time I've used startsWith in Java (either in or outside codegolfing). ;)
Input as a String.
Try it online.
Explanation:
s->{                       // Method with String parameter and integer return-type
  int r=0,                 //  Result-sum, starting at 0
  i=0;for(;i<s.length();)  //  Loop `i` in the range [0,input-length):
    r+=                    //   Increase the result-sum by:
       s.substring(i++)    //    Take the substring of the input, starting at index `i`
                           //    And increase `i` by 1 afterwards with `i++`
        .startsWith(i+"")? //    If this substring starts with `i` (converted to String):
          i                //     Increase the result-sum by `i`
         :                 //    Else:
          0;               //     Leave the result-sum the same by increasing with 0
  return r;}               //  And return the sum as result

C# (Visual C# Interactive Compiler), 74 bytes
a=>Enumerable.Range(1,a.Length).Sum(x=>a.Remove(0,x).StartsWith(x+"")?x:0)

Try it online!

T-SQL, 103 bytes
SELECT number+1FROM spt_values
WHERE type='P'and-~number=substring(concat(@,''),number+3,len(number+1))

Try it online

Zsh, 43 bytes
repeat $#1 ((r+=0${(M)1[++i,-1]#$i}))
<<<$r

Try it online!
Takes input as a string. Repeatedly (M)atches the part of the string string at position ++i to -1 that #starts with $i, and adds it to $r. The 0 ensures that a valid number is added in the case of no match, so $r is set to a value before being printed.

Japt -x, 12 bytes
ÊÇ¥UtZZsl¹*Z

Try it online!


text:
Put in the quotes
Background
There's a terrible problem in my console - the quotes never get included inside the arguments! So, when given this argument:
["abc","def","ghi","jkl"]

it says that the argument is like this:
[abc,def,ghi,jkl]

It would be very nice if you can fix this problem!
Challenge
Add double-quotes (") in order to surround a word (i.e. something that matches [a-z]+).
Test cases
[[one, two, three], -> [["one", "two", "three"],
[one, two, three],     ["one", "two", "three"],
[one, two, three],     ["one", "two", "three"],
[one, two, three]]     ["one", "two", "three"]]

[abc,def,ghi,jkl] -> ["abc","def","ghi","jkl"]

this is a test    -> "this" "is" "a" "test"

test              -> "test"

this "one" "contains' "quotations -> "this" ""one"" ""contains"' ""quotations"

But This One Is SpeciaL! -> B"ut" T"his" O"ne" I"s" S"pecia"L!

Rules

The inputted words are never capitalized. Capital letters are not considered part of a word.
The input is always a string, not a list. The test-cases aren't quoted because that's the only possible type.
A word is something that matches [a-z]+.

Sandbox

Don't understand how the rule: The inputted words are never capitalized. works with the test case: But This One Is SpeciaL! -> B"ut" T"his" O"ne" I"s" S"pecia"L!

I don't get how the lists of lists in the first code block relates to the challenge.

Some of the test case inputs are strings, some are arrays.  Is it our choice which to support?  It's also unclear what the first block quoted example of the array [one,two,three] repeated 4 times is supposed to demonstrate.

@Jonah I interpreted the first test case [abc,def,ghi,jkl] to be a string that happens to look like an array (the first character of the string is '[', etc.).

What's the input format here? A 2D-array? A 1D-array? A string? Or dealer's choice? If a string then, for the purposes of this challenge, what is the definition of a "word"?

Scratch that last question, I see now that you did define what a word is.

What happened to the whole backstory part from the Sandbox? It makes a lot more sense with some context

@a'_' I've edited your challenge to add the 3D list as part of the test cases, since that seems to be the main reason it was closed. If I edited something incorrectly, feel free to edit it again to clarify.

@Noodle9 The rule means capital letters are not considered part of a word.

Can the input contain any unicode character, or only (printable) ASCII?

Gema, 8 characters
<J>="$0"

Copy of Adám's QuadR solution, just adjusted the syntax and the explanation:
Replace
 <J> one or more lowercase letters
with
 "$0" the quoted match.
Sample run:
bash-5.0$ gema '<J>="$0"' <<< '[abc,def,ghi,jkl]'
["abc","def","ghi","jkl"]

Try it online!

perl -pE, 15 bytes
s/[a-z]+/"$&"/g

QuadR, 10 bytes
[a-z]+
"&"

Try it online!
Replace
 [a-z]+ one or more lowercase letters
with
 "&" the quoted match.

sed -E, 20 15 14 bytes
Saved 5 bytes thanks to @Neil!  And then 1 more byte thanks to @manatwork pointing out that we no longer have to add bytes to our score for command-line options.
s/[a-z]+/"&"/g

Original solution:
s/\([a-z]\+\)/"\1"/g

Test run:
$ cat quotelc.sed
s/\([a-z]\+\)/"\1"/g

$ sed -f quotelc.sed << EOF
> [abc,def,ghi,jkl]
> this is a test
> test
> this "one" "contains' "quotations
> But This One Is SpeciaL!
> EOF
["abc","def","ghi","jkl"]
"this" "is" "a" "test"
"test"
"this" ""one"" ""contains"' ""quotations"
B"ut" T"his" O"ne" I"s" S"pecia"L!

Note: In TIO's sed, there's some issue with the collating sequence; the pattern [a-z] matches upper-case letters too. If you want to run this in TIO, you can do something like this.

s/[a-z]\+/"&"/g saves 5 bytes, I think?

Thanks, @Neil!  I haven't golfed for a while, and I forgot about '&' in sed.

Since command line arguments are for free, with GNU sed you can specify --regexp-extended (or -r) to not need to escape the + quantifier.

@manatwork : I've understood that you need to add the number of bytes in any additional options. That would be 3 bytes here (including the space before the option), which wouldn't be worth it.  (By the way, grep has a standard POSIX option for extended regexes now: -E instead of the old -r.  So if you want to do that, -E is more portable.)

Yepp, that's how we did it once, but then changed. Got aware of it only when AdmBorkBork commented on a solution of mine: “You don't need to count command-line flags anymore.”

@manatwork  Thanks, I hadn't seen that. I liked the old policy (after all, those options are doing something, so in principle they should be counted.  But if that's how scoring works now, I'll do it that way :) .

They're free, but it's considered a different language.

Japt, 11 bytes
r"%a+"`"$&"

Try it

I never knew "$&" existed, I was trying "$0", because C# does that and I assumed other languages would too. When that didn't work, I thought Japt doesn't have that built in. But you learn something new each day!

Retina, 11 bytes
[a-z]+
"$0"

Pretty straight-forward approach.
Try it online.

Python 3, 47 bytes
lambda s:re.sub('([a-z]+)',r'"\1"',s)
import re

Try it online!

Jelly, 15 bytes
Ż;0e€ØaIkƊj”"ḊṖ

Try it online!
A monadic link taking a Jelly string and returning a Jelly string. No regex in Jelly so identifies boundaries between lower letter segments and others, splits and joins with quotes.

05AB1E, 14 13 bytes
0.ø.γ.l}'"ý¦¨

Try it online!

J, 39 35 bytes
load'regex'
f=.'[a-z]+'dquote rxapply]

Try it online!
-4 bytes thanks to Bubbler teaching me about dquote builtin
NOTE: The TIO link is showing an error, but this works correctly on my machine (j807), and passes the test cases.  I'm unsure if it's a version issue or something else causing TIO to fail.
Task is accomplished almost entirely by the rxapply adverb.  We simply have to supply the regex to apply to [a-z]+ and the verb to apply: surround in quotes dquote

Use dquote stdlib verb instead of ('"',,&'"') for 35 bytes (regex lib still not working).

Thanks @Bubbler.  TIL...

Charcoal, 20 bytes
Ｆ⁺Ｓ «ω✂"⁼№⪪β¹ω№βι≔ιω

Try it online! Link is to verbose version of code. I was stuck at 24 bytes for some time until I came up with this approach. Explanation:
Ｆ⁺Ｓ «

Loop over the input with a space appended. (Any non-alphalower character would do.)
ω

Print the previous character. On the first pass through the loop, this variable holds the empty string, so nothing is output. Additionally, we never print the appended space, as it's never the previous character.
✂"⁼№⪪β¹ω№βι

Check whether both or neither the previous or current characters are alphalower characters. If exactly one is, then output a quote. (The predefined alphalower string has to be split for the first check otherwise the empty string would match 27 times on the first pass.)
≔ιω

Save the current character so that it's the previous character on the next pass of the loop.

Husk, 10 bytes
ṁ?sIΛ√ġo¬√

Try it online!

PHP, 43 41 bytes
<?=preg_replace('/[a-z]+/','"$0"',$argn);

Try it online!
A simple straightforward regex implementation
EDIT: Thanks to @manatwork for saving 2 bytes!

There you capture the entire matched substring into $1, so it contains the same as $0. So better use that one and that way you can remove the capturing (..).

Burlesque, 32 bytes
J"[^a-z]+"~?[~jqup"[a-z]+"~aj.+Q

Try it online!
Depressingly, more than half of this is attempting to overcome what I can only assume is a bug where the ~a cuts off the last non-match.
J            # Duplicate
"[^a-z]+"~?  # All matches for not a-z
[~           # Take the last one
j            # Swap
# Main block (13 bytes)
qup          # Unparse to string
"[a-z]+"     # Matches a-z
~a           # Apply to those that match regex
####
j.+          # Add on hacky fix
Q            # Pretty print

Deorst, 20 bytes
'"\1"'@
'([a-z]+)'gs

Try it online!
Again, just uses a regex based approach

PHP, 69 bytes
for(;$c=$argn[$i++];){if(($n=$c>'`'&$c<'{')^$p)echo'"';echo$c;$p=$n;}

Try it online!

Japt, 12 bytes
r"%a+"@Q+X+Q

Try it

Sorry, edited your solution, thinking it was mine and that I'd somehow managed to post the wrong one! It's been a long weekend!

Jelly, 13 bytes
Ø1je€ØanƝ”"ẋż

A full program which prints the result.
Try it online! Or see the test-suite.
How?
Ø1je€ØanƝ”"ẋż - Main Link: list of characters e.g.  Foo 'Bar', baz
                                                ->  ['F','o','o',' ',"'",'B','a','r',"'",',',' ','b','a','z']
Ø1            - ones                                [1,1]
  j           - join                                [1,'F','o','o',' ',"'",'B','a','r',"'",',',' ','b','a','z',  1]
     Øa       - lower-case alphabet                 ['a','b',...,'z']
    €         - for each:
   e          -   exists in?                        [0,  0,  1,  1,  0,  0,  0,  1,  1,  0,  0,  0,  1,  1,  1,  0]
        Ɲ     - for neighbouring pairs:
       n      -   not equal?                        [  0,  1,  0,  1,  0,  0,  1,  0,  1,  0,  0,  1,  0,  0,  1]
         ”"   - quote character                     '"'
           ẋ  - repeat (vectorises)                 [ [],['"'],[],['"'],[],[],['"'],[],['"'],[],[],['"'],[],[],['"']]
            ż - zip together                        [[[],'F'],[['"'],'o'],[[],'o'],[['"'],' '],[[],"'"],[[],'B'],[['"'],'a'],[[],'r'],[['"'],"'"],[[],','],[[],' '],[['"'],'b'],[[],'a'],[[],'z'],[['"']]]
              - implicit, smashing print            F"oo" 'B"ar"', "baz"

JavaScript (V8), 33 bytes
f=i=>i.replace(/[a-z]+/g,'"$&"');

-9 Bytes thanks to manatwork
Try it online!

Why the callback? '"$&"' is shorter than e=>"\""+e+"\"". (But if you really want to use callback, e=>'"'+e+'"' is shorter. Not mentioning e=>\"${e}"``.)

Same moment you wrote the shorter callback version i wanted to update to this solution too. And yes, first one is even shorter.. wasn't able to produce this due to errors I got.. update to post incoming :D


text:
Is this a circular step sequence?
Background
We define a circular step sequence of order \$n\$ as follows:
$$
a_1, a_2, \dots, a_n = \text{Permutation of } 1 \dots n \\
b_i = \min ( |a_{i+1} - a_i|, n-|a_{i+1} - a_i| ), 1 \le i < n \\
\text{Circular step sequence} \stackrel{\text{def}}{=} b_1, b_2, \dots, b_{n-1}
$$
Informally, it is the \$n-1\$ distances between \$n\$ points evenly spaced on a circle, given a permutation of those points.
For example, if we choose a permutation \$1, 3, 6, 2, 4, 5 \$ for \$n = 6\$, we get a circular step sequence of \$2, 3, 2, 2, 1\$. (Refer to the circular layout below.)
 1 2
6   3
 5 4

On the other hand, a circular step sequence of order 6 cannot have a substring of \$2, 2, 2\$. Regardless of where you start and in which direction you go first, you'll get stuck at the third 2.
Task
Given the value of \$n\$ and a sequence \$b_1, b_2, \dots, b_{n-1}\$ of positive integers, determine if the given sequence can be a circular step sequence of order \$n\$, i.e. there exists a permutation \$a_1, \dots, a_n\$ which leads to the given sequence \$b\$.
Input and output
The elements \$b_i\$ of the input sequence are guaranteed to satisfy \$ 1 \le b_i \le n/2 \$ and \$ b_i \in \mathbb{Z}^+ \$. Also, you can assume \$n \ge 1\$. If \$ n = 1 \$, the only possible \$b\$ is a zero-length sequence. You can omit the number \$n\$ from the input.
For output, you can use truthy/falsy values for your language (swapping is allowed). If such a convention is not defined, you can use two distinct values to represent true/false respectively.
Scoring and winning criterion
Standard code-golf rules apply. The shortest code measured in bytes wins.
Test cases
True
1, []              # permutation: [1]
2, [1]             # permutation: [1, 2]
3, [1, 1]          # permutation: [1, 2, 3]
4, [1, 1, 1]       # permutation: [1, 2, 3, 4]
4, [1, 2, 1]       # permutation: [1, 2, 4, 3]
4, [2, 1, 2]       # permutation: [1, 3, 2, 4]
5, [1, 2, 2, 1]    # permutation: [1, 2, 5, 3, 4]
6, [2, 3, 2, 2, 1] # permutation: [1, 3, 6, 2, 4, 5]

False
4, [2, 2, 1]
5, [2, 2, 1, 1]
6, [1, 2, 2, 2, 3]
6, [3, 2, 1, 1, 2]
7, [2, 2, 3, 1, 2, 2]

Related OEIS sequence

I'd find it more circular if also $b_n$ was defined in the obvious way.

Do the permutations 135642, 135624, 135462, 135426, 153462, 153426, 153264 and 153246 all have the same step sequence 22122?

@Neil Yes, exactly.

From the other perspective, $b_1, \dots, b_{n-1}$ is a CSS iff you can choose signs $s_1, \dots, s_{n-1} \in {-1, 1}$ such that the $n$ partial sums of $0 + s_1b_1 + s_2b_2 + \dots$ considered modulo $n$ are a permutation of all the members of $\mathbb{Z}_n$.

As a consequence of @Lynn's observation, the partial sums are a permutation of $Z_n$ exactly if no two are the same modulo $n$, which means that no infix has $s_i b_i + s_{i+1} b_{i+1} + \cdots + s_{j} b_{j}  = 0 \bmod n$.

JavaScript (ES7),  99 79 74  72 bytes
Takes input as (n)(b). Returns a Boolean value.
n=>g=([d,...b],x=0,m=2**n-2)=>d?[x+d,x-d+n].some(y=>g(b,y%=n,m^1<<y)):!m

Try it online!
How?
Instead of using an array for \$a_i\$, we use a bitmask \$m\$ initialized to \$2^n-2\$ and a bit pointer \$x\$ initialized to \$0\$ (i.e. pointing to the least significant bit).
For instance: for \$n=4\$, we start with \$m=4^2-2=14=1110_2\$. Because the LSB is our starting position, it is cleared right away to mark it as visited.
The main part of the code is a recursive search in a binary tree: for each \$b_i\$, we move the bit pointer to either \$x+b_i\$ or \$x-b_i\$ (wrapping around modulo \$n\$) and toggle the bit at the new position in \$m\$.
We have \$m=0\$ on a leaf node iff all positions have been reached exactly once.

Jelly, 9 bytes
Œ!Iæ%H{Aċ

Try it online!
A dyadic link taking \$n\$ as its left argument and the input sequence \$b\$ as its right argument. Returns a truthy value (positive integer) for True and a falsy value (zero) for False.
Explanation
Œ!        | Permutations of 1..n
  I       | Differences (vectorises)
   æ%H{   | Symmetric mod half of n (for n=6, [-5,-4,-3,-2,-1,0,1,2,3,4,5] will map to [1,2,3,-2,-1,0,1,2,3,-2,-1])
       A  | Absolute
        ċ | Count occurrences of b

Really cool solution...

APL (Dyalog Unicode), 28 26 bytes
⊣∊⊣{≢∪⍺|+\⍵}¨⊂⍤,×¯1*2⍳⍤⍴⍨⊣

Try it online!
TIO is only on 17.1, so I've implemented the ⍤ operator from 18.0 manually. Takes \$n\$ as the left argument, and the sequence as the right.
Explanation
                 ¯1*2⍳⍤⍴⍨⊣    ⍝ Get all possible combinations of ¯1 1 with length n
             ⊂⍤,×             ⍝ Multiply it by n concatenated with the array (it doesn't matter what the starting value is)
  ⊣{       }¨                 ⍝ Map each to
        +\⍵                   ⍝ The cumulative sum
      ⍺|                      ⍝ Modulo n
    ≢∪                        ⍝ Then get the number of unique values
⊣∊                            ⍝ Is one of these n?

Japt -x, 11 10 bytes
Outputs 0 for false or an integer >0 for true.
õ á Ëäa eV

Try it
õ á Ëäa eV     :Implicit input of integer U & array V
õ              :Range [1,U]
  á            :Permutations
    Ë          :Map
     ä         :  Consecutive pairs
      a        :    Reduced by absolute difference
        eV     :  Is equal to V?
               :Implicit output of sum of resulting array

Wolfram Language (Mathematica), 84 bytes
(y=#;!FreeQ[(x=#;Abs[#-#2]&@@@Array[x[[{#,#+1}]]&,y-1])&/@Permutations@Range@y,#2])&

Try it online!

What does the @@@ do?

@RGS  f@@@expr or Apply[f,expr,{1}]   replaces heads at level 1 of expr by f.

Python 3,  90  89 bytes
-1 thanks to FryAmTheEggman
f=lambda n,a,v=[0]:a and any(f(n,a[1:],[(v[0]+x*a[0])%n]+v)for x in(-1,1))or len({*v})==n

Try it online!

Indeed I do not, thanks!

Python, 77 bytes
f=lambda n,l,m=1:all(f(n,l[1:],m<<d*l[0]|1)for d in[1,n-1])if l else m%~-2**n

Try it online!
Outputs True/False swapped.
The idea to store visited values as a bitmask is from Arnauld.
But, instead of storing our current position on the tape of bits and updating it after we move, we simply move the whole tape so that we're located at the end. We treat the tape as unrolled, so that every n-th position is the same, and we always move the tape left with << by converting each rightwards move to an equivalent leftwards move modulo n.
In the end, we collapse the tape to its last n positions by taking the numerical value modulo 2**n-1. The only way to get a result of zero is if every position modulo n was hit exactly once.

Very nice. You are missing the f= for a recursive function though.

Ruby, 99 81 71 bytes
f=->n,s,w=[0]{w[-n]||(a=s.pop)&&[a,-a].any?{|g|f[n,s,w|[(w[-1]+g)%n]]}}

Try it online!

05AB1E, 13 bytes
Lœ€üαD¹αÅLJIå

Try it online!

Python 3, 100 bytes
f=lambda n,b,i=[0]:b and(f(n,b[1:],[(i[0]+b[0])%n]+i)+f(n,b[1:],[(i[0]-b[0])%n]+i))or len(set(i))==n

Try it online!
Returns a non-zero integer (n>1) / True (n==1) for True and False for False.
Explanation
i is the list of visited numbers in reverse order. At each step of the recursion, we remove the first entry of b, move either forwards or backwards by the corresponding amount (modulo n) and append the new position at the 0th position of i. Terminates when b=[], for which the function evaluates to True if i has exactly n distinct numbers and False otherwise.

94 bytes

Scala, 88 82 80 bytes
n=>d=>1.to(n).permutations.map(l=>(l.zip(l.tail)).map(_-_)map(_.abs))contains(d)

Try it online!

-6 thanks to user!

70 bytes by using underscore and toSet. (Btw, there's something wrong with your current TIO link)

I think the problem is l.zip(l.tail), since it returns a list of tuples, and you can't call map(_-_) on that unless you're using Scala 3/Dotty.

K (ngn/k), 29 bytes
{|/x=#'?'+x!+\-1 1[!x#2]*x,y}

Try it online!
Takes n as x and b (the sequence) as y. A port of @Jo King's APL answer.

-1 1[!x#2] generate all combinations of -1 and 1 with length n
*x,y multiply these by n prepended to the sequence b
x!+\ take the column-wise cumulative sums, mod'ing them by n
+ transpose the result
#'?' calculate the number of distinct values in each row
|/x= are any of those equal to n?

J, 21 17 bytes
e.2|@-/\"1!A.&i.]

Try it online!
-4 bytes thanks to Bubbler
Literal translation of the question: Is the given list and element of e. the adjacent differences of every possible perm?

17 bytes. You don't need 1+ since it doesn't affect the adjacent differences, and you can refactor the duplicated i. using &.

Excellent edits.  Thank you very much!

Python 2, 101 bytes
lambda n,b:n in map(len,map(set,reduce(lambda Q,k:[q+[(q[-1]+v)%n]for q in Q for v in-k,k],b,[[0]])))

Try it online!
Returns True/False if b is/isn't a circular set sequence.

Python 3, 120 115 90 bytes
f=lambda n,l,x=0,m=0:all(f(n,l[1:],y%n,m^1<<y%n)for y in[x+l[0],x-l[0]])if l else m-2**n+2

You can try it online! Outputs False for CSS and True otherwise.
This is a port of Arnauld's answer (who saved me almost 20 bytes!). Go upvote his answer because it looks better than this one!

Python 3, 101 bytes
lambda n,a,r=range:n in(len({sum([a[j]*(k>>j&1or-1)for j in r(i)])%n for i in r(n)})for k in r(1<<n))

Try it online!

Really cool way of defining r to be the range!

Wolfram Language (Mathematica), 54 bytes
Or@@(0!=##&@@@Mod[Accumulate/@Tuples[{#,-#}&/@#2],#])&

Try it online!
See all possible permutations:
Try it online!

Python 3.8 (pre-release), 137 \$\cdots\$ 119 118 bytes
Saved a byte thanks to Surculose Sputum!!!
lambda n,b:any(b==[min(i:=abs(a-b),n-i)for a,b in zip(p,p[1:])]for p in permutations(range(n)))
from itertools import*

Try it online!

You can use lambda and any to lower the byte count to 118. Try it online!

@SurculoseSputum Snap, was just posting a 119 byte version of that

@SurculoseSputum Clever rejig of the equality/for loop - thanks! :-)

Charcoal, 41 bytes
⬤ＥＸ²ＬθＥ⊕Ｌθ﹪∨ΣＥ…◧⍘ι²Ｌθλ×∨Σλ±¹§θμ⁰⊕Ｌθ⊙ι⊖№ιλ

Try it online! Link is to verbose version of code. Outputs - only if the input is not a circular step sequence. Explanation:
ＥＸ²Ｌθ

Outer loop to 2ⁿ⁻¹ (exclusive).
Ｅ⊕Ｌθ

Inner loop to n (exclusive)
…◧⍘ι²Ｌθλ

Convert the outer loop index to binary with n-1 digits, but only take the first inner loop index bits.
Ｅ...×∨Σλ±¹§θμ

Replace the 1 bits with the values from the input and the 0 bits with the negated values respectively.
﹪∨Σ...⁰⊕Ｌθ

Take the sum modulo n. Because only the first inner loop index bits were used, each result takes one more bit into account, resulting in a list of the partial sums of the possibly negated values.
⬤...⊙ι⊖№ιλ

Check that all resulting lists contain duplicate elements. This will be true if the input is not a circular step sequence.