Как написать палиндром

специально для gwean и mym_kak_mym
Лена набила рожу мужу — муж орал и банан ел. (Михаил Фельдман)

1. Допустим, что исходное слово при построении палиндрома Лена.

2. Запишем его дважды одно под другим в две строки:

         Лена

         Лена

3. Первую строчку прочитаем как обычно — слева направо: Лена, а вторую в обратном порядке — справа налево (бустрофедон, «ходом быка», как читали древние греки): анел.

4. Соберем все в одно целое, читая теперь уже только слева направо в одну строчку: Лена … анел.

5. Если левая часть (аверс) — исходное слово — была осмысленна изначально: Лена, то правая (реверс) получилась явно бессмысленной: анел.

6. Попробуем выделить в реверсе осмысленные слова («материализовать» слова): -ан [ел].

7. Сборка: Лена … — ан ел.

8. Согласовывая Субъект Лена и Предикат ел — получим: Лена … ел(а).

9. Соответственно согласованная флексия -а симметрично породит союз А в начале Предложения в общем случае: А Лена … -ан ел(а), или слово, начинающееся на А-, если повезет: Алена … -ан ел(а)

10. Если исходить из семантической матрицы Предложения SVO: Субъект Предикат(глагол) Объект, то здесь заполнены только 2 места — SV, а место Объекта (Лена ела Что?) свободно.

11. Материализуем Объект: А Лена … БАНан ел(а).

12. Тогда слева возникает паразитный морф НАБ-.

13. В нем сразу же материализуется [НА] = 1) предлог на или 2) префикс на-.

14. Далее возникает альтернатива: 1) остаться в пределах одного простого Предложения SVO, выбрав предлог на, задающий косвенный падеж периферийного участника, что-то типа А Лена НА БОКУ/ БАЗАРЕ /БИДЕ … БАНан ела (Ср.: А Лена на боку, суко!, банан ела!) или 2) выбрав префикс на-, ввести новый Предикат и тем самым перейти к сложному Предложению  SVO1- SVO2 или  хотя бы причастному обороту SVO1,VO2 (Ср.: А Лена, набрав чвар, банан ела!).

15. Если выбран второй Предикат наб-, первоначальное Предложение разрушается и возникает 2 новых: А Лена НАБИЛА … -АЛ И БАНан ел(а) с незаполненными ячейками семантической матрицы: SV?1… ?OV2.

16. Что же такое набила Лена? Первое, что приходит в голову — идиома Набила морду! (Ср.: Лена, набила рот — оря, рот орал — и банан ел!).

17. Поскольку ничего путного при обратном чтении не материализуется, попробуем синоним морду=рожу: Набила рожу!

18. Сборка: А Лена набила рожу… уж орал и банан ел(а).

19. Поскольку явно намечаются однородные предикаты орал и ел в левой части, проведем рассогласование — уберем флексию -а и соответственно уйдет союз А слева: Лена набила рожу… уж орал и банан ел.

20. В первом Предложении не хватает только Адресата (набила рожу Кому?). Если Субъектом второго Предложения считать ужа, то конечно — ужу! Тем более что это просто пробка в дырке челюстно-лицевого палиндрома.

21. Сборка: Лена набила рожу ужу, уж орал и банан ел.

22. Но тут есть противоречие: рожа — неприятное лицо, а лицо только у человека, а у ужа — морда, да и орать он может только чисто метонимически-метафорически (издавал звук), скорее — шипел, и не факт еще, что ужи питаются бананами! Да и как можно набить маленькую мордочку ужа,  да и чем? Тут налицо разные семантические миры!

23. Слава богу, что центр палиндрома можно заполнить добавлением одной согласной (материализовать слово Муж), и соответственно Адресатом будет Мужу, что сразу же исправляет семантический мир: у мужа и [жена] Лена, и рожа, которую легко набить, так, что он будет орать, да и банан — вполне его еда.

24. Сборка: Лена набила рожу мужу, муж орал — и банан ел.

25. А полная семантическая экспликация: [Жена] Лена набила рожу [своему]  мужу, [в результате чего] муж орал — и [потом] банан ел.

26. Если отключиться от конкретики, то в Предложении кроме Субъект-Предикат-Объектных отношений выражаются отношения Родства, Принадлежности, Причины-Следствия, Следования.

27. Т.о. вырисовываются семантические приемы построения палиндрома: бустрофедон, сборка, материализация слова, согласование, рассогласование, заполнение семантической матрицы простого предложения SVO, преобразование одной группы  SVO простого предложения в несколько групп SVO1,  SVO2 и т.д. сложного предложения, идиомы, синонимы, однородные члены, поиск периферийных участников при заполненной матрице SVO, однородный семантический мир, образность.

28. Но м.б. есть смысл идти от предикатов (глаголов)? Если здесь идти от фразы: набила рожу мужу, или хотя бы устойчивой синтагмы набила рожу, то это автоматически породит всю фразу: 1) набила рожу …; 2) набила рожу … Муж орал и бан-; 3) ЛЕНА набила рожу … Муж орал и банАН ЕЛ; 4) Лена набила рожу МУЖУ муж орал и банан ел.

vector<int> pal_array(string s) {
    int n = s.size();

    // окружим строку спецсимволами, чтобы не рассматривать выход за границы
    s = "#" + s + "$";

    // в этом массиве будем хранить расстояние от центра до границы палиндрома
    vector<int> t(n, 0);

    for(int i = 1; i <= n; i++)
        while (s[i - t[i - 1]] == s[i + t[i - 1]])
            r[i-1]++;

    return r;
}

vector<int> manacher_odd(string s) {
    int n = (int) s.size();
    vector<int> d(n, 1);
    int l = 0, r = 0;
    for (int i = 1; i < n; i++) {
        if (i < r)
            d[i] = min(r - i + 1, d[l + r - i]);
        while (i - d[i] >= 0 && i + d[i] < n && s[i - d[i]] == s[i + d[i]])
            d[i]++;
        if (i + d[i] - 1 > r)
            l = i - d[i] + 1, r = i + d[i] - 1;
    }
    return d;
}

vector<int> manacher_even(string s) {
    int n = (int) s.size();
    vector<int> d(n, 0);
    int l = -1, r = -1;
    for (int i = 0; i < n - 1; i++) {
        if (i < r)
            d[i] = min(r - i, d[l + r - i - 1]);
        while (i - d[i] >= 0 && i + d[i] + 1 < n && s[i - d[i]] == s[i + d[i] + 1])
            d[i]++;
        if (i + d[i] > r)
            l = i - d[i] + 1, r = i + d[i];
    }
    return d;
}

const int maxn = 1e5, k = 26;

int s[maxn], len[maxn], link[maxn], to[maxn][k];

int n, last, sz;

void init() {
    s[n++] = -1;
    link[0] = 1;
    len[1] = -1;
    sz = 2;
}

int get_link(int v) {
    while (s[n-len[v]-2] != s[n-1])
        v = link[v];
    return v;
}

void add_char(int c) {
    s[n++] = c;
    last = get_link(last);
    if (!to[last][c]) {
        len[sz] = len[last] + 2;
        link[sz] = to[get_link(link[last])][c];
        to[last][c] = sz++;
    }
    last = to[last][c];
}

The most important thing to do when solving a Technical Test is Don’t use shortcut methods — they want to see how you think algorithmically! Not your use of methods.

Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume false and alter the logic if its looking to be true.

isPalindrome():

Basically, to make this run in O(N) (linear) complexity you want to have 2 iterators whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to break/return once they meet in the middle, but it may save some work to only give each iterator a half-length by default.

for loops seem to force the use of more checks, so I used while loops — which I’m less comfortable with.

Here’s the code:

/**
 * TODO: If func counts out, let it return 0
 *  * Assume !isPalindrome (invert logic)
 */
function isPalindrome(S){
    var s = S
      , len = s.length
      , mid = len/2;
      , i = 0, j = len-1;

    while(i<mid){
        var l = s.charAt(i);
        while(j>=mid){
            var r = s.charAt(j);
            if(l === r){
                console.log('@while *', i, l, '...', j, r);
                --j;
                break;
            }
            console.log('@while !', i, l, '...', j, r);
            return 0;
        }
        ++i;
    }
    return 1;
}

var nooe = solution('neveroddoreven');  // even char length
var kayak = solution('kayak');  // odd char length
var kayaks = solution('kayaks');

console.log('@isPalindrome', nooe, kayak, kayaks);

Notice that if the loops count out, it returns true. All the logic should be inverted so that it by default returns false. I also used one short cut method String.prototype.charAt(n), but I felt OK with this as every language natively supports this method.

The most important thing to do when solving a Technical Test is Don’t use shortcut methods — they want to see how you think algorithmically! Not your use of methods.

Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume false and alter the logic if its looking to be true.

isPalindrome():

Basically, to make this run in O(N) (linear) complexity you want to have 2 iterators whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to break/return once they meet in the middle, but it may save some work to only give each iterator a half-length by default.

for loops seem to force the use of more checks, so I used while loops — which I’m less comfortable with.

Here’s the code:

/**
 * TODO: If func counts out, let it return 0
 *  * Assume !isPalindrome (invert logic)
 */
function isPalindrome(S){
    var s = S
      , len = s.length
      , mid = len/2;
      , i = 0, j = len-1;

    while(i<mid){
        var l = s.charAt(i);
        while(j>=mid){
            var r = s.charAt(j);
            if(l === r){
                console.log('@while *', i, l, '...', j, r);
                --j;
                break;
            }
            console.log('@while !', i, l, '...', j, r);
            return 0;
        }
        ++i;
    }
    return 1;
}

var nooe = solution('neveroddoreven');  // even char length
var kayak = solution('kayak');  // odd char length
var kayaks = solution('kayaks');

console.log('@isPalindrome', nooe, kayak, kayaks);

Notice that if the loops count out, it returns true. All the logic should be inverted so that it by default returns false. I also used one short cut method String.prototype.charAt(n), but I felt OK with this as every language natively supports this method.

Время на прочтение
9 мин

Количество просмотров 7.4K

Поздравляю всех трансляторов человеческого языка в машинный с их профессиональным днем, желаю вам меньше багов и больше-либо-равно классных идей! А в качестве идейного подарка со своей стороны предлагаю решение одной красивой задачи — написание кода, который на выходе выдаёт свой собственный текст, является валидным для интерпретаторов и компиляторов разных языков, и при этом правильно исполняется при реверсе исходников.

Не так давно я узнал о коде, который может одновременно интерпретироваться в PHP и компилироваться в Java: PhpJava.java. Как оказалось, эта идея не нова: код, валидный сразу для нескольких компиляторов или интерпретаторов, называется полиглотом (polyglot). Такой код возможно писать из-за особенностей обработки строк и комментариев в различных интерпретаторах или компиляторах.

Например, в Java можно описывать символы как в обычном виде, например символ ‘/’, так и в виде юникод-записи: ‘u002F’. В компиляторе C# такие записи не будут валидными. Однако если их «спрятать» в комментарий, то, с одной стороны, они не будут мешать при компиляции C# кода, с другой — будут валидными в Java-коде. Например, если нужно, чтобы код A компилировался только в языке C#, но не компилировался в Java, а код B компилировался только в Java, но не компилировался в C#, нужно использовать следующий фрагмент:

//u000Au002Fu002A
A//u002Au002FB

C#-компилятор будет «воспринимать» этот код обычным образом, комментарии останутся комментариями:

//u000Au002Fu002A
A//u002Au002FB

А вот с Java все интересней, т.к. юникод-запись трасформируется и получится следующее:

//
/*
A//*/B

Комбинируя общие для обоих языков инструкции, а также разделяя различные, можно написать любую программу.

Однако такими юникод-записями трюки не ограничиваются. Например, в C-подобных языках существуют директивы препроцессора, которые могут определять, какой код должен компилироваться, а какой нет. В некомпилируемый код можно помещать код совсем другого языка. Например, ниже приведен код-полиглот на C++ и Python (отсюда), в котором в секции #if false как раз и помещен код Python. А последовательности ''' начинают и заканчивают комментарий в коде Python.

#include <stdio.h>
#if false
print "Hello world"
'''
#endif
int main() {
printf("Hello world");
return 0;
}
#if false
'''
#endif

В HTML, например, комментарии начинаются с последовательности символов <!--, что также можно использовать. Есть и более сложные полиглоты, работающие одновременно на 6 и на 16 языках. Первый выводит сообщение «hitforum» для всех языков, а второй работает интересней: выводит название языка, на котором происходит его компиляция или интерпретация.

Код-полиглот на C, Shell, Perl, Brainfuck, Befunge, Whitespace

# define x u    /*            v
#    :::::::::::::::::::>>>>>>>$$$a"muroftih"#[>:#,_@]
eval 'echo "hitforum";exit';sub echo { print    "@_n"}               
__END__>++++++++++>++++++++++[>+++++++++++>++++++++++    
+<<-]>------.+.>++++++.<---.+++++++++.>--.+++                        
.<--.<<.    */
main() { printf ("hitforumn"); }

# /* [  <!-- */ include <stdio.h> /*    
    #`{{coding=utf-8
"true" if 0 != 0 and    q != """0"  ;   `   
    
if [ -n "$ZSH_VERSION" ]; then                  
    
    echo exec   echo I'm a zsh script.; 
    
elif [ -n "$BASH_VERSION" ]; then               
    
    echo exec   echo I'm a bash script.; 
else    
    echo exec   echo    I'm    a sh    script.;        
fi`;    #!;#
BEGIN{print"I'm a ", 0 ? "Ruby" :"Perl",    " program.n";  exit; }  
    #
%q~                     

set =dummy 0; puts [list "I'm"  "a" "tcl"   "script."]; exit      

all: ; @echo "I'm a Makefile."              
    #*/
/*: */ enum {a, b};                     
    
static int c99(void) {                  

 #ifndef __cplusplus /* bah */              

unused1: if ((enum {b, a})0)                
    (void)0;
 #endif                 

unused2:    return a;        
}   
static int trigraphs(void) {                
    
    return sizeof   "??!"   ==  2;       
}   
char X;                         
    
int main(void) {                    
    
    struct X    {            
    
        char    a[2];       
    };
    if (sizeof(X)   !=  1) {            
    
printf("I'm a C++ program (trigraphs %sabled).n",               
    
     trigraphs()    ? "en"  : "dis");
    
}else if (1//**/2

)unused3 : { ; 
        printf("I'm a C program (C%s, trigraphs %sabled).n", 
               c99() ? "89 with // comments" : "99", 
               trigraphs() ? "en" : "dis"); 
    } else { 
        printf("I'm a C program (C89, trigraphs %sabled).n", 
               trigraphs() ? "en" : "dis"); 
    } 
    return 0; 
} /*
 # 
begin{code}
import Prelude hiding ((:)); import Data.List (intercalate); import Language.Haskell.TH; import Data.String; default (S, String, Integer, Double); data S = S; instance Eq S where { _ == _ = False }; instance IsString S where { fromString = const S }; ifThenElse c t e = case c of True -> t; False -> e
cPP = False; {-
#define cPP True
-} main :: IO ()
main = putStr ("I'm a Literate Haskell program" ++ bonus ++ ".n") where
  _ = (); bonus | null details = "" | otherwise = " (" ++ details ++ ")"
  details = intercalate ", " [ name | (True, name) <- extensions ] :: String
  extensions =
    (bangPatterns,              "BangPatterns"             ) :
    (templateHaskell,           "TemplateHaskell"          ) :
    (rebindableSyntax,          "RebindableSyntax"         ) :
    (magicHash,                 "MagicHash"                ) :
    (overloadedStrings,         "OverloadedStrings"        ) :
    (noMonomorphismRestriction, "NoMonomorphismRestriction") :
    (scopedTypeVariables,       "ScopedTypeVariables"      ) :
    (cPP,                       "CPP"                      ) :
    (unicodeSyntax,             "UnicodeSyntax"            ) :
    (negativeLiterals,          "NegativeLiterals"         ) :
    (binaryLiterals,            "BinaryLiterals"           ) :
    (numDecimals,               "NumDecimals"              ) : []
  (!) = (!!)
  bangPatterns = [True] ! 0 where foo !bar = False
  templateHaskell = thc $(return (TupE []) :: ExpQ)
  rebindableSyntax = null (do { [()]; [()] })
    where _ >> _ = [] :: [()]
  magicHash = foo# () where
    foo = ['.']; "." # _  = False; foo# _ = True
  overloadedStrings = "" /= ""
  noMonomorphismRestriction = show foo == "0" where
    foo = 0
    bar = foo :: Double
  unicodeSyntax = let (★) = True in (*) where
    (*) = False
  negativeLiterals = -1 == NNa
  binaryLiterals = let b1 = 1 in 0b1 == 1
  numDecimals = show 0e0 == "0"
  scopedTypeVariables = stv (0 :: Double) == "0.0"
data{- = -} NN = NNa | NNb deriving Eq; instance Num NN where { fromInteger _ = NNa; negate _ = NNb; _ + _ = NNa; _ * _ = NNa; abs _ = NNa; signum _ = NNa }
instance{- = -} (Num a) => Num (e -> a) where { fromInteger = const . fromInteger; negate = (.) negate; abs = (.) abs; signum = (.) signum; x + y = e -> x e + y e; x * y = e -> x e * y e }
class THC a where { thc :: a -> Bool }; instance THC () where { thc _ = True }; instance THC (Q a) where { thc _ = False }; class (Show a, Num a) => STV a where
  stv :: a -> String
  stv = const $ show (f 0) where
    f = id :: a -> a
instance STV Double -- : 
end{code}

 # 
]>++++++++[<+++++++++>-]<+.>>++++[<++++++++++>-]<-.[-]>++++++++++ 
[<+++++++++++>-]<-.>>++++[<++++++++>-]<.>>++++++++++[<++++++++++> 
-]<- - -.<.>+.->>++++++++++[<+++++++++++>-]<++++.<.>>>++++++++++[ 
<++++++++++>-]<+++++.<<<<+.->>>>- - -.<+++.- - -<++.- ->>>>>+++++ 
+++++[<+++++++++++>-]<- - -.<<<<<.<+++.>>>.<<<-.- ->>>>+.<.<.<<.> 
++++++++++++++.[-]++++++++++""" else 0
 # 
from platform import * # 
print("I'm a Python program (%s %s)." % # [-][ 
(python_implementation(), python_version())); """--><html><head>
<!--:--><title>I'm a HTML page</title></head><body>
<!--:--><h1>I'm a <marquee><blink>horrible HTML</blink></marquee> page</h1>
<!--:--><script language="JavaScript">
<!--: # 
setTimeout( // 
   function () { // 
      document.body.innerHTML = "<h1>I'm a javascript-generated HTML page</h1>"; // 
   }, 10000); // 
//-->
</script><!--: 
</body></html><!-- }} # 
say "I'm a Perl6 program."; # """ # */
 #define FOO ]-->~

Квайн-полиглот

Для того чтобы написать квайн-полиглот на языках C# и Java, необходимо совместить принципы разработки квайна и полиглота. Как оказалось, и такая тема не нова: на сайте codegolf пользователи соревнуются, у кого квайн-полиглот или поликвайн получится короче: Write a Polyquine. Однако в этом вопросе не было вариантов с более многословными языками C# и Java, что мне и захотелось исправить.

Для написания такого квайна-полиглота нужно экранировать символы, запрещенные в строках обоих языков и встречающиеся в строках самой программы. Такими символами являются кавычки «, перенос строки n и обратный слеш . А чтобы еще уменьшить размер кода, повторяющиеся последовательности символов, такие как u000A, u002F и u002A, также были заменены на одиночные символы в самой кодирующей строке. Вот пример получившегося квайна-полиглота, валидного для компиляторов C# и Java:

PolyglotQuine.cs.java, 757 символов:

//u000Au002Fu002A
using System;//u002Au002F
class Program{public static void//u000Au002Fu002A
Main//u002Au002Fmain
(String[]z){String s="//@#'^using System;//'#^class Program{public static void//@#'^Main//'#main^(String[]z){String s=!$!,t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&'!,s};for(int i=0;i<7;i++)t=t.//@#'^Replace//'#replace^(!!+(char)a[i],b[i]);//@#'^Console.Write//'#System.out.printf^(t);}}",t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{""","n","\","\u000A","\u002F","\u002A",s};for(int i=0;i<7;i++)t=t.//u000Au002Fu002A
Replace//u002Au002Freplace
(""+(char)a[i],b[i]);//u000Au002Fu002A
Console.Write//u002Au002FSystem.out.printf
(t);}}

Квайн-полиглот-палиндром

Еще больше усложним задачу: попробуем написать квайн-полиглот-палиндром. Напомню, что палиндром — это число или текст, одинаково читающиеся в обоих направлениях. Принцип разработки квайнов-палиндромов я описывал в статье 3 года назад, тоже в день программиста. Принцип кода-палиндрома заключается в том, что зеркальная часть программы помещается в однострочный или многострочный комментарий, что не мешает при компиляции. Простейший код-палиндром в C# выглядит следующим образом:

/**/class P{static void Main(){}};/*/;}}{)(niaM diov citats{P ssalc/**/

Как видим, многострочный комментарий /* начинается с середины и продолжается до конца, где и закрывается последовательностью */. Пустой комментарий в начале нужен для того, чтобы строка полностью стала симметричной.

Итак, объединяя принципы создания палиндрома, полиглота и квайна, я написал следующий код:

PalidromePolyglotQuine.cs.java, 1747 символов:

/**///u000Au002Fu002A
using System;//u002Au002F
class Program{public static void//u000Au002Fu002A
Main//u002Au002Fmain
(String[]z){String s="`**?`@#_^using System;?_#^class Program{public static void?@#_^Main?_#main^(String[]z){String s=!$!,t=s;int i;int[]a=new int[]{33,94,38,64,35,95,96,63,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&_!,!`!,!?!,s};for(i=0;i<9;i++)t=t.?@#_^Replace?_#replace^(!!+(char)a[i],b[i]);t+='*';for(i=872;i>=0;i--)t=t+t?@#_^[i];Console.Write?_#.charAt(i);System.out.printf^(t);}}/",t=s;int i;int[]a=new int[]{33,94,38,64,35,95,96,63,36};String[]b=new String[]{""","n","\","\u000A","\u002F","\u002A","/","//",s};for(i=0;i<9;i++)t=t.//u000Au002Fu002A
Replace//u002Au002Freplace
(""+(char)a[i],b[i]);t+='*';for(i=872;i>=0;i--)t=t+t//u000Au002Fu002A
[i];Console.Write//u002Au002F.charAt(i);System.out.printf
(t);}}/*/}};)t(
ftnirp.tuo.metsyS;)i(tArahc.F200uA200u//etirW.elosnoC;]i[
A200uF200uA000u//t+t=t)--i;0=>i;278=i(rof;'*'=+t;)]i[b,]i[a)rahc(+""(
ecalperF200uA200u//ecalpeR
A200uF200uA000u//.t=t)++i;9<i;0=i(rof;}s,"//","/","A200u\","F200u\","A000u\","\","n","""{][gnirtS wen=b][gnirtS;}63,36,69,59,53,46,83,49,33{][tni wen=a][tni;i tni;s=t,"/}};)t(^ftnirp.tuo.metsyS;)i(tArahc.#_?etirW.elosnoC;]i[^_#@?t+t=t)--i;0=>i;278=i(rof;'*'=+t;)]i[b,]i[a)rahc(+!!(^ecalper#_?ecalpeR^_#@?.t=t)++i;9<i;0=i(rof;}s,!?!,!`!,!_&!,!#&!,!@&!,!&&!,!n&!,!!&!{][gnirtS wen=b][gnirtS;}63,36,69,59,53,46,83,49,33{][tni wen=a][tni;i tni;s=t,!$!=s gnirtS{)z][gnirtS(^niam#_?niaM^_#@?diov citats cilbup{margorP ssalc^#_?;metsyS gnisu^_#@`?**`"=s gnirtS{)z][gnirtS(
niamF200uA200u//niaM
A200uF200uA000u//diov citats cilbup{margorP ssalc
F200uA200u//;metsyS gnisu
A200uF200uA000u///**/

К сожалению, монстр получился слишком большим (1747 символов), однако это объясняется длинными цепочками юникод-символов и многословностью языков C# и Java. Уверен, что на других языках можно будет написать квайн-палиндром-полиглот гораздо меньшего размера.

Теперь проверим, как эта программа исполняется. Для начала избавимся от всех комментариев и правильно отформатируем код:

using System;
class Program
{
    public static void Main(String[] z)
    {
        String s = "`**?`@#_^using System;?_#^class Program{public static void?@#_^Main?_#main^(String[]z){String s=!$!,t=s;int i;int[]a=new int[]{33,94,38,64,35,95,96,63,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&_!,!`!,!?!,s};for(i=0;i<9;i++)t=t.?@#_^Replace?_#replace^(!!+(char)a[i],b[i]);t+='*';for(i=872;i>=0;i--)t=t+t?@#_^[i];Console.Write?_#.charAt(i);System.out.printf^(t);}}/",
            t = s;
        int i;
        int[] a = new int[] { 33, 94, 38, 64, 35, 95, 96, 63, 36 };
        String[] b = new String[] { """, "n", "\", "\u000A", "\u002F", "\u002A", "/", "//", s };
        for (i = 0; i < 9; i++)
            t = t.Replace("" + (char)a[i], b[i]);
        t += '*';
        for (i = 872; i >= 0; i--)
            t = t + t[i];
        Console.Write(t);
    }
}

Из листинга становится понятно, что переменная s содержит код программы, в котором экранированы запрещенные в строках символы и сжаты повторяющиеся последовательности. Ниже представлена таблица символов в формате код — символ — замена, которая используется для формирования выводимой строки t.

На следующем этапе происходит конкатенация строки t с ней же, инвертированной для того, чтобы на выходе получился палиндром. Стоит отметить, что число 872 (длина строки t) необходимо просчитывать после того, как квайн уже был написан. А для этого необходимо запускать уже написанный код, что также представляет определенные сложности.

Главным критерием при написании такого кода было достижение наименьшего размера в текстовом виде, а не его чистота. Поэтому, понятное дело, выглядит он несколько странно.

Как видим, ничего сложного в написании таких квайнов нет. Для тех, кто не верит, что это все действительно работает, были написаны тесты в репозитории Freaky-Sources (для запуска требуется, чтобы Java была установлена).

Кидайте в комментарии ваши квайнды-палиндромы-полиглоты на других языках и другие интересные кодофричные вещи, с удовольствием их изучу.

Еще раз поздравляю всех программистов и сочувствующих!