Aquí hay un desafío relativamente simple para ti.

Dada una cadena de longitud N , envíe la cadena hacia adelante, luego hacia atrás, luego hacia adelante, luego hacia atrás ... etc. N veces. Por ejemplo, si su entrada fue

Hello!

Deberías generar:

Hello!!olleHHello!!olleHHello!!olleH

Opcionalmente, también puede generar una nueva línea final.

Su envío puede ser un programa completo o una función, y puede tomar entradas y salidas en cualquier formato razonable . Por ejemplo, puede tomar IO de STDIN / STDOUT, argumentos de función y valor de retorno, de un archivo, etc. Puede asumir con seguridad que la cadena de entrada no estará vacía y solo contendrá ASCII imprimible. Usted debe enviar la nueva cadena en una sola línea. Entonces, por ejemplo, si el resultado del último ejemplo fue

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

¡Esta no sería una solución válida!

Aquí hay algunos casos de prueba más:

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

Tablas de clasificación

Dado que este es un desafío de código de golf , las lagunas estándar están prohibidas, ¡y la respuesta más corta en bytes gana! Sin embargo , esta también es una competencia para tener la respuesta más corta en cualquier idioma en particular. Si bien es poco probable que una respuesta de Java supere a una respuesta en perl, o en algún lenguaje de golf, sigue siendo muy impresionante tener la respuesta de Java más corta. Entonces, puedes usar esta tabla de clasificación para ver ambos

1. La respuesta más corta de todos los idiomas, y

2. La respuesta más corta en cada idioma individual.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

# [><>](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>

Vim, 39 , 34 pulsaciones de teclas

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

¡5 bytes guardados gracias a @Lynn!

Aquí hay un gif de suceder en vivo: (Tenga en cuenta que este gif es de una versión anterior ya que no he tenido tiempo de volver a grabarlo).

Y aquí hay una explicación de cómo 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

En una nota al margen, Ytoma una nueva línea adicional, que generalmente es una característica desagradable. ¡Esta es probablemente la primera vez que realmente ha guardado varios bytes!

Python, 40 bytes

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

Una función recursiva. Antepone la cadena de entrada sa la función del reverso hasta que el contador iexceda la longitud de s.

Cerebro-Flak , 418 378 228 bytes

Esta es mi obra maestra Brain-Flak. Puede que no esté bien jugado, pero el desafío es el más difícil que he encontrado.

Pruébalo en línea!

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

Explicación

Esta explicación ahora está un poco desactualizada pero todavía hace un buen trabajo al explicar el programa.

Esta explicación va a ser un poco diferente de mi proceso de explicación habitual. Voy a explicar cómo llegué a este resultado en lugar de explicar el resultado en orden. Aquí va:

Rodillo

Después de trabajar un poco en el problema, se me ocurrió este código:

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

Este código (donde n es el literal para algún número, por ejemplo ()()) tomará el elemento en la parte superior de la pila y lo moverá hacia abajo n pasos. Con n como la altura de la pila, se realizará un "roll" de la pila. es decir, mover el elemento superior al final de la pila. Así es como funciona:

Ponemos el lugar donde queremos mover el elemento a menos uno en la pila. ¿Por qué menos uno? No sé, simplemente funciona de esa manera.

(n[()])

Luego realizamos un ciclo hasta que este número llegue a cero, manteniendo el seguimiento del ciclo con a ().

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

Cada vez que hacemos un bucle, recogemos el elemento superior y lo movemos debajo de él a la otra pila. Esto pone el número en la parte superior en su lugar.

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

Todo lo que tenemos que hacer ahora es poner los números que retrocedimos. Cambiamos a la pila apagada y empujamos el número de corridas realizadas por el ciclo.

(...<>)

Hacemos un bucle decrementando el número recién empujado hasta que llegue a cero. Cada vez que retrocedemos un número.

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

Marcha atrás

Luego modifiqué el rollo para hacer una pila completa inversa:

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

Una vez más, n representa la profundidad del reverso. Es decir, los n elementos principales de la pila se revertirán. Cómo funciona:

El reverso es solo un rodillo envuelto lujosamente. Simplemente rodamos la parte superior de la pila n veces disminuyendo la profundidad del rollo en uno cada vez.

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

Duplicar

En el lugar, la duplicación es difícil. Realmente difícil. Después de descubrir cómo invertir la pila, todavía me costó mucho trabajo encontrar el algoritmo de duplicación.

Aquí está:

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

Es un poco grande, pero así es como funciona:

Comience presionando n. n es la profundidad del duplicado. También abrimos dos paréntesis. Estos nos permiten almacenar el valor de la n en el ámbito hasta que sea necesario nuevamente.

(((n)<

A continuación, hacemos un bucle n veces cada vez que empujamos el valor superior de la pila a la pila dos veces. Esto hace que los duplicados iniciales para cada número en la pila.

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

Ahora tenemos dos copias de cada número en la pila. Necesitamos separarlos en dos grupos.

Entonces cambiamos a la pila y recuperamos una de las ns que guardamos al principio.

<>>)

Hacemos bucles n veces.

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

Cada vez que movemos una copia al mainstack.

({}<>)<>

Y rodar una copia al final de la pila. (Esto supone que la pila estaba vacía para comenzar haciendo que este duplicado no se apile)

([][()])ROLLER

Una vez hecho esto, hemos dividido el original en dos grupos, el "original" y una copia en la pila (la copia está en realidad al revés). Entonces, simplemente movemos la copia a la pila principal y podemos terminar con ella.

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

Programa esqueleto

Ahora que he hecho todas las piezas del programa, solo tengo que insertarlas en un marco.

El marco duplica el texto una vez menos que la altura de la pila usando el duplicado.

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

Y luego invierte la pila en incrementos decrecientes de la altura inicial de la pila de n ^ 2-n a 0.

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

Gelatina , 4 3 bytes

,Ṛṁ

Pruébalo en línea! o Verificar todos los casos de prueba.

Salvó un byte gracias a @ Maltysen .

Explicación

,Ṛṁ  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, pero no funcionan si la cadena contiene '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Â

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Ruby, 39 bytes

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

Le chupo a Ruby. Ayuda de golf es apreciada.

Ruby es un lenguaje muy agradable para esto debido a .reverse!

Explicación

Esperaba que fuera algo simple como:

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

pero debido a la restricción repetitiva / desafío es más largo.

Lo que s.reverse!es muy útil. s.reverse!es básicamente s = s.reverse!, lo que significa que también muta s.

Lo que hace cada sección del programa se describe a continuación:

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

Lo bueno de s.reverse!eso es que cada vez que se evalúa la cadena se voltea. Entonces, ya que reemplaza la cadena. s¡es modificado!

Perl, 24 bytes

Incluye +2 para -lp

Dar entrada en STDIN:

rev.pl <<< Hello!

rev.pl:

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

Sorprendentemente, esto no utiliza el reverseoperador incorporado . Ese nombre es tan largo, todas las soluciones que se me ocurren reverseson al menos 1 byte más largas.

J, 13 8 bytes

¡Ahorró 5 bytes gracias a millas!

#;@$];|.

Este es un tren de 5 con los siguientes verbos:

# ;@$ ] ; |.

La bifurcación interna se compone de ](identidad), ;(enlace) y |.(reverso). Observar:

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

Los dos verbos externos forman el resto del tren. #es, en este caso, el tamaño del argumento, es decir, la longitud. El verbo que une estos es ;@$, o ravelterminado 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

Antigua solución

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

Suficientemente simple. |.es inverso y ^:es una conjunción de potencia, que repite su verbo izquierdo (mano derecha) # de veces. Cuando el argumento correcto es un verbo, ese verbo se llama al argumento. El verbo correcto en este caso es el rango de cero ( i.) a la longitud ( #). Cuando se eleva a una matriz, los resultados intermedios se mantienen. Todo lo que hay que hacer es aplanar la matriz con ,.

Resultados intermedios

   (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 gracias a Hedi y Huntro.

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

función recursiva.

Invertir la cadena toma casi la mitad del tamaño ( 25 22 bytes!) ...
¿Por qué no hay una forma nativa para eso?

Minkolang , 17 bytes:

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

Pruébalo aquí!

Explicación

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

8088 Assembly, IBM PC DOS, 29 28 bytes

Montado, xxdvolcado:

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

Listado sin ensamblar:

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 ejecutable independiente de DOS para PC. Cadena de entrada a través de la línea de comando, la salida es la consola.

Pip , 11 10 bytes

L#aORVRV:a

Pruébalo en línea!

Explicación:

            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

Ejemplo:

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

Aún más corto (crédito a Damien):

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

s >> [s, reverse s] cycles ["abc", "cba", ...] que está comprimido al tamaño correcto y concatMap'ped con fst

Perl 6 ,  31  30 bytes

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

Ahorre un byte por mal uso .ords, lo que devuelve una lista de ordinales, luego implícitamente conviértalo en un número para crear un rango.

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

Explicación:

# 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 pulsaciones de teclas

Nunca puedes tener demasiadas respuestas Vim.

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

Explicación

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

Empuja todos los elementos, combina al 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

Pruébalo en línea!

Versiones antiguas:

Enfoque completamente diferente, basado en 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

Versión basada en revertir una cadena de plantilla

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

Este es mi primer intento de golf de código, así que estoy seguro de que hay innumerables mejoras.

Actualizar:

Golfed 1 byte quitando los soportes.

Gracias a Destructible Watermelon por su sugerencia, afeitado un byte.

Cubix , 52 bytes

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

En un cubo:

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

Este fue divertido; Todavía hay bytes por jugar, pero esto definitivamente funcionará.

Pruébalo en línea!

explicación:

Entrada de ABC

• /A: ir al norte y leer todas las entradas como caracteres; -1estará en la parte inferior
• p\;.: eliminar el -1de la pila
• u# : empuje la longitud de la cadena (número de elementos en la pila)
• \:\:qq : duplica la longitud de la cadena dos veces, empuja dos copias al final de la pila

• lazo:

  • soq(?/<u : intercambie la parte superior de la pila, salga de la parte superior de la pila como ASCII, presione la parte superior (letra) hacia abajo, disminuya la parte superior de la pila, gire a la derecha si no lo hizo, luego mueva la IP al lugar correcto.
  • al final del ciclo, la pila se verá como C B A 3 3 0

• ;u : pop top of stack C B A 3 3

• B : pila inversa 3 3 A B C
• p( : mover de abajo hacia arriba y disminuir 3 A B C 2
• ?si la parte superior es cero, vaya directamente @y termine
• más
  • psq:uq : mover de abajo hacia arriba, intercambiar de arriba hacia arriba y mover de arriba hacia abajo dup, y mover de arriba hacia abajo 3 2 A B C 3
  • $u : saltar u
  • < nos vuelve a poner en el circuito.

Interprete

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

-1 gracias a ceilingcat

Versión antigua

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

Pruébalo en línea!

Versión más corta (ligeramente rota)

Refiriéndose al enfoque de 76 bytes de ASCII, solo en los comentarios, y -1 byte de su ajuste de mi ajuste.

Editar: esta versión está ligeramente rota, ya que supone que cada cadena está precedida por un byte NULL, que no siempre es cierto. (Ver último caso de prueba en el enlace). Volviendo a la versión de 83 bytes por ahora.

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

Pruébalo en línea!

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 prueba sin golf

    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

Asume que la entrada está separada por espacio o nueva línea para cada carácter.

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

Algunos casos de prueba:

> 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]})

No hay una forma realmente limpia de obtener longitudes de cadena o invertirlas, por lo que esto es bastante largo.

Toma entrada $a, recorre desde 1hasta $a.length(almacenado $xpara su uso posterior). Cada iteración usamos un pseudoternario para indexar en una matriz de uno $ao $a[$x..0](es decir, invertido), en función de si nuestro número de entrada es impar / par [$_%2]. Todos estos están encapsulados en parens y editados -joinjuntos para formar una sola cadena. Eso queda en la tubería, y la salida es 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));}}

}

Sin golf:

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 el método + 18 bytes para la importación LINQ.

Cómo 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%}*

Pruébalo en línea!

Explicación

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

Octava, 39 35 bytes

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

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

Explicación:

@(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 gracias a Luis. ~xen lugar de 0*xguardar un byte (funciona porque todos los elementos de x no son cero. en fliplugar de flipudguardar otros dos bytes (no sabía que flipexistían).

bash + util-linux, 68 58 53 bytes

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

Explicación

Dos cosas con el forbucle:

• Hay una forma aparentemente indocumentada de escribir forbucles donde uno reemplaza las palabras clave doy donecon llaves {y }. El espacio después del primer paréntesis es necesario, y el punto y coma al final también es necesario.
• Resulta que en los forbucles de "estilo C" , puede simplemente inicializar con en i;lugar de usar i=0;.
• La ${#1}parte de la condición se i < ${#1}refiere a la longitud de nuestra entrada (el primer parámetro $1). En general, puede usar ${#foo}para recuperar el tamaño de la cadena $foo.

Adicionalmente:

• rev es la herramienta en util-linux que invierte una cadena.
• Necesitamos pasar la -nbandera para echodeshacernos de las nuevas líneas.
• La expresión rev<<<$yse llama here-string (consulte esta página relevante de tldp.org ), que pasa la variable $ya la entrada estándar de rev.

Japt , 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.

Pruébalo en línea!

05AB1E , 7 bytes

vDR}v}J

Pruébalo en línea!

Continuará trabajando en ello. Realmente no me gusta la parte "v}", probablemente pueda guardar un byte allí.

Explicación

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