text:
Race Around the Track
I'm looking to find the fastest racer around. Show me your fastest lap around this 18x14 track shown below.
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/

Your job is to move the car below around the track once in all possible positions.
 _
| |
|_|

 /\
/ /
\/

 __
|__|

/\
\ \
 \/

The car can drive in 3 spaces in a row before turning. Here's an example of what a lap should look like.
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /_  /      \   \
|| ||        |   |
||_||        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
| _ |        |   |
|| ||        |   |
||_||        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
| _ |        |   |
|| ||        |   |
||_||        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
| /\|        |   |
 \\ \\      /   /
  \\/ \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \ /\\      /   /
  \\ \\____/   /
   \\/        /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \ /\\____/   /
   \\ \       /
    \\/      /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \   __     /
    \ |__|   /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \    __    /
    \  |__|  /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \     __   /
    \   |__| /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____//\ /
   \       / //
    \      \//
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      //\ /
  \   \____// //
   \        \//
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |/\ |
 \   \      // //
  \   \____/ \//
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        | _ |
|   |        || ||
|   |        ||_||
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        | _ |
|   |        || ||
|   |        ||_||
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \   \
 /   /      \  _\
|   |        || ||
|   |        ||_||
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  /   /    \ /\\
 /   /      \\ \\
|   |        |\/ |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____ /\\
  /   /    \\ \\
 /   /      \\/ \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /      /\\
   /   ____\ \\
  /   /    \\/ \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /   __ \
    /   |__| \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /  __  \
    /  |__|  \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     / __   \
    / |__|   \
   /   ____   \
  /   /    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    //\      \
   // /____   \
  / \//    \   \
 /   /      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   //\ ____   \
  // //    \   \
 / \//      \   \
|   |        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/
      ______
     /      \
    /        \
   /   ____   \
  //\ /    \   \
 // //      \   \
| \/|        |   |
|   |        |   |
|   |        |   |
|   |        |   |
 \   \      /   /
  \   \____/   /
   \          /
    \        /
     \______/

Rules

The output should show the car in all possible positions. 3 positions in each of the 8 sections of the track mean there are 24 possible positions to show.
The car positions must be shown in sequence. (You can't teleport to another part of the track!)
The starting position and direction (clockwise/counter clockwise) are not important.
Output can be in any reasonable format for text.
No input.
Standard code-golf rules. The fewer bytes your code has, the faster your car runs.

I take it no or non-usable input?

@Veskah Correct. Edited the post to include this.

Very nice first challenge!

Canvas, 131 bytes
｛↔］
ø５／２２╋___７１╋__８４╋|¶|１７╋|¶|５７╋２／６５╋╬
３［⁵ __¶|__|²６＋２╋］
３［⁵ _¶| |¶|_|２５²＋╋］
３［⁵ /\¶/ /¶\/６²－２²＋╋］
⁷⁸⇵｛↕］∔⁶｛↕］∔⁸｛↕↔］∔⁷⇵⁴∔⁸⇵⁴∔⁶⁴∔⁸∔

Try it here!

JavaScript (ES6), 371 bytes
Rotates clockwise. Probably still golfable.
f=(i=24,A=[])=>i--?A.map(r=>r.join``,g=(s,x,y)=>[...s].map(c=>(j=c.charCodeAt(),d='12221',m=k=>(x-=~-d[j&7],y-=~-d[j-2&7],k--)&&((A[y]=A[y]||Array(18).fill` `)[x]='|/_\\'[j&3],k&&m(k)))(j/8&7)),g('voF`ir@kBdm',5,1),g('fWF`Qb@SBdU',6,4),g(['NFPJAT','MDWFI@S','VFHRAL','UDOFQ@K'][i/3&3],'0x'+'111123678ABCEEECBA876321'[i],'0x'+'678BCDDDDEDC876654222567'[i])).join`
`+f(i):A

Try it online!
Animated version

f=(i=24,A=[])=>i--?A.map(r=>r.join``,g=(s,x,y)=>[...s].map(c=>(j=c.charCodeAt(),d='12221',m=k=>(x-=~-d[j&7],y-=~-d[j-2&7],k--)&&((A[y]=A[y]||Array(18).fill` `)[x]='|/_\\'[j&3],k&&m(k)))(j/8&7)),g('voF`ir@kBdm',5,1),g('fWF`Qb@SBdU',6,4),g(['NFPJAT','MDWFI@S','VFHRAL','UDOFQ@K'][i/3&3],'0x'+'111123678ABCEEECBA876321'[i],'0x'+'678BCDDDDEDC876654222567'[i])).join`
`+f(i):A

F = 0;
setInterval(_ => O.textContent = f().substr((F++ % 24) * 285 + 1, 285), 200)

Less golfed
// i = frame counter, A[] = drawing matrix
f = (i = 24, A = []) =>
  i-- ?
    A.map(r =>
      r.join``,
      // g() draws the shape described by s, starting at (x, y)
      g = (s, x, y) =>
        [...s].map(c => (
          // j holds the direction in bits 0-2 and the length in bits 3-5
          // a length of 0 means 'move without drawing'
          j = c.charCodeAt(),
          d = '12221',
          // m() either draws a line or just moves the pen by 1 step
          m = k => (
            x -= ~-d[j & 7],
            y -= ~-d[j - 2 & 7],
            k--
          ) && (
            (A[y] = A[y] || Array(18).fill` `)[x] = '|/_\\'[j & 3],
            k && m(k)
          )
        )(j / 8 & 7)),
      // draw the outer boundary of the track
      g('voF`ir@kBdm', 5, 1),
      // draw the inner boundary of the track
      g('fWF`Qb@SBdU', 6, 4),
      // draw the car, using the correct shape for this frame and hard-coded coordinates
      g(['NFPJAT', 'MDWFI@S', 'VFHRAL', 'UDOFQ@K'][i / 3 & 3],
        '0x'+'111123678ABCEEECBA876321'[i],
        '0x'+'678BCDDDDEDC876654222567'[i]
      )
    ).join`\n` + f(i)
  :
    A

Python 2, 641 639 592 576 bytes
for i in range(24):
 t='s  ______s  Xs / 642  \s Xs/875310  \sX   /:;8____   \   X  /<9:/s\   \  X />=</s  \   \ X|A@?|ss|   |X|BCB|ss|   |X|DED|ss|   |X|FHG|ss|   |X \ILK\s  /   / X  \KJM\____/   /  X   \MNPRTVs/   Xs\POQSUW  /sXs \______/s '.replace('s',4*' ')
 for c,C in[zip([chr(x)for x in range(48,88)],' '*ord(s)+r+' '*40)for s,r in zip("\0\n	!",'|____|?| ____|?\/\/?/\/\ ?\  / //\ ?_| ||_?_ | |_?_| ||_?\/\/\ ?\/\/?/  \ /\ ?| ____|?| ____|'.split('?'))][abs(12-i)]+zip('\/!','!\/')*(i>12):t=t.replace(c,C)
 print'\n'.join(l[::2*(i<13)-1]for l in t.split('X'))

Try it online!

-2 bytes, thanks to Kevin Cruijssen
-30 bytes, thanks to Mnemonic
-16 bytes, thanks to Jonathan

609 bytes

Possibly 578 bytes.

[1,-1][i>12] -> 2*(i<13)-1.

@JonathanFrech Thanks :)

Deadfish~, 26942 bytes
{iii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{iiiii}ddc{dddddd}dddcc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiicc{{d}i}ddc{{i}d}iicc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiicc{ddd}ic{iii}dcc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddc{iiiiii}iiic{dddddd}dddc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiicc{{d}i}ddc{{i}d}iicc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiicc{ddd}ic{iii}dcc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{iiiiii}iiic{dddddd}dddc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiicc{{d}i}ddc{{i}d}iicc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiicc{ddd}ic{iii}dcc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{i}iiiiic{iiii}iiiiic{iii}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}cc{dddddd}c{iiiiii}cc{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}cc{dddd}dddddc{d}dddddc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}c{i}iiiiic{iiii}iiiiicc{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}cc{dddddd}c{iiiiii}cciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}cc{dddd}dddddc{d}dddddcccccccc{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}c{i}iiiiic{iiii}iiiiicciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}cc{dddddd}c{iiiiii}c{dddddd}ccccccc{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}cc{dddd}dddddc{d}dddddcccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}ccc{iiiiii}iiicc{dddddd}dddccccc{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}c{{i}d}iic{ddd}icc{iii}dc{{d}i}ddccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}cccc{iiiiii}iiicc{dddddd}dddcccc{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cc{{i}d}iic{ddd}icc{iii}dc{{d}i}ddcc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}ccccc{iiiiii}iiicc{dddddd}dddccc{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}ccc{{i}d}iic{ddd}icc{iii}dc{{d}i}ddc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iicc{iiii}iiiiic{dddddd}c{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}ccccccc{i}iiiiic{d}dddddc{i}iiiiicc{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccc{iiiiii}c{dddd}dddddcc{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiicc{iiii}iiiiic{dddddd}c{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iicc{d}dddddc{i}iiiiicc{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}cccccccc{iiiiii}c{dddd}dddddcc{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}ii}iiic{iiii}iiiiic{dddddd}c{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiicc{d}dddddc{i}iiiiicc{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddc{iiiiii}c{dddd}dddddcc{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddc{iiiiii}iiic{dddddd}dddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{{d}i}ddc{{i}d}iicc{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{ddd}ic{iii}dcc{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddc{iiiiii}iiic{dddddd}dddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{{d}i}ddc{{i}d}iicc{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{ddd}ic{iii}dcc{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}cc{iiiiii}iiicdddc{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{{d}i}ddc{{i}d}iicc{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iicc{ddd}ic{iii}dcc{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}c{i}iiiiic{iiii}iiiiicc{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}cc{dddddd}c{iiiiii}cc{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{ddd}ddc{dddd}dddddc{d}dddddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddc{i}iiiiic{iiii}iiiiicc{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}cc{dddddd}c{iiiiii}cc{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}cc{dddd}dddddc{d}dddddc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccc{i}iiiiic{iiii}iiiiicc{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiiccccdddc{dddddd}c{iiiiii}cc{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}cc{dddd}dddddc{d}dddddc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddccc{iiiiii}iiicc{dddddd}dddc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddccc{{i}d}iic{ddd}icc{iii}dc{{d}i}ddc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcc{iiiiii}iiicc{dddddd}dddcc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcc{{i}d}iic{ddd}icc{iii}dc{{d}i}ddcc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddc{iiiiii}iiicc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddc{{i}d}iic{ddd}icc{iii}dc{{d}i}ddccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiicc{iiii}iiiiic{dddddd}cccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiicc{d}dddddc{i}iiiiic{iiiii}ddcccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiic{d}dddddc{iiiiii}c{dddd}dddddcc{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddccc{i}iiiiic{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiicc{iiii}iiiiic{dddddd}c{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiicc{d}dddddc{i}iiiiicc{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiic{d}dddddc{iiiiii}c{dddd}dddddcc{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic{dddd}iiic{ii}iicccccc{iiiiii}iiicccccc{{d}ii}dddddc{ii}iiccccc{i}iiiiic{d}dddddcccccc{iiiiii}c{{d}ii}ddc{ii}iicccc{i}iiiiic{d}dddddcccccccc{iiiiii}c{{d}ii}ddc{ii}iiccc{i}iiiiic{d}dddddccc{iiiiii}iiicccc{dddddd}dddccc{iiiiii}c{{d}ii}ddc{ii}iicc{i}iiiiicc{iiii}iiiiic{dddddd}c{i}iiiiic{d}dddddcccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{ii}iic{i}iiiiicc{d}dddddc{i}iiiiicc{d}dddddcccccc{iiiiii}c{dddddd}ccc{iiiiii}c{{d}ii}ddc{{i}}{i}iiiic{{d}i}ddc{iiiiii}c{dddd}dddddc{{i}dd}dddc{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddccc{{i}d}iic{{d}i}ddcccccccc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}}{d}ddddc{ii}iic{iiiiii}c{dddddd}ccc{iiiiii}c{dddddd}cccccc{i}iiiiic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iicc{iiiiii}c{dddddd}ccc{iiiiii}ciiicccc{ddddd}iic{d}dddddccc{i}iiiiic{dddd}iiic{ii}iiccc{iiiiii}c{dddddd}{c}{i}iiiiic{dddd}iiic{ii}iicccc{iiiiii}c{dddddd}cccccccc{i}iiiiic{dddd}iiic{ii}iiccccc{iiiiii}ciiicccccc{ddddd}iic


text:
Diamond creator +
Challenge :
Given an integer n as input. Create a diamond that is 2x the given number n.
Input :
Input is integer n and 2 < n ≤ 3000.
Output :
Output will be a string and it will be in form of a diamond consisting of + with an addition line at the start showing n using +
Examples :

D(3) :

+++
  +
 +++
+++++
+++++
 +++
  +

D(5) :

+++++
    +
   +++
  +++++
 +++++++
+++++++++
+++++++++
 +++++++
  +++++
   +++
    +

D(6) :

++++++
     +
    +++
   +++++
  +++++++
 +++++++++
+++++++++++
+++++++++++
 +++++++++
  +++++++
   +++++
    +++
     +

Winning Criteria :
This is code-golf so shortest code in bytes for each programming language wins.

Related: Print this diamond and related: User Scored Code Golf - Drawing Diamonds

@KevinCruijssen : Um so is this ok , or should I remove this ?

No it's ok. It's related, not a duplicate. :) Related challenges are just linked as inspiration, but yours is different enough (imo) to not be closed as a dupe.

@KevinCruijssen : Ok so it can stay ?

@KevinCruijssen : I see , i'm still new so learning the rules , thanks for telling me.

May we take n in unary?

… using + as tally mark?

@Adám : I guess you can if you feel like the normal doesn't work

Can you add a test case where n is even?

@Shaggy : sure why not. I will add that right away. Thanks

@Shaggy : There implemented.

@Adám here is the meta post on unary I/O

This is a grenade.

brainfuck, 151 139 bytes
,[.[<]<+[>>]++++[-<++++++++>],]<[<]<<<++++++++++.>>[[>]>[-<+>]>[-<+>]>>[.>>]<<[<]<<.<<[..<<]<.>>-]>[[>]>[.>>]<<[<<]>.>>[..>>]<<,<[<]<<.>>>]

Try it online!
Takes input via unary, with +s as tally marks (allowed by the poster). Decided to rework this, as I thought the old one was a bit longer than it could be (though this one is too!).
Old Version (151 bytes):
>--[>+<++++++]<[->+>.<<]++++++++[-<+<++++>>]<++>>[<<.>>-[-<+<<.>>>]<[->+<]>>>+[-<.>>+<]>+[-<+>]<<<]>>[<<<<.>>[-<+<<.>>>]<[->+<]>+>>-[-<.>>+<]>-[-<+>]<]

Try it online!
Takes input as the starting cell. I couldn't think of a way to leverage the first half to help with the second, so there's a loop for each of them.
How It Works:
 >--[>+<++++++]  Create 43 ('+') two space to the left of n
 <[->+>.<<]      Print n '+'s while preserving n
 ++++++++[-<+<++++>>]<++  Create 32 (' ') and 10 ('\n')
                         Tape: 32 10 0 n 43 t
 >>
 [ Loop over the first half of the diamond
   <<.>>         Print a newline
   -[-<+<<.>>>]  Decrement n and print n spaces
   <[->+<]       Restore n
   >>>+[-<.>>+<] Increment t and print t '+'s
   >+[-<+>]<<<   Increment t again and restore it
]>>
[ Loop over the second half
  <<<<.>>        Print a newline
  [-<+<<.>>>]<   Print n spaces
  [->+<]>+       Restore and increment n
  >>-[-<.>>+<]   Decrement t and print t '+'s
  >-[-<+>]<      Decrement t again and restore it
]

And just for fun:
+++++++++
        >
       --[
      >+<++
     ++++]<[
    ->+>.<<]+
   +++++++[-<+
  <++++>>]<++>>
 [<<.>>-[-<+<<.>
>>]<[->+<]>>>+[-<
.>>+<]>+[-<+>]<<<
 ]>>[<<<<.>>[-<+
  <<.>>>]<[->+<
   ]>+>>-[-<.>
    >+<]>-[-<
     +>]<]++
      +++++
       +++
        +

Try it online!

You got my vote for the just for the fun thing. Cool answer

Canvas, 9 bytes
+×Ｏ｛+×］±╪

Try it here!
Explanation (some characters have been replaced to look monospace):
+×O{+×]±╪
+×         repeat "+" input times
  O        output that
   {  ]    map over 1..input
    +×       repeat "+" that many times
       ±   interpret the array as a 2D string, and reverse it
        ╪  quad-palindromize with 1 horizontal overlap and 0 vertical overlap

Python 3, 95 94 75 bytes
def f(n):a=[' '*(n+~i)+'+'*(i-~i)for i in range(n)];return['+'*n]+a+a[::-1]

Try it online!

My first attempt at some golfing, any suggestions for improvement are welcome.
EDIT: saved 1 byte thanks to Kevin Cruijssen
EDIT: removed misunderstanding about byte count
EDIT: Saved many more bytes thanks to Jo King and user202729

Welcome to PPCG! :)

Also, if you change to Python 2, print'\n'.join(['+'*n]+a+a[::-1]) can be used without parenthesis to save 2 more bytes. +1 from me though. Nice first answer. :)

Wow, I didn't know that the ~ operator worked like that for integers. I'll stick to Python 3 for now, as I have very limited experience with Python 2, and someone else could probably come up with a better solution. Thanks for the help!

Your byte-count is wrong (was correct previously). If you define a function that returns the result, you can use the footer to call that function and display the result. You can't do part of the challenge in the footer and not count those bytes.

I reverted to the previous edit. I was just a bit confused as the other Python answer had a bit of logic in the footer, I'll try to read up on the rules.

@JoKing I saw that you used that approach in your answer, is there any consensus on what is allowed in the footer and what isn't?

Submissions can be either a full program (nothing in header/footer) or a function (which must defines a function (or reference, in case of anonymous function such as lambda)).

In this case it's allowed to return a list of lines.

And, 2*i+1 == i+i+1 == i-(-i-1) == i-~i.

Great first answer. well done.

05AB1E, 14 bytes
'+×sL·<'+×∊.c»

Try it online!
Explanation
'+×              # push "+" repeated <input> times
   sL            # push range [1 ... input]
     ·<          # multiply each element by 2 and decrement (x*2-1)
       '+×       # replace each number with the corresponding number of "+"'s
          ∊      # mirror vertically
           .c    # center
             »   # join with the "+"-row created at the start

Also 14 bytes: L‚˜'+×ćs.∞∊.c»

'+×s·ÅÉ'+×∊.C» using ÅÉ is another

@MagicOctopusUrn: My initial thought was using ÅÉ but I discarded it because I didn't think of using · to make it work.

sL can be ā for -1

Python 3, 79 78 bytes
def f(n):x=[('++'*i+'+').center(n*2)for i in range(n)];return[n*'+']+x+x[::-1]

Try it online!
Thanks to this Tips for golfing Python answer for informing me about the .center function. Returns a list of strings.

Isn't the footer included in the byte count? In that case, my solution is 58 bytes

@maxb If you're using a function, it is generally okay to return output as a list of lines

@JoKing : Hum might wanna do a lil recheck ? TRY

@JoKing : It fails.

@MuhammadSalman 1. You’re testing my function for n=3 against the return for n=5, 2. You have a trailing newline in the test, and 3. My code has trailing spaces on each line. Maybe you should just look at the output next time

@JoKing : 1). oops. My bad forgot to change it back to 5. 2). Hum , well I guess that works too. Cool

@JoKing : Apologies for inconvenience

You can do this in 75 bytes by calculating the number of spaces: def f(n):x=[' '*(n+~i)+'++'*i+'+'for i in range(n)];return[n*'+']+x+x[::-1]

Eh, it ends up being a copy of maxb's answer

R, 135 110 96 bytes
function(n){cat("+"<n,"
",sep="")
for(i in c(1:n,n:1))cat(" "<n-i,"+"<2*i-1,"
",sep="")}
"<"=rep

Try it online!
@JayCe with the final cut.
The rep function is assigned to an existing infix operator, such as < or ^ so that rep("+", n) is equivalent to "<"("+", n) which can be written out using < as an infix operator as in "+" < n and shortened to "+"<n.

Save 25 bytes and make it a function.

So totally your answer :) Great original code!

There's some whitespace here that can be removed, and using "+" directly instead of saving it as z saves some bytes! Try it here

@ngm @Giuseppe On top of Giuseppe's improvement, substitute < for rep to get under 100 chars! Here

Charcoal, 15 bytes
Ｇ→→↙Ｎ+↓‖Ｍ↑×⊕ⅈ+‖

Try it online! Link is to verbose version of code. Explanation:
Ｇ→→↙Ｎ+

Print an inverted triangle of +s the height of the input and almost twice the width.
↓

Move the cursor down so it lands on the additional line after the reflection.
‖Ｍ↑

Make a mirror image of the triangle.
×⊕ⅈ+

Draw the additional line using the current column to avoid having to read the input again.
‖

Reflect the output so that the additional line points to the left.

J, 29 22 bytes
-7 bytes thanks to Jonah!
' +'{~#&1,]>:[:+/~|@i:

Try it online!
Original solution:
J, 29 bytes
'+'(,]\(}:@|."1,.])@,]\.)@$~]

Try it online!
Explanation:
'+'$~] - generates the line at the start, which is a seed for the diamond:

   '+'$~]  3
+++

]\,]\. - finds the prefixes (]\) and suffixes (]\.) of the line, making "half" the diamond

   '+'(]\,]\.)@$~] 3
+
++
+++
+++
++
+

}:@|."1,.] - makes the other "half" of the diamond by reversing each line (|."1)
and dropping its last '+' (}:) and stitches the first half to it (,.])

 '+'(]\(}:@|."1,.])@,]\.)@$~] 3
  +
 +++
+++++
+++++
 +++
  +

, - prepends the initial line to the diamond

'+'(,]\(}:@|."1,.])@,]\.)@$~] 3
+++
  +
 +++
+++++
+++++
 +++
  +

25 - ' +'{~1"+@i.,]>:[:+/~|@i: - Try it online!

@Jonah Thanks! I have forgotten this one...

Just popped in my feed. Also, just realized we can go to 22: Try it online!

Python 3, 76 75 bytes
lambda n:['+'*n]+[' '*(n+~i)+'+'*(i-~i)for i in[*range(n),*range(n)[::-1]]]

Try it online!

Stax, 11 bytes
ñ1┌╙@↔g+┤a☻

Run and debug it

QB64, 82 79 bytes
INPUT n
?STRING$(n,43):FOR a=1TO 2*n:d=a-(a>n)*2*(n-a):?SPC(n-d);STRING$(2*d-1,43):NEXT

Welcome to PPCG! This is a great first submission, and I've added it to the list of solutions posted while QBasic is Language of the Month. If you like, you can improve this answer by adding a short explanation. Enjoy your time here!

Scala, 95 94 bytes
saved 1 byte(s) thanks to the comment.

Golfed version. Try it online!
def f(n:Int)={val a=(0 until n).map(i=>" "*(~i+n)+"+"*(2*i+1)).toSeq;Seq("+"*n)++a++a.reverse}

Ungolfed version.
object Main {
  def f(n: Int): Array[String] = {
    val a = (0 until n).map(i => " "*(n-1-i) + "+"*(2*i+1)).toArray
    Array("+"*n) ++ a ++ a.reverse
  }

  def main(args: Array[String]): Unit = {
    val result = f(10)
    println(result.mkString("\n"))
  }
}

n-1-i can be ~i+n for -1 byte.

JavaScript (Node.js), 106 105 bytes

thanks to @Kevin Cruijssen for reducing by 1 byte

n=>[...Array(n*2+1)].map((_,i)=>" ".repeat(i?i>n?i+~n:n-i:0)+"+".repeat(i?i>n?4*n-2*i+1:i*2-1:n)).join`
`

Try it online!
________________________________________________
Second approach
JavaScript (Node.js), 105 100 99 98 bytes

thanks to @Kevin Cruijssen for reducing by 1 byte
thanks to @ovs for reducing by 1 byte

n=>[X="+"[r="repeat"](n),...x=[...X].map((_,i)=>" "[r](n+~i)+"+"[r](i-~i)),...x.reverse()].join`
`

Try it online!

Just as a matter of convention, you should have your shortest submission at the top of your post if you have multiple approaches within it. This allows for other people to easily attempt the challenge,
search for their language, and see how they compare to your best answer (and is needed for scoreboards to work properly on challenges that have scoreboards)

Haskell, 85 82 bytes
Saved 3 bytes thanks to nimi!
n!c=[1..n]>>c
f n|x<-[(n-i)!" "++(i*2-1)!"+"|i<-[1..n]]=unlines$n!"+":x++reverse x

Try it online!

Using this tip you can get rid of the twice used variable x which saves 4 bytes: Try it online!

Japt -R, 18 17 bytes
õÈ+Y î+Ãû ê1 iUî+

Try it online!

PowerShell, 55 bytes
param($l)'+'*$l;1..$l+$l..1|%{" "*($l-$_)+'+'*($_*2-1)}

Try it online!

Great answer but the character should be + instead of x. Also you can make your response a bit more community friendly by using Try it online! and adding a link to your answer

Derp - can't believe I didn't see that. Thanks!

Python 3, 98 bytes
def d(s):print("+"*s);t=[("+"*i).center(2*s-1)for i in range(1,2*s,2)];print("\n".join(t+t[::-1]))

Try it online!
Readable version:
def diamond(size):
    print(size * "+")
    top = [("+" * i).center(2*size - 1) for i in range(1, 2*size, 2)]
    print("\n".join(top))
    print("\n".join(reversed(top)))

Much better :) I formatted your entry so that it looks like other answers. You want want to visit tio.run it formats your answer for you and makes it easy for others to reproduce your code.

05AB1E, 9 8 bytes
Dη€û.C∊»

Try it online! Takes input in unary with + as a tally mark; allowed as per OP's comment.
Dη€û.C∊»  # full program
       »  # join...
D         # implicit input...
       »  # and...
 η        # prefixes of...
D         # implicit input...
  €       # with each element...
   û      # concatenated with...
          # (implicit) current element in list...
   û      # reversed excluding the first character...
    .C    # with...
          # (implicit) each element...
    .C    # centered by spaces to length of longest element in this list (extra space on the left if unequal spaces)...
      ∊   # mirrored vertically...
       »  # by a newline
          # implicit output

8 bytes with vertical mirror ∊.

@ovs Thanks! Added

Ruby, 71 61 bytes
->n{[?+*n]+(a=(1..n).map{|x|?\s*(n-x)+?+*(x+x-1)})+a.reverse}

Try it online!

PHP, 103 bytes
for(;$i++<$argn;$s.="
".str_pad(str_pad("",$i*2-1,"+",2),$argn*2-1," ",2))echo"+";echo"$s
",strrev($s);

Run as pipe with `-nR´ or try it online.

PowerShell, 58 bytes
param($n)'+'*$n;1..$n+$n..1|%{" "*($n-$_)+"+"*$_+"+"*--$_}

Try it online!
Simply a loop-up and -down, each iterating outputting the appropriate number of spaces and then the appropriate number of plus signs. Ho-hum.

F# (Mono), 123 bytes
let d n=
 let t n=String('+',n)
 let s n=t(n*2-1)
 [1..n]@[n.. -1..1]|>Seq.fold(fun a x->a+sprintf"\n%*s"(n+x-1)(s x))(t n)

Try it online!

Welcome to PPCG.

This doesn't appear to work. Also, input should be taken from STDIN, a file, or a function argument. We don't allow pre-assigned variables as input.

@mbomb007 Can you approve it now?

@HenrikHansen : Why is this giving an error ? /home/runner/code.fs(2,10): error FS0039: The value or constructor 'String' is not defined. Cannot open assembly 'code.exe': No such file or directory.

@HenrikHansen : great the error is gone but now Main module of program is empty: nothing will happen when it is run . You should probably look into it as well

@MuhammadSalman You can include(open) certain standard libraries or provide the full namespace path. I anticipated that is was alright to anticipate that the System library is loaded.

@HenrikHansen : I don't know anything about F#. Except its name. Maybe this will help : https://codegolf.stackexchange.com/questions/16116/tips-for-golfing-in-f

@HenrikHansen The error is because of the first line. You should read input n from STDIN. What's the best way to read from stdin?. Either that, or the syntax for a multiline function is wrong. I don't know F#.

@HenrikHansen : I suggested an edit. Take a look

PHP 102 bytes
for($r=str_pad;$i++<$a;$s.="\n".$r($r("",$i*2-1,"+",2),$a*2-1," ",2))echo"+";echo"$s\n",strrev($s);

Ik know it can be much smaller than this ;) Greetz  mangas

Welcome to PPCG!

Your code seems to produce an error when I try to run it?

Why did you suggest this as a separate edit? It makes no sense.

@StephenLeppik : Oops , probably a mistake on my part. Soory

Yabasic, 102 bytes
An anonymous function that takes input as a unary number with + tally marks and outputs to the console.
Input""s$
n=Len(s$)
?s$
For i=-n To n
j=Abs(i)
If i For k=2To j?" ";Next:?Mid$(s$+s$,1,2*(n-j)+1)
Next

Try it online!
Alternate Version, 117 bytes
An anonymous function answer that takes input as a decimal integer and outputs to the console.
Input""n
For i=1To n s$=s$+"+"Next
?s$
For i=-n To n
j=Abs(i)
If i For k=2To j?" ";Next:?Mid$(s$+s$,1,2*(n-j)+1)
Next

Try it online!

Anonymous functions? They look like whole programs to me...

@ØrjanJohansen this term, for Yabasic, only means that they are not wrapped as a user defined subroutine, are not part of any library and thus cannot be called discretely like builtin functions can be (eg. Abs(x)) . You can read a bit more about this here if you like.

sed 4.2.2, 69
Score includes +1 for the -r option to sed.
h
y/1/+/
p
x
s/1\B/ /g
y/1/+/
p
:
s/ \+/+++/p
t
p
:a
s/\+\+/ /p
ta
d

Try it online!

Ruby, 59 bytes
->i{[?+*i,b=(1..i).map{|c|' '*(i-c)+?+*(2*c-1)},b.reverse]}

Try it online!

JavaScript (Node.js), 183 bytes
a=x=>{g='\n';r=(m,n)=>String.prototype.repeat.call(m,n);k='+';l=r(k,x)+g;c=d='';for(i=0;i++<x;c+=r(' ',x-i)+r(k,i)+r(k,i-1)+g,d+=r(' ',i-1)+r(k,x+1-i)+r(k,x-i)+g);console.log(l+c+d);}

Try it online!
Updated my answer thanks to @JoKing

@JoKing sorry, my mistake, I just update my answer, thank you my friend.

@JoKing, thank you for your time

APL (Dyalog Unicode), 25 bytesSBCS
⍪∘⊖⍨c,⍨⌽1↓[2]c←↑,\⎕←⎕/'+'

Try it online!
Explanation:
⍪∘⊖⍨c,⍨⌽1↓[2]c←↑,\⎕←⎕/'+'  ⍝ Full program
                       ⎕/'+'  ⍝ Get input from user as N, replicate '+' N times
                    ⎕←        ⍝ Print above string
                  ,\           ⍝ Find all prefixes of above string, e.g. '+','++','+++' etc.
                 ↑             ⍝ Mix the above into a matrix - right-pads with spaces as needed
               c←              ⍝ Assign above matrix to 'c' for 'corner'
          1↓[2]                ⍝ Drop the first column
        ⌽                     ⍝ Reverse the resulting matrix
     c,⍨                      ⍝ Append 'c' to above - this gives us the top half
⍪∘⊖⍨                         ⍝ Take the above, flip it about the horizontal axis,
                              ⍝ and append it to itself

1↓[2] -> 0 1↓ or even better: c,⍨⌽1↓[2]c← -> ⍉(⊖⍪1↓⊢)⍉

Canvas (v8), 8 5 bytes
［］↔╪∔

Try it here!
Takes input as unary using + as tally.
The other Canvas answer here uses v2.

Seems to be the exact same algorithm as my answer! D → ∔, η» → ［］, €û.C∊ → ↔╪.

@Makonede I grabbed the prefixes idea from your answer actually, but the rest I'll call convergent evolution ;)

Vyxal j, 6 bytes
¦ʁøĊmJ

Try it Online!
How?
¦ʁøĊmJ
¦      # Prefixes of implicit input
 ʁ     # Palindromize each
  øĊ   # Center
    m  # Mirror each
     J # Join the (implicit) input with this

Input must be an integer.

@Shaggy https://codegolf.stackexchange.com/questions/162798/diamond-creator#comment394399_162798 several other answers do this too

Japt -R, 18 16 15 bytes
õÈç+²Ãû ê ÕiUç+

Try it

Java 11, 159 155 154 153 bytes
n->{var r="";for(int i=n,j;i-->0;r+=i>0?"\n":"")for(j=-n;++j<n;)r+=(j<0?-j:j)<n-i?"+":" ";return"+".repeat(n)+"\n"+r+"\n"+new StringBuffer(r).reverse();}

-5 bytes thanks to @ceilingcat.
Explanation:
Try it online.
n->{                       // Method with integer parameter and String return-type
  var r="";                //  First-line String, starting empty
  for(int i=n,j;i-->0      //  Loop `i` in the range (n,0]
      ;                    //    After every iteration:
       r+=i>0?"\n":"")     //     Add a new-line, unless it's the last iteration of `i`
    for(j=-n;++j<n;)       //   Inner loop `j` in the range (-n,n]
      r+=                  //    Append the result with:
         (j<0?-j:j)        //     If the absolute value of `j`
         <n-i?             //     is smaller than the input `n` minus `i`:
              "+"          //      Append a "+"
             :             //     Else:
              " ";         //      Append a space " " instead
  return"+".repeat(n)+"\n" //  Return the input `n` amount of "+", plus a new-line,
        +r+"\n"            //  plus the result-String, plus another new-line,
        +new StringBuffer(r).reverse();}
                           //  plus the result-String again reversed

Attache, 62 bytes
{"+"*_+lf+UnGrid!Bounce=>"+ "[Table[`>,1:_]|>~`'#Reverse|>@N]}

Try it online!
A lambda which takes the integer as an argument.
Example
A> n := 3
3
A> Table[`>,1:n]
 false false false
  true false false
  true  true false
A> Table[`>,1:n]|>~`'#Reverse
  true  true false
  true false false
 false false false
 false false false
  true false false
  true  true false
A> Table[`>,1:n]|>~`'#Reverse|>@N
 1 1 0
 1 0 0
 0 0 0
 0 0 0
 1 0 0
 1 1 0
A> "+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
 " " " " "+"
 " " "+" "+"
 "+" "+" "+"
 "+" "+" "+"
 " " "+" "+"
 " " " " "+"
A> Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
 " " " " "+" " " " "
 " " "+" "+" "+" " "
 "+" "+" "+" "+" "+"
 "+" "+" "+" "+" "+"
 " " "+" "+" "+" " "
 " " " " "+" " " " "
A> UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> lf+UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> "+"*n+lf+UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"+++\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> Print[_]
+++
  +
 +++
+++++
+++++
 +++
  +
["+++\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "]
A>

T-SQL, 152 bytes
Per our IO rules, input is taken via pre-existing table t with a integer field n.
DECLARE @n INT,@ INT=1,@k INT=1SELECT @n=n FROM t
PRINT REPLICATE('+',@n)a:PRINT SPACE(@n-@)+REPLICATE('+',2*@-1)IF @=@n SET @k-=1SET @+=@k IF @>0GOTO a

Manual counting loop, not very "SQL-like". Formatted:
DECLARE @n INT,@ INT=1,@k INT=1
SELECT @n=n FROM t
PRINT REPLICATE('+',@n)
a:
    PRINT SPACE(@n-@)+REPLICATE('+',2*@-1)
    IF @=@n SET @k-=1
    SET @+=@k
IF @>0 GOTO a

V, 20 bytes
é+ÄÀñ>GMÙX2é+ÄHñÄÒ+

Try it online!
Hexdump:
00000000: e92b c4c0 adf1 3e47 4dd9 5832 e92b c448  .+....>GM.X2.+.H
00000010: f1c4 d22b                                ...+

Explanation:
é+                      " Insert a '+' character
  Ä                     " Duplicate this line
   À                   " 'arg' - 1 times...
     ñ          ñ       " Repeat the following code:
      >G                "   Indent every line
        M               "   Move to the center line
         Ù              "   Duplicate this line
          X             "   Delete the first character of it (the space)
           2é+          "   Insert two '+' characters
              Ä         "   Duplicate this new line we made
               H        "   Return to the first line
                 Ä      " After the loop is over, duplicate the top line
                  Ò+    " Replace every character on this line with a '+'

Excel VBA, 89 bytes

Anonymous VBE immediate window function that takes input as a unary number with + tally marks from range [A1] (ie [A1]="++++") that outputs to the VBE immediate window.
?[A1]:n=[Len(A1)]:For i=-n To n:i=i-(i=0):j=Abs(i):?Spc(j-1)Mid([A1&A1],1,2*(n-j)+1):Next

Alternate Version, 96 bytes
Anonymous VBE immediate window function that takes input as a decimal number from range [A1] that outputs to the VBE immediate window.
?[Rept("+",A1)]:For i=[-A1]To[A1]:i=i-(i=0):[B1]=Abs(i):?Spc([B1]-1)[Rept("+",2*(A1-B1)+1)]:Next

Phooey, 82 bytes
&.@@($c43-1)&>&1<[-1$c10@[-1$c32]&>@[-1$c43]&+2<][!$c10@[-1$c32]&+1>-2@[-1$c43]&<]

Try it online!
Phooey is an extended form of Foo, adding input, sane loops, and some helper functions.

Swift, 218 169 bytes
Sadly, I could not use map instead of for loops, since it timed out.
func r(i:Int)->String{var l="";for j in(0...i*2){for k in(0..<i*2-1){l+=j==0&&k<i||j>0&&(j>i ?j-i-1:i-j)...(j>i ?i*3-1-j:i+j-2)~=k ?"+":" "};if j<i*2{l+="\n"}};return l}

Prettyfied:
func r(i: Int) -> String {
    var l = "";

    for j in (0 ... i * 2) {
        for k in (0 ..< i * 2 - 1) {
            l += (j == 0 && k < i) ||
            (j > 0 && (j > i ? j - i - 1 : i - j) ... (j > i ? i * 3 - 1 - j : i + j - 2) ~= k) ? "+" : " "
        }

        if j < i * 2 {
            l += "\n"
        }
    }

    return l
}

Try it online!

Retina, 35 bytes
¶<,-2`\+

\+` (\++)$
$&$%"$1++
^O`

Takes unary + as input
Try it online!

Jelly, 18 17 14 13 bytes
”+ẋṄ¹Ƥz⁶ŒBṚ;$

Try it online!
-1 byte thanks to Erik the Outgolfer
”+ẋṄ¹Ƥz⁶ŒBṚ;$
”+                  '+' literal
  ẋ                 repeat this <input> number of times: '+++'
   Ṅ                print this string + a new line
    ¹Ƥ              get the prefixes: ['+', '++', '+++']
      z             transpose and fill with...
       ⁶            space (' '). yields ['+++', ' ++', '  +']
        ŒB         palindromize each row: ['+++++', ' +++ ', '  +  ']
          Ṛ;$      reverse and append with itself.

”  -> ⁶

@EriktheOutgolfer of course, thanks

CJam, 34 bytes
q~:X,'+X*n{_X-~' *\2*)'+*+}%_W%+:n

Try it online!
Still wrapping my head around CJam, could probably be improved.

R, 141 139 137 135 126 bytes
Another approach borrowing from the other R answer to this challenge by ngm as well as this other answer from Kirill L.:
function(n)cat(c(g(n),format(sapply(c(1:n,n:1),function(i)g(2*i-1)),j="c",w=2*n-1)),sep="
")
g=function(x)intToUtf8(rep(43,x))

Try it online!
Below a fully recursive solution growing the initial line and the diamond at each step:
function(n)cat("
",intToUtf8(rbind(t(f(n)[c(1:n,n:1),-1]),13)),sep="")
f=function(n)"if"(n,{cat("+");rbind(cbind(32,f(n-1),32),43)},43)

Try it online!

C (gcc), 111 bytes
Rather than having two loops (one for [0..i-1] and [i-i..0]), I loop for 2*i iterations and compute the offsets from 0 for the first half and from 2*i for the last half. printf() takes care of the spacing!
f(i,j,k){char s[9999];for(memset(s,43,j=2*i+1),k=-1;printf("%*.*s\n",i+k,~k?2*k+1:i,s),--j;)k=(j>i)?2*i-j:j-1;}

Try it online!

Suggest x-~x instead of 2*x+1 and j>i instead of (j>i)

MY-BASIC, 126 bytes
An anonymous function that takes input as a unary number with + tallys
Input"",s$
n=Len(s$)
Print s$;
For i=-n To n
j=Abs(i)
If i Then
For k=2 To j
Print" "
Next
Print Mid(s$+s$,1,2*(n-j)+1);
Next

Try it online!

uBASIC, 114 bytes
0input"",s$:n=len(s$):?s$:fork=2ton:t$=t$+" ":nextk:fork=0-nton:f=abs(k):iffthen?mid$(t$+s$+s$,n-f+1,2*n-f)
1nextk

Try it online!

Oracle SQL, 166 bytes
select decode(x,1,lpad('x',n,'x'),lpad(' ',n-y,' ')||lpad('x',2*y-1,'x'))from(select level x,abs(trunc((level-2)/n)*(2*n+1)+1-level)y,n from t connect by level<2*n+2)

Test in SQL*PLus (This table is used as an input create table t(n) as select 5 from dual)
SQL> set pages 0 lines 2000 feedback off
SQL> select decode(x,1,lpad('x',n,'x'),lpad(' ',n-y,' ')||lpad('x',2*y-1,'x'))
  2  from(select level x,abs(trunc((level-2)/n)*(2*n+1)+1-level)y,n from t connect by level<2*n+2)
  3  /
xxxxx
    x
   xxx
  xxxxx
 xxxxxxx
xxxxxxxxx
xxxxxxxxx
 xxxxxxx
  xxxxx
   xxx
    x

C# (Visual C# Interactive Compiler), 105 bytes
n=>new int[2*n+1].Select((_,i)=>new String('+',i<1?n:i>n?4*n-2*i+1:2*i-1).PadLeft(i<1?0:i>n?3*n-i:n+i-1))

Try it online!
The idea is to create an enumerator with length equal to the number of returned lines. Iterate over the enumerator and return strings of + characters with varying padding dependent upon the current index in the enumeration.
// n is the diamond size
n=>
  // create an array to iterate over
  new int[2*n+1]
  // this version of select includes an index
  .Select((_,i)=>
    // create the diamond body
    new String('+',i<1?n:i>n?4*n-2*i+1:2*i-1)
    // pad according
    .PadLeft(i<1?0:i>n?3*n-i:n+i-1))

Wolfram Language (Mathematica), 97 bytes
d[n_]:=Column[Row/@(Drop[Prepend[DiamondMatrix[n][[All,2;;]],Table[1,n]],{n+2}]/.{1->"+",0->""})]

Try it online!

Zephyr, 241 bytes
input n as Integer
set s to""
for i from 1to n
set s to"+"+s
next
print s
for i from 1to n*2
set s to""
if i>n
set r to(i-n)-1
else
set r to n-i
end if
for j from 2to(n-r)*2
set s to"+"+s
next
for j from 1to r
set s to" "+s
next
print s
next

Try it online!
Not having a string multiplication operator really hurts here.
Ungolfed/commented
# Input number
input n as Integer

# Build string of that many plusses in s
set s to ""
for i from 1 to n
  set s to s + "+"
next
# Output it
print s

# Output diamond
for i from 1 to n * 2
  # Build string for each line in s
  set s to ""
  # Set r to the number of spaces on the current line: n-1, ... , 1, 0, 0, 1, ... , n-1
  if i > n
    set r to (i - n) - 1
  else
    set r to n - i
  end if
  # Add that many spaces to s
  for j from 1 to r
    set s to s + " "
  next
  # Add (n - r) * 2 - 1 plusses to s
  for j from 2 to (n - r) * 2
    set s to s + "+"
  next
  # Output it
  print s
next

Regenerate, 70 bytes
(\+{$~1})(
( {#3-1}! {#1-1})(\+\+$4!\+)){#1}(
( $6!)(\+{#7-2}!$4)){#1}

Attempt This Online!
Explanation
For clarity, space is replaced with _ and newline is replaced with ¶ in the explanation.
(\+{$~1})

Group 1: Repeat + a number of times equal to the input.
(¶...){#1}

Group 2 generates the top half of the diamond. Repeat it (length of group 1) times. It contains groups 3 and 4.
(_{#3-1}!_{#1-1})

Group 3: Add spaces, one less than the last time we matched group 3; or, if group 3 hasn't been matched yet, one less than the length of group 1.
(\+\+$4!\+)

Group 4: Add plusses, two more than the last time we matched group 4; or, if group 4 hasn't been matched yet, a single plus.
(¶...){#1}

Group 5 generates the bottom half of the diamond. Repeat it (length of group 1) times. It contains groups 6 and 7.
(_$6!)

Group 6: Add spaces, one more than the last time we matched group 6; or, if group 6 hasn't been matched yet, none.
(\+{#7-2}!$4)

Group 7: Add plusses, two less than the last time we matched group 7; or, if group 7 hasn't been matched yet, copy the last match of group 4.

source: Stack Exchange

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

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

sort: votes


text:
Will you be my Weaver?
I've been recently playing through 'The Weaver' and I think it presents an interesting challenge for code-golf.
Premise:
The Weaver is a game wherein you are given a number of ribbons coming from 2 directions 90 degrees apart and your goal is to swap them at certain intersections to achieve a desired output.
   Like this:         This is a swap:         This isn't:

Input:
3 arrays:

Top ribbons (left to right)
Left ribbons (top to bottom)
The coordinates of the intersections to swap

Output:
2 arrays:

Bottom ribbons (left to right)
Right ribbons (top to bottom)

Examples:
I'll use the above image as the first example:
Input: [r, y, b], [r, y, b], [(0, 1), (2, 1), (2, 2)]
What happens:
   r   y   b
   r   y   b
r r r r•y y y y
   r   r   b
y y y y y y y y
   r   r   b
b b b b•r r•b b
   r   b   r
   r   b   r

Where • represents a swap.
Output: [r, b, r], [y, y, b]

Input: [a, b, c], [d, e, f], [(0, 0), (2, 1)]
What happens:
   a   b   c
   a   b   c
d d•a a a a a a
   d   b   c
e e e e e e e e
   d   b   c
f f f f•b b b b
   d   f   c
   d   f   c

Output: [d, f, c], [a, e, b]

Input: [a, b], [a, b, c], [(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1)]
What happens:
   a   b
   a   b
a a a a•b b
   a   a
b b•a a•a a
   b   a
c c•b b•a a
   c   b
   c   b

Output: [c, b], [b, a, a]
Notes:

The examples show coordinates given as (row, column) though you may take them as (column, row).
The top row and left column may have ribbons of the same color
The board can be rectangular
All coordinates will be non-negative (>=0) (or strictly positive (>=1) if you choose 1-indexing)
Ignore any swaps that are outside the board
You may choose to work with letters ([a-zA-Z]), integers ([0-9]) or both
The ribbons in your output must match the ribbons in the input exactly (a -> a)
You may assume the list of swaps is sorted in any way you want, as long as it's consistent (if you do, please specify how it should be sorted)
You may take the swap coordinates as 0 or 1-indexed
Default loopholes are forbidden

More examples:
Input:
[b], [r], []
Output:
[b], [r]

Input:
[b], [r], [(0, 0)]
Output:
[r], [b]

Input:
[r, p, y], [r, y, p], [(0, 0), (1, 2), (2, 1), (3, 2)]
Output:
[r, p, y], [r, y, p]

Input:
[b, y, o, r],
[r, o, b, y],
[(0, 0), (2, 0), (3, 2)]
Output:
[b, y, y, r],
[b, o, r, o]

The last example relates to this case (if that makes it easier to visualize):

This is code-golf so the shortest answer in bytes for each language wins.

Re "Ignore any swaps that are outside the board" - does that mean we cannot assume that all swap coordinates are on the board, and we need to filter them for validity (ignore the invalid ones), or does that mean that we can ignore the case of coordinates being outside of the board because the input will always be valid?

@Bergi it means that the input may include swaps outside the board and you have to filter or ignore them. (The 3rd example includes such a swap)

Oh. I think the challenge would have been more interesting if the swaps would only have had valid coordinates, but that we could not assume they were sorted in an order that fits our solution.

@Bergi maybe, but if that was the challenge, most answers would simply sort the list (which is a boilerplate action just like filtering invalid coordinates). Personally, I think that filtering (or ignoring) invalid coordinates can be done more cleverly than sorting.

Yeah, they're both boilerplate, so I would have expected both or neither. Depending on the language, sorting takes some cleverness or many bytes as well - and I would have loved to see clever algorithms that don't require a particular order :-)

Regarding invalid coordinates, can they be negative (or 0 in 1-indexed solutions)?

@Bergi You're probably right, well, it's too late to change now. And no, all coordinates will be positive, I'll update the question.

"positive" is the same as ">0". Maybe you meant this?

@user202729 No, I mean positive (>=0) if you take. 0-indexed coordinates and (>0) otherwise. Or in other words, no coordinate will be above or left of the board.

No, >=0 is non-negative. According to this.

Missing comma in first example input

@AsoneTuhid If coords are (row,col), it makes more sense to i/o the left ribbons first and the top ribbons second. Is that allowed?

@ngn I'm leaning towards no. Would it significantly simplify your solution?

@AsoneTuhid It would save some precious bytes.

@ngn Alright, it was probably an unnecessary restriction anyway.

@AsoneTuhid Thank you! I think it makes more sense this way - axes come in a consistent order.

Python 3, 74 bytes
def g(a,b,l):
 for x,y in l:
  if x<len(a)and y<len(b):a[x],b[y]=b[y],a[x]

Try it online!
Requires l to be sorted in lexicographical order. a and b are lists of characters representing (left ribbon, top ribbon).
Returns by modifying the list a and b.

Jelly, 37 35 30 bytes
ṙ"z0U1¦Zḟ€0ṙ"N}
<Ạ¥ÐfL€}⁹ṭṚç/Y

Try it online!
Dyadic program, take 0-indexing list of swap indices as left argument (sorted in reverse lexicographical order) and (left ribbon, top ribbon) as right argument. Returns (right ribbon, bottom ribbon).

Jelly is a tacit language. There is (almost) no variable to work with, so doing anything involves more than two variables at once is a mess.
The first link takes [l,t] as its left argument, [x,y] (0-indexing) as its right argument, and return [l,t] with l[x] and r[y] exchanged.

ṙ"z0U1¦Zḟ€0ṙ"N}
ṙ"               Zipwith rotate. Current value: `[l ṙ x, t ṙ y]`
                   (so l[x] and r[x] becomes l[0] and r[0] respectively)
  z0             Zip, fill with 0. Elements at corresponding (new) indices are
                   paired together, with 0 as the filler.
    U1¦          Reverse the pair at index `1` (first index).
       Zḟ€0      Zip again and filter out the `0`s, effectively undo the z0.
           ṙ"N}  Zipwith rotate by negative shift amount, reverse of `ṙ"`.

So basically "U1¦ under ṙ"z0".

The second link simply filter out OoB indices (<Ạ¥Ðf L€), append the second argument (⁹ṭ), reverse (Ṛ), and reduce over ç (similar to Haskell's foldl)

Python 2, 193 bytes
def f(t,l,s):
 m=[[x,y]for y in[0]+l for x in[0]+t];L=len(t)+1
 for i in range(len(m)):
  if i%L:m[i]=[m[i-L][0],m[i-1][1]][::[1,-1][(i/L,i%L)in s]]
 s=sum(m,[]);print s[2-L*2::2],s[4*L-1::2*L]

Try it online!
Takes 1-indexed swap coordinates

APL (Dyalog Classic), 31 30 bytes
{⊃{⌽@(0 1,¨⍺)⊢⍵}/(⍵∩,⍳≢¨⍺),⊂⍺}

Try it online!
The left argument is a pair of character vectors - left ribbons and top ribbons. The right argument is a vector of coordinate pairs - swap locations. Returns a pair of right ribbons and bottom ribbons. (Note that unlike in the examples, I use the order left-top and right-bottom for the ribbons in order to be consistent with the row-col axis order in the coordinates.)
Swaps must be sorted so that a swap to the upper-left of another comes before after it. If two swaps are to the lower-left/upper-right of each other, their order doesn't matter.
EDIT: saved one byte (⌽) by requiring reverse order of swaps in the input

Javascript, 87 76 62 bytes
(c,r,s)=>{for([i,j]of s)if(r[i]&&c[j])[r[i],c[j]]=[c[j],r[i]]}

Try it online!
Same trivial algorithm as the Python 3 answer. Uses arrays as coordinate tuples. Requires ribbon colors to be designated by truthy values. Requires coordinates to be partially ordered so that x1,y1 comes before x2,y2 if either x1 < x2 && y1 = y2 or x1 = x2 && y1 < y2. Returns by modifying input arrays.

I'm pretty sure you can delete ;return[r,c] and call it a return by modification

if(r[i]&&c[j]) would save some more bytes.

I know that my condition is too strong, but your condition is self-contradictory. Consider x1=1,x2=2,y1=2,y2=1. Because x1<x2, (x1,y1) comes before (x2,y2); but because y2<y1, (x2,y2) comes before (x1,y1). I think "x1 < x2 and y1 < y2" suffices.

@AsoneTuhid Hm, I think that's cheating. Modifying the input objects is not the same as output by reference parameters.

@Neil Oh, I was thinking the colors could be integers including 0. That's not necessary of course. Thanks!

@user202729 Oops, messed that up, I need an and indeed. (1,2) and (2,1) are not supposed to be related, they could be in either order.

I think those <=s only need to be =s in that ordering condition.

Q: "Does this mean that in languages that allow it, the seven characters for return can simply be replaced with an assignment?" A: "Yes, provided the changed value will then be accessible in the context that called the function.". Seems pretty clear to me.

@Neil Yeah, that works as well (and conveys the idea better), the partial ordering is transitive anyway

@AsoneTuhid JS is not a pass-by-reference language, and there would be no reference assignment instead of the return - there simply would be nothing.

I think this counts as passing by reference and the assignment doesn't need to "replace" the return keyword. What's important is that the result(s) of executing the function can be accessed in the scope from which it was called. By the way, I think you can omit f= as the function doesn't need to refer to itself.

Your answer doesn't seem to work, please include a tio link

@AsoneTuhid Fixed. I had confused myself whether r would mean "the colors in the top row" or "the start colors of the rows" :-/

Ruby, 56 54 bytes
->t,l,s{s.map{|i,j|a=t[j];t[j]&&=l[i]||a;a&&l[i]&&=a}}

Try it online!
A port of user202729's Python 3 answer with some ruby tricks
Coordinates have to be lexicographically sorted

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


text:
Digging quarry timelapse
Do you love watching cool timelapses of constructions or other massive work done in minutes? Lets make one here.
We will be looking at an excavator digging quarry, making pictures each day to see whole progress. And your task is to show us this process!
Quarry is defined by the width of its first layer.
Excavator is defined by its capability to dig in one day.
Input
Width of quarry. Integer number, always >= 1.
Excavator dig speed. Integer number, always >= 1.
Output
Progress of digging quarry on each day.
Started with flat untouched ground and finished with completed quarry.
Rules

On the last day there may be less units to dig, than excavator is
capable of. Excessive work won't be used anywhere, so you should just
output fully dug quarry.
All days progress must be present in the output at once. You can't clear or overwrite previous day progress in the output.
Trailing and leading newlines for each day output are acceptable in any reasonable number.
This is code-golf, so make your code as compact as possible.

Clarifications
Work starts with a flat ground. Length of displayed ground is width of quarry + 2. So there always will be one underscore character on both sides of quarry.
__________

Dug quarry is looking like this for even width:
_        _
 \      /
  \    /
   \  /
    \/

And like this for odd width
_       _
 \     /
  \   /
   \ /
    V

Here are examples of quarry progress:
_ _______
 V          dug 1 unit

_  ______
 \/         dug 2 units

_     ___
 \___/      dug 5 units

_       _
 \   __/    dug 10 units
  \_/

Full progress example. Quarry width: 8. Excavator speed: 4 units per day.
__________

_    _____
 \__/

_        _
 \______/

_        _
 \    __/
  \__/

_        _
 \      /
  \  __/
   \/

_        _
 \      /
  \    /
   \  /
    \/

Cornercases
Excavator will need to dig on the last day exactly its capability (speed)
Width: 7, Speed: 3
Width: 10, Speed: 4

Stax, 65 bytes
Θ└R4∞√4Fµ■zJ┐╚▌▼ZJ╧fφ½à╘▲☼å♥s≥┤ÖòOúU╬ΩmPê|ë↕ƒ].Y┴↓á÷>}St☺┐B╒╞O☼╧O

Run and debug it
If first calculates the digging characters, in one flat string.  Then it adds depth.  For instance "_V___" is one day of digging, and "_\V/_" is the completed flat string.
It uses this method for doing one unit of digging.

Start with a single "\", plus the appropriate number of "_" characters.
If "V_" is in the string, replace it with "/".
Otherwise, if "/_" is in the string, replace it with "_/".
Otherwise, if "\_" is in the string, replace it with "\V".
The new string is the result from one unit of digging.  Repeat from step 2.

Here's the whole program unpacked, ungolfed, and commented.
'_*'\s+                 initial string e.g. "\_______"
{                       generator block to get each day's flat digging results
  {                     block to repeat digging within each day
    "V_\//__/\_\V"4/    replacement strings
    {[2:/|em|!H         find the first substring that exists and do replacement
  };*                   repeat digging within day specified number of times
gu                      get all unique results
                            when digging is complete, the result duplicates
{Dm                     drop the leading "\" characters from each result
F                       for each day's flat result, execute the rest of the program
  '_|S                  surround with "_"
  M                     split into chars; e.g. ["_", "\", "/", "_"]
  c|[                   copy and get all prefixes
  {                     mapping block to get "depth" of each character
    '\#                 get number of backslashes in this prefix (A)
    _1T'/#-             get number of forward slashes prior to last character of prefix (B)
    'V_H=+^             is the current character "V"? 1 for yes. (C)
  m                     map prefixes to A - B + C + 1
  \                     zip depths with original characters
  {E)m                  prefix each character with spaces; e.g. ["_", " \", " /", "_"]
  M                     transpose grid; e.g. ["_  _", " \/ "]
  m                     print each row

Run and debug it

Good job! Awaiting explanation :D

@DeadPossum: You only had to wait a week!

Retina 0.8.2, 163 156 bytes
.+
$*_
(_+)¶(_+)
$2¶$1¶$1
r`__\G
$%`$&
¶
;
(?<=(_+);.*)(?<=;_+;\1*)_
¶$`_
m`^_+;
__
+`(>*)_(_+)(_+<?;)\2
$1_$.2$* $3¶$1>$2<;
T`>\_` \\`>+_
T`\\\_;<`V/_`.<|;

Try it online! Explanation:
.+
$*_

Convert the inputs to unary. This gives us W¶S.
(_+)¶(_+)
$2¶$1¶$1

Swap the inputs and duplicate the width. This gives us S¶W¶W.
r`__\G
$%`$&

Calculate the volume of the quarry. This gives us S¶W¶V.
¶
;

Join the inputs into one line. This gives us S;W;V.
(?<=(_+);.*)(?<=;_+;\1*)_
¶$`_

Calculate the amount of progress for each day on its own line. Each day has the format S;W;D, where D is 0 on the first line and increments by S each day until it reaches V.
m`^_+;
__

Delete S and increase W by 2 on each line. This gives us G;D for each day.
+`(>*)_(_+)(_+<?;)\2
$1_$.2$* $3¶$1>$2<;

While D is nonzero, dig either D or G-2 from the line (so the first and last characters are always left), moving the depth to the next line. Each line is indented with one more > than the previous. Newly dug lines also include a <.
T`>\_` \\`>+_

Turn the indent into spaces and the following _ into a \.
T`\\\_;<`V/_`.<|;

If a < is following a \ then turn it into a V, if it's following a _ then turn it into a /. Delete all the <s and ;s.

Retina amazes me for some reason ._. Good job!

Python 2, 265 bytes
w,s=input();R=range((3+w)/2)
d=0
while d-s<sum(range(w%2,w+1,2)):
 q=[[' _'[i<1]]*(w+2)for i in R];D=d
 for i in R[:-1]:
  a=min(D,w-i*2);D-=a
  if a:q[i][1+i:1+i+a]=[' ']*a;q[i+1][1+i:1+i+a]=(['\\']+['_']*(a-2)+['/'])*(a>1)or['v']
 for l in q:print''.join(l)
 d+=s

Try it online!

2x 1+i+a to i-~a.

sum(range(0,w+1,2)) can be w/2*(w/2+1)

@ovs t can possibly also be inlined, resulting in 257 bytes.

@DeadPossum Fixed

@TFeld Good job!

golf in progress

JavaScript (Node.js), 329 315 307 300 301 298 285 275 260 254 bytes

fixed solution duo to error on odd w(thanks to @Shaggy) + reduce by 2 bytes
thanks to @Herman Lauenstein for reducing by 1 byte

(w,s)=>{h=[...Array(-~w/2+1|0)].map((x,i)=>[...(i?" ":"_").repeat(w)])
for(t=S="";t<s&&h.map((x,i)=>S+=(p=i?" ":"_")+x.join``+p+`
`);)for(y in t=s,h)for(x in D=h[y])if(D[x]=="_"&&t){(d=h[-~y])[x]=x^y?(d[x-1]=x^-~y?"_":"\\","/"):"v"
D[x]=" "
t--}return S}

Try it online!
Explanation
(w,s)=>{
h=[...Array(-~w/2+1|0)]                       //the height of the quarry when finished is w/2+1 if even or (w+1)/2+1 if odd
.map((x,i)=>
    [...(i?" ":"_").repeat(w)]                //the first row is the _ w times (i will explain why w and not w+2 in the following lines) afterwards lets just fill with spaces so the output would be clear(when convertion to string)
    )
for(t=S="";                                   //t="" is like t=0(we actually need t to be different from s in the start and s>=1), S will hold the final output
t^s&&                                         //if t not equals s -> it means that now changes were made to the quarry->it means we finished digging
h.map((x,i)=>
S+=(p=i?" ":"_")+x.join``+p+`                 //here comes the reason for w and not w+2. because the border _XXXX_ are not to be touched i only add them to the output and not woking with them in the solution
                                              //that ways its much easier to replace the correct chars. so here i just add _ to either sides if its the first row otherwise space(to pad correctly).
                                              //in the end i add a new line to differ from the previous day
`);)
    for(y in t=s,h)                           //always update t back to s so we know weve passed a day
        for(x in D=h[y])
            if(D[x]=="_"&&t)                  //if the current cell is _ we need to work, but only if the day have yet to pass(t)
            {
                (d=h[-~y])[x]=                //updating the row below us because we just dug a hole
                x^y?                          //if x == y that means we are digging the first hole in the row below
                (d[x-1]=x^-~y?"_":"\\", //we want to update the row below and cell before([y+1][x-1]) only if its not the first cell(AKA not space). if v we need \ other wise _
                    "/")                          //other wise (x!=y) we put "/"
                :"v"                          //so we should put v (if they are equal)
                D[x]=" "                      //always remove the _ from the current one because we dug it
                t--}                          //decrement the counter for the day by one digging
return S}

Doesn't work if w is odd.

@Shaggy fixed :)

@HermanLauenstein could you be more specific?

You don't need to count the variable assignment (f=) and you can save another byte by currying the parameters (w=>s=>).

@DeadPossum its seems to work for 7,3 are you sure? could you put the expected output?

@DeadPossum fixed it (i think)

Now its working, good job!

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


text:
string char rotation
Challenge :
Given a string rotate every char by its index. e.g --> 'Hello' should be 'Hfnos'.

Input :
Input is given as string s length of string is  2 < s ≤ 100. Input will either be alphabet , number or one of the following whitespace , ! , @ , # , $ , % , ^ , & , * , ( , )

Output :
Output will be a string with all characters rotated by their index. Example given above.

Examples :
Input                     Output

Hello World!              Hfnos%]vzun,
Who                       Wiq
PPCG                      PQEJ

Note :
This is code-golf so shortest code in bytes in each language wins.

what happens when a character goes over ~? e.g. what's the output for ~~ (or is that not a valid input?)

@dzaima : That is not a valid input.

How about {|}? Is it invalid too? Please be more specific. Also, if the resulting code poing cannot go beyond 126, it's a shift rather than rotation, isn't it?

But if the length of s can be 3000 ...

@Shaggy Good point. The challenge it not only unclear but apparently contradictory

No need to check for edge cases What does that mean exactly?

@LuisMendo : Updated , thanks

@Shaggy : updated

Do we rotate over ASCII values 32-126, or between the allowed input characters?

Perhaps consider taking some more time to refine your answers and avoid confusion. The Sandbox can help you with that.

By the way, when you say 'alphabet' I think you mean 'letter'

@AsoneTuhid : thanks. this is one of many things i need to fix

@AsoneTuhid Stating to use the Sandbox is useless against him.. I think he's allergic to it or something.. In every single one of his challenges (except his Diamond challenge) it was suggested to use the Sandbox (see these screenshots as prove of those comments). And he only used it once thus far for about 5 hours (the yellow circled one). Muhammad, I know it can be annoying to wait 72+ hours when you have a good idea for a challenge, but you're kinda starting to piss me (and others) off by not using the Sandbox when everyone suggests it every time again..

@KevinCruijssen : I apologize I will use the sand box next time.

Hmm, my comment sounds more hostile than I meant it to be now that I read it back again.. Sorry about that. Just wanted to let you understand the Sandbox is there for a reason, and actually helps a lot to have questions answered there instead of here. I actually liked some of the challenges you've posted thus far, but when you posted them it was initially lacking some key parts that caused confusion. In the Sandbox those lacking parts can be fixed, and then here it will get more upvotes. You'll probably still get questions, but a lot less when most is already covered after the Sandbox. :)

@KevinCruijssen : I will remember to post in the sand box.

Haskell, 37 36 28 bytes
zipWith($)(iterate(succ.)id)

Try it online!
How it works
iterate(succ.)id     -- starting with the identity function 'id' this
                     -- creates an infinite list of function where the next
                     -- element has one more 'succ' (the successor function)
                     -- composed to it than the current element:
                     -- -> [id, succ.id, succ.succ.id, succ.succ.succ.id, ...]
zipWith ($) (   )    -- combine the above list and the input string
                     -- elementwise with the function application operator '$'.
                     -- 1st char c0:            id $ c0 =            c0
                     -- 2nd char c1:       succ.id $ c1 =       succ c1
                     -- 3rd char c2:  succ.succ.id $ c2 = succ (succ c2)
                     -- etc.

Edit: -8 bytes thanks to @Angs

zipWith($)(iterate(succ.)id) saves some bytes

Also 28 bytes: zipWith(\n c->[c..]!!n)[0..]

Python 2, 47 bytes
lambda I:[chr(ord(c)+i)for i,c in enumerate(I)]

Try it online!

Japt, 2 bytes
c+

Try it out here

JS, 31 bytes - will post when/if challenge is reopened.

This isn't rotation.

@PeterTaylor, what do you mean? It does exactly what the challenge asks.

The challenge says "rotate every char by its index". Rotation implies wrapping around. It's not clear exactly what permutation should be applied, so the question isn't really answerable at all at the moment, but this definitely isn't it.

@PeterTaylor, nowhere in the spec does it mention wrapping around, nor is it covered in the test cases.