(A [l(t [e(r)n] e)s] t)一个字符串!


36

Alternesting,是将一个字符串并嵌套在交替的括号中的行为。这是改变字符串的方式。

  • 对于长度为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)


我们必须始终以括号(())开头还是可以以方括号([])开头?
完全人类

@totallyhuman它应该始终以括号开头()
DJMcMayhem

建议的测试用例:HelloWorld
暴民埃里克(Erik the Outgolfer)'17

另外,是否允许尾随空格?
暴民埃里克(Erik the Outgolfer),2017年

Answers:



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(")");}

如果我没有记错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]

测试用例


5

V25 26 25字节

1感谢@DJMcMayhem关闭2个字节

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

在线尝试!

借用了@udioca的 一些想法。终于知道,虽然可能不是最好的方法,但最终还是使用了V中包含的环绕插件该插件不希望被使用。

十六进制转储:

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

哇,干得好!我停留在29个字节上,但错过了一些边缘情况。这是一个很好的答案。您可以使用;而不是最后一个来保存一个字节f)
DJMcMayhem

由于空间原因,它现在实际上已损坏,我将删除并修复
nmjcman101

@DJMcMayhem我可以看到您的29个字节吗?除非您计划在我下面打高尔夫球并参加比赛,否则我不会对此感到惊讶:)
nmjcman101

它不起作用,所以我不介意向您展示它:tio.run / ## K / v /// ...哦,顺便说一句:chat.stackexchange.com/transcript/message/38434285#38434285 :)
DJMcMayhem

:(做交替操作()[]字节变短了,但是却不那么酷了
nmjcman101 '17

5

Haskell96 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

在线尝试!


1
您可以将父母放到(x:y)(init y)k==""=""比短k==""=k
Laikoni

1
更改cycle["()","[]"]为just可以节省更多字节"()[]"在线尝试!
Laikoni

@Laikoni的好建议,谢谢
bartavelle

1
保持cycle时间更短的好收获。您仍然可以删除圆括号(init y)
Laikoni

1
您可以将案件k==""=k移至末尾并将其更改为0<1=k
Zgarb


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行:函数语句变为箭头函数,重命名inputi。成为i=>

第2行: Array.from是将字符串转换为数组的新方法,也是本行使用的方法。但是,与之相比,点差算子是一种比旧.split('')方法更便宜的方法,这是高尔夫球版本中使用的方法。最终显示为[...i]

3号线: .map通过数组循环,给你三个参数:itema在golfed)index; golfed如b,和baseArrayc。虽然我们只关心itemand 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 operatorsto if语句转换为。在实际的代码高尔夫中没有任何内容。

第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谢谢。
David Archibald

b%2<1可以由!b%2
路加福音

另外,d==b?x:y可能成为,d-b?y:x并且d%1==0可能成为!d%1
路加福音

不幸的是,由于操作顺序,!d%1只能使用括号:!(d%1),并且不能删除任何字节。我忘记了0是唯一的虚假数字,出于某种原因,我认为-1是虚假的数字。如果我对第二个问题有误,请纠正我。
David Archibald

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


您可以删除一行,然后将其移至-2的辅助链接,如下所示:LHĊRị¶ç⁾)]żUFUż@ç⁾([$
Erik the Outgolfer

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:我会问一些问题。我明白了为什么此代码不断重复我的字符串的字符集中,如果我有一个奇怪的长(我只是不检查,并将其添加两次,都lr字符串)。但是,当我尝试像THAT一样更正时,为什么会得到一对括号呢?我一点都不明白


1
你可以改变i%2==0,以i%2<1挽救两个字节。
马里奥·伊沙克


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

1

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;}

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)

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.