Альтернестінг - це акт взяття струни і вкладення її в чергуються дужки. Ось як ви alternest рядок.

• Для рядка довжиною N візьміть центральні символи N і оточіть їх у дужках. Отже, якщо наш рядок був Hello world!(12 символів), ми закінчимо

  (Hello world!)
  

• Потім візьміть інші центральні n-2символи та оточіть їх у квадратні дужки. У цьому випадку в центрі 10 символів ello world, тож наступною ітерацією є:

  (H[ello world]!)
  

• Поки в середині рядка залишилося більше двох символів, повторіть два останні кроки, чергуючи між ()і []. Ось останні кроки:

  (Hello world!)
  (H[ello world]!)
  (H[e(llo worl)d]!)
  (H[e(l[l(o[ w]o)r]l)d]!)
  

  Оскільки в останній ітерації посередині залишилося лише два символи, ми зупиняємось. Наш заключний рядок - це

  (H[e(l[l(o[ w]o)r]l)d]!)
  

  Зверніть увагу, як у середніх дужках є два символи. Це відбувається, коли вхід рівної довжини. Якби вхід був непарної довжини (наприклад, Hello, world!із додаванням кома), у нас був би лише один символ:

  (H[e(l[l(o[,( )w]o)r]l)d]!)
  

Для сьогоднішнього виклику ви повинні написати програму або функцію, яка приймає рядок як вхідний файл та змінює його, виводячи новий рядок. Ви можете приймати введення та вихід у будь-якому розумному форматі, який вам подобається. Вхід завжди буде принаймні одним символом і міститиме лише ASCII для друку. Ви також можете припустити, що вхід не містить жодних дужок чи квадратних дужок. Для традиційних мов це не повинно мати великого значення, але це може полегшити деякі езотеричні мови.

Як завжди, це змагання з кодового гольфу , тому постарайтеся дати якомога коротший відповідь на обраній вами мові. Веселіться!

Тест IO

#Input                      #Output

"Alternesting is fun!"  --> (A[l(t[e(r[n(e[s(t[in]g) ]i)s] )f]u)n]!)
"PPCG"                  --> (P[PC]G)
"Code-golf"             --> (C[o(d[e(-)g]o)l]f)
"4 8 15 16 23 42"       --> (4[ (8[ (1[5( [1]6) ]2)3] )4]2)
"a"                     --> (a)
"ab"                    --> (ab)
"abc"                   --> (a[b]c)

Python 3 , 70 69 65 байт

-1 байт завдяки @Uriel
-4 байти завдяки @xnor

f=lambda s,b=0:s and'(['[b]+s[0]+f(s[1:-1],~b)+s[1:][-1:]+')]'[b]

Спробуйте в Інтернеті!

C, 143 137 135 байт

i,l,k;f(char*s){for(k=i=0,l=strlen(s);*s;printf("%c%c","([])"[i++%2+2*(i>l/2+!k)],*s++))i>l/2-1&&l&1^1&&putchar(*s++,k=++l);puts(")");}

Спробуйте в Інтернеті!

Пояснення:

// Function (and variable) declaration.
i,l,k;f(char*s){

// Start the loop and initialize the variables. The loop terminates
// when the NUL-terminator of the string is reached.
for(k=i=0,l=strlen(s);*s;<this part saved for later>)

// Check if we have reached the middle of the string. Because of the
// short-circuiting of the conditions, we don't need to use an 'if'
// statement here; if a condition is false, no further conditions
// are evaluated.
i>l/2-1&&

// Equivalent to '!(l%2)', but one byte shorter. Checks if the length
// of the string is even.
l&1^1

// If we have reached the middle and the length of the string is even, 
// we'll need to skip one bracket, so we'll print the current character
// of the string and increment the pointer. Also we increment 'l' to
// avoid this getting done more than once, and give 'k' a non-zero
// value.
&&putchar(*s++,k=++l);

// The following is inside the 'increment' part of the 'for' loop.
// We print two characters. The first one is a bracket and the second
// one is the current character in the string.
printf("%c%c","([])"[i++%2+2*(i>l/2+!k)],*s++)

// The type of bracket is  chosen depending on the value of 'i'. A 
// character from the string "([])" is selected with the index 'i%2 + 2', 
// if we have reached the  middle of the string, and with index 'i%2', if
// we haven't.

// The exact part where this change happens depends on the parity of 
// the string length, so we use 'k' to signal if the length is even or 
// odd. If the length is odd, 'k==0', so '+!k' is the same as '+1'.  
// Otherwise 'k' is non-zero, so '+!k' is the same as '+0'.

// Output the final ')'.
puts(")");}

Сітківка , 52 байти

+`(?<!\()[^()]+(?!\))
($&)
(\(.)\(
$1[
r`\)(.\))
]$1

Спробуйте в Інтернеті! Перший етап вставляє пари дужок між кожною парою вхідних символів, а другий і третій етапи виправляють альтернативні дужки в дужки.

Сід, 78

Оцінка включає +1 для -rопції, переданої до с.

s/.*/(&)/
:
s/(\(.)([^][]+)(.\))/\1[\2]\3/
t
s/(\[.)([^)(]+)(.\])/\1(\2)\3/
t

Спробуйте в Інтернеті .

JavaScript (ES6), 69 68 байт

f=([c,...s],i,l=s.pop())=>'[('[i^=1]+c+(s[0]?f(s,i)+l:l||'')+'])'[i]

Тестові справи

f=([c,...s],i,l=s.pop())=>'[('[i^=1]+c+(s[0]?f(s,i)+l:l||'')+'])'[i]

console.log(f("Alternesting is fun!")) // (A[l(t[e(r[n(e[s(t[in]g) ]i)s] )f]u)n]!)
console.log(f("PPCG"                )) // (P[PC]G)
console.log(f("Code-golf"           )) // (C[o(d[e(-)g]o)l]f)
console.log(f("4 8 15 16 23 42"     )) // (4[ (8[ (1[5( [1]6) ]2)3] )4]2)
console.log(f("a"                   )) // (a)
console.log(f("ab"                  )) // (ab)
console.log(f("abc"                 )) // (a[b]c)

V , 25 26 25 байт

1 2 байти від @DJMcMayhem

òC()Pé
%llòÍî
òF)%r[r];

Спробуйте в Інтернеті!

Запозичені деякі з @ udioca в ідеях. Також нарешті використали для відповіді плагін об'ємного звучання, включений у V, хоча, мабуть, це був не найкращий спосіб. Плагін НЕ хоче використовуватись.

Hexdump:

00000000: e3e1 0a6b f2e9 286c 6ce9 5b6c 6cf2 6af2  ...k..(ll.[ll.j.
00000010: e129 6868 e15d 6868 f2cd ce              .)hh.]hh...

Пояснення:

-> |abcdefg      (the input, where | is the cursor)
ò              ' recursively
 C()           ' (C)hange from the cursor to the end of the line to '()'
-> (|)    (where | is the cursor)
     P         ' (P)aste the changed bit (what was there) left of the cursor
-> (abcdef|g)
      é        ' nsert a newline
-> (abcdef
   |g)
%              ' Goto the previous matching parenthese
-> |(abcdef
   g)
 ll            ' Move two characters right
-> (a|bcdef
   g)
   ò           ' End recursive loop (it will break on ll when there are no characters left
-> (a(b(c
   d)
   e)
   f)
    Íî         ' Remove all newlines
-> (a(b(cd)e)f|)
ò              ' Recursively
 F)            ' Go backwards to the next )
-> (a(b(cd)e|)f)
   %r[         ' Go to the matching paren and (r)eplace it with [
-> (a|[b(cd)e)f)
               ' Go back to the previous cursor location
-> (a[b(cd)e|)f)
       r]      ' (r)eplace this paren with ]
-> (a[b(cd)e|]f)
         ;     ' repeat F)
-> (a[b(cd|)e]f)
               ' implicitly end recursion

Haskell , 96 91 81 79 77 байт

(cycle"()[]"!)
(l:r:a)!k|[x]<-k=[l,x,r]|x:y<-k=l:x:a!init y++[last y,r]|2>1=k

Спробуйте в Інтернеті!

Рубі , 79 77 байт

-2 байти завдяки @Value Ink

->s{z=s.size
(z/2+z%2).times{|i|s.insert k=i*2,'(['[i%2]
s[~k]+=')]'[i%2]}
s}

Спробуйте в Інтернеті!

Javascript (ES6) 110 105 байт

^{Дякую @powelles, що нагадав про мене x%y<1.}

^{Дякуємо @Luke за a-b?y:x}

i=>'('+[...i].map((a,b,c,d=i.length/2-1,e=b%2<1)=>a+(d>b?e?'[':'(':d-b?(d%1==0?!e:e)?')':']'):'').join``

let f=i=>'('+[...i].map((a,b,c,d=i.length/2-1,e=b%2<1)=>a+(d>b?e?'[':'(':d==b?'':(d%1==0?!e:e)?')':']')).join``

<input onkeyup="result.textContent = f(this.value)"/>
<p id="result"></p>

Перше, що в розумінні цього звіра - це невольфство:

function alternest(input) { //input is i in the original
  let inputArray = Array.from(input); //the [...i] section
  let result = inputArray.map((item, index, baseArray) => { //result is an added helper variable
    let middle = input.length / 2 - 1, //the middle of the string
        alternate = index % 2 == 0; //should you alternate from '(' and '[' or ')' and ']'

    let symbol; //the alternating symbol

    if(middle > index) { //if its opening braces
      symbol = alternate ? '[' : '(';
    } else if(middle < index) {
      if(middle % 1 === 0) //if middle is a whole number
        alternate = !alternate; //reverse alternate
      symbol = alternate ? ')' : ']';
    } else { //if middle === index
      symbol = ''; //there's no symbol in the center for even alternests
    }
    return item + symbol; //convert the array item into the item and symbol
  }).join('');

  return '(' + result; //add the first symbol.
}

Майже кожен рядок є частиною версії для гольфу, тому переглядаючи:

Рядок 1: Оператор функції стає функцією стрілки , перейменовуючи inputв i. Стає i=>.

Рядок 2: Array.from це новий правильний спосіб перетворення рядка в масив і що ми використовуємо в цьому рядку. Однак поряд з цим оператор розповсюдження - це дешевший спосіб, ніж старий .split(''), це зробити, що використовується у версії для гольфу. Закінчується як [...i].

Рядок 3: .map прокручується через масив, даючи три аргументи: item( aу гольфі) index,; гольф як bі baseArrayта c. У той час як ми тільки піклуватися про itemі indexми продовжували baseArray(див лінії 4, чому). Гольфи до .map((a,b,c,...)=>....

Рядок 4: Змінна middle, або аргумент dу версії golfed створена для збереження кількох байт при повторенні. Аргумент cпотрібно було зберегти для створення аргументу d. Перетворюється на (...,d=i.length/2-1,...).

Рядок 5 : Змінна alternateабо аргумент eвикористовується для перевірки того, на якому символі він був "(" або "[" або якщо він був минулим посередині, ")" та "]". b%2<1дорівнює b%2==0тому, що в цьому випадку він не може бути меншим за 1, але 0. Дорівнює (...,e=b%2<1).

Рядок 6: Допоміжна змінна, яка дозволяє мені перетворити ternary operatorsна ifоператори. Чи не є нічого у фактичному кодогольфі.

Рядки 7-8 : Якщо індекс менший від середини рядка, встановіть символ на чергування "[" і "(". Зрівнює до d>b?e?'[':'(':....

Рядки 9-12 : Інше (якщо індекс більший за середину), перевірте, чи є середнє ціле число, якщо так, переключіть чергування. Потім встановіть символ на чергування ')' і ']'. Заплутаний до (d%1==0?!e:e)?')':']'.

Рядки 13-15 : Якщо в середині встановити символ порожнім рядком. Це не стосується непарних альтернестерів, оскільки середній має десятковий. Стає: d==b?'':....

Рядок 16 : Приєднується до масиву символів назад до рядка. Прирівнюється до .join``.

Рядок 17 : Повертає початковий символ "(" та результат. Корелює з '('+....

Желе , 23 21 байт

LHĊRị
ç⁾)]żUFUż@ç⁾([$

Спробуйте в Інтернеті!

LHĊRị           - helper function. Takes inputs of the input string and list of brace types
L                 - length of the input string
 HĊ               - number of parenthesis/brackets facing a single direction
   R              - range
    ị             - indexed into right argument: list of brace types ')]' or '(['

ç⁾)]żUFUż@ç⁾([$ - main function 
ç⁾)]              - get list of left-facing parentheses/brackets
    żU            - zip to the end (U) of the input string
      FU          - move the beginning of the string back to the beginning
        ż@        - zip with (to the start of the string):
          ç⁾([$   -the list of right-facing parentheses/brackets to the beginning

-2 байти завдяки @EricTheOutgolfer

SCALA, 140 138 символів, 140 138 байт

Вибачте, що я не зміг зробити кращого ... Я впевнений, що існує багато способів покращити це. Все-таки:

val n=s.length-1
var l=""
var r=""
for(i<-0 to n/2){l+=(if(i%2<1)"("else"[")
if(i!=n-i)l+=""+s(i)
r=""+s(n-i)+(if(i%2<1)")"else"]")+r}
l+r

Спробуйте в Інтернеті!

Дякую за цей виклик, мені це було досить важко.

EDIT: -2 ​​байти завдяки Mar Dev.

PS: Хоч щось запитаю. Я розумію, чому ЦІЙ КОД продовжує дублювати центральну таблицю мого рядка, якщо у мене непарна довжина (я просто не перевіряю і додаю її двічі в обох lі rрядках). Але чому я отримую пару круглих дужок, коли намагаюся виправити це так, як це ? Я взагалі не розумію.

Perl, 77 74 (73 + 1) байт

Регулярні вирази - це славні речі. Виконати з -pпрапором командного рядка.

$x=qr/[^]()[]/;$z=qr/(^|$x)\K($x+)($|$x)/;s/$z/[$2]$3/ while s/$z/($2)$3/

05AB1E , 31 байт

2ä`Rð«„)]Ig©×øRJ®Èƒ¦}s„([®×søJì

Спробуйте в Інтернеті!

Пояснення

З прикладами для введення: abcd/abcde

2ä`                              # split input to 2 separate parts on stack
                                 # RESULT: 'ab','cd' / 'abc', 'de'
   R                             # reverse the second part
    ð«                           # append a space
      „)]                        # push the string ")]"
         Ig©×                    # repeat it len(input) times
             ø                   # zip with the second part of the input string
              RJ                 # reverse and join to string
                                 # RESULT:  ' )c]d)' /  ' )d]e)'
                ®Èƒ¦}            # remove the first (1,2) chars for (odd,even) length input
                                 # RESULT: 'c]d)' / ')d]e)'
                     s           # swap the first part of the input string to top of stack
                      „([®×      # repeat the string "([" len(input) times
                           sø    # zip with first part of input string
                                 # RESULT: ['(a', '[b'] / ['(a', '[b', '(c']
                             Jì  # join to string and prepend to the second part

C ++ 14, 154 145 байт

[Рекурсивний]

auto L(string i,bool b=1){int l=i.length();string o=b?"(":"[";auto c=b?")":"]";if(l<3)return o+i+c;return o+i[0]+L(i.substr(1,l-2),!b)+i[l-1]+c;}

C ++ 14, 177 байт

[Ітеративний]

auto l(string s){int z=s.length();string r(z*2+z%2,'-');int i=0;for(;i<z;i+=2)r[i]=i/2%2?'[':'(',r[i+1]=s[i/2];for(i=z;i<2*z;i+=2)r[i]=s[i/2],r[i+1]=(i+1)/2%2?')':']';return r;}

Pyth , 42 (!) Байти

M?!lHH+@,\[\(G++hHg!GPtH+?qlH1keH@,\]\)Gg1

Перевірте це в Інтернеті! Вхід повинен бути цитований.

Пояснення

M                                             # Define a function g with arguments G and H
 ?!lHH                                        # If len(H) == 0, return H. Otherwise...
      +@,\[\(G                                # Concatenate [ or ( to...
               +hHg!GPtH                      # ...to H[0] concatenated to g(not(G), H[1:-1]), itself concatenated...
              +          ?qlH1keH             # ...to H[-1] if len(H) != 1, otherwise to "" (that's for odd length input strings)...
                        +        @,\]\)G      # ...and to that concatenate ] or ).
                                        g1    # Call g(True, Q). Q is implicit input

Таким чином, я поступово видаляю голову та кінець Н (будучи вхідним рядком на початку), поєднуючи дужки / дужки. G - просто булева інформація, яка пам'ятає, чи потрібно використовувати дужки або круглі дужки.

05AB1E , 49 42 байт

g;îD„([×s£©"s‚.Bøvy¬ðQi¦}}JR"DU.V®D∞sKRX.V

Спробуйте в Інтернеті!

PowerShell, 125 119 111 байт

{param($s)for($p='()[]';($f,$s,$g=$s-split'(?<=.)(.+)(?=.)')[0]){$l+=$p[$i++]+$f;$r=$g+$p[$i++]+$r;$i%=4}$l+$r}

Спробуйте в Інтернеті!

Попередня версія *

{for($s="($args)";$s-ne($t=$s-replace'(\(.)([^][]+)(.\))','$1[$2]$3'-replace'(\[.)([^)(]+)(.\])','$1($2)$3')){$s=$t}$s}

* Дякуємо @Digital Trauma.

QuadR , 82 байти

(81 байт +1 для ≡прапора)

(\(.)([^[])(.+?)([^\]])(.\))
(\(.)(..?)(.\))
^[^\(].*
\1[\2(\3)\4]\5
\1[\2]\3
(&)

Спробуйте в Інтернеті!

AWK, 118 байт

{b=")";for(j=l=length(c=$0);j>0;){x=substr(c,j--,1);b=(j>l/2?(((d=!d)?"]":")")x):j==l/2?x:((d=!d)?"(":"[")x)b}print b}

Тестується з gawk, але він повинен працювати з будь-якими сумісними тлумачами awk

$ awk -f alternesting.awk <<< 'abc'
(a[b]c)

JavaScript, 101 байт

Не переможець, але було цікаво спробувати replaceпідхід. Це, безумовно, можна покращити, але це швидко вийшло з рук ...

s=>"("+s.replace(/./g,(a,b)=>a+(l%2|b*2+2!=l?")][("[3*(c=l>(b+=l%2-1)*2+2)+(b-c*l)%2]:""),l=s.length)

Java (OpenJDK 8) , 124 байти

c->{String s="";for(int l=c.length-1,a=l/2;a>=0;)s=(a%2<1?"(":"[")+(a<-~l/2?c[a]+s+c[l-a]:c[a])+(a--%2<1?")":"]");return s;}

Спробуйте в Інтернеті!

Кредити

• -2 байти завдяки стельовій коті .