StringgnirtSStringgnirtSStringgnirtS

42

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

DJMcMayhem
fuente
En su ejemplo, ¿no debería ser eso olleH, no elloH?
Arnaud
2
@Downgoat No, debe tomar la entrada y la salida en el mismo formato que se describe en la especificación.
DJMcMayhem
44
¿No debería ser el título StringgnirtSStringgnirtSStringgnirtS ?
Luis Mendo
2
@carusocomputing No lo hará: "Puede suponer con seguridad que la cadena de entrada no estará vacía y solo contendrá ASCII imprimible".
Martin Ender
1
en.wikipedia.org/wiki/ASCII#Printable_characters Ah, no sabía que era un subconjunto bien definido de ASCII. Me imaginé imprimible para incluir \ t, \ n, etc ...
Magic Octopus Urn

Respuestas:

22

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

ingrese la descripción de la imagen aquí

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!

DJMcMayhem
fuente
2
En lugar de :%s/\n<cr>, puede hacer v{gJpara guardar tres bytes.
Lynn
2
¿Una respuesta VIM? Es un movimiento elegante de tu parte.
Urna de pulpo mágico
@ Lynn ¡Gracias por la sugerencia! Terminé haciendo algo un poco diferente y quité 5 en su lugar.
DJMcMayhem
Esto supone que @qestá vacío al principio, ¿verdad? o @qantes de detener la grabación haría algo arbitrario. (Esto me lleva a mi vim trivium favorito que se me ocurrió: todos saben que salir de vim es tan fácil como :q<CR>, pero ¿cómo cierras y guardas todos tus archivos? ¡Fácil: solo qqqqqZZ@qq@q!)
wchargin
@wchargin Sí, esto requiere @qestar vacío. ¿Por qué no simplemente hacer en su :wqalugar? ¿También quieres saber cómo generar un fractal en vim? qqqqq<C-w>v<C-w>n@qq@q: D
DJMcMayhem
18

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.

xnor
fuente
Guau. Estaba a punto de enviar una respuesta de Python de 56 bytes, jaja
DJMcMayhem
@DJMcMayhem también late lambda s:(len(s)*(s+s[::-1]))[:len(s)**2]por un byte.
Jonathan Allan
Obtuve esto, f = lambda s : ''.join([s[((-1)**(i//len(s)) <= 0)*(len(s)-1)+(-1)**(i//len(s))*(i%len(s))] for i in range(len(s)*len(s))])pero es de 136 bytes sys.sizeof, curiosamente, es del mismo tamaño quef = lambda s : ''.join([s[::1] if i%2 else s for i in range(len(s))])
Carel
12

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
  >)
 >)
}{}{}
Asistente de trigo
fuente
55
Asombroso. ¡Siempre me vuelves loco con lo que este lenguaje puede hacer! : D
DJMcMayhem
10

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
millas
fuente
1
molde no necesita elL
Maltysen
@ Maltysen wow gracias, ¿lo sabías por el código fuente o por experiencia
Millas
Por experiencia, no conozco a Jelly, pero supuse que eso sería lo que el moho haría en un no número, ya que Jelly realmente no hace sobrecargas, también el moho me recordó la remodelación de J
Maltysen el
En realidad, el molde solo toma iterables, pero arroja enteros para rango primero.
Dennis
1
Sí, traté el moho como una nueva forma, así que habitualmente le di un número. Hay tantas pequeñas delicias en Jelly, como la forma en que una serie de cadenas se genera automáticamente como una cadena concatenada
millas del
9

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);
Cripto
fuente
Me olvidé por completo str_pad. ¡Buena esa!
Titus
8

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!

Adnan
fuente
6

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!

Downgoat
fuente
Con la -pbandera puede guardar 4 bytes:$_.reverse!;gsub(/./){$_.reverse!}
Jordan
@ Jordan ¿no necesitaría un pensamiento .chompsobre el $_? parece incluir la nueva línea en este momento
Downgoat
No si haces algo como ruby -pe '$_.reverse!;gsub(/./){$_.reverse!}' < file.txtdónde file.txtestá una línea sin la nueva línea final: V De todos modos, si decides no hacer eso, no necesitas parens en el lambda, así que ->sfunciona
Value Ink
@ValueInk, puede proporcionar una entrada sin línea nueva sin archivo si la canaliza. O incluso puede escribirlo manualmente, simplemente no presione Entrar: i.stack.imgur.com/6luxM.png
manatwork
1
No necesita paréntesis alrededor del argumento de lambda. Además, creo que puede afeitarse uno de los signos de exclamación:s.gsub(/./){s.reverse!.reverse}
m-chrzan
6

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.

Ton Hospel
fuente
Votado a favor de encontrar una solución que tome menos bytes que un incorporado
MilkyWay90
6

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
Conor O'Brien
fuente
Puede guardar un byte encajonando la longitud<@#
millas del
Una solución ordenada de 8 bytes es la #;@$];|.que encajona el inicio y el reverso, da nueva forma a las cadenas en caja y las arrasa juntas
millas del
@miles whoa, eso es bastante bueno.
Conor O'Brien
5

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?

Titus
fuente
1
Podrías usar s[n]?...intead den<s.length?...
Hedi
1
También puede guardar 3 bytes usando en [...s]lugar des.split``
Huntro
sí 36 bytes idealmentef=(s,n=1)=>n==1?s:s+s.reverse(),n-1)
caub
uno no recursivo f=(s,n=1)=>Array.from({length:n},(_,i)=>i%2?s.reverse():s).join``)que también sería mejor con una mejor función para el rango
caub
@caub: SyntaxError: Unexpected token )JS no tiene reversión de cadena nativa. SyntaxError: Invalid or unexpected tokenpara su segunda sugerencia ¿En qué navegador funciona eso?
Titus
4

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.
El'endia Starman
fuente
4

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.

ingrese la descripción de la imagen aquí

640 KB
fuente
3

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)
DLosc
fuente
3

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

michi7x7
fuente
2
q s=zip(s>>[s,reverse s])s>>=fst
Damien
3
O Pointfree uno con el mismo tamaño:(>>=fst).(iterate reverse>>=zip)
Damien
3

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
Brad Gilbert b2gills
fuente
3

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
Jordán
fuente
1
Con coreutils? ¡Eso es hacer trampa! : P
Christian Rondeau
3

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
Sanchises
fuente
Me gusta el uso inteligente de td!
DJMcMayhem
@DJMcMayhem Gracias! tnq:"Primero tuve lo obvio , pero tn:"es un poco un olor a código (vea este consejo de golf de Matlab), así que pensé que también tnq:podría ser más compacto.
Sanchises
3

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.

Él Mismo12794
fuente
No sé scala, pero ¿puedes cambiar i%2==1a i%2>0?
Destructible Lemon
@DestructibleWatermelon No había pensado en eso, sí puedo
Él mismo12794
3

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

Giuseppe
fuente
Aquí hay uno de 24 bytes . La misma lógica general se comprimió un poco.
MickyT
@MickyT Me sentiría mal por tomar crédito por 28 bytes de golf. ¡Publícalo tú mismo!
Giuseppe
3

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!

gastropner
fuente
67
Solo ASCII
@ Solo ASCII 68 es posible con algunos ajustes.
Gastropner
: P es 67 ahora lol @gastropner
solo ASCII
@ ASCII-only 66
:-P
@ Solo ASCII Lamentablemente, la versión corta resulta que no funciona en ciertos casos.
Gastropner
2

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!", ""));
}
Shaun Wild
fuente
Esto se puede jugar un poco más: (s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?s:new StringBuffer(s).reverse();return r;};( 88 bytes ). Además, especificaría que esto es Java 8.
Kevin Cruijssen
No, está bien suponer que está usando la última versión de Java.
Shaun Wild
@KevinCruijssen Java 7 ya no es compatible (excepto con grandes $$$). No deberíamos tener que especificar la versión de Java. Además, si escribe como Java 7, la mayoría de las respuestas se pueden escribir en Java 1.1 o 1.2. Entonces, ¿no deberías escribir la versión más baja con la que funciona? Si el código en esta respuesta fuera compatible con Java 7, sería compatible con Java 1.2 y ... aún funcionaría en Java 8.
Olivier Grégoire
2

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
rturnbull
fuente
2

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
AdmBorkBork
fuente
2

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

Hierba Wolfe
fuente
1
Hola, bienvenido a PPCG! En primer lugar, me gustaría recomendar leer los Consejos para jugar golf en Java . En cuanto a su código, hay algunas cosas que aún se pueden jugar: puede eliminar el public staticantes de su método. Puede eliminar los espacios entre t=new StringBuffer. Puede eliminar los paréntesis y paréntesis innecesarios. Y puede cambiar la verificación del módulo de ==1a <1(que es equivalente a ==0para números no negativos). Además, puede mover i++al último uso dentro del ciclo for.
Kevin Cruijssen
66
Entonces, en total se convierte en: void r(String s){for(int i=0;i<s.length();)System.out.print(i++%2<1?s:new StringBuffer(s).reverse()+"");}( 105 bytes )
Kevin Cruijssen
2

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
        )
    )
;
Leche
fuente
2

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
Luis Mendo
fuente
2

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

Stewie Griffin
fuente
2

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.
marcos
fuente
Por favor explique algunos de sus conocimientos. También quizás el espacio antes del eco pueda ser removible, aunque no estoy bien informado sobre bash
Rohan Jhunjhunwala
@RohanJhunjhunwala Se agregó una pequeña explicación a la respuesta para ayudar a aclarar algunas cosas. También: cuando se omite el doy donepalabras clave en un forbucle, que en realidad no necesita ese espacio!
marcos
+1 se ve bien ahora. Solo comenté porque su código dibujó una bandera automática de baja calidad. Las respuestas de solo código se marcan automáticamente
Rohan Jhunjhunwala
y=$1;for((;i<${#1};i++)){ printf $y;y=`rev<<<$y`;}... guardó un par de bytes
roblogic
2

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!

Liendre
fuente
@ Shaggy Intenté usarlo, pero por mi vida, no puedo entenderlo. : P ¡Muchas gracias por el ejemplo, sin embargo!
Nit
Lo sentimos, publicó el enlace incorrecto, en realidad son 6 bytes .
Shaggy
1
@ Shaggy No me importaría, y es lo suficientemente diferente a la respuesta de Nit. Ve por ello hombre.
Oliver
2

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
Multi
fuente
1
vÂ}\J 5 bytes es lo mismo que su código, pero con los componentes que estaba buscando. :)Âes Bifurcado (abreviatura de Duplicar e Invertir, que es exactamente lo que estás haciendo). \ elimina el elemento superior en la pila.
Kevin Cruijssen