นี่คือความท้าทาย Cops and Robbers นี่คือเธรดของโจร ด้ายของตำรวจอยู่ที่นี่

ตำรวจจะเลือกลำดับใด ๆ จากOEISและเขียนโปรแกรมpที่พิมพ์จำนวนเต็มแรกจากลำดับนั้น พวกเขายังจะได้พบกับบางสตริงs หากคุณใส่sที่ไหนสักแห่งที่เข้าสู่หน้าโปรแกรมนี้จะต้องพิมพ์เลขที่สองจากลำดับ หากคุณแทรกs + sลงในตำแหน่งเดียวกันในpโปรแกรมนี้จะต้องพิมพ์จำนวนเต็มที่สามจากลำดับ s + s + sในตำแหน่งเดียวกันจะพิมพ์ที่สี่เป็นต้นไปเรื่อย ๆ นี่คือตัวอย่าง:

Python 3 ลำดับA000027

print(1)

สตริงซ่อนเป็นไบต์ที่สอง

สตริงคือ+1เนื่องจากโปรแกรมprint(1+1)จะพิมพ์จำนวนเต็มที่สองใน A000027 โปรแกรมprint(1+1+1)จะพิมพ์จำนวนเต็มที่สามเป็นต้น

ตำรวจต้องเปิดเผยลำดับโปรแกรมเดิมPและความยาวของสตริงที่ซ่อนs โจรแตกส่งโดยการหาสตริงใดขึ้นอยู่กับความยาวที่และสถานที่ที่จะแทรกเพื่อสร้างลำดับ สตริงไม่จำเป็นต้องตรงกับโซลูชันที่ต้องการให้เป็นรอยแตกที่ถูกต้องและไม่ได้แทรกตำแหน่งไว้

หากคุณถอดรหัสตำรวจคนใดคนหนึ่งตอบโพสต์โซลูชั่นของคุณ (ด้วยสตริงที่ซ่อนอยู่และสถานที่เปิดเผย) และลิงค์ไปยังคำตอบ จากนั้นแสดงความคิดเห็นในคำตอบของตำรวจพร้อมลิงก์ไปยังช่องโหว่ของคุณที่นี่

กฎระเบียบ

• โซลูชันของคุณจะต้องทำงานกับหมายเลขใด ๆ ในลำดับหรืออย่างน้อยก็จนกว่าข้อ จำกัด ที่เหมาะสมซึ่งจะล้มเหลวเนื่องจากข้อ จำกัด ของหน่วยความจำจำนวนเต็ม / สแต็คล้นเป็นต้น

• โจรผู้ชนะคือผู้ใช้ที่ถอดรหัสสิ่งที่ได้รับความนิยมมากที่สุดโดยผู้ที่เข้ามาถึงจำนวนรอยร้าวนั้นจะถึงที่ก่อน

• ตำรวจชนะคือตำรวจกับที่สั้นที่สุดสตริงsที่ไม่ได้แตก tiebreaker เป็นที่สั้นที่สุดพี หากไม่มีการส่งที่ไม่ได้ทำการคัดลอกตำรวจที่มีทางออกที่ไม่ได้ติดตามจะได้รับชัยชนะนานที่สุด

• ในการประกาศความปลอดภัยโซลูชันของคุณจะต้องไม่ถูกถอดออกเป็นเวลา 1 สัปดาห์จากนั้นเปิดเผยสตริงที่ซ่อนอยู่ (และตำแหน่งที่จะแทรก)

• sอาจไม่ซ้อนกันมันจะต้องต่อกันจนจบ ตัวอย่างเช่นถ้าsเป็น10แต่ละซ้ำจะไป10, 1010, 101010, 10101010...มากกว่า10, 1100, 111000, 11110000...

• โซลูชันการเข้ารหัสทั้งหมด (ตัวอย่างเช่นการตรวจสอบแฮชของสตริงย่อย) จะถูกแบน

• หากsมีอักขระที่ไม่ใช่ ASCII คุณต้องระบุการเข้ารหัสที่ใช้

Python 2 , ลำดับA138147 โดย xnor

เดิม:

print 10

Cracked:

print "1%s0"%10
      ^^^^^^^

ลองออนไลน์!

Brain-Flak , A000984โดยNitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

นี่เป็นเพียง 30 ไบต์ไม่แน่ใจว่า Nitrodon มีอยู่ในใจ

ลองออนไลน์!

คำอธิบาย

ฉันลองหลายอย่างแล้ว แต่นี่คือสิ่งที่ใช้ได้ เงื่อนไขของ A000984 เป็นองค์ประกอบสำคัญของสามเหลี่ยมปาสคาล

ตอนนี้ฉันรู้แล้วว่าฉันสามารถหาพวกมันได้โดยการเพิ่มเส้นทแยงมุมข้างบน:

ตัวอย่างเช่น:

$1+3+6+10 = 20$

และเนื่องจากการกระทำขั้นสุดท้ายในโปรแกรมของ Nitrodon คือการสรุปทุกสิ่งเหล่านี้ดูเหมือนว่าจะเป็นผู้สมัครที่ดี (เหมือนฉันได้ลองทำอะไรหลาย ๆ อย่าง

ดังนั้นเราต้องการโปรแกรมที่ใช้ผลรวมบางส่วนและสร้างผลรวมถัดไป โชคดีที่มีวิธีที่ประณีตในการรับจากสิ่งเหล่านี้ไปยังอีก แต่ละแถวเป็นเดลต้าของแถวถัดไป นั่นคือคำที่$n$ในแถวคือความแตกต่างระหว่างคำที่$n$และ$n-1$ในแถวถัดไป

ปัญหาหนึ่งคือเราไม่ได้มีแถวมากพอที่จะคำนวณแถวที่เราต้องการ เนื่องจากแต่ละแถวยาวกว่าแถวสุดท้ายหากเรามีแถวเราจึงไม่สามารถรับสมาชิกคนสุดท้ายของแถวถัดไปด้วยวิธีนี้ อย่างไรก็ตามที่นี่เรามีเคล็ดลับอื่นสมาชิกสุดท้ายของแต่ละแถวเท่ากับสมาชิกก่อนหน้าของแถวนั้น!

$1+3+6=10$

และถ้าคุณมีความคุ้นเคยกับ Brain-Flak ที่ควรยื่นมือออกมาเป็นสิ่งที่ง่ายต่อการทำ

ตอนนี้สำหรับรหัส:

ในการเริ่มต้นเราทำการคำนวณแถวถัดไปโดยที่สมาชิกใหม่แต่ละรายมีผลรวมของสมาชิกเก่าสองรายที่อยู่ติดกัน สามารถทำได้ด้วย:

{({}<>({}))<>}<>

ซึ่งโดยทั่วไปจะย้ายองค์ประกอบไปและเพิ่ม (โดยไม่ลบ) สิ่งที่เคยมีอยู่ด้านบนไปแล้ว อย่างไรก็ตามสิ่งนี้กลับตรงกันข้ามทุกอย่างดังนั้นในครั้งต่อไปที่เราได้แถวเราจำเป็นต้องนำมันกลับมา

{({}<>({}))<>}<>{({}<>)<>}<>

ตอนนี้เราจำเป็นต้องคำนวณสมาชิกสุดท้ายของแถว อย่างที่ฉันพูดไปก่อนหน้านี้มันง่ายสุด ๆ เนื่องจากเรามีการวนรอบองค์ประกอบทั้งหมดของแถวเราจึงสามารถหาผลรวมนั้นและผลักมันได้ เราดันมันก่อนที่วงที่สองดังนั้นมันจะจบลงที่ด้านล่าง

({({}<>({}))<>}<>){({}<>)<>}<>

และนั่นคือมัน

Brain-Flak, A000290 , โดย Sriotchilism O'Zaic

เดิม:

((()))({}<>)

Cracked:

((()))({}([])[]<>)
         ^^^^^^

ลองออนไลน์!

อีกวิธีหนึ่งคือ:

((())([])[])({}<>)
     ^^^^^^

ลองออนไลน์!

MATLลำดับA005206โดยหลุยส์ Mendo

เดิม:

voOdoO

ลองออนไลน์!

Cracked:

voOdoOdNq17L/k
      ^^^^^^^^

ฉันไม่ใช่ผู้เชี่ยวชาญ MATL แต่จากสิ่งที่ฉันเข้าใจดั้งเดิมvoOdoOสร้างอาร์เรย์ว่างสองชุดและอาร์เรย์[0]บนสแต็ก นี่[0]คือสิ่งที่ได้รับการพิมพ์โดยไม่ต้องวงเล็บเป็นองค์ประกอบแรกของลำดับ รอยแตก / สารละลายทำสิ่งต่อไปนี้:

• dนำองค์ประกอบออกจากสแต็กและ (สมมติว่าเป็นตัวเลขหรืออาร์เรย์ที่มีขนาด 1) เปลี่ยนให้เป็นอาร์เรย์ว่าง อาร์เรย์ที่ว่างเปล่าเหล่านี้จะไม่ได้รับการพิมพ์ แต่สนับสนุนขนาดสแต็ก
• Nqนับขนาดของสแต็กและลบออกหนึ่งรายการ นี่เป็นn+1คำศัพท์ที่ใช้ประเมินฟังก์ชั่น (เนื่องจากมันเริ่มต้นที่ 2 และเพิ่มขึ้นทีละหนึ่งทุกการวนซ้ำเนื่องจากการdเพิ่มสิ่งที่มองไม่เห็นลงในสแต็ก)
• 17L นี่คือค่าคงที่ Phi = (1+sqrt(5))/2
• /kสิ่งนี้จะดำเนินการfloor((n+1)/Phi)ซึ่งเป็นหนึ่งในสูตรที่คำนวณองค์ประกอบของลำดับ สูตรนี้แสดงรายการอยู่ใน OEIS a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2ยกเว้นว่าเราใช้ข้อมูลประจำตัว(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

ลองออนไลน์!

เบียร์ 100 ขวดเพิ่ม-1เพื่อรับหมายเลขต่อไป99ฯลฯ

ถังลำดับA000045โดยA__

เดิม:

0.

Cracked:

01":&+.
 ^^^^^

โปรดทราบว่าความท้าทายกำลังค้นหาซับสตริงที่มีความยาว <= 6 แต่สตริงที่พบนั้นมีความยาว 5

คำจำกัดความของคำสั่งสำหรับผู้ที่ขี้เกียจเกินกว่าที่จะค้นหาข้อมูลจำเพาะของ Keg 0และ1กดหมายเลขที่เกี่ยวข้องไปยังสแต็ก "ย้ายสแต็คด้านบนไปที่สแต็คด้านล่าง (ม้วน); &ย่อส่วนสแต็กเข้าสู่การลงทะเบียนถ้าว่างเปล่ามิฉะนั้นให้รีจิสเตอร์ลงในสแต็ก +เพิ่มค่าสแต็กสองอันดับแรก

เริ่มต้น1"เพียงแค่แทรก 1 ที่ด้านล่างของสแต็ก นี้รายการที่เพิ่มขึ้นจาก 1 เท่านั้นมีบทบาทในการซ้ำแรกซึ่งจะช่วยให้เราสามารถสมมติกองเริ่มต้นเป็นมากกว่าแค่1 0 0แท้จริงแล้วโปรแกรม10:&+.ที่:&+มีการทำซ้ำส่วนนั้นมีพฤติกรรมเช่นเดียวกับวิธีการแก้ปัญหาข้างต้นยกเว้นว่ามันไม่มีรายการ 1 ที่ด้านล่าง

เนื่องจาก&ถูกใช้เพียงครั้งเดียวในส่วนที่ทำซ้ำและมีพฤติกรรมสลับกันพฤติกรรมของ1":&+ขึ้นอยู่กับความเท่าเทียมกันของการทำซ้ำ

ตอนนี้โปรแกรมนี้ไม่ได้พิมพ์ลำดับ Fibonacci จริง ๆ เริ่มต้นด้วย 0, 1 จากจุดเริ่มต้น มันพิมพ์ลำดับ 1, 0 Fibonacci จากที่สองเช่นจาก 0 (ผลลัพธ์นี้ในลำดับเดียวกัน) เมื่อรู้สิ่งนี้โปรแกรมจะวิเคราะห์อย่างง่ายดาย:

• ในครั้งแรกที่สาม ... ย้ำรัฐเริ่มต้นเป็นและสิ้นสุดเป็น[a, b]a+b (&=b)
• ในครั้งที่สองสี่ ... ย้ำเริ่มรัฐและปลายเป็น[b] (&=a)[b, b+a]

นี่เป็นการคำนวณลำดับตามความต้องการอย่างแท้จริง

Java 8+ ตามลำดับA010686 โดย Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Brain-Flak, A000578 โดย Sriotchilism O'Zaic

เดิม:

((())<>)

ลองออนไลน์!

Cracked:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

ลองออนไลน์!

PyretลำดับA083420โดยMLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

คุณสามารถเรียกใช้ที่นี่ แต่ฉันไม่ได้คิดวิธีการเชื่อมโยงไปยังรหัส คุณจะต้องคัดลอกวาง

ฟังก์ชั่นที่มีให้ละเว้นอาร์กิวเมนต์ที่สอง มันเพิ่มเป็นสองเท่าก่อนและเพิ่มอีกหนึ่งอันซึ่งจะสร้าง2^n - 1ลำดับที่จำเป็นที่จำเป็นในที่นี้สิ่งที่ฉันต้องทำคือบอกให้ทราบว่ากี่ครั้งในการดำเนินการนั้นทำได้โดยการเปลี่ยนความยาวของรายการที่พับ โชคดีที่ Pyret ไม่ได้บ่นเกี่ยวกับจุลภาคที่ตามมา

Python 3ลำดับ A268575โดยNieDzejkob

เดิม:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

แคร็ก (100 ไบต์):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

ลองออนไลน์!

จากสิ่งที่ฉันสามารถรวบรวมได้รหัสต้นฉบับกำลังตั้งค่าคำจำกัดความเพื่อทำให้สตริงที่ซ่อนอยู่นั้นย่อให้ได้มากที่สุดแล้วกำหนดรูปแบบเกมแห่งชีวิตเริ่มต้น สตริงที่ซ่อนอยู่นั้นเทียบเท่ากับการเขียนซ้ำของเกมแห่งชีวิตของคอนเวย์ใน 102 ไบต์

สำหรับวัตถุประสงค์ของการถอดรหัสSนี้เป็นฟังก์ชั่นที่สรุปองค์ประกอบภายในอาร์กิวเมนต์ (ซึ่งเป็น iterables) และFใช้ฟังก์ชันที่คืนค่า iterable ให้กับทุกองค์ประกอบของรายการและแตกผลลัพธ์ทั้งหมดเข้าด้วยกัน

• ;A=-1,1,0;สิ้นสุดคำสั่งก่อนหน้านี้และย่อ tuple (-1,1,0) ด้วย A ซึ่งใช้เป็นproduct(A,A)ที่ให้เพื่อนบ้านทั้งหมดที่เกี่ยวข้องกับเซลล์ที่กำหนดเช่นเดียวกับเซลล์ตัวเอง
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);สร้างรายการใหม่ที่Xเก็บเพื่อนบ้านทั้งหมดของเซลล์ในWและเซลล์ในWตัวเองโดยการเพิ่มตำแหน่งสัมพัทธ์ของเพื่อนบ้านไปยังแต่ละเซลล์และทุบพวกเขาเข้าด้วยกันเป็นรายการ
• W={p for p in X if 2<X.count(p)<4+({p}<W)}ผ่านรายการนี้Xและพิจารณาว่าแต่ละเซลล์Xอยู่ในชุดของเซลล์ในการทำซ้ำครั้งถัดไปหรือไม่ นี้ถูกนำเกือบคำต่อคำจากเกมกอล์ฟชีวิตนี้

Haskell, A014675โดยKhuldraeseth na'Barya

รหัสเดิม

main=print$uncurry(!!)([2],0)

ด้วยซับสตริง

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

ลองออนไลน์!

เครื่องคิดเลขตั้งโต๊ะ, A006125 , โดย A__

เดิม:

1n

Cracked:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

ลองออนไลน์!

การใช้งานที่ไม่ซับซ้อน

cQuents , ลำดับA003617โดยStephen

=10#2:pZ
  ^

ลองออนไลน์!

เริ่มต้นด้วยตัวเลขต่ำสุด n + 1 หลักตามด้วย n เลขศูนย์ การ#2ระบุว่าจะมีการพิมพ์เฉพาะคำที่สองของลำดับซึ่งเป็นคำจำกัดความของลำดับที่ใช้เพียงครั้งเดียวกับเมล็ดเท่านั้น การนิยามลำดับนี้จะค้นหาและส่งคืนไพรม์ถัดไป

Python 3 - ตลอดไป

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

ลองออนไลน์!

MATL, sequence A000796 by Luis Mendo

Original:

'pi'td1_&:_1)Y$J)

Try it online!

Cracked:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

ผู้เขียนต้นฉบับที่สร้างลอบอาร์เรย์และสกัดแล้วและเมื่อตะกี้องค์ประกอบแรกของมันที่จะได้รับ[-7:-1] 7จากนั้นเขาก็ใช้มันเพื่อให้ได้ตัวเลข 7'th ของไพ (ซึ่งคือ3) และนำเสนอเป็นหลักแรกของไพ การเพิ่มเข้าไป|SQทำให้อาร์เรย์ดั้งเดิมนั้นเป็นค่าบวกเรียงลำดับและเพิ่มเข้าไปในทุกสิ่ง ซึ่งหมายความว่าหลังจากทุกอย่างแทนการรับดัชนี7มันจะได้รับดัชนี-2หลังจากหนึ่งแอปพลิเคชัน-3หลังจากสองแอปพลิเคชันและอื่น ๆ -เป็นสิ่งสำคัญเพราะมันบอกY$ฟังก์ชั่นเพื่อไม่ให้รอบตัวเลข

Forth (gforth), A000042, by NieDzejkob

.( 1)1 .
^^^^^

Try it online!

1-byter เล็ก ๆ น้อย ๆ เป็นเพียงการขยายตัวอักษร ปัญหาคือว่าล้น 64 บิตเร็วที่สุดเท่าที่ตัวเลขที่สิบเก้า การแก้ไขอย่างง่ายคือการพิมพ์ตัวเลขหลักซ้ำ ๆ ใช่ไหม? ใช่ แต่มันไม่ง่ายเลย แม้ว่าการตรึง1 . onto the end will indeed print the additional digits we require, they'll be separated by spaces. That ain't gonna work.

ตอนนี้ตามวิกิพีเดีย " .((dot-paren) เป็นคำที่แยกวิเคราะห์สตริงที่คั่นด้วยวงเล็บแล้วแสดงเป็น" โชคดีที่การแสดงนั้นไม่มีตัวอักษรแปลก ๆ ดังนั้นการใช้.(พิมพ์ 1 ตัวเดียวก็น่าจะเพียงพอแล้ว และมันก็เป็นเช่นนั้น ไม่จำเป็นต้องเว้นที่ว่างหลังการถ่ายภาพระยะใกล้ดังนั้นตัวละครทั้งห้า (มีช่องว่างหลังจากการเปิดแบบเปิด) สามารถทำซ้ำกับเนื้อหาในใจของเรา ในการสาธิตฉันได้รวม TIO ไว้ในตัวอย่างที่อาจทำให้เกิดการไหลล้นของ 64- บิต int หลายต่อหลายครั้ง ทำงานเหมือนจับใจ

Unefunge-98 (PyFunge)ลำดับA000108โดยNieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

ลองออนไลน์!

ทำซ้ำหกครั้ง

อนุญาตให้ใช้สองไบต์เพื่อสำรองของสิบเก้า! สิ่งที่ดูเหมือนจะเป็นช่องว่างมีอักขระ 0x01 เริ่มต้นของส่วนหัว

คำอธิบาย:

ความท้าทายที่นี่คือทั้งหมดที่เกี่ยวกับการสร้างa(n)จากและบางทีอาจจะa(n-1) nOEIS ให้สูตรอย่างชัดเจนซึ่งเป็นแปลงได้อย่างง่ายดายมากพอที่จะa(n) = (2n)!/(n!(n+1)!) a(n) = a(n-1) * (4n-6) / nตอนนี้จะใช้สิ่งนี้ใน Funge

ผมจะต้องใส่รหัสระหว่างและ1 .นั่นเป็นปริศนาที่ทำไปแล้วครึ่งหนึ่ง สิ่งที่เหลืออยู่คือรหัสอะไรที่จะแทรก? Funge ขาดเครื่องมือจัดการสแต็กอย่างยอดเยี่ยมดังนั้นด้านล่างของสแต็กจึงไม่ จำกัด ฉันต้องติดตามทั้งสองnและa(n) without growing the stack. And how better to do that than with Funge space?

นั่น 0x01 nตัวอักษรเป็นเคาน์เตอร์ของฉัน ฉันเก็บไว้a(n)ในกองตามที่จะต้องอยู่ในกองหลังจากบิตของฉันเสร็จสิ้นการดำเนินการ

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3, A008574 by tsh

print(1*2+2)
       ^^^^

Try it online!

V, A000290, by DJMcMayhem

é*Ä2é*Ø.
  ^^^^

yields the squares from 1.

Try it online!

The base é* inserts * and Ø. counts the number of non-newline characters in the entire buffer. The insertion Ä duplicates the top line to its own line, on which 2é* inserts **. Concatenations of the insertions yield successive odd numbers with the largest at the top. The final Ø. in effect sums the first n odd numbers, hence yielding the n-th square .

AsciiDots, sequence A019523 by Alion

\+++/
//\/\

Once!

Twice!

Ten times!

While trying to figure out how the code/language works, I learned that the first two lines of the existing code does all the work of outputting the Fibonacci sequence infinitely. The code terminates when any dot hits the &, so I merely needed to add further delay in the remaining lines to allow for the appropriate number of entries to output.

After some trial, error, and observation, I discovered that the correct delay interval is 16 time units per number. Fitting enough characters in a single row seemed infeasible, so I would need to put the delay in 2 rows, leaving 10 characters for the actual delay. In order for the pattern to match up with itself, both rows had to have 5 characters, and since the middle three characters in a row can be traversed twice, this gives 16 time units as desired.

The requirement to match this up to the & in the eighth column seemed to make this impossible, until I realized that I could start with a newline in the interior of the third row. This makes the penultimate row the right length, and removes the now-redundant end of the third line.

Brachylog, sequence A114018 by Unrelated String

Original program:

≜ṗ↔ṗb&w

String to insert:

≜ṗ↔ṗẹbb&w
    ^^

Try it online!

Explanation

Here is first the explanation of the original program (knowing that the sequence used is "least n-digit prime whose digit reversal is also prime")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

As you can see, the program is fairly straightforward except for one thing: there is a completely useless b - behead predicate call, that removes the first element of the reverse of our number, with which we don't do anything.

This is a definite clue as to how we can find the string. The idea is that, since we want to increase the length of the number by 1 digit each time we add the string, we need a string that "evaluates" the length of that number somehow, using that useless b.

The solution is to use ẹb: first, ẹ - elements will transform the number into a list of digits; then, b - behead will remove its first element. The trick is that b will fail if the list of digits is empty. So everytime we append a b, we will increase the length of the required number by 1 (because it will fail until the assigned value of ? is high enough to contain sufficiently many digits so that the last b is applied on a list of one digit).

Re-appyling ẹ each time has no effect because it's already a list of digits. We only need it once at the beginning because if we behead a number like 9001 instead of the list of its digits, we will get 001 = 1 which loses information about the number of digits.

VDM-SL, A000312, by Expired Data

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Since VDM-SL's let-expressions can re-bind variables which are already bound in an enclosing scope, x**x can be evaluated arbitrarily deeply nested in scopes in which x is one more than in the previous scope, while the original x is still less than the cardinality of m(1).

Haskell, A083318 by xnor

f=length     [2]
        $show

Try it online!

Haskell, A000045 (Fibonacci), by Rin's Fourier transform

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Try it online!

23 bytes exactly.

This one was fun and a bit tricky. The reversed 0 and 1 threw me off for a little bit before I realized that wasn't an issue. The lack of $ in the original had me trying sketchy stuff like $...$id (one byte too long) before it dawned on me that I could just wrap it all in parentheses. All in all, a nice little puzzle.

H.PWiz points out that pattern matching could have saved me at least five bytes: $(\[x,y]->[y,x+y]). That darn pointfree challenge has me thinking pointfree everywhere.