Infinite quote escaping sequence

Question

We start with the string a, and forever append to the string a comma followed by the string quote-escaped, where quote-escaping means doubling all quotes in a string, and then surrounding it with an additional pair of quotes.

In the first few steps we will get:

a
a,'a'
a,'a','a,''a'''
a,'a','a,''a''','a,''a'',''a,''''a'''''''

If we continue to do that forever, we get the following infinite string: a,'a','a,''a''','a,''a'',''a,''''a''''''','a,''a'',''a,''''a'''''',''a,''''a'''',''''a,''''''''a''''''''''''''','a,''a'',''a,''''a'''''',''a,''''a'''',''''a,'''...

If create a sequence, which is 1 at indices that string contains a quotes, we'll get the following sequence:

0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, ...

Alternatively, we can look at the indices of quotes, and get the following sequence (this is 0-indexed):

2, 4, 6, 9, 10, 12, 13, 14, 16, 19, 20, 22, 23, 25, 26, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 42, 45, 46, ...

Your task is to output one of these numeric sequences.

Rules

You can choose whether you use 0-indexing or 1-indexing.
If you output sequence 1, you can use any truthy/falsey values instead of 1/0, or any two different consistent values.
If you output sequence 2 (the one with the indices), you can choose if those indices use 0-indexing or 1-indexing.
You can use one of following output modes:
- Take \$n\$ as an input, and output the \$n\$-th element in the sequence.
- Take \$n\$ as an input, and output all elements in the sequence up to the \$n\$-th element.
- Take no input, and output the entire sequence forever.
You can use any reasonable input/output format.
Standard loopholes are disallowed.

This is code golf, so the shortest code wins.

loopy walt · Accepted Answer · 2022-07-16 19:17:19Z

7

Python, 57 bytes (@Steffan)

a=b="/"
while[print(end=b)]:b="/\%s\\"%repr(a)[1:-1];a+=b

Attempt This Online!

Old Python, 58 bytes

a=b="/"
while[print(end=b)]:b="/\\%s\\"%repr(a)[1:-1];a+=b

Attempt This Online!

Prints the entire sequence using / for 0 and \ for 1.

edited Jul 16, 2022 at 19:17

answered Jul 16, 2022 at 19:08

loopy walt

16.8k2 gold badges11 silver badges69 bronze badges

3

\$\begingroup\$ Smart abuse of the behavior of repr on backslashes \$\endgroup\$
– mousetail 'he-him'
Commented Jul 16, 2022 at 19:10
2

\$\begingroup\$ You don't need to escape the backslash in \\%s for -1 byte \$\endgroup\$
– naffetS
Commented Jul 16, 2022 at 19:14

Add a comment |

Jonah · Accepted Answer · 2022-07-16 19:12:10Z

5

J, ²² 19 bytes

{1&(],1,~0 1,+#])&0

Try it online!

-3 thanks to ovs!

Quite slow, as we iterate n times and take the nth result.

TIO link shows first 17 terms.

Approach is straightforward recursion:

{ nth item (0-indexed) from...
1&( )&0 Iterate n times, starting with 0, and using a constant left arg of 1...
(],1,~0 1,+#]) Bookend +#] (to be explained below) with 0 1 and 1
+#] The only interesting part, really. This is how we double up the quotes. Consider 0 0 1 0 1:
- + adds 1 to every element, taking advantage of the fixed left arg of 1:
```
1 1 2 1 2
```
- #] use that as a duplication mask for 0 0 1 0 1:
```
0 0 1 1 0 1 1
```

edited Jul 16, 2022 at 19:12

answered Jul 16, 2022 at 18:39

Jonah

33.8k4 gold badges40 silver badges94 bronze badges

1

\$\begingroup\$ {.1&(],1,~0 1,+#])&0 is 20 bytes, and can you do { instead of {. for the n-th value output format? \$\endgroup\$
– ovs
Commented Jul 16, 2022 at 19:06
\$\begingroup\$ @ovs, I really like the idea of reusing the fixed left arg of 1 to save a but for >:! \$\endgroup\$
– Jonah
Commented Jul 16, 2022 at 19:12

Add a comment |

naffetS · Accepted Answer · 2022-07-16 17:58:11Z

4

Vyxal, 16 bytes

0w?(:k≈$vß"1Wf)Ẏ

Try it Online!

Same idea as the Jelly answer.

answered Jul 16, 2022 at 17:58

naffetS

12.8k2 gold badges20 silver badges53 bronze badges

Add a comment |

Mama Fun Roll · Accepted Answer · 2022-07-16 23:07:40Z

lin, 57 bytes

.\n0\;.n e*.n `t
dup \; `' `flat1`,0`,1`+ `+
dup \; e&
1,

Try it here! Returns an iterable with the first n elements.

The code above extremely inefficiently runs through n iterations. For testing purposes, the following code is equivalent:

100 ; `_
.\n0;.n `t
dup \; `' `flat1`,0`,1`+ `+ `size.n < \@ e&
dup \; e&
1,

Explanation

Prettified code:

.\n 0 \; .n e* .n `t
dup ( dup ( 1, ) e& ) `' `flat 1`, 0`, 1`+ `+

.\n 0 \; .n e* store the input as n, push 0, execute the next line n times...
- dup ( dup ( 1, ) e& ) `' `flat top of stack with 1s replaced with 1 1
- 1`, 0`, 1`+ `+ prepend 0 1, append 1, append result to existing sequence

lynn · Accepted Answer · 2022-07-19 19:58:23Z

4

Haskell, 43 bytes

f n=iterate(\x->x++'b':show x)"a"!!n!!n<'a'

Attempt This Online!

f n is the nth element of sequence #1, as either True or False.

The string built by iterate has the same "shape" as the real string:

ab"a"b"ab\"a\""b"ab\"a\"b\"ab\\\"a\\\"\""…
a,'a','a,''a''','a,''a'',''a,''''a'''''''…

"\ both correspond to quotes, ab correspond to a,. So, we can use char<'a' to detect quotes.

answered Jul 19, 2022 at 19:58

lynn

69.2k11 gold badges133 silver badges283 bronze badges

Add a comment |

Jonathan Allan · Accepted Answer · 2022-07-17 16:10:00Z

Jelly, 13 bytes

0;x‘Ø1jƲŻ$$¡ḣ

A monadic Link that accepts n and yields the first n terms of the boolean is-a-quote sequence.

Try it online! Or see a longer prefix (by not heading) here.

How?

Starts with a zero (the initial a) and builds up the sequence exactly as described in the question, using zeros for non-quotes and ones for quotes.

0;x‘Ø1jƲŻ$$¡ḣ - Link: integer, n
0             - set the left argument, x, to zero
           ¡  - repeat n times:
          $   -   last two links as a monad - f(x):
         $    -     last two links as a monad - g(x):
       Ʋ      -       last four links as a monad - h(x):   e.g. [0,0,1,0,1]
   ‘          -         increment                               [1,1,2,1,2]
  x           -         repeat (double the quotes)              [0,0,1,1,0,1,1]
    Ø1        -         [1,1]
      j       -         join (wrap in quotes)                   [1,0,0,1,1,0,1,1,1]
        Ż     -       prepend a zero (prepend a comma)          [0,1,0,0,1,1,0,1,1,1]
 ;            -     concatenate that to x
            ḣ - head to index n

Unrelated String · Accepted Answer · 2022-07-16 17:33:15Z

Jelly, 14 bytes

;Ø.;x‘$;1
0Ç¡ḣ

Try it online!

Full program yielding first \$n\$ elements of the quote/non-quote sequence. Exponentially slow; better tested with manual control of the number of iterations.

;Ø.;x‘$;1    Monadic helper link: iterate
;Ø.          Append [0, 1].
   ;         Append
    x $      the argument with its elements repeated by
     ‘       themselves incremented.
       ;1    Append 1.

0Ç¡ḣ    Main link
 Ç¡     Repeat that n times
0       starting from 0,
   ḣ    and take the first n elements.

user15194465 · Accepted Answer · 2022-07-17 14:54:57Z

2

Batch Script, 80 bytes

Outputs the first n elements of sequence 1,

CMD/VON/CSET s=0^&(FOR /L %%Q in (1,1,8)DO @SET s=!s!01!s:1=11!1)^&ECHO !s:~,%1!

so ie if file is called quote.bat

CALL quote.bat 5

gives you

I hardcoded 8 iterations because that's the maximum amount before the string gets too big and CMD fails to parse it. So I'm not too sure if this answer counts, but I thought it would be neat to post it anyway.

Edit : minus a bunch of bytes thanks to Neil

edited Jul 17, 2022 at 14:54

answered Jul 16, 2022 at 18:09

user15194465

512 bronze badges

\$\begingroup\$ I'm not sure p is necessary, is it? (Also, I tried 9 iterations and CMD simply crashed on me. Oops.) \$\endgroup\$
– Neil
Commented Jul 17, 2022 at 0:04
\$\begingroup\$ Ahhhh thanks, that was big oversight on my part lol \$\endgroup\$
– user15194465
Commented Jul 17, 2022 at 14:55

Add a comment |

G B · Accepted Answer · 2022-07-18 10:07:48Z

2

Ruby, 52 47 bytes

f=->n,r=?0{r[n]||f[n,r+"01#{r.gsub ?1,'11'}1"]}

Try it online!

Returns the nth element.

edited Jul 18, 2022 at 10:07

answered Jul 18, 2022 at 8:59

G B

22.8k1 gold badge20 silver badges53 bronze badges

Add a comment |

Fmbalbuena · Accepted Answer · 2022-07-20 18:06:22Z

2

Python 3, 109, 71, 64, 63, 62 bytes

a=w='0'
while[print(end=w)]:w=f"01{a.replace('1','11')}1";a+=w

Try it online!

-45 thanks to @Steffan

-1 because of this answer

-1 thanks to @AnttiP

Explanation (Outdated):

a=w="0"

Self-explanatory

while 1:

Repeat infinite times.

print(end=w+"0");

print w with 0. There's "0" because "0" is a comma.

w="1"+

w is "1" and...

a.replace("1","11")+

double the ones of a and...

"1";

one.

a="00"+w

Put two zeroes and w.

edited Jul 20, 2022 at 18:06

answered Jul 16, 2022 at 18:42

Fmbalbuena

4,2631 gold badge10 silver badges52 bronze badges

1

\$\begingroup\$ Why not just use raw 0 and 1 instead of using a' and replacing them? Try it online! \$\endgroup\$
– naffetS
Commented Jul 16, 2022 at 18:51
\$\begingroup\$ This actually doesn't produce correct output. 64 bytes that does, though \$\endgroup\$
– naffetS
Commented Jul 16, 2022 at 19:13
\$\begingroup\$ Use a format string to save a byte: Try it online! \$\endgroup\$
– AnttiP
Commented Jul 17, 2022 at 6:45

Add a comment |

Neil · Accepted Answer · 2022-07-16 17:27:33Z

1

Charcoal, 29 bytes

Ｎθ≔0ηＷ›θＬη≔⁺⁺η0⪫11⪫⪪η1¦11η…ηθ

Try it online! Link is to verbose version of code. Outputs the first n elements of sequence 1. Explanation:

Ｎθ

Input n.

≔0η

Start with a string of 0 instead of a.

Ｗ›θＬψ

Repeat until there are enough elements.

≔⁺⁺η0⪫11⪫⪪η1¦11η

Extend the string by appending its quotation, but use 0 instead of a comma and 1 instead of a quote.

…ηθ

Output the first n elements.

answered Jul 16, 2022 at 17:27

Neil

177k12 gold badges74 silver badges281 bronze badges

Add a comment |

Kevin Cruijssen · Accepted Answer · 2022-07-18 07:35:30Z

05AB1E, 14 bytes

ÎFDX3:5šbJÀ«I£

Outputs the first \$n\$ items of the binary sequence as string.

Try it online.

Explanation:

Î              # Push 0 and the input
 F             # Pop and loop the input amount of times:
  D            #  Duplicate the current string
   X3:         #  Replace all 1 with 3
      5š       #  Convert the string to a list of digits, and prepend a 5
        b      #  Convert each digit to a binary string
               #  (3 become 11; 5 becomes 101; 0 and 1 remain unchanged)
         J     #  Join it back together to a single string
          À    #  Rotate it once towards the right, so the leading 1 is trailing
           «   #  Append it to the previous string we've duplicated
            I£ #  Only leave the first input amount of characters
               # (after the loop, the result is output implicitly)

Arnauld · Accepted Answer · 2022-07-18 08:06:11Z

1

JavaScript (ES6), 50 49 bytes

Saved 1 byte thanks to @tsh

Returns the \$n\$-th term of the binary sequence, 0-indexed, where 0's are encoded with 2's.

f=(n,s='2')=>s[n]||f(n,s+21+s.replace(/1/g,11)+1)

Try it online!

edited Jul 18, 2022 at 8:06

answered Jul 16, 2022 at 20:57

Arnauld

198k20 gold badges179 silver badges650 bronze badges

1

\$\begingroup\$ By applying the "any two different consistent values" rule, you can use other number instead of 0 to save a byte. \$\endgroup\$
– tsh
Commented Jul 18, 2022 at 1:55

Add a comment |

Noodle9 · Accepted Answer · 2022-07-17 14:25:49Z

0

Bash, 61 bytes

for((a=0;${#a}<=$1;));do a+=01${a//1/11}1;done;echo ${a:$1:1}

Try it online!

Returns the \$0\$-based \$n^{\text{th}}\$ element of the binary sequence.

edited Jul 17, 2022 at 14:25

answered Jul 17, 2022 at 12:23

Noodle9

20.3k3 gold badges21 silver badges46 bronze badges

Add a comment |

alephalpha · Accepted Answer · 2022-07-18 02:53:35Z

0

Haskell, 57 bytes

s>>=id
s=[0]:[0:1:[b|b<-a,c<-[0..b]]++[1]|a<-scanl1(++)s]

Attempt This Online!

answered Jul 18, 2022 at 2:53

alephalpha

50k7 gold badges68 silver badges182 bronze badges

Add a comment |

Adalynn · Accepted Answer · 2023-01-05 21:21:02Z

0

APL (Dyalog Extended), 27 bytes

{{∊⍵0 1(,⍨¨@(⍸⍵)⊢⍵)1}⍣⍵⊢,0}

Try it online!

answered Jan 5, 2023 at 21:21

Adalynn

6,1521 gold badge17 silver badges36 bronze badges

\$\begingroup\$ Hey, welcome back to PPCG! Btw converting this to a tradfn saves some bytes. Besides, I think porting Jonah's solution would be shorter. \$\endgroup\$
– user41805
Commented Jan 6, 2023 at 17:26

Add a comment |

Stack Exchange Network

Infinite quote escaping sequence

Rules

16 Answers 16

Python, 57 bytes (@Steffan)

Old Python, 58 bytes

J, ²² 19 bytes

Vyxal, 16 bytes

lin, 57 bytes

Explanation

Haskell, 43 bytes

Jelly, 13 bytes

How?

Jelly, 14 bytes

Batch Script, 80 bytes

Ruby, 52 47 bytes

Python 3, 109, 71, 64, 63, 62 bytes

Explanation (Outdated):

Charcoal, 29 bytes

05AB1E, 14 bytes

JavaScript (ES6), 50 49 bytes

Bash, 61 bytes

Haskell, 57 bytes

APL (Dyalog Extended), 27 bytes

Your Answer

Not the answer you're looking for? Browse other questions tagged
code-golf
string
sequence
or ask your own question.

Linked

Hot Network Questions

Infinite quote escaping sequence

Rules

16 Answers 16

Python, 57 bytes (@Steffan)

Old Python, 58 bytes

J, 22 19 bytes

Vyxal, 16 bytes

lin, 57 bytes

Explanation

Haskell, 43 bytes

Jelly, 13 bytes

How?

Jelly, 14 bytes

Batch Script, 80 bytes

Ruby, 52 47 bytes

Python 3, 109, 71, 64, 63, 62 bytes

Explanation (Outdated):

Charcoal, 29 bytes

05AB1E, 14 bytes

JavaScript (ES6), 50 49 bytes

Bash, 61 bytes

Haskell, 57 bytes

APL (Dyalog Extended), 27 bytes

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged code-golfstringsequence or ask your own question.

Linked

Related

Hot Network Questions

J, ²² 19 bytes

Not the answer you're looking for? Browse other questions tagged
code-golf
string
sequence
or ask your own question.