Jeśli kiedykolwiek próbowałeś pisać kod palindromiczny, będziesz wiedział, ile nawiasów przeszkadza. ()()nie jest palindrom, choć to trochę wygląda jak powinno być, podczas gdy ())(i ()(to zarówno palindromiczna i oba bardzo głupi patrząc. Czy nie byłoby wygodnie, gdyby było na odwrót?

Łańcuch jest dogodnie palindromiczny, jeśli jest równy łańcuchowi pochodnemu, gdy jego odwrotność ma obrócone wszystkie nawiasy ( ()), nawiasy ( []) i nawiasy klamrowe ( {}). Żadne inne postacie nie są wyjątkowe i wymagają przewracania. ( <>czasami są sparowane, ale często nie, więc są pomijane).

Twoim zadaniem jest napisanie w Twoim języku programu (przyjmującego dane wejściowe na STDIN) lub funkcji (przyjmującego pojedynczy argument łańcuchowy), który (a) daje spójną prawdziwą wartość *, gdy jej argument jest dogodnie palindromiczny i inny, spójny fałszywy wartość inaczej, i (b) to samo dogodnie palindromową.

Na przykład następujące dane wejściowe są dogodnie palindromiczne:

racecar
(a)(bb)(a)
void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov

A następujące nie są:

non-palindrome
A nut for a jar of tuna?
(old [style] parens) )snerap ]elyts[ dlo(
ingirumimusnocte)etconsumimurigni

Nie możesz polegać na żadnym stanie zewnętrznym (konkretna nazwa pliku, struktura katalogów, inne dane wejściowe użytkownika, dostęp do Internetu itp.), Z wyjątkiem flag interpretera / kompilatora.

Nie możesz również używać „sztuczki komentowania”, gdy komentujesz lub renderujesz nieużywany fragment kodu, korzystając z możliwości komentowania w swoim języku. Na przykład wszystkie poniższe elementy są niedozwolone, ponieważ zawierają niefunkcjonalne części, które można bezpiecznie usunąć lub zniszczyć (kosztem utraty dogodnej palindromii):

{some code} // {edoc emos}
{some code} NB.BN {edoc emos}
"n\" ;{edoc emos} ;"; {some code}; "\n"

Oczywiście może to nie dotyczyć każdego takiego przypadku, ale duchem wyzwania nie jest tutaj stosowanie komentarzy i nieparsowanego ** kodu w celu osiągnięcia palindromii, zamiast korzystania z poprawionych części i nawiasów. Patrzę na ciebie, LISP, Brainfuck.

To jest golfowy kod , więc wygrywa najkrótszy kod, ale mile widziane są wszystkie długości kodu.

* ^{Przez spójne wartości prawda i fałsz rozumiem, że możesz zwrócić jedną z dwóch wartości, na przykład 1prawda i 0fałsz lub Falseprawda i "no"fałsz, o ile wartości te różnią się od siebie i nie zmień z uruchomienia na uruchomienie programu. Użyj tego, co ocali ci postacie.}

** ^{Nie należy mylić z niewykonanym : kod, który jest prawidłowy i może robić dziwne rzeczy, ale nigdy nie wywoływany jest w porządku.}

J (60)

(|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|)

Ta funkcja przyjmuje argument:

   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) 'ingirumimusnocte)etconsumimurigni'
0
   (|.-:'())([]][{}}{'&charsub) :: (busrahc&'}{{}][[])(()':-.|) '(a)(bb)(a)'
1

Wyjaśnienie:

• f :: guruchamia funkcję fnad wejściem i zwraca wynik, jeśli zwraca bez błędu. Jeśli się fnie powiedzie, działa gzamiast tego.

• fO to (|.-:'())([]][{}}{'&charsub), co robi rzeczywistej pracy:

  • |.: rewers
  • -:: jest równe
  • '())([]][{}}{'&charsub: wymiana każdego wspornika na przeciwny wspornik
• Ta gfunkcja jest (busrahc&'}{{}][[])(()':-.|)nonsensowna, ale poprawna pod względem składniowym. busrahcnie jest zdefiniowany, ale to nie ma znaczenia, ponieważ jest rozwiązywany tylko wtedy, gdy jest uruchamiany (i nie działa).

GolfScript, 107 91

.4:ab-1:ba=;1
%ba%{...fi@@=
c43.=;)('"([{
}])"'~?~'"([{
}])"')(;=.34c
=@@if...}%ab%
1;=ab:1-ba:4.

Newlines są artystyczne. fi, c43I csą noops, ale cały kod jest wykonywany.

Drukuje -3-1-1dla wygodnych palindromów, w -4-1-1przeciwnym razie. Wypróbuj online!

Alternatywna wersja, 155 bajtów

Kosztem 64 bajtów można to poprawić:

0!*1{!}\;:);0:f;0:i;-1:ab;9:ba;
...=;1%ab%{....i@f@@fi@@=@.=@\)
+""'"([{}])"'~+?+~'"([{}])"'""+
(\@=.@=@@if@@f@i....}%ba%1;=...
;ab:9;ba:1-;i:0;f:0;(:;\{!}1*!0

Tak jak poprzednio, cały kod jest wykonywany, a każdy bajt wpływa na wynik.

Drukuje 010dla wygodnych palindromów, w -100przeciwnym razie. Wypróbuj online!

Testy i przykłady

$ base64 > palindrome.gs -d <<< LjQ6YWItMTpiYT07MSViYSV7Li4uZmlAQD1jNDMuPTspKCciKFt7fV0pIid+P34nIihbe31dKSInKSg7PS4zNGM9QEBpZi4uLn0lYWIlMTs9YWI6MS1iYTo0Lg==
$ wc -c palindrome.gs
91 palindrome.gs
$ rev palindrome.gs | tr '([{}])' ')]}{[(' | diff - palindrome.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript palindrome.gs
-3-1-1
$ echo -n 'totallynotapalindrome' | golfscript palindrome.gs
-4-1-1
$
$ base64 > pal.gs -d <<< MCEqMXshfVw7Oik7MDpmOzA6aTstMTphYjs5OmJhOy4uLj07MSVhYiV7Li4uLmlAZkBAZmlAQD1ALj1AXCkrIiInIihbe31dKSInfis/K34nIihbe31dKSInIiIrKFxAPS5APUBAaWZAQGZAaS4uLi59JWJhJTE7PS4uLjthYjo5O2JhOjEtO2k6MDtmOjA7KDo7XHshfTEqITA=
$ wc -c pal.gs
155 pal.gs
$ rev pal.gs | tr '([{}])' ')]}{[(' | diff - pal.gs
$ echo -n 'r(a[c{"e"}c]a)r' | golfscript pal.gs
010
$ echo -n 'totallynotapalindrome' | golfscript pal.gs
-100
$ for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
> [ "$(echo -n 'r(a[c{"e"}c]a)r' | golfscript tmp.gs 2> /dev/null)" = "010" ] && echo $i
> done; rm tmp.gs
1
for i in {1..154}; do head -c $i pal.gs > tmp.gs; tail -c +$[i+2] pal.gs >> tmp.gs
>  [ "$(echo -n '42' | golfscript tmp.gs 2> /dev/null)" = "-100" ] && echo $i
> done | grep '^1$'; rm tmp.gs

Jak to działa

.             # Duplicate the input string.
4:ab-1:ba     # Save 4 in “ab” and -1 in “ba”.
=;            # Compare 4 to -1 and discard the result.
1%            # Save every element from the input string in a new string.
ab%           # Reverse the input string.
{             # For each character in the input string:
  ...         # Duplicate the character thrice.
  fi          # Variable “fi” is undefined; this does nothing.
  @@=         # Verify that the character is equal to itself; push 1.
  c43         # Variable “c43” is undefined; this does nothing.
  .=;         # Verify that 1 is equal to itself and discard the result.
  )(          # Increment and decrement the character.
  '"([{}])"'~ # Push that string and evaluate it. Result: '([{}])'
  ?           # Retrieve the character's position in '([{}])'. -1 means not found.
  ~           # Negate the position.. Examples: -1 -> 0    0 -> -1    2 -> -3
  '"([{}])"') # Push that string and pop its last element. Result: '"([{}])' 34
  (;          # Decrement 34 (the ASCII code of a double quote) and discard.
  =           # Retrieve the corresponding character.
  .34         # Duplicate the character and push 34.
  c           # Variable “c” is undefined; this does nothing.
  =           # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  ...         # Duplicate the new character thrice.
}%            #
ab%           # Save every fourth element in a new string to discard dummy values.
1;            # Push 1 and discard.
=             # Push 1 if the modified string matches the original, 0 otherwise.
ab:1-         # Save 4 in “1” and subtract.
ba:4.         # Save -1 in “4” and duplicate.

0!*           # Pop and push the input string.
1{!}\;:);     # Make “)” an alias for “!”.
0:f;0:i;      # Variables.
-1:ab;9:ba;   # Moar variables.
...=;         # Duplicate the input string.
1%ab%         # Reverse the copy.
{             # For each character in the input string:
  ....        # Duplicate the character four times.
  i@          # Push 0 and rotate a string copy on top of it.
  f@@fi@@     # Push 0 and rotate 0 on top of it.
  =@          # Push 1 and rotate a string copy on top of it.
  .=@         # Push 1 and rotate 1 on top of it.
  \)+         # Negate a 1 and add. Result: 1
  ""          # Push that string.
  '"([{}])"'  # Push that string.
   ~+         # Evaluate the second string and concatenate. Result: '([{}])'
   ?          # Retrieve the characters position in '([{}])'. -1 means not found.
   +~         # Add 1 to the position and negate. Ex.: -1 -> -1 | 0 -> -2 | 1 -> -3
  '"([{}])"'  # Push that string.
  ""          # Push that string.
  +           # Concatenate. Result: '"([{}])"' 
  (\          # Pop the first double quote and swap it with the rest of the string.
  @=.         # Retrieve the corresponding character and duplicate it.
  @=          # If the character is a double quote, the index was -1.
  @@if        # In that case, replace the double quote with the original character.
  @@          # Rotate the modified character to the bottom.
  f@i....     # Push dummy values.
  }%          #
  ba%         # Save every ninth element in a new string to discard dummy values.
  1;          # Push 1 and discard.
  =           # Push 1 if the modified string matches the original, 0 otherwise.
  ...;        # Duplicate thrice and discard the last copy.
  ab:9;ba:1-; # Variables.
  i:0;f:0;    # Moar variables.
  (:;\        # Negate, override “;” and swap.
  {!}1*!0     # Negate twice and push 0.

Ruby, 110

(z=gets;r=z.tr *["([{}])",")]}{[("];p *z==r.reverse;1)||(1;esrever.r==z* p;[")]}{[(","([{}])"]* rt.z=r;steg=z)

Drukuje, truejeśli wejście jest wygodnym palindromem, a falsejeśli nie jest. Zauważ, że to rozwiązanie zakłada, że ​​dane wejściowe nie są zakończone znakiem nowej linii, więc przetestuj je za pomocą echo -n:

echo -n '(a)(bb)(a)' | ruby convpal.rb
true

echo -n '(a)(bb()a(' | ruby convpal.rb
false

# note that for this to work, the file must not contain a newline
# to remove a trailing newline, pipe it through tr -d $'\n'
cat convpal.rb | ruby convpal.rb
true

Jest to dość prosty port mojej odpowiedzi na Palindromic Palindrome Checker (i do tej pory nie grał w golfa). Główna sztuczka polega na tym, że pierwsze wyrażenie w nawiasach zawsze zwraca 1, więc druga połowa wyrażenia boolowskiego nigdy nie jest oceniana (ale jest analizowana).

Jedyną trudnością w dostosowaniu tego było wymyślenie, jak dodać wywołanie, aby z.trjego „wygodny rewers” ​​był również poprawny pod względem składniowym - ale mógłbym po prostu użyć tej samej sztuczki, którą już użyłem,: *która w pierwszej połowie jest analizowana jako operator splat (użyj zawartości tablicy jako parametrów funkcji) i jako operatora mnożenia tablicy (lub powtarzania) w drugiej połowie.

Ruby, 157 297, cały kod wykonany

w=tsoh=gets p
o=rt=esrever=Gem
q=tsoh.tr *["([{}])",")]}{[("]
q==esrever.host=w=tsoh.reverse==q
[")]}{[(","([{}])"]* rt.host=q
meG=reverse=tr=o
p steg=host=w

Ta (nieco dłuższa) wersja wykonuje cały kod i wszystkie oprócz dwóch wierszy wpływają na wynik, który jest drukowany w ostatnim wierszu - ale wszystkie wiersze są analizowane i wykonywane bez błędów. Ta wersja interpretuje każdy końcowy echo -nznak nowej linii jako część danych wejściowych, więc użyj go, aby go przetestować, lub uzupełnij swój tekst znakiem nowej linii. Drukuje, truejeśli wejście jest wygodnym palindromem, i w falseprzeciwnym razie.

Wyjaśnienie

# Read the input by calling gets(nil), which is achieved by passing the return
# value of a call to Kernel#p (which returns nil if no argument is supplied) to
# gets.
w=tsoh=gets p
# Assign the global Gem module to three variables.
# The variable names are the reversed names of methods we have to call later.
# This doesn't necessarily have to be the Gem module, any global module/variable
# (or class that allows object creation through a call to the module itself,
# e.g. Hash or GC) with a writable property would do, but Gem#host was
# the shortest one I could find. This is necessary because Ruby doesn't
# allow setting previously undefined properties through the dot syntax.
o=rt=esrever=Gem
# Replace the parentheses with the corresponding flipped one.
# sserts is the reverse of the property name we're going to use later.
q=tsoh.tr *["([{}])",")]}{[("]
# Do the convinient palindrome check and assign its result to a few variables
# and Gem's host property.
q==esrever.host=w=tsoh.reverse==q
# Here, the * is parsed as array join operator.
[")]}{[(","([{}])"]* rt.host=q
# Nothing special here.
meG=reverse=tr=o
# Print the result of the palindrome check, which was stored in w.
p steg=host=w

GolfScript, 61 znaków

OK, oto podstawowe rozwiązanie w GolfScript. Jestem pewien, że można to jeszcze poprawić:

{.-1%{"([{}])".2$?~@[.]@+=}%=}~{=%{=+@[.]@~?$2."([{}])"}%1-.}

Jak zwykle dla GolfScript, ten program odczytuje dane wejściowe ze standardowego wejścia. Wyprowadza:

1{=%{=+@[.]@~?$2."([{}])"}%1-.}

jeśli dane wejściowe to wygodny palindrom, jak zdefiniowano w powyższym wyzwaniu, i:

0{=%{=+@[.]@~?$2."([{}])"}%1-.}

Jeżeli nie jest.

Objaśnienie: Ten program w dużej mierze opiera się na stwierdzeniu, że niewykonywany kod jest OK, o ile jest analizowany. Składa się z dwóch bloków kodu, ograniczonych nawiasami klamrowymi ( { }), które są lustrzanymi odbiciami.

Pierwszy blok kodu jest wykonywany ~po nim i sprawdza, czy dane wejściowe są wygodnym palindromem, wyświetlając 1je, jeśli tak jest, a 0jeśli nie. Drugi blok kodu nie jest wykonywany, a więc po prostu pozostaje na stosie, dopóki program się nie skończy, a wszystko na stosie zostanie automatycznie oznaczone i wydrukowane przez interpreter GolfScript.

Należy zauważyć, że interpreter GolfScript wykonuje bardzo niewiele kontroli składni w czasie analizy (lub kiedykolwiek, jeśli o to chodzi); literał bloku kodu GolfScript może zawierać prawie wszystko, nawet jeśli może ulec awarii podczas wykonywania. Mimo to kilka błędów składniowych, takich jak nieokreślone literały łańcuchowe, powoduje błąd nawet w niewykonywanym kodzie, więc uważam, że to rozwiązanie (ledwo) mieści się w zakresie reguł.

Ps. Patrząc na faktycznie wykonany kod, zawiera kilka dogodnych elementów palindromicznych, takich jak @[.]@literał ciągu "([{}])", a nawet pętla %{ ... }%. Daje to kuszącą sugestię, że „wewnętrznie palindromiczne” rozwiązanie GolfScript, w którym pełny program palindromiczny zostałby wykonany i działał, może być faktycznie możliwe. Ponieważ nie udało mi się jeszcze go wyprodukować, niniejszym oferuję premię +100 powtórzeń pierwszej osobie, która zdoła ją wymyślić!

JavaScript (ES6), 245 bajtów

Chciałem odpowiedzi JS, którą można uruchomić w przeglądarce, więc oto jest.

eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true

Usuwając cały kod, który nigdy nie jest uruchomiony, otrzymujemy:

eurt=>eurt==(("",eurt))["split"||"nioj"]("")["map"||"esrever"](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x)["reverse"||"pam"]("")["join"||"tilps"]((true,""))==true>=true
eurt=>eurt==(("",eurt))["split"        ]("")["map"           ](x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x                                                           )["reverse"       ]("")["join"         ]((true,""))==true>=true

Co można uprościć do tego:

eurt=>eurt==eurt.split("").map(x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x).reverse("").join("")

JavaScript (ES6) 288

Działa w powłoce wiersza poleceń Spidermonkey . Odczytuje pojedynczy wiersz ze STDIN i wyjścia truelub w falsezależności od tego, czy wejście jest wygodnym palindromem.

((print)((eval)('r=readline()')==([0]['map']['call'](r,x=>({'{':'}','}':'{','[':']',']':'[','(':')',')':'('})[x]||x)['reverse']()['join']('')))&&((('')['nioj']()['esrever'](x||[x]({')':'(','(':')',']':'[','[':']','}':'{','{':'}'})>=x,r)['llac']['pam'][0])==('()enildaer=r')(lave))(tnirp))

Ten kod jest poprawny pod względem składniowym, ale wszystko po nim &&nie jest wykonywane, ponieważ printfunkcja zwraca wartość falsey.

Możesz uruchomić ten kod w konsoli Firefox, uruchamiając najpierw ten podkładka, aby emulować funkcje readlinei print. Edytuj dane wejściowe w readlinerazie potrzeby:

readline = function(){ 
    return "void main(int argc, *char[] argv) {} (vgra []rahc* ,cgra tni)niam diov"; 
}, print = console.log.bind(console);

A oto krótki przykład wyniku:

05AB1E, 35 bajtów

"{[()]}"DRr‡`rJ¹Q,Q¹Jr`‡rRD"{[()]}"

Wypróbuj online!

Wyjaśnienie:

                     # Implicit input
 "{[()]}"            # Push "{[()]}" onto the stack
         DR          # Pushes a reversed copy onto the stack
           r         # Reverse the order of the stack
            ‡        # Transliterate
             `       # Flatten array on stack
              r      # Reverse order of stack
               J     # Join stack
                ¹Q   # Check equality with first input
                  ,  # Print
                     # Everything after is still syntactically correct, but just does not print anything.

CJam, 38 bajtów

Q~"=re%W_@%W_q"`{[()]}`"q_W%@_W%er="~Q

Drukuje, "=re%W_@%W_q"1jeśli dane wejściowe są wygodnie palindromiczne i w "=re%W_@%W_q"0inny sposób.

Wypróbuj online w interpretatorze CJam .

Jak to działa

Q~                                     e# Evaluate an empty string.
  "=re%W_@%W_q"                        e# Push that string.
               `                       e# Inspect. Pushes "\"=re%W_@%W_q\"".
                {[()]}                 e# Push that block.
                      `                e# Inspect. Pushes "{[()]}".
                       "           "~  e# Push and evaluate.
                        q              e# Read from STDIN.
                         _W%           e# Push a reversed copy.
                            @          e# Rotate "{[()]}" on top of the stack.
                             _W%       e# Push a reversed copy.
                                er     e# Perform transliteration.
                                  =    e# Compare to the input string.
                                     Q e# Push an empty string.

Po uruchomieniu programu CJam automatycznie drukuje wszystkie trzy elementy na stosie: sprawdzony ciąg, wartość logiczną z porównania ciągów i pusty ciąg.

Perl, 83 + 2 = 85 bajtów

Biegnij z -nl

say$_~~reverse y-"({[]})"-")}][{("-r;exit;tixe;r-")}][{("-"({[]})"-y esrever~~_$yas

Kod kończy działanie po wydrukowaniu prawdziwości danych wejściowych. Wszystko po średniku jest interpretowane (i ulega awarii, gdy skrypt osiągnie ten punkt, gdyby nie exitnapotkane), ale nie jest wykonywane. Gdybym pominął exit;tixe;kod, nadal drukowałby wynik poprawnie, zanim się zawiesił.