Aqui está um desafio relativamente simples para você.

Dada uma sequência de comprimento N , produza a sequência para frente, depois para trás, depois para frente e depois para trás ... etc. N vezes. Por exemplo, se sua entrada foi

Hello!

Você deve produzir:

Hello!!olleHHello!!olleHHello!!olleH

Opcionalmente, você também pode enviar uma nova linha à direita.

Seu envio pode ser um programa completo ou uma função, e você pode receber entradas e saídas em qualquer formato razoável . Por exemplo, você pode obter E / S de STDIN / STDOUT, argumentos de função e valor de retorno, de um arquivo etc. Você pode assumir com segurança que a sequência de entrada não estará vazia e conterá apenas ASCII imprimível. Você deve gerar a nova string em uma única linha. Então, por exemplo, se a saída para o último exemplo foi

Hello!
!olleH
Hello!
!olleH
Hello!
!olleH

Esta não seria uma solução válida!

Aqui estão mais alguns casos de teste:

Input:
a
Output:
a

Input:
abcd
Output:
abcddcbaabcddcba

Input:
OK!
Output:
OK!!KOOK!

Input:
4815162342
Output:
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Input:
PPCG
Output:
PPCGGCPPPPCGGCPP

Input:
42
Output:
4224

Classificação

Como este é um desafio do código-golfe , as brechas padrão são proibidas e a resposta mais curta em bytes vence! No entanto , também é uma competição ter a resposta mais curta em qualquer idioma específico. Embora seja improvável que uma resposta Java supere uma resposta em perl ou alguma linguagem de golfe, ainda é muito impressionante ter a resposta Java mais curta. Então, você pode usar esse cabeçalho para ver os dois

1. A resposta mais curta de todos os idiomas e

2. A resposta mais curta em cada idioma individual.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=93261,OVERRIDE_USER=31716;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Teclas Vim, 39 , 34

:se ri
Y:s/./<C-r>"/g
<C-o>qqgJC<C-r>"<esc>gJ@qq@q

5 bytes salvos graças a @Lynn!

Aqui está um gif dele acontecendo ao vivo: (Observe que este gif é de uma versão anterior, pois ainda não tive tempo de regravá-lo).

E aqui está uma explicação de como funciona:

:se ri                  "Turn 'reverse indent' on.
Y                       "Yank this line
:s/./<C-r>"/g           "Replace every character on this line with the register
                        "We just yanked followed by a newline
<C-o>                   "Jump to our previous location
     qq                 "Start recording in register 'q'
       gJ               "Join these two lines
         C              "Delete this line, and enter insert mode
          <C-r>"<esc>   "Paste the line we just deleted backwards 
gJ                      "Join these two lines
  @q                    "Call macro 'q'. This will run until we hit the bottom of the buffer.
    q                   "Stop recording.
     @q                 "Start our recursive macro

Em uma nota lateral, Ypega uma nova linha extra, que geralmente é um recurso desagradável. Esta é provavelmente a primeira vez que ele realmente salvou vários bytes!

Python, 40 bytes

f=lambda s,i=0:s[i:]and s+f(s[::-1],i+1)

Uma função recursiva. Anexa a sequência de entrada sà função de reversão até que o contador iexceda o comprimento de s.

Flak cerebral , 418 378 228 bytes

Esta é minha obra-prima Brain-Flak. Pode não ser um bom golfe, mas o desafio é o mais difícil que já encontrei.

Experimente online!

(([])[()]){({}[()]<(({}(<()>))<{({}[()]<(({}()<(({}<>))>)<({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}>)>)}{}{}<>([]){{}({}<>)<>([])}{}<>>)>)}{}([(({}))]{({})({}[()])}{}){(({}[({}<>)<>])<<>({}<><{(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)>)}

Explicação

Agora, essa explicação está um pouco desatualizada, mas ainda funciona muito bem ao explicar o programa.

Essa explicação vai ser um pouco diferente do meu processo de explicação regular. Vou explicar como obtive esse resultado, em vez de explicar o resultado em ordem. Aqui vai:

Roller

Depois de trabalhar bastante no problema, vim com esse código:

(n[()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>

Este código (onde n é o literal para algum número, por exemplo ()()), pega o item no topo da pilha e o move para baixo n etapas. Com n como a altura da pilha, isso executará um "rolo" da pilha. ou seja, mova o item superior para o final da pilha. Veja como funciona:

Colocamos o local em que queremos mover o item para menos um na pilha. Por que menos um? Eu não sei, apenas funciona dessa maneira.

(n[()])

Em seguida, fazemos um loop até esse número chegar a zero, acompanhando o loop com a ().

{()<({}[()]<...>)>)>}{}

Cada vez que fazemos um loop, pegamos o item superior e movemos o item abaixo para a outra pilha. Isso coloca o número no topo em seu lugar.

({}<({}<>)<>>)

Tudo o que precisamos fazer agora é colocar os números que retornamos. Mudamos para a pilha desativada e aumentamos o número de execuções que o loop fez.

(...<>)

Fazemos um loop decrescente do número recém-enviado até que ele chegue a zero. Cada vez que movemos um número para trás.

{({}[()]<({}<>)<>>)}{}<>

Marcha ré

Em seguida, modifiquei o rolo para reverter a pilha completa:

(n){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}

Mais uma vez, n representa a profundidade do reverso. Esses são os n itens principais da pilha serão revertidos. Como funciona:

O inverso é apenas um rolo sofisticado. Simplesmente rolamos o topo da pilha n vezes, diminuindo a profundidade do rolo uma vez a cada vez.

(n){(({}[()])<ROLLER>)}{}

Duplicado

A duplicação é difícil. Muito difícil. Depois que eu descobri como reverter a pilha, ainda era preciso muito esforço para criar o algoritmo de duplicação.

Aqui está:

(((n)<{({}[()]<(({}<>))<>>)}{}<>>)<{({}[()]<({}<>)<>([][()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>>)}{}<>([]){{}({}<>)<>([])}{}<>([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)

É um pouco grande, mas eis como funciona:

Comece pressionando n. n é a profundidade da duplicata. Também abrimos dois parênteses. Isso nos permite armazenar o valor de n no escopo até que seja necessário novamente.

(((n)<

Em seguida, repetimos n vezes cada vez, empurrando o valor superior da pilha para fora da pilha duas vezes. Isso faz as duplicatas iniciais para cada número na pilha.

{({}[()]<(({}<>))<>>)}{}

Agora, temos duas cópias de cada número na cartela. Precisamos separá-los em dois grupos.

Então, mudamos para o offstack e lembramos de um dos ns que salvamos no início.

<>>)

Nós repetimos n vezes.

{({}[()]<...>)}{}

Cada vez que movemos uma cópia para a pilha principal.

({}<>)<>

E role uma cópia para o final da pilha. (Isso pressupõe que o offstack estava vazio para começar a tornar essa duplicata não empilhável)

([][()])ROLLER

Feito isso, dividimos o original em dois grupos, o "original" e uma cópia no offstack (a cópia é realmente ao contrário). Então, apenas movemos a cópia para a pilha principal e podemos concluir com ela.

([]){{}({}<>)<>([])}{}<>

Programa esqueleto

Agora que criei todas as partes do programa, só tenho que inseri-las em um quadro.

O quadro dobra o texto um a menos que os tempos de altura da pilha Usando duplicado.

(([])[()])
{
 ({}[()]<
  DUPLICATE 
 >)
>)}{}

E então inverte a pilha em incrementos decrescentes da altura inicial da pilha de n ^ 2-n para 0.

(({}))
{
 (({}[()])<
  ({}<>)<>(({}))({<({}[()])><>({})<>}{})<>{}<>
  ({}<({}<>)<>>)<>({}<>)
  ({}<
   REVERSE
  >)
 >)
}{}{}

Gelatina , 4 3 bytes

,Ṛṁ

Experimente online! ou Verifique todos os casos de teste.

Guardou um byte graças a @ Maltysen .

Explicação

,Ṛṁ  Input: string S
 Ṛ    Reverse S
,     Join S with reverse of S. Makes a list [S, rev(S)]
  ṁ   Mold [S, rev(S)] to len(S) by repeating elements cyclically
      Return and print implicitly as a string

PHP, 54 52 bytes

(49 bytes, mas não funciona se a string contiver '0')

for(;($a=$argv[1])[$i++];)echo$i%2?$a:strrev($a);

(52 bytes)

<?=str_pad('',strlen($a=$argv[1])**2,$a.strrev($a));

(54 bytes)

for(;$i++<strlen($a=$argv[1]);)echo$i%2?$a:strrev($a);

2sable , 3 bytes

Código:

gGÂ

Explicação:

g   # Get the length of the input
 G  # Do the following n - 1 times:
  Â # Bifurcate, which duplicates a and reverses the duplicate

Usa a codificação CP-1252 . Experimente online!

Ruby, 39 bytes

->(s){s.reverse!.gsub(/./){s.reverse!}}

Eu sou péssima com Ruby. A ajuda do golfe é apreciada.

Ruby é uma linguagem muito boa para isso por causa de .reverse!

Explicação

Eu esperava que fosse algo simples como:

s.gsub(/./){s.reverse!}

mas devido à restrição de clichê / desafio, é mais longo.

O que s.reverse!é muito útil. s.reverse!é basicamente s = s.reverse!, o que significa que também muda s.

O que cada seção do programa faz é descrito abaixo:

->(s){             # Lambda with argument s
      s.reverse!   # Reverse `s` see above for details
      .gsub(/./)   # Replace every character with...
      {s.reverse!} # the input reversed!

O s.reverse!que é ótimo é que toda vez que é avaliada, a string é invertida. Então, como ele substitui a cadeia. sé modificado!

Perl, 24 bytes

Inclui +2 para -lp

Dê entrada no STDIN:

rev.pl <<< Hello!

rev.pl:

#!/usr/bin/perl -lp
s%.%s/.?/chop/eg;$`%eg

Surpreendentemente, isso não usa o reverseoperador interno . Esse nome é muuuuito longo, todas as soluções em que eu poderia pensar reversesão pelo menos 1 byte a mais.

J, 13 8 bytes

Economizou 5 bytes graças a milhas!

#;@$];|.

Este é um trem de 5 com os seguintes verbos:

# ;@$ ] ; |.

O fork interno é composto por ](identidade), ;(link) e |.(reverso). Observar:

   (| ; |.) 'Hello!'
+------+------+
|Hello!|!olleH|
+------+------+

Os dois verbos exteriores formam o resto do trem. #é, nesse caso, o tamanho do argumento, ou seja, o comprimento. O verbo que liga estes é ;@$, ou ravelacabou reshape. Observar:

   # 'Hello!'
6
   6 $ (] ; |.) 'Hello!'
+------+------+------+------+------+------+
|Hello!|!olleH|Hello!|!olleH|Hello!|!olleH|
+------+------+------+------+------+------+
   ; 6 $ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   6 ;@$ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ (] ; |.)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ ] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (#;@$];|.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

Solução antiga.

[:,|.^:(i.@#)

Simples o suficiente. |.é reverso e ^:é uma conjunção de poder, que repete o verbo esquerdo (mão direita) # vezes. Quando o argumento certo é um verbo, esse verbo é chamado no argumento. O verbo certo, neste caso, varia de zero ( i.) ao comprimento ( #). Quando elevados para uma matriz, os resultados intermediários são mantidos. Tudo o que precisa ser feito é achatar a matriz ,.

Resultados intermediários

   (i.@#) 'Hello!'
0 1 2 3 4 5
   |.^:0 1 2 3 4 5 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   |.^:(i.@#) 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   ([:,|.^:(i.@#)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

JavaScript (ES 6), 59 50 bytes

9 bytes graças a Hedi e Huntro.

f=(s,n=1)=>s[n]?s+f([...s].reverse().join``,n+1):s

função recursiva.

A reversão da string ocupa quase metade do tamanho ( 25 22 bytes!) ...
Por que não existe um caminho nativo para isso?

Minkolang , 17 bytes:

$oId$z$Dz[rz[O]].

Experimente aqui!

Explicação

$o                   Read in whole input as characters
  Id                 Push the length of stack and duplicate
    $z               Pop top of stack and store in register (z)
      $D             Pop top of stack (n) and duplicate whole stack n-1 times
        z[     ]     z times, do the following:
          r          Reverse the stack
           z[O]      z times, pop the top of stack and output as character
                .    Stop.

Conjunto 8088, IBM PC DOS, 29 28 bytes

Montado, xxddespejo:

00000000: d1ee ac48 938a cbfc 518a cbf7 da78 01fd  ...H....Q....x..
00000010: acac b40e cd10 e2f9 59e2 ecc3            ........Y...

Listagem desmontada:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load input string length into AL 
48          DEC  AX             ; remove leading space from length counter 
93          XCHG BX, AX         ; save input length to BL 
8A FB       MOV  BH, BL         ; string output counter in BH 
        S_LOOP: 
FC          CLD                 ; set direction forward 
8A CB       MOV  CL, BL         ; reset char counter in CL 
F7 DA       NEG  DX             ; flip DX to toggle fwd/back output 
78 01       JS   C_START        ; if positive, go forward 
FD          STD                 ; otherwise go backwards 
        C_START: 
AC          LODSB               ; adjust SI to first/last char
        C_LOOP: 
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
E2 F9       LOOP C_LOOP         ; continue looping through chars
FE CF       DEC  BH             ; decrement string count loop
75 EC       JNZ  S_LOOP         ; if not zero, continue loop
C3          RET                 ; exit to DOS

Programa executável autônomo do PC DOS. Seqüência de entrada via linha de comando, a saída é console.

Pip , 11 10 bytes

L#aORVRV:a

Experimente online!

Explicação:

            a is first cmdline argument (implicit)
L#a         Loop len(a) times:
      RV:a   Reverse a and assign back to a
   ORV       Output the reverse of a (since it needs to go forward first then backward)

Haskell, 40 36 32 Bytes

m s=take(length s^2)$cycle$s++reverse s

Exemplo:

*Main> m "Hello!"
"Hello!!olleHHello!!olleHHello!!olleH"

Ainda mais curto (crédito para Damien):

q s=zip(s>>[s,reverse s])s>>=fst

s >> [s, s reverso] ciclos ["abc", "cba", ...] zipados para corrigir o tamanho e concatMap'ped com fst

Perl 6 ,  31  30 bytes

{[~] (|($_,.flip)xx*)[^.chars]}

Salve um byte usando incorretamente .ords, o que retorna uma lista de ordinais e, em seguida, converta implicitamente isso em um número para criar um intervalo.

{[~] (|($_,.flip)xx*)[^.ords]}

Explicação:

# bare block lambda with implicit parameter ｢$_｣
{
  # reduce using string concatenation operator ｢~｣
  [~]

  (
    # create a Slip
    |(
      # of the input, and its string reverse
      $_, .flip

    # list repeated infinitely
    ) xx *

  # get the values in the range from 0 up-to and excluding
  # the number of characters ｢0 ..^ +$_.ords｣
  )[ ^.ords ]
}

Uso:

my &code = {[~] (|($_,.flip)xx*)[^.ords]}

say code 'a'; # a
say code 'abcd'; # abcddcbaabcddcba
say code 'OK!'; # OK!!KOOK!
say code 4815162342; # 4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Vim + coreutils, 32 pressionamentos de teclas

Você nunca pode ter muitas respostas do Vim.

qqYv:!rev
Pjq@=len(@")
@q2dkv{gJ

Explicação

qq               " Start recording macro
Y                " Yank (copy) line
v:!rev<CR>       " Reverse line with coreutils rev command
Pj               " Paste yanked line above this line
q                " Stop recording
@=len(@")<CR>@q  " Playback macro once for each character
2dk              " Delete last 3 lines
v{gJ             " Join lines

MATL, 13 12 8 bytes

Empurra todos os elementos, combina no final.

td"tP]&h

td"  ]     %For loop over string length - 1 due to diff
   tP      %Push copy of string, reverse
      &h   %Concatenate entire stack horizontally

Experimente online!

Versões antigas:

Abordagem completamente diferente, com base em fprintf:

t"t1$0#YDP]x

t"        ]   % For loop over string
  t           % Duplicate string for printing:
   1$0#YD     % `fprintf` with 1 input, 0 output (i.e., to screen).
         P    % Reverse
           x  % Empty stack to prevent implicit output

Versão baseada na reversão de uma sequência de modelos

ttd"wPtbYc]Dx

t                 %Duplicate input, to create 'accumulator' string 
                  % (alongside the input string which will serve as 'template'
 td               %Duplicate input, diff to get an stringof size input-1
   "       ]      %For loop over size n-1 string (consumes diff'd string)
     wP           %Get 'template' string on top of stack, and reverse
       tb         %Duplicate template string, and switch with 'accumulator' string
         Yc       %Concatenate template string with accumulator. 
            Dx   %Display top element, delete template string to prevent implicit disp

Scala, 73 72 71 bytes

def f(s:String)=for(i<-1 to s.length){print(if(i%2>0)s else s.reverse)}

Esta é a minha primeira tentativa no código de golfe, por isso tenho certeza de que há inúmeras melhorias.

Atualizar:

Jogou 1 byte de golfe removendo os suportes.

Agradecemos a Destructible Watermelon pela sugestão, raspou um byte.

Cubix , 52 bytes

Ap\:\;.#u/\:qqsoq(?;u.q..$u<../pB@u:\.....\(?q..s..p

Em um cubo:

      A p \
      : \ ;
      . # u
/ \ : q q s o q ( ? ; u
. q . . $ u < . . / p B
@ u : \ . . . . . \ ( ?
      q . .
      s . .
      p . .

Este foi divertido; ainda há bytes a serem jogados fora disso, mas isso definitivamente funcionará.

Experimente online!

explicação:

Entrada de ABC

• /A: vá para o norte e leia todas as entradas como caracteres; -1estará na parte inferior
• p\;.: remova o -1da pilha
• u# : pressione o comprimento da string (número de itens na pilha)
• \:\:qq : duplique o comprimento da sequência duas vezes, empurre duas cópias para o final da pilha

• loop:

  • soq(?/<u : troque a parte superior da pilha, coloque a parte superior da pilha como ASCII, empurre a parte superior (letra) para baixo, diminua a parte superior da pilha, vire à direita se não estiver pronto e mova o IP para o lugar certo.
  • no final do loop, a pilha parecerá C B A 3 3 0

• ;u : pop pop da pilha C B A 3 3

• B : pilha reversa 3 3 A B C
• p( : mova de baixo para cima e diminua 3 A B C 2
• ?se top for zero, vá direto para @e termine
• outro
  • psq:uq : mova de baixo para cima, troque de cima para baixo e mova de cima para baixo e mova de cima para baixo 3 2 A B C 3
  • $u : pular u
  • < nos coloca de volta no circuito.

Intérprete

C (gcc) , 88 87 85 83 68 66 83 82 78 bytes

-1 graças a ceilingcat

Versão antiga

p,q;f(char*s){p=q=1;for(char*m=s--;*m;s[p+=q]*p?:(m++,p+=q=-q))putchar(s[p]);}

Experimente online!

Versão mais curta (ligeiramente quebrada)

Analisando a abordagem de 76 bytes pela ASCII, apenas nos comentários, e -1 byte de sua emenda na minha emenda.

Edit: Esta versão é um pouco quebrada, pois pressupõe que toda string é precedida por um byte NULL, o que nem sempre é verdadeiro. (Veja o último caso de teste no link). Revertendo para a versão de 83 bytes por enquanto.

f(char*s){for(char*n=s-1,k=1;*s++;k=-k)for(;*(n+=k);)putchar(*n);}

Experimente online!

Java, 127 111 88 bytes

(s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?new StringBuffer(s).reverse():s;return r;};

Programa de teste ungolfed

    public static void main(String[] args) {
    BiFunction<String, String, String> func = (s, r) -> {
        for (int i = 0; i++ < s.length();) {
            r += i % 2 < 1 ? new StringBuffer(s).reverse() : s;
        }
        return r;
    };
    System.out.println(func.apply("Hello!", ""));
}

R, 53 bytes

Supõe que a entrada seja separada por espaço ou nova linha para cada caractere.

cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")

Alguns casos de teste:

> cat(rep(c(i<-scan(,""),rev(i)),len=length(i)^2),sep="")
1: h e l l o !
7: 
Read 6 items
hello!!ollehhello!!ollehhello!!olleh

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a
2: 
Read 1 item
a

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a b c d
5: 
Read 4 items
abcddcbaabcddcba

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: O K !
4: 
Read 3 items
OK!!KOOK!

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 8 1 5 1 6 2 3 4 2
11: 
Read 10 items
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: P P C G
5:    
Read 4 items
PPCGGCPPPPCGGCPP

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 2
3: 
Read 2 items
4224

PowerShell v2 +, 57 bytes

param($a)-join(1..($x=$a.length)|%{($a[$x..0],$a)[$_%2]})

Não existe uma maneira realmente limpa de obter comprimentos de string ou revertê-los, portanto isso é bastante demorado.

Recebe entrada $a, passa de 1para $a.length(armazenado $xpara uso posterior). A cada iteração, usamos um pseudo-ternário para indexar em uma matriz de um $aou outro $a[$x..0]( ou seja, invertido), com base no fato de nosso número de entrada ser ímpar / par [$_%2]. Tudo isso é encapsulado em parênteses e -joineditado em conjunto para formar uma única sequência. Isso é deixado no pipeline e a produção está implícita.

PS C:\Tools\Scripts\golfing> .\stringgnirts.ps1 'TimmyD'
TimmyDDymmiTTimmyDDymmiTTimmyDDymmiT

Java, 151 bytes

public static void r(String s){String t = new StringBuffer(s).reverse().toString();for(int i=0;i<s.length();i++){System.out.print(((i%2==1)?t:s));}}

}

Ungolfed:

public static void r(String s) {
    String t = new StringBuffer(s).reverse().toString();
    for(int i = 0; i < s.length();i++) {
        System.out.print(((i % 2 == 1) ? t : s));
    }
}

C #, 94 bytes

using System.Linq;string R(string n)=>string.Concat(n.SelectMany((c,i)=>1>i%2?n:n.Reverse()));

76 bytes para o método + 18 bytes para importação de LINQ.

Como funciona:

using System.Linq; // Required for LINQ extension methods.

string R(string n) => 
    string.Concat( // Concatenate the following chars into a single string
        n.SelectMany( // Enumerate each char in n, flattening the returned IEnumerable<char>'s into a single IEnumerable<char>
            /*IEnumerable<char> Lambda*/(/*char*/ c, /*int*/ i) => // i = index in n
                1 > i % 2 // Check if i is even or odd
                    ? n // if i is even, add n to the concat
                    : n.Reverse() // else reverse n and concat that
        )
    )
;

CJam , 10 bytes

l_,({_W%}*

Experimente online!

Explicação

l            e# Read line
 _           e# Duplicate
  ,(         e# Length minus 1
    {   }*   e# Run code block that many times
     _       e# Duplicate
      W%     e# Reverse
             e# Implicitly display

Oitava, 39 35 bytes

@(x)[x'+~x;flip(x'+~x),''](1:end/2)

f('Hello!')
ans = Hello!!olleHHello!!olleHHello!!olleH

Explicação:

@(x)            % Take x as input, inside apostrophes 'Hello!'
x'+~x           % Create a mesh of the ASCII-code of the input letters
                % For input `bcd` this will be:
                %    98    98    98
                %    99    99    99
                %   100   100   100
;flip(x'+~x)   % Concatenate vertically to create:
                %    98    98    98
                %    99    99    99
                %   100   100   100
                %   100   100   100
                %    99    99    99
                %    98    98    98
___,'']         % Short cut to convert ASCII-code to characters
(1:end/2)       % Display the first half of this array of letters, as a
                % horizontal string

Guardado 4 bytes graças a Luis. ~xem vez de 0*xsalvar um byte (funciona porque todos os elementos de x são diferentes de zero. em flipvez de flipudsalvar outros dois bytes (eu não sabia que flipexistiam).

bash + util-linux, 68 58 53 bytes

y=$1;for((i;i<${#1};i++)){ echo -n $y;y=`rev<<<$y`;}

Explicação

Duas coisas com o forloop:

• Existe uma maneira aparentemente não documentada de escrever forloops, onde se substitui as palavras-chave doe donepor chaves {e }. O espaço após o primeiro colchete é necessário e o ponto e vírgula no final também é necessário.
• Acontece que nos forloops "estilo C" , você pode apenas inicializar com em i;vez de usar i=0;.
• A ${#1}parte da condição i < ${#1}refere-se ao comprimento da nossa entrada (o primeiro parâmetro $1). Em geral, você pode usar ${#foo}para recuperar o tamanho da sequência $foo.

Além disso:

• rev é a ferramenta no util-linux que reverte uma string.
• Precisamos passar a -nbandeira para echonos livrar das novas linhas.
• A expressão rev<<<$yé chamada string aqui (consulte esta página relevante do tldp.org ), que passa a variável $ypara a entrada padrão de rev.

Japonês , 11 bytes

ê1 pUÊ ¯Uʲ
ê1          // Append the reverse of the input to the input,
   pUÊ      // then repeat it input length times
       ¯Uʲ // and finally trim to length input length squared.

Experimente online!

05AB1E , 7 bytes

vDR}v}J

Experimente online!

Continuará a trabalhar nisso. Eu realmente não gosto da parte "v}", provavelmente posso salvar um byte lá.

Explicação

vDR}v}J

v         ; Iterates through each character
 D        ; Duplicate top of stack
  R       ; Push top of stack reversed
   }      ; end for loop
   v}     ; same as other v, effectively pops top of stack off
     J    ; Join everything together