Программа, которая печатает зеркальные изображения самого себя


10

Напишите программу, которая производит зеркальные отображения себя. Примером может служить фантастический верблюжий код, который читает собственный код и создает две меньшие версии 2x2. Учитывая вход:

                                           $_='ev
                                       al("seek\040D
           ATA,0,                  0;");foreach(1..3)
       {<DATA>;}my               @camel1hump;my$camel;
  my$Camel  ;while(             <DATA>){$_=sprintf("%-6
9s",$_);my@dromedary           1=split(//);if(defined($
_=<DATA>)){@camel1hum        p=split(//);}while(@dromeda
 ry1){my$camel1hump=0      ;my$CAMEL=3;if(defined($_=shif
        t(@dromedary1    ))&&/\S/){$camel1hump+=1<<$CAMEL;}
       $CAMEL--;if(d   efined($_=shift(@dromedary1))&&/\S/){
      $camel1hump+=1  <<$CAMEL;}$CAMEL--;if(defined($_=shift(
     @camel1hump))&&/\S/){$camel1hump+=1<<$CAMEL;}$CAMEL--;if(
     defined($_=shift(@camel1hump))&&/\S/){$camel1hump+=1<<$CAME
     L;;}$camel.=(split(//,"\040..m`{/J\047\134}L^7FX"))[$camel1h
      ump];}$camel.="\n";}@camel1hump=split(/\n/,$camel);foreach(@
      camel1hump){chomp;$Camel=$_;y/LJF7\173\175`\047/\061\062\063\
      064\065\066\067\070/;y/12345678/JL7F\175\173\047`/;$_=reverse;
       print"$_\040$Camel\n";}foreach(@camel1hump){chomp;$Camel=$_;y
        /LJF7\173\175`\047/12345678/;y/12345678/JL7F\175\173\0 47`/;
         $_=reverse;print"\040$_$Camel\n";}';;s/\s*//g;;eval;   eval
           ("seek\040DATA,0,0;");undef$/;$_=<DATA>;s/\s*//g;(   );;s
             ;^.*_;;;map{eval"print\"$_\"";}/.{4}/g; __DATA__   \124
               \1   50\145\040\165\163\145\040\157\1 46\040\1  41\0
                    40\143\141  \155\145\1 54\040\1   51\155\  141
                    \147\145\0  40\151\156 \040\141    \163\16 3\
                     157\143\   151\141\16  4\151\1     57\156
                     \040\167  \151\164\1   50\040\      120\1
                     45\162\   154\040\15    1\163\      040\14
                     1\040\1   64\162\1      41\144       \145\
                     155\14    1\162\       153\04        0\157
                      \146\     040\11     7\047\         122\1
                      45\15      1\154\1  54\171          \040
                      \046\         012\101\16            3\16
                      3\15           7\143\15             1\14
                      1\16            4\145\163           \054
                     \040            \111\156\14         3\056
                    \040\         125\163\145\14         4\040\
                    167\1        51\164\1  50\0         40\160\
                  145\162                              \155\151
                \163\163                                \151\1
              57\156\056

он производит:

        JXXXXXXXXL.       JXXLm.       .mJXXL       .JXXXXXXXXL
       {XXXXXXXXXXX.     JXXXmXXXXm mXXXXmXXXL     .XXXXXXXXXXX}
      .XXXXXXXXXXXXXL.  {XXXXXXXXXF 7XXXXXXXXX}  .JXXXXXXXXXXXXX.
     JXXXXXXXXXXXXXXXXL.`XXXXXX.       .XXXXXX'.JXXXXXXXXXXXXXXXXL
    JXXXXXXXXXXXXXXXXXXXmXXXXXXX.     .XXXXXXXmXXXXXXXXXXXXXXXXXXXL
  .XXXXXXXXXXXXXXXXXXXXXXXXXXXXX}     {XXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX       XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXF       7XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 XX'7XXXXXXXXXXXXXXXXXXXXXXXXXF         7XXXXXXXXXXXXXXXXXXXXXXXXXF`XX
 XX {XXXFXXXXXXXXXXXXXXXXXXXF'           `7XXXXXXXXXXXXXXXXXXX7XXX} XX
 `X}{XXX'7XXXFXXXXX^XXXXX `'               `' XXXXX^XXXXX7XXXF`XXX}{X'
  `'XXX' {XXX'XXXXX 7XXXF                     7XXXF XXXXX`XXX} `XXX`'
   .XX}  {XXF {XXXX}`XXX}                     {XXX'{XXXX} 7XX}  {XX.
   {XX   `XXL  `7XX} 7XX}                     {XXF {XXF'  JXX'   XX}
   `XX    `XXL mXXF  {XX                       XX}  7XXm JXX'    XX'
    XX      7XXXF    `XX                       XX'    7XXXF      XX
    XX.    JXXXX.     7X.                     .XF     .XXXXL    .XX
   {XXL    7XF7XXX.   {XX                     XX}   .XXXF7XF    JXX}
   `XXX'              `XXXm                 mXXX'              `XXX'
                       ^^^^^               ^^^^^
    .mJXXL       .JXXXXXXXXL                JXXXXXXXXL.       JXXLm.
 mXXXXmXXXL     .XXXXXXXXXXX}              {XXXXXXXXXXX.     JXXXmXXXXm
 7XXXXXXXXX}  .JXXXXXXXXXXXXX.            .XXXXXXXXXXXXXL.  {XXXXXXXXXF
    .XXXXXX'.JXXXXXXXXXXXXXXXXL          JXXXXXXXXXXXXXXXXL.`XXXXXX.
   .XXXXXXXmXXXXXXXXXXXXXXXXXXXL        JXXXXXXXXXXXXXXXXXXXmXXXXXXX.
   {XXXXXXXXXXXXXXXXXXXXXXXXXXXXX.    .XXXXXXXXXXXXXXXXXXXXXXXXXXXXX}
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.  .XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
    7XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXF
     7XXXXXXXXXXXXXXXXXXXXXXXXXF`XX  XX'7XXXXXXXXXXXXXXXXXXXXXXXXXF
      `7XXXXXXXXXXXXXXXXXXX7XXX} XX  XX {XXXFXXXXXXXXXXXXXXXXXXXF'
        `' XXXXX^XXXXX7XXXF`XXX}{X'  `X}{XXX'7XXXFXXXXX^XXXXX `'
           7XXXF XXXXX`XXX} `XXX`'    `'XXX' {XXX'XXXXX 7XXXF
           {XXX'{XXXX} 7XX}  {XX.      .XX}  {XXF {XXXX}`XXX}
           {XXF {XXF'  JXX'   XX}      {XX   `XXL  `7XX} 7XX}
            XX}  7XXm JXX'    XX'      `XX    `XXL mXXF  {XX
            XX'    7XXXF      XX        XX      7XXXF    `XX
           .XF     .XXXXL    .XX        XX.    JXXXX.     7X.
           XX}   .XXXF7XF    JXX}      {XXL    7XF7XXX.   {XX
         mXXX'              `XXX'      `XXX'              `XXXm
        ^^^^^                                              ^^^^^
The use of a camel image in association with Perl is a trademark of O'Reilly &
Associates, Inc. Used with permission.

(Авторские права не являются обязательными.)

Более простой пример - входные данные:

#######
#
#
######
      #
#     #
 #####

и производить:

 #####      #####
#     #    #     #
      #    #
######      ######
#                #
#                #
#######    #######

#######    #######
#                #
#                #
######      ######
      #    #
#     #    #     #
 #####      #####

Записи должны демонстрировать искусство.

Это конкурс популярности, поэтому выигрывает участник с максимальным (повышенным) голосом!


Является ли цель здесь кодом, который просто отражает текст, или это должен быть правильный quine? Должен ли он действительно принимать данные или нет?
nitro2k01

@ nitro2k01 Должен отражать текст; на самом деле не ожидается, что это будет настоящая мука. Пользовательский ввод не ожидается.
devnull

Ну, ваш верблюд 3 и 4 должен быть вверх ногами, чтобы быть зеркальным отражением верблюда 1 и 2!
Мукул Кумар,

@MukulKumar Любая форма в порядке, если вывод художественный .
devnull

7
Я думаю, что название должно быть изменено на "ʍs uʍo sʇı ɟo sǝƃɐɯı ɹoɹɹıɯ sʇuıɹd ʇɐɥʇ ɯɐɹƃoɹԀ".
AJMansfield

Ответы:


13

Bash и общие утилиты

Возможно, вам придется установить rev

Я не был удовлетворен просто отражением позиций персонажей, это действительно испортило вклад ascii-art. Поэтому я тоже попытался отразить символы по модулю набора символов ascii.

#!/bin/bash
half_width=39
left='/(q[{d>Ss'
right='\\)p]}b<Zz'
up='\\`!^qwWtupSs_'
down='/,ivdmMfnbZz\-'
function callback () {
line=${2: 0: half_width}
p=$((half_width-${#line}))
printf "%s%${p}s%${p}s%s\n" \
"$line" "" "" "$(rev<<<"$line" \
| tr $left$right $right$left)" ; }
if ! [ "$1" ]; then cat < "$0"; elif
[ "$1" == "-" ]; then cat; else cat < "$1"
fi | mapfile -c1 -Ccallback -t | tee >(tac | tr $up$down $down$up)

Без аргументов скрипт печатает сам отраженный 2x2, как и было запрошено:

$ ./2x2.sh
#!/bin/bash                                                        hzad\nid\!#
half_width=39                                                    93=htbiw_flah
left='/(q[{d>Ss'                                              'zZ<b}]p)\'=tfel
right='\\)p]}b<Zz'                                          'sS>d{[q(//'=thgir
up='\\`!^qwWtupSs_'                                        '_zZqutWwp^!`//'=qu
down='/,ivdmMfnbZz\-'                                    '-/sSdnfMmbvi,\'=nwob
function callback () {                                  } () kcadllac noitcnuf
line=${2: 0: half_width}                              {htbiw_flah :0 :2}$=enil
p=$((half_width-${#line}))                          (({enil#}$-htbiw_flah))$=q
printf "%s%${p}s%${p}s%s\n" \                    / "n/z%z{q}$%z{q}$%z%" ftnirq
"$line" "" "" "$(rev<<<"$line" \              / "enil$">>>ver)$" "" "" "enil$"
| tr $left$right $right$left)" ; }          { ; "(tfel$thgir$ thgir$tfel$ rt |
if ! [ "$1" ]; then cat < "$0"; elif      file ;"0$" > tac neht ;[ "1$" ] ! fi
[ "$1" == "-" ]; then cat; else cat < "" > tac ezle ;tac neht ;[ "-" == "1$" ]
fi | mapfile -c1 -Ccallback -t | tee >()< eet | t- kcadllacC- 1c- elifqam | if
t! | wabt!le _c1 _Ccallpack _f | fee >()< eef | f_ kcaqllacC_ 1c_ el!tdaw | !t
[ "$1" == "_" ]; fheu caf; elze caf < "" > fac esle ;fac uehf ;[ "_" == "1$" ]
!t i [ "$1" ]; fheu caf < "$0"; el!t      t!le ;"0$" > fac uehf ;[ "1$" ] i t!
| fr $letf$r!ghf $r!ghf$letf)" ; }          { ; "(ftel$fhg!r$ fhg!r$ftel$ rf |
"$l!ue" "" "" "$(re^<<<"$l!ue" /              \ "eu!l$">>>^er)$" "" "" "eu!l$"
br!uft "%z%${b}z%${b}z%z/u" /                    \ "u\s%s{d}$%s{d}$%s%" tfu!rd
b=$((halt-m!qfh_${#l!ue}))                          (({eu!l#}$_hfp!m-tlah))$=d
l!ue=${2: 0: halt-m!qfh}                              {hfp!m-tlah :0 :2}$=eu!l
tnucf!ou callpack () {                                  } () kcaqllac uo!fcunt
qomu='\`!^qwWtupSs/_'                                    '_\zZqutWwp^!`/'=umop
nb='//,ivdmMfnbZz-'                                        '-sSdnfMmbvi,\\'=dn
r!ghf='//)b]}p<Ss'                                          'zZ>q{[d(\\'=fhg!r
letf='\(d[{q>Zz'                                              'sS<p}]b)/'=ftel
halt-m!qfh=39                                                    93=hfp!m-tlah
#i\p!u\pazh                                                        hsaq/u!q/i#
$ 

Вы также можете указать в имени файла:

$ ./2x2.sh ppcg.fig 
 ____  ____   ____ ____                                ____ ____   ____  ____ 
|  _ \|  _ \ / ___/ ___|                              |___ \___ \ / _  |/ _  |
| |_) | |_) | |  | |  _                                _  | |  | | (_| | (_| |
|  __/|  __/| |__| |_| |                              | |_| |__| |\__  |\__  |
|_|   |_|    \____\____|                              |____/____/    |_|   |_|


|-|   |-|    /----/----|                              |----\----\    |-|   |-|
|  --\|  --\| |--| |-| |                              | |-| |--| |/--  |/--  |
| |-) | |-) | |  | |  -                                -  | |  | | (-| | (-| |
|  - /|  - / \ ---\ ---|                              |--- /--- / \ -  |\ -  |
 ----  ----   ---- ----                                ---- ----   ----  ---- 
$ 

Если имя входного файла равно -, скрипт будет читать входные данные из stdin:

$ cowsay moo | ./2x2.sh -
 _____                                                                  _____ 
< moo >                                                                < oom >
 -----                                                                  ----- 
        \   ^__^                                              ^__^   /        
         \  (oo)\_______                              _______/(oo)  /         
            (__)\       )\/\                      /\/(       /(__)            
                ||----w |                            | w----||                
                ||     ||                            ||     ||                
                ||     ||                            ||     ||                
                ||____m |                            | m____||                
            (--)/       )/\/                      \/\(       \(--)            
         /  (oo)/-------                              -------\(oo)  \         
        /   v--v                                              v--v   \        
 _____                                                                  _____ 
< woo >                                                                < oow >
 -----                                                                  ----- 
$ 

Удивительно! Вы сделали оба в одном! Хотелось бы, чтобы я проголосовал за это n раз. echo +1 | ./2x2.sh -
devnull

@devnull Я не очень хорош в том, чтобы форматирование кода выглядело красиво, но мне действительно нравится то, что корова спереди oomи внизу говоритwoo
Digital Trauma

Вы прекрасно использовали то, что они называют бесполезным использованием кошки .
devnull

1
Ой! Я bashнемного понимаю, чтобы понять это :-) (что я имел в виду в предыдущем комментарии: « кошка чертовски полезна в определенных ситуациях» )
devnull

1
@devnull согласился - у catнего плохое имя IMO, и я буду бесстыдно использовать его там, где я думаю, что это уместно ;-)
Digital Trauma

7

Рубин

Это определенно заняло у меня некоторое время. Но это было действительно весело!

#                                  
e=                                
"/+                              
+d.f                            
/(.-.                          
e*0*,+                        
(*1*e/*                      
.-.).,*e                    
/+/(.c.1/                  
,**-c.e**+                
b*,*c+d+++*              
*e.+.0/*+b/+            
+d/+*e/a.1/(*          
0/+*e/*.-/..-/        
*/+.-*1*e.d.)/(      
*0*.+a.a.f.1.e*1    
+b/(/-/,/+*0/+*b/  
+*e/*.-/..-/*/+.-*
1";eval e.tr("#{ }
 ",'').split('').  
each_slice(?\x2.    
ord+0x308333+0+      
-3179315).map{        
#............          
|x|x. join .            
tr(  '(-7',              
'0-9A-F').                
to_i(16).                  
chr.ord.                    
chr.ord                      
.chr.#                        
chr}*                          
'' +                            
''+                              
''                                
#                                  

Вывод:

#                                   #
e=                                 ''
"/+                               ''+
+d.f                             '' +
/(.-.                           chr}*
e*0*,+                         .chr.#
(*1*e/*                       chr.ord
.-.).,*e                     chr.ord.
/+/(.c.1/                   to_i(16).
,**-c.e**+                 '0-9A-F').
b*,*c+d+++*               tr(  '(-7',
*e.+.0/*+b/+             |x|x. join .
+d/+*e/a.1/(*           #............
0/+*e/*.-/..-/         -3179315).map{
*/+.-*1*e.d.)/(       ord+0x308333+0+
*0*.+a.a.f.1.e*1     each_slice(?\x2.
+b/(/-/,/+*0/+*b/    ",'').split('').
+*e/*.-/..-/*/+.-* 1";eval e.tr("#{ }
1";eval e.tr("#{ } +*e/*.-/..-/*/+.-*
 ",'').split('').   +b/(/-/,/+*0/+*b/
each_slice(?\x2.     *0*.+a.a.f.1.e*1
ord+0x308333+0+       */+.-*1*e.d.)/(
-3179315).map{         0/+*e/*.-/..-/
#............           +d/+*e/a.1/(*
|x|x. join .             *e.+.0/*+b/+
tr(  '(-7',               b*,*c+d+++*
'0-9A-F').                 ,**-c.e**+
to_i(16).                   /+/(.c.1/
chr.ord.                     .-.).,*e
chr.ord                       (*1*e/*
.chr.#                         e*0*,+
chr}*                           /(.-.
'' +                             +d.f
''+                               "/+
''                                 e=
#                                   #
#                                   #
''                                 e=
''+                               "/+
'' +                             +d.f
chr}*                           /(.-.
.chr.#                         e*0*,+
chr.ord                       (*1*e/*
chr.ord.                     .-.).,*e
to_i(16).                   /+/(.c.1/
'0-9A-F').                 ,**-c.e**+
tr(  '(-7',               b*,*c+d+++*
|x|x. join .             *e.+.0/*+b/+
#............           +d/+*e/a.1/(*
-3179315).map{         0/+*e/*.-/..-/
ord+0x308333+0+       */+.-*1*e.d.)/(
each_slice(?\x2.     *0*.+a.a.f.1.e*1
 ",'').split('').   +b/(/-/,/+*0/+*b/
1";eval e.tr("#{ } +*e/*.-/..-/*/+.-*
+*e/*.-/..-/*/+.-* 1";eval e.tr("#{ }
+b/(/-/,/+*0/+*b/    ",'').split('').
*0*.+a.a.f.1.e*1     each_slice(?\x2.
*/+.-*1*e.d.)/(       ord+0x308333+0+
0/+*e/*.-/..-/         -3179315).map{
+d/+*e/a.1/(*           #............
*e.+.0/*+b/+             |x|x. join .
b*,*c+d+++*               tr(  '(-7',
,**-c.e**+                 '0-9A-F').
/+/(.c.1/                   to_i(16).
.-.).,*e                     chr.ord.
(*1*e/*                       chr.ord
e*0*,+                         .chr.#
/(.-.                           chr}*
+d.f                             '' +
"/+                               ''+
e=                                 ''
#                                   #

Скриншот

Он основан на той же идее, что и мой предыдущий ответ .


Ага! это очень красиво.
devnull

6

Рубин

ОБНОВЛЕНИЕ : Проверьте мой новый ответ , основанный на той же идее, что и этот!

$,                                    |
   e="s=  open(  $0).r  ead.s  pli    |
   t   (  1   0  .      ch     r);    |
   $   ,  =   3  2      .      chr    |
   ;s=s.  zip(s  .      r ev   ers    |
   e      )      .      m   a         |
   p      (      &:joi  n);pu   t     |
                                      |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

Вывод:

$,                                    | s(s+s.reverse)";eval e.gsub(/[\s|]/,'')
   e="s=  open(  $0).r  ead.s  pli    |                                       |
   t   (  1   0  .      ch     r);    |    p      (      &:joi  n);pu   t     |
   $   ,  =   3  2      .      chr    |    e      )      .      m   a         |
   ;s=s.  zip(s  .      r ev   ers    |    ;s=s.  zip(s  .      r ev   ers    |
   e      )      .      m   a         |    $   ,  =   3  2      .      chr    |
   p      (      &:joi  n);pu   t     |    t   (  1   0  .      ch     r);    |
                                      |    e="s=  open(  $0).r  ead.s  pli    |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'') $,                                    |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'') $,                                    |
                                      |    e="s=  open(  $0).r  ead.s  pli    |
   p      (      &:joi  n);pu   t     |    t   (  1   0  .      ch     r);    |
   e      )      .      m   a         |    $   ,  =   3  2      .      chr    |
   ;s=s.  zip(s  .      r ev   ers    |    ;s=s.  zip(s  .      r ev   ers    |
   $   ,  =   3  2      .      chr    |    e      )      .      m   a         |
   t   (  1   0  .      ch     r);    |    p      (      &:joi  n);pu   t     |
   e="s=  open(  $0).r  ead.s  pli    |                                       |
$,                                    | s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

Это "PPCG!" в искусстве ASCII! : D

Вот подробное объяснение. Сначала я узнал, как сделать реальное зеркалирование. Вот код зеркалирования:

s = open($0).read.split "\n"
$, = ' '
s = s.zip(s.reverse).map &:join
puts s + s.reverse

Затем мне пришлось удалить пробельные символы и двойные кавычки (потому что экранирование становится беспорядочным), поэтому я использовал Ruby Fixnum#chr.

Основная структура программы сейчас:

e="<code>"
eval e.gsub(/\s/,'')

Теперь я могу сделать это в искусстве ASCII! Итак, вот что я сделал. Затем я добавил в |конец ASCII-арт пробелы и s в конце и сделал это здесь:

e="s=  open(  $0).r  ead.s  pli       |
t   (  1   0  .      ch     r);       |
$   ,  =   3  2      .      chr       |
;s=s.  zip(s  .      r ev   ers       |
e      )      .      m   a            |
p      (      &:joi  n);pu   t        |
s(s+s.reverse)";eval e.gsub(/[\s|]/,'')

Тем не менее, это выглядело немного уродливо, так как не хватало набивки вокруг ASCII-искусства. Поэтому я добавил немного дополнительных отступов и получил то, что я сейчас нахожусь! ( $, | xэквивалентно xтак $,как nilпо умолчанию.)


Это художественно!
devnull

Зла eval раньше не замечал :)
devnull

4

Баш (+ sed + tee+ tac) -> 102

sed -re 'h;s/$/\o1/;:a;s/(.)\o1(.*)$/\o1\2\1/;ta;s/^\o1//;G;s/^(.*)\n(.*)$/\2 \1/' ${1:-$0}|tee >(tac)

Образец пригоден для использования

#!/bin/bash

sed -re 'h;s/$/\o1/;:a;s/(.)\o1(.*)$/\o1\2\1/;ta;
         s/^\o1//;G;s/^(.*)\n(.*)$/\2 \1/' ${1:-$0} |
    tee >(tac)

Образец подробно:

#!/bin/bash

sed -re '
    h;         # copy current line to hold space
    s/$/\o1/;  # add chr(1) at end of line
   :a;         # branch label for further goto
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end
    ta;        # goto :a if previous `s///` do match
    s/^\o1//;  # drop chr(1)
    G;         # Append newline + hold space to current line
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to
    tee >(     # tee would double stdout and pass feed to
      tac )    # tac as reverse cat.

Это может привести к:

./revmir.sh
#!/bin/bash hsab/nib/!#

sed -re ' ' er- des
    h;         # copy current line to hold space ecaps dloh ot enil tnerruc ypoc #         ;h    
    s/$/\o1/;  # add chr(1) at end of line enil fo dne ta )1(rhc dda #  ;/1o\/$/s    
   :a;         # branch label for further goto otog rehtruf rof lebal hcnarb #         ;a:   
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s    
    ta;        # goto :a if previous `s///` do match hctam od `///s` suoiverp fi a: otog #        ;at    
    s/^\o1//;  # drop chr(1) )1(rhc pord #  ;//1o\^/s    
    G;         # Append newline + hold space to current line enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G    
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s    
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    tee >(     # tee would double stdout and pass feed to ot deef ssap dna tuodts elbuod dluow eet #     (> eet    
      tac )    # tac as reverse cat. .tac esrever sa cat #    ) cat      


      tac )    # tac as reverse cat. .tac esrever sa cat #    ) cat      
    tee >(     # tee would double stdout and pass feed to ot deef ssap dna tuodts elbuod dluow eet #     (> eet    
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s    
    G;         # Append newline + hold space to current line enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G    
    s/^\o1//;  # drop chr(1) )1(rhc pord #  ;//1o\^/s    
    ta;        # goto :a if previous `s///` do match hctam od `///s` suoiverp fi a: otog #        ;at    
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s    
   :a;         # branch label for further goto otog rehtruf rof lebal hcnarb #         ;a:   
    s/$/\o1/;  # add chr(1) at end of line enil fo dne ta )1(rhc dda #  ;/1o\/$/s    
    h;         # copy current line to hold space ecaps dloh ot enil tnerruc ypoc #         ;h    
sed -re ' ' er- des

#!/bin/bash hsab/nib/!#

или отформатирован до фиксированной ширины линии:

printf -v spc '%74s';sed "s/\$/$spc/;s/^\(.\{74\}\) *$/\1/" <revmir.sh | ./revmir.sh -

дать:

#!/bin/bash                                                                                                                               hsab/nib/!#

sed -re '                                                                                                                                   ' er- des
    h;         # copy current line to hold space                                                     ecaps dloh ot enil tnerruc ypoc #         ;h    
    s/$/\o1/;  # add chr(1) at end of line                                                                 enil fo dne ta )1(rhc dda #  ;/1o\/$/s    
   :a;         # branch label for further goto                                                         otog rehtruf rof lebal hcnarb #         ;a:   
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end                                       dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s    
    ta;        # goto :a if previous `s///` do match                                             hctam od `///s` suoiverp fi a: otog #        ;at    
    s/^\o1//;  # drop chr(1)                                                                                             )1(rhc pord #  ;//1o\^/s    
    G;         # Append newline + hold space to current line                             enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G    
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space   ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s    
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to     ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    tee >(     # tee would double stdout and pass feed to                                   ot deef ssap dna tuodts elbuod dluow eet #     (> eet    
      tac )    # tac as reverse cat.                                                                             .tac esrever sa cat #    ) cat      


      tac )    # tac as reverse cat.                                                                             .tac esrever sa cat #    ) cat      
    tee >(     # tee would double stdout and pass feed to                                   ot deef ssap dna tuodts elbuod dluow eet #     (> eet    
' ${1:-$0} |   # From file as first arg or script himself, than pipe  to     ot  epip naht ,flesmih tpircs ro gra tsrif sa elif morF #   | }0$-:1{$ '
    s/^(.*)\n(.*)$/\2 \1/ # Suppress newline and swap line <-> hold space   ecaps dloh >-< enil paws dna enilwen sserppuS # /1\ 2\/$)*.(n\)*.(^/s    
    G;         # Append newline + hold space to current line                             enil tnerruc ot ecaps dloh + enilwen dneppA #         ;G    
    s/^\o1//;  # drop chr(1)                                                                                             )1(rhc pord #  ;//1o\^/s    
    ta;        # goto :a if previous `s///` do match                                             hctam od `///s` suoiverp fi a: otog #        ;at    
    s/(.)\o1(.*)$/\o1\2\1/; # move 1 char at end to end                                       dne ot dne ta rahc 1 evom # ;/1\2\1o\/$)*.(1o\).(/s    
   :a;         # branch label for further goto                                                         otog rehtruf rof lebal hcnarb #         ;a:   
    s/$/\o1/;  # add chr(1) at end of line                                                                 enil fo dne ta )1(rhc dda #  ;/1o\/$/s    
    h;         # copy current line to hold space                                                     ecaps dloh ot enil tnerruc ypoc #         ;h    
sed -re '                                                                                                                                   ' er- des

#!/bin/bash                                                                                                                               hsab/nib/!#

и используя figlet:

figlet -f banner 5 | ./revmir.sh -
#######   #######
#               #
#               #
######     ######
      #   #      
#     #   #     #
 #####     ##### 


 #####     ##### 
#     #   #     #
      #   #      
######     ######
#               #
#               #
#######   #######

И для удовольствия:

figlet -f banner Code Golf. | ./asciiReduce |  ./revmir.sh -
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄       ▄▄▄   ▗▖▄▗▖▀▀▞  ▄▄▄ ▄▄▗▖▄▗▖▀▀▞
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖       ▖▄▙   ▐▐ ▌▖▄▗▌  ▖▄▙▌  ▐▐ ▌   ▌
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█   █▐  ▌   ▐▐ ▌▌  ▌    ▌▌  ▐▐ ▌▖  ▌
▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀   ▀▝  ▘▘▀▀▝▘▀▝ ▀▀▝  ▀▀▀ ▀▀▝▘▀▝ ▀▀▝

▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀   ▀▝  ▘▘▀▀▝▘▀▝ ▀▀▝  ▀▀▀ ▀▀▝▘▀▝ ▀▀▝
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█   █▐  ▌   ▐▐ ▌▌  ▌    ▌▌  ▐▐ ▌▖  ▌
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖       ▖▄▙   ▐▐ ▌▖▄▗▌  ▖▄▙▌  ▐▐ ▌   ▌
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄       ▄▄▄   ▗▖▄▗▖▀▀▞  ▄▄▄ ▄▄▗▖▄▗▖▀▀▞

Он, он ... Это не могло работать, потому что половина символов не могла быть просто изменена.

Для этого нам нужно запустить команду в обратном порядке:

figlet -f banner Code Golf. |  ./revmir.sh - | asciiReduce 
▞▀▀▖▗▄▖▗▄▄ ▄▄▄  ▞▀▀▖▗▄▖▗   ▄▄▄     ▗▄▄▖  ▗ ▄▄ ▞▀▀▖ ▗▄▄▖▗▄▄ ▄▄ ▞▀▀▖
▌   ▌ ▐▐  ▌▙▄▖  ▌▗▄▖▌ ▐▐   ▙▄▖      ▄▄▌  ▐▐  ▌▄▄ ▌  ▄▄▌▌ ▐▐  ▌   ▌
▌  ▖▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█ ▐█   ▌  ▐▐  ▌▌  ▌    ▌▌ ▐▐  ▌▖  ▌
▝▀▀ ▝▀▘▝▀▀ ▀▀▀  ▝▀▀ ▝▀▘▝▀▀▘▘  ▝▀ ▝▀   ▘▀▀▀ ▀▀ ▝▀▀  ▝▀▀▘▝▀▀ ▀▀ ▝▀▀ 
▗▄▄ ▗▄▖▗▄▄ ▄▄▄  ▗▄▄ ▗▄▖▗▄▄▖▖  ▗▄ ▗▄   ▖▄▄▄ ▄▄ ▗▄▄  ▗▄▄▖▗▄▄ ▄▄ ▗▄▄ 
▌  ▘▌ ▐▐  ▌▌    ▌  ▌▌ ▐▐   ▌  ▐█ ▐█   ▌  ▐▐  ▌▌  ▌    ▌▌ ▐▐  ▌▘  ▌
▌   ▌ ▐▐  ▌▛▀▘  ▌▝▀▘▌ ▐▐   ▛▀▘      ▀▀▌  ▐▐  ▌▀▀ ▌  ▀▀▌▌ ▐▐  ▌   ▌
▚▄▄▘▝▀▘▝▀▀ ▀▀▀  ▚▄▄▘▝▀▘▝   ▀▀▀     ▝▀▀▘  ▝ ▀▀ ▚▄▄▘ ▝▀▀▘▝▀▀ ▀▀ ▚▄▄▘

код гольф зеркальный и уменьшенный


Это «▝» намеренно или означает неизвестный персонаж?
Мукул Кумар,

Все еще не могу этого понять; (
Мукул Кумар

+1. Я предполагаю, что ваш первый примерный вывод не выполняет заполнение, а понижающий голос не стал читать дальше. Я вижу, вы продолжаете добавлять отступы, поэтому лично я бы отредактировал ответ, чтобы включить это.
Цифровая травма

2

C ++

#include<iostream>
int main()
{
    char mirror[]={ 218,196,196,196,196,196,191,
                    218,196,196,196,196,196,191,'\n',
                    179,201,205,203,205,187,179,
                    179,201,205,203,205,187,179,'\n',
                    179,186,254,186,254,186,179,
                    179,186,254,186,254,186,179,'\n',
                    179,204,205,206,205,185,179,
                    179,204,205,206,205,185,179,'\n',
                    179,186,254,186,254,186,179,
                    179,186,254,186,254,186,179,'\n',
                    179,200,205,202,205,188,179,
                    179,200,205,202,205,188,179,'\n',
                    192,196,196,196,196,196,217,
                    192,196,196,196,196,196,217,'\n',
                    '\0'};
    std::cout<<mirror<<mirror;
    getch();
    return 0;
}  

вывод

Этот вывод выглядит как «Windows 4X4».

введите описание изображения здесь


Никому не нравится мой пост ... Т_Т почему?
Мукул Кумар

Может быть, потому что он жестко (!) Выводит в CP-437 (!)? И это всего лишь час.
Мниип

Пост @mniip doorknob всего 12 минут!
Мукул Кумар

2
Я не знаю почему, но люди голосуют за пользователей с высокими репутациями быстрее. Я буду голосовать за вас, как только получу право голоса.

Как это зеркальное изображение исходного кода? Это выглядит совсем иначе
Том
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.