Alternierend ist der Vorgang, bei dem eine Zeichenfolge in abwechselnde Klammern gesetzt wird. Hier sehen Sie, wie Sie eine Zeichenfolge abwechseln .

• Nehmen Sie für eine Zeichenfolge der Länge N die mittleren N Zeichen und umgeben Sie sie in Klammern. Wenn also unsere Zeichenfolge Hello world!(12 Zeichen) war, werden wir mit enden

  (Hello world!)
  

• Nehmen Sie dann die verbleibenden mittleren n-2Zeichen und umgeben Sie sie in eckigen Klammern. In diesem Fall sind die mittleren 10 Zeichen. ello worldDie nächste Iteration lautet also:

  (H[ello world]!)
  

• Solange mehr als zwei Zeichen in der Mitte der Zeichenfolge verbleiben, wiederholen Sie die letzten beiden Schritte abwechselnd mit ()und []. Hier sind die letzten Schritte:

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

  Da bei der letzten Iteration nur noch zwei Zeichen in der Mitte übrig sind, hören wir auf. Unsere letzte Saite ist

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

  Beachten Sie, wie es zwei Zeichen in den mittleren Klammern gibt. Dies passiert, wenn die Eingabe eine gerade Länge hat. Wenn die Eingabe eine ungerade Länge hätte (zum Beispiel Hello, world!mit einem Komma), hätten wir nur ein Zeichen in der Mitte:

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

Für die heutige Herausforderung müssen Sie ein Programm oder eine Funktion schreiben, die eine Zeichenfolge als Eingabe verwendet und diese alterniert, wobei die neue Zeichenfolge ausgegeben wird. Sie können Eingaben und Ausgaben in jedem vernünftigen Format vornehmen, das Sie möchten. Die Eingabe ist immer mindestens ein Zeichen lang und enthält nur druckbares ASCII. Sie können auch davon ausgehen , dass der Eingang nicht jede Klammer oder eckige Klammern enthalten. Für traditionelle Sprachen sollte dies nicht allzu wichtig sein, aber es könnte für einige esoterische Sprachen einfacher sein.

Wie üblich ist dies ein Code-Golf- Wettbewerb. Versuchen Sie daher, die kürzestmögliche Antwort in der Sprache Ihrer Wahl zu geben. Habe Spaß!

Testen Sie 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 Bytes

-1 Byte dank @Uriel
-4 Byte dank @xnor

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

Probieren Sie es online!

C 143 137 135 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Netzhaut , 52 Bytes

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

Probieren Sie es online! Die erste Stufe fügt Klammerpaare zwischen jedes Eingabezeichenpaar ein, während die zweite und dritte Stufe abwechselnde Klammern in eckige Klammern setzen.

Sed, 78

Die Punktzahl enthält +1 für -rdie an sed übergebene Option.

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

Probieren Sie es online aus .

JavaScript (ES6), 69 bis 68 Byte

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

Testfälle

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 Bytes

1 2 Bytes weniger dank @DJMcMayhem

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

Probieren Sie es online!

Einige Ideen von @udioca entlehnt. Außerdem wurde schließlich das in V enthaltene Surround-Plugin für eine Antwort verwendet, obwohl es möglicherweise nicht der beste Weg war, wer weiß. Das Plugin will NICHT verwendet werden.

Hexdump:

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

Erläuterung:

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

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

Probieren Sie es online!

Ruby , 79 77 Bytes

-2 Bytes dank @Value Ink

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

Probieren Sie es online!

Javascript (ES6) 110 105 Bytes

^{Vielen Dank an @powelles, der mich daran erinnert hat x%y<1.}

^{Danke @Luke für 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>

Das erste, was dieses Biest versteht, ist, es zu entgolfen:

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

Fast jede Linie ist Teil der Golfversion.

Zeile 1: Die Funktion Anweisung wird eine Pfeil - Funktion , die Umbenennung inputzu i. Wird i=>.

Zeile 2: Array.from ist die neue, richtige Methode zum Konvertieren eines Strings in ein Array und das, was wir in dieser Zeile verwenden. Allerdings ist der Spread-Operator eine kostengünstigere Methode als .split('')die bisherige, die in der Golf-Version verwendet wird. Endet als [...i].

Zeile 3: .map Schleifen durch eine Anordnung, so dass Sie drei Argumente: item( ain der golfed) index; golfen als b, und baseArrayoder c. Während wir uns nur um itemund kümmern index, haben wir behalten baseArray(siehe Zeile 4 für warum). Golf zu .map((a,b,c,...)=>....

Zeile 4: Die Variable middle, das oder das Argument din der Golf-Version wird erstellt, um ein paar Bytes zu sparen, wenn es wiederholt wird. Das Argument cmusste aufbewahrt werden, damit das Argument derstellt werden konnte. Wird konvertiert zu (...,d=i.length/2-1,...).

Zeile 5 : Die Variable alternateoder das Argument ewird verwendet, um zu überprüfen, auf welchem ​​Zeichen es sich befand "(" oder "[" oder ob es nach der Mitte ")" und "]". b%2<1ist gleich, b%2==0weil es nicht weniger als 1 sein kann, in diesem Fall aber 0. Equals (...,e=b%2<1).

Zeile 6: Ein Helfer Variable mir zu erlauben , das zu konvertieren , ternary operatorsum ifAussagen. Ist nichts im eigentlichen Codegolf.

Zeilen 7-8 : Wenn der Index kleiner als die Mitte des Strings ist, setzen Sie das Symbol auf eine Abwechslung von "[" und "(". Entspricht d>b?e?'[':'(':....

Zeilen 9-12 : Andernfalls (wenn der Index größer als die Mitte ist), überprüfen Sie, ob die Mitte eine ganze Zahl ist, und schalten Sie in diesem Fall die Abwechslung um. Setzen Sie dann das Symbol auf eine Abwechslung von ')' und ']'. Verschleiert zu (d%1==0?!e:e)?')':']'.

Zeilen 13-15 : Wenn in der Mitte, setzen Sie das Symbol auf eine leere Zeichenkette. Dies gilt nicht für ungerade Alternativen, da die Mitte eine Dezimalstelle hat. Wird: d==b?'':....

Zeile 16 : Verbindet das Zeichenfeld wieder zu einer Zeichenfolge. Entspricht .join``.

Zeile 17 : Liefert das Startsymbol "(" und das Ergebnis. Entspricht '('+....

Jelly , 23 21 Bytes

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

Probieren Sie es online!

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 Bytes dank @EricTheOutgolfer

SCALA, 140 138 Zeichen, 140 138 Byte

Es tut mir leid, dass ich es nicht besser machen konnte ... Ich bin mir sicher, dass es viele Möglichkeiten gibt, es zu verbessern. Immer noch:

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

Probieren Sie es online!

Danke für diese Herausforderung, das war ziemlich schwer für mich.

EDIT: -2 ​​Bytes dank Mar Dev.

PS: Ich werde allerdings etwas fragen. Ich verstehe, warum DIESER CODE das zentrale Zeichen meines Strings immer wieder dupliziert, wenn ich eine ungerade Länge habe (ich überprüfe es einfach nicht und füge es zweimal hinzu, in beiden lund in rStrings). Aber warum bekomme ich ein Paar Klammern , wenn ich es so versuchen zu korrigieren , DASS ? Ich verstehe überhaupt nicht.

Perl, 77 74 (73 + 1) Bytes

Reguläre Ausdrücke sind herrliche Dinge. Führen Sie mit dem -pBefehlszeilenflag aus.

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

05AB1E , 31 Bytes

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

Probieren Sie es online!

Erläuterung

Mit Beispielen für die Eingabe: 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 Bytes

[Rekursiv]

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 Bytes

[Iterativ]

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 (!) Bytes

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

Online testen! Die Eingabe muss in Anführungszeichen stehen.

Erklärungen

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

Im Grunde genommen entferne ich also nach und nach den Kopf und das Ende von H (wobei es sich am Anfang um die Eingabezeichenfolge handelt), während ich die Klammern / Klammern verkette. G ist nur ein Boolescher Wert, der sich daran erinnert, ob ich Klammern oder Klammern verwenden muss.

05AB1E , 49 42 Bytes

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

Probieren Sie es online!

PowerShell, 125 119 111 Byte

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

Probieren Sie es online!

Vorherige Version*

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

* Danke @Digital Trauma.

QuadR , 82 Bytes

(81 Byte +1 für ≡Flag)

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

Probieren Sie es online!

AWK, 118 Bytes

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

Getestet mit gawk, aber es sollte mit jedem kompatiblen awk-Interpreter funktionieren

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

JavaScript, 101 Bytes

Kein Gewinner, aber es war interessant, den replaceAnsatz zu versuchen . Dies könnte definitiv verbessert werden, aber es wurde schnell außer Kontrolle geraten ...

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 Byte

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

Probieren Sie es online!

Credits

• -2 Bytes dank Ceilingcat .