Alternatif , bir dize alma ve alternatif parantez içine yerleştirme eylemidir. Bir dizgiyi nasıl değiştireceğiniz aşağıda açıklanmıştır .

• Bir uzunluk N dizesi için, orta N karakterlerini alın ve parantez içine alın. Eğer dizgimiz Hello world!(12 karakter) olsaydı , sonunda bitiririz.

  (Hello world!)
  

• Ardından, kalan orta n-2karakterleri alın ve bunları köşeli parantez içine alın. Bu durumda, merkez 10 karakter ello world, yani bir sonraki yineleme:

  (H[ello world]!)
  

• Dizenin ortasında ikiden fazla karakter kaldığı sürece, ()ve arasında değişen son iki adımı tekrarlayın []. İşte son adımlar:

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

  Son yinelemenin ortasında sadece iki karakter kaldığından, dururuz. Son dizgimiz

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

  Orta parantez içerisinde iki karakterin nasıl olduğuna dikkat edin. Bu, giriş düzgün bir uzunluk olduğunda gerçekleşir. Giriş tek bir uzunluktaysa (örneğin, Hello, world!virgül eklenmişse), ortada yalnızca bir karakter olacaktı:

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

Bugünün mücadelesi için, dizgeyi girdi olarak alan ve alternatifini değiştirerek yeni dizgeyi çıkaran bir program veya işlev yazmalısınız. İstediğiniz herhangi bir makul formatta girdi ve çıktı alabilirsiniz. Giriş her zaman en az bir karakter uzunluğunda olacak ve yalnızca yazdırılabilir ASCII içerecektir. Ayrıca giriş varsayabiliriz değil herhangi parantez veya köşeli ayraç içerir. Geleneksel diller için bu çok fazla önemli olmamalıdır, ancak bazı ezoterik diller için daha kolay olabilir.

Her zamanki gibi, bu bir kod-golf yarışmasıdır, bu nedenle seçtiğiniz dilde mümkün olan en kısa sürede yanıt vermeye çalışın. İyi eğlenceler!

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 bayt

@ Xriel sayesinde @Uriel -4 byte sayesinde -1 bayt

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

Çevrimiçi deneyin!

C, 143 137 135 bayt

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

Çevrimiçi deneyin!

Açıklama:

// 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 bayt

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

Çevrimiçi deneyin! İlk aşama, her giriş karakteri çifti arasına parantez çifti eklerken, ikinci ve üçüncü aşamalar parantez içindeki alternatif parantezleri düzeltir.

Sed, 78

Skor, -rsed'e iletilen seçenek için +1'i içerir .

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

Çevrimiçi deneyin .

JavaScript (ES6), 69 68 bayt

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

Test durumları

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 bayt

@DJMcMayhem sayesinde 1 2 bayt kapalı

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

Çevrimiçi deneyin!

@ Udioca'nın bazı fikirlerini ödünç aldım. Ayrıca nihayet V'de bulunan surround eklentisini , en iyi yol olmasa da, bir cevap için kullandı . Eklenti kullanılmak istemiyor.

HexDump:

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

Açıklama:

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

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

Çevrimiçi deneyin!

Ruby , 79 77 bayt

@Value Ink sayesinde -2 bayt

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

Çevrimiçi deneyin!

Javascript (ES6) 110 105 bayt

^{Bana hatırlattığın için teşekkür ederim x%y<1.}

^{İçin @Luke teşekkürler 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>

Bu canavarı anlamada ilk şey onu çözmedir:

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

Hemen hemen her satır golf versiyonunun bir parçası, bu yüzden adım adım:

Hat 1: işlevi deyimi bir hale ok fonksiyonu yeniden adlandırma, inputiçin i. Olur i=>.

Satır 2: Array.from Bir dizgiyi diziye dönüştürmenin yeni ve uygun yolu ve bu satırda ne kullanıyoruz. Bununla birlikte, yayma operatörü , eski .split('')sürümden daha ucuz bir yoldur , golf versiyonunda kullanılan şeydir. Olarak biter [...i].

Satır 3: .map bir dizi boyunca dolaşır, size üç argüman verir: item( agolfed) index,; olarak golf oynadı bve baseArrayveya c. Biz sadece itemve onunla ilgilenirken index, biz de devam ettik baseArray(neden için 4. satıra bakınız). Golfe .map((a,b,c,...)=>....

Satır 4: Değişken middle, ya da dgolf versiyonundaki argüman tekrarlandığında birkaç bayttan tasarruf etmek için yaratılır. Argümanın yaratılması ciçin argüman saklanmalıydı d. Dönüştürülür (...,d=i.length/2-1,...).

Satır 5 : Değişken alternateveya argüman e"(" veya "[" veya hangi karakterin ortasından geçtiyse ")" ve "]" üzerinde hangi karakterin olduğunu kontrol etmek için kullanılır. b%2<1eşittir b%2==0çünkü 1'den küçük olamaz, ancak bu durumda 0'dır. Eşittir (...,e=b%2<1).

Hat 6: Bir yardımcı değişken beni dönüştürmek için izin ternary operatorsiçin ififadeleri. Gerçek kodlayıcıda hiçbir şey yok.

Satırlar 7-8 : Dizinin dizginin ortasından az olması durumunda, sembolü "[" ve ​​"(" seçeneğine ayarlayın) d>b?e?'[':'(':....

Satır 9-12 : Başka (eğer indeks ortadan büyükse), ortalamanın tam sayı olup olmadığını kontrol edin, öyleyse geçişi değiştirin. Ardından sembolü ')' ve ']' olarak değiştirin. Şaşkın (d%1==0?!e:e)?')':']'.

Satır 13-15 : Ortada simge boş bir dizeye ayarlanmışsa. Bu, tuhaf alternatifler için geçerli değildir, çünkü ortada ondalık bir sayı vardır. Oluyor: d==b?'':....

Satır 16 : Karakter dizisini tekrar bir dizgeye bağlar. Eşittir .join``.

17 Satırı : "(") başlangıç ​​sembolünü ve sonucunu döndürür '('+....

Jöle , 23 21 bayt

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

Çevrimiçi deneyin!

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

@EricTheOutgolfer sayesinde -2 bayt

SCALA, 140 138 karakter, 140 138 bayt

Üzgünüm, daha iyisini yapamadım ... Bunu geliştirmenin birçok yolu olduğuna eminim. Yine:

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

Çevrimiçi deneyin!

Bu meydan okuma için teşekkürler, bu benim için oldukça zordu.

EDIT: Mar Dev sayesinde -2 bayt.

Not: Yine de bir şey soracağım. Neden anlamak BU KOD ben garip bir uzunluğa varsa benim dize merkezi kömürü çoğaltarak tutar (Sadece kontrol etmiyoruz ve ikisi de, iki kere ekleyin lve rdizeleri). Ben gibi düzelterek çalıştığımda Ama neden parantez çifti alabilirim OLDUĞUNU ? Ben hiç anlamıyorum.

Perl, 77 74 (73 + 1) bayt

Düzenli ifadeler şanlı şeylerdir. -pKomut satırı bayrağıyla çalıştırın .

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

05AB1E , 31 bayt

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

Çevrimiçi deneyin!

açıklama

Giriş için örneklerle: 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 bayt

[Özyinelemeli]

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 bayt

[Yinelemeli]

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

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

Çevrimiçi test edin! Giriş belirtilmelidir.

açıklamalar

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

Bu yüzden temel olarak parantez / parantez birleştirirken H'nin başını ve sonunu (başlangıçta giriş dizesi olmak üzere) kademeli olarak kaldırıyorum. G, parantez veya parantez kullanmam gerekip gerekmediğini hatırlatan bir booleandır.

05AB1E , 49 42 bayt

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

Çevrimiçi deneyin!

PowerShell, 125 119 111 bayt

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

Çevrimiçi deneyin!

Önceki versiyon*

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

* Teşekkürler @ Dijital Travma.

QuadR , 82 bayt

( ≡Bayrak için 81 bayt + 1 )

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

Çevrimiçi deneyin!

AWK, 118 bayt

{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 ile test edilmiştir ancak uyumlu awk tercümanlarıyla çalışmalıdır.

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

JavaScript, 101 bayt

Kazanan değil, ancak replaceyaklaşımı denemek ilginçti . Bu kesinlikle düzelebilirdi, ama hızlıca elden çıktı ...

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 bayt

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

Çevrimiçi deneyin!

Kredi

• Ceilingcat sayesinde -2 bayt .