Alterner consiste à prendre une chaîne et à l’emboîter de manière alternée. Voici comment vous alternez une chaîne.

• Pour une chaîne de longueur N , prenez les caractères du centre N et entourez-les de parenthèses. Donc, si notre chaîne était Hello world!(12 caractères), nous finirons avec

  (Hello world!)
  

• Ensuite, prenez les n-2caractères centraux restants et entourez-les entre crochets. Dans ce cas, les 10 caractères centraux sont ello world, ainsi la prochaine itération est:

  (H[ello world]!)
  

• Tant qu'il reste plus de deux caractères au milieu de la chaîne, répétez les deux dernières étapes en alternant entre ()et []. Voici les dernières étapes:

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

  Comme il ne reste que deux caractères au milieu de la dernière itération, nous nous arrêtons. Notre dernière chaîne est

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

  Notez qu’il ya deux caractères entre les parenthèses. Cela se produit lorsque l'entrée est de longueur égale. Si l'entrée avait une longueur impaire (par exemple, Hello, world!avec une virgule ajoutée), nous n'aurions qu'un seul caractère au milieu:

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

Pour le défi d'aujourd'hui, vous devez écrire un programme ou une fonction qui prend une chaîne en tant qu'entrée et l'alterne, générant la nouvelle chaîne. Vous pouvez prendre des entrées et des sorties dans n’importe quel format raisonnable. L'entrée comportera toujours au moins un caractère et ne contiendra que de l'ASCII imprimable. Vous pouvez également supposer que l'entrée ne contiendra pas de parenthèses ni de crochets. Pour les langues traditionnelles, cela ne devrait pas avoir trop d'importance, mais cela pourrait faciliter la tâche de certaines langues ésotériques.

Comme d’habitude, il s’agit d’une compétition de code-golf . Essayez donc de donner la réponse la plus courte possible dans la langue de votre choix. S'amuser!

Test 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 octets

-1 octet grâce à @Uriel
-4 octets grâce à @xnor

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

Essayez-le en ligne!

C, 143 137 135 octets

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

Essayez-le en ligne!

Explication:

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

Retina , 52 octets

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

Essayez-le en ligne! La première étape insère des paires de parenthèses entre chaque paire de caractères saisis, tandis que les deuxième et troisième étapes corrigent les parenthèses alternatives entre crochets.

Sed, 78

Le score inclut +1 pour l’ -roption passée à sed.

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

Essayez-le en ligne .

JavaScript (ES6), 69 à 68 octets

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

Cas de test

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 octets

1 2 octets de moins grâce à @DJMcMayhem

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

Essayez-le en ligne!

Emprunté certaines des idées de @ udioca. Enfin , nous avons également utilisé le plug - in Surround inclus dans V pour une réponse, bien que cela n'ait peut-être pas été le meilleur moyen, qui sait. Le plugin ne veut PAS être utilisé.

Hexdump:

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

Explication:

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

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

Essayez-le en ligne!

Ruby , 79 77 octets

-2 octets grâce à @Value Ink

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

Essayez-le en ligne!

Javascript (ES6) 110 105 octets

^{Merci à @powelles de me l'avoir rappelé x%y<1.}

^{Merci @ Luke pour 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>

La première chose à faire pour comprendre cette bête est de ne pas le faire:

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

Presque chaque ligne fait partie de la version jouée au golf.

Ligne 1: L'instruction de fonction devient une fonction de flèche , renommée inputen i. Devient i=>.

Ligne 2: Array.from est la nouvelle façon de convertir une chaîne de caractères en tableau, et ce que nous utilisons sur cette ligne. Cependant, parallèlement, l’ opérateur de spread est un moyen moins coûteux que l’ancien .split(''), de le faire, comme dans la version jouée au golf. Se termine comme [...i].

Ligne 3: .map boucles à travers un tableau, vous donnant trois arguments: item( adans le golfed), index; joué au golf b, et baseArrayou c. Alors que nous nous soucions seulement de itemet index, nous avons gardé baseArray(voir la ligne 4 pour savoir pourquoi). Golfs à .map((a,b,c,...)=>....

Ligne 4: La variable middle, l'argument ou l'argument dde la version golfée est créé pour économiser quelques octets lors de sa répétition. L'argument cdevait être conservé pour que l'argument dsoit créé. Est converti en (...,d=i.length/2-1,...).

Ligne 5 : La variable alternate, ou l'argument, eest utilisé pour vérifier le caractère sur lequel il était "(" ou "[" ou s'il était passé au milieu, ")" et "]". b%2<1est égal à b%2==0parce qu'il ne peut pas être inférieur à 1, mais à 0 dans ce cas. Est égal (...,e=b%2<1).

Ligne 6: Une variable d'aide pour me permettre de convertir les ternary operatorsaux ifdéclarations. N'y a-t-il rien dans le codegolf actuel?

Lignes 7-8 : Si l’index est inférieur au milieu de la chaîne, indiquez une alternance de "[" et "(". Equates à d>b?e?'[':'(':....).

Lignes 9-12 : Sinon (si l'index est supérieur au milieu), vérifiez si le milieu est un nombre entier, si c'est le cas, changez l'alternance. Puis définissez le symbole sur une alternance de ')' et ']'. Obfusqué à (d%1==0?!e:e)?')':']'.

Lignes 13-15 : Si dans le milieu, définissez le symbole sur une chaîne vide. Cela ne s'applique pas aux alternants impairs, car le milieu a une décimale. Devient: d==b?'':....

Ligne 16 : joint le tableau de caractères en une chaîne. Équivaut à .join``.

Ligne 17 : renvoie le symbole de départ "(" et le résultat. Corrélé à '('+....

Gelée , 23 21 octets

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

Essayez-le en ligne!

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 octets grâce à @EricTheOutgolfer

SCALA, 140 138 caractères, 140 138 octets

Je suis désolé de ne pouvoir faire mieux ... Je suis sûr qu'il y a plusieurs façons de l'améliorer. Encore:

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

Essayez-le en ligne!

Merci pour ce défi, ce fut assez difficile pour moi.

EDIT: -2 ​​octets grâce à Mar Dev.

PS: Je vais demander quelque chose cependant. Je comprends pourquoi CE CODE continue à dupliquer le caractère central de ma chaîne si ma longueur est étrange (je ne vérifie pas et ne l'ajoute pas deux fois, dans les deux chaînes let r). Mais pourquoi dois - je obtenir une paire de parenthèses lorsque je tente de corriger comme QUE ? Je ne comprends pas du tout.

Perl, 77 74 (73 + 1) octets

Les expressions régulières sont des choses glorieuses. Exécuter avec l' -pindicateur de ligne de commande.

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

05AB1E , 31 octets

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

Essayez-le en ligne!

Explication

Avec des exemples à saisir: 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 octets

[Récursif]

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 octets

[Itératif]

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

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

Testez-le en ligne! L'entrée doit être citée.

Des explications

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

Donc, fondamentalement, je supprime progressivement la tête et la fin de H (la chaîne d'entrée au début) tout en concaténant les parenthèses / crochets. G est juste un booléen qui me rappelle si je dois utiliser des crochets ou des parenthèses.

05AB1E , 49 42 octets

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

Essayez-le en ligne!

PowerShell, 125 119 111 octets

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

Essayez-le en ligne!

La version précédente*

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

* Merci Traumatismes numériques.

QuadR , 82 octets

(81 octets +1 pour le ≡drapeau)

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

Essayez-le en ligne!

AWK, 118 octets

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

Testé avec gawk, mais il devrait fonctionner avec tous les interprètes awk compatibles.

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

JavaScript, 101 octets

Pas un gagnant, mais c'était intéressant d'essayer l' replaceapproche. Cela pourrait certainement être amélioré, mais cela est devenu incontrôlable ...

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 octets

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

Essayez-le en ligne!

Crédits

• -2 octets grâce à ceilingcat .