(A [l (t [e (r) n] e) s] t) строка!

36

Альтернатива - это процесс взятия строки и ее размещения в чередующихся скобках. Вот как вы чередуете строку.

  • Для строки длины 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)
DJMcMayhem
источник
Связанные
DJMcMayhem
Должны ли мы всегда начинаться с круглых скобок ( ()) или мы можем начать с квадратных скобок ( [])?
полностью человек
@totallyhuman Это всегда должно начинаться с круглых скобок()
DJMcMayhem
Предлагаемые TestCase: HelloWorld.
Эрик Outgolfer
Кроме того, разрешены ли пробелы?
Эрик Outgolfer

Ответы:

9

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(")");}
Steadybox
источник
Если я правильно помню C, переменные, объявленные глобально, инициализируются в 0. Таким образом, вам не нужно k=i=0,. Я могу быть не прав. Посмотрите этот ТАК ответ
Tas
@Tas Вы действительно правы, но функции должны многократно использоваться, чтобы быть действительными представлениями, поэтому переменные должны быть инициализированы внутри функции.
Steadybox
7

Сетчатка , 52 байта

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

Попробуйте онлайн! Первый этап вставляет пары скобок между каждой парой входных символов, а второй и третий этапы исправляют альтернативные скобки в скобках.

Нил
источник
6

Сед, 78

Оценка включает +1 для -rопции, переданной в sed.

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

Попробуйте онлайн .

Цифровая травма
источник
6

JavaScript (ES6), 69 68 байт

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

Контрольные примеры

Arnauld
источник
5

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
nmjcman101
источник
Вау, хорошая работа! Я застрял на 29 байтах, но пропустил несколько крайних случаев. Это довольно приятный ответ. Вы можете сохранить один байт, используя ;вместо последнего. f) Попробуйте онлайн!
DJMcMayhem
Это на самом деле сломано прямо сейчас из-за пробелов, я собираюсь удалить и исправить
nmjcman101
@DJMcMayhem Могу ли я увидеть ваш 29 байт? Если вы не планируете играть в гольф подо мной и соревноваться, что меня не удивит :)
nmjcman101
Это не работает, поэтому я не против показать вам это: tio.run/##K/v///… Да, и кстати: chat.stackexchange.com/transcript/message/38434285#38434285 :)
DJMcMayhem
:( делает чередование ()и []является байтом короче, но гораздо менее круто
nmjcman101
5

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

Попробуйте онлайн!

bartavelle
источник
1
Вы можете бросить родителей (x:y)и (init y). k==""=""короче как k==""=k.
Лайкони
1
Сохраните еще несколько байтов, выбрав cycle["()","[]"]просто "()[]": Попробуйте онлайн!
Лайкони
@Laikoni отличные предложения, спасибо
bartavelle
1
Хорошо поймать, что хранение cycleеще короче. Вы все еще можете удалить круглые скобки вокруг (init y).
Лайкони
1
Вы можете переместить дело k==""=kдо конца и изменить его на 0<1=k.
Згарб
2

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``


Первое, что нужно понять этому зверю, это развеять его:

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в golfed) index; игра в гольф, как bи baseArrayили c. В то время как мы заботимся только о itemи index, мы сохранили baseArray(см. Строку 4, почему). Гольф до .map((a,b,c,...)=>....

Строка 4: переменная middle, или аргумент dв версии для гольфа создается для сохранения нескольких байтов при повторении. Аргумент 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отчетности. Нет ничего в настоящем Codegolf.

Строки 7-8 : если индекс меньше середины строки, установите для символа чередование "[" и "(". Приравнивается к d>b?e?'[':'(':....

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

Строки 13-15 : если в середине установить символ на пустую строку. Это не относится к нечетным заместителям, потому что середина имеет десятичную дробь. Становится: d==b?'':....

Строка 16 : объединяет массив символов обратно в строку. Приравнивается к .join``.

Строка 17 : возвращает начальный символ "(" и результат. Соответствует '('+....

Дэвид Арчибальд
источник
Для некоторых простых побед вы могли бы изменить , %2==0чтобы %2<1и использовать [...i]вместоi.split
powelles
1
Спасибо @powelles. Я работаю над объяснением, а не над полным ответом, так что это еще не внесено в редактирование. Я уже имел [..i] idea, но я забыл о %2<1спасибо.
Дэвид Арчибальд
b%2<1может быть заменено на!b%2
Люк
Кроме того, d==b?x:yмог стать d-b?y:xи d%1==0мог стать !d%1.
Люк
К сожалению, из-за порядка операций !d%1работает только с круглыми скобками: !(d%1)и не сбрасывает ни одного байта. Я забыл, что 0 был единственным ложным числом, по какой-то причине я думал, что -1 был ложным. Поправь меня, если я что-то не так насчет второго.
Дэвид Арчибальд
2

Желе , 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

fireflame241
источник
Вы можете удалить линию и переместить ссылку помощника на -2, например так:LHĊRị¶ç⁾)]żUFUż@ç⁾([$
Эрик Игрок в гольф
1

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

Попробуйте онлайн!

Спасибо за этот вызов, это было довольно сложно для меня.

РЕДАКТИРОВАТЬ: -2 байта благодаря Mar Dev.

PS: я спрошу что-то, хотя. Я понимаю , почему Этот код сохраняет дублируя центральный символ моей строки , если у меня есть нечетная длина (я просто не проверить и добавить его в два раза, в обоих lи rстроках). Но почему я получаю пару скобок, когда пытаюсь исправить это, как ТО ? Я вообще не понимаю.

В. Куртуа
источник
1
Вы можете изменить , i%2==0чтобы i%2<1спасти два байта.
Марио Исхак
1

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

Регулярные выражения - великолепные вещи. Запустите с -pфлагом командной строки.

$x=qr/[^]()[]/;$z=qr/(^|$x)\K($x+)($|$x)/;s/$z/[$2]$3/ while s/$z/($2)$3/
Сильвио Майоло
источник
1

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
Emigna
источник
1

С ++ 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;}
Роберт Анджейюк
источник
0

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

Поэтому в основном я постепенно удаляю начало и конец H (будучи входной строкой в ​​начале), объединяя скобки / скобки. G - это просто логическое значение, которое помнит, нужно ли мне использовать скобки или скобки.

Джим
источник
0

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.

Андрей Одегов
источник
0

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)
Дэн Андреатта
источник
0

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)
jrich
источник