StringgnirtSStringgnirtSStringgnirtS


42

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

code-golf  string  code-golf  math  geometry  data-structures  repeated-transformation  code-golf  number  random  code-golf  math  rational-numbers  code-golf  ascii-art  animation  code-golf  ascii-art  number  code-golf  math  number  code-golf  data-structures  code-golf  string  parsing  code-golf  array-manipulation  random  permutations  code-golf  string  code-golf  parsing  code-golf  string  quine  code-golf  string  parsing  comment  code-golf  string  counting  natural-language  code-golf  string  decision-problem  code-golf  math  code-challenge  metagolf  test-battery  code-golf  string  code-golf  math  number  arithmetic  source-layout  code-golf  number  primes  decision-problem  code-golf  math  arithmetic  code-golf  date  code-golf  string  cryptography  code-golf  code-golf  chess  board-game  code-golf  geometry  grid  puzzle-solver  set-partitions  code-golf  number  natural-language  code-golf  ascii-art  code-golf  math  code-golf  string  ascii-art  kolmogorov-complexity  code-golf  string  natural-language  code-golf  game  board-game  tic-tac-toe  code-golf  ascii-art  hexagonal-grid  code-golf  string  comment  code-golf  internet  code-golf  sorting  code-golf  kolmogorov-complexity  unicode  code-golf  tips  code-golf  string  natural-language  code-golf  string  kolmogorov-complexity  source-layout  hello-world  code-golf  string  kolmogorov-complexity  counting  natural-language  code-golf  random  quine  code-golf  string  math  bitwise  code-golf  permutations  code-golf  string  code-golf  arithmetic 

No seu exemplo, não deve ser isso olleH, não elloH?
Arnaud

2
@Downgoat Não, você deve receber entrada e saída no mesmo formato que a especificação descreve.
DJMcMayhem

4
O título não deve ser StringgnirtSStringgnirtSStringgnirtS ?
Luis Mendo

2
@carusocomputing Não será: "Você pode assumir com segurança que a string de entrada não estará vazia e conterá apenas ASCII imprimível".
Martin Ender

1
en.wikipedia.org/wiki/ASCII#Printable_characters Ah, não sabia que era um subconjunto bem definido de ASCII. Imaginei impressão para incluir \ t, \ n, etc ...
Magia Octopus Urna

Respostas:


22

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

insira a descrição da imagem aqui

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!


2
Em vez de :%s/\n<cr>, você pode fazer v{gJpara salvar três bytes.
Lynn

2
Uma resposta VIM ?! Essa é uma jogada elegante da sua parte.
Magic Octopus Urn

@ Lynn Obrigado pela dica! Acabei fazendo algo um pouco diferente e tirei 5 em vez disso.
DJMcMayhem

Isso pressupõe que @qestá vazio no início, certo? ou o @qantes de parar a gravação faria algo arbitrário. (Isso me leva a minha trivium vim favorita que eu vim acima com: todos sabem que desistir vim é tão fácil como :q<CR>, mas como você fechar e salvar todos os seus arquivos fáceis:? Apenas qqqqqZZ@qq@q!)
wchargin

@wchargin Sim, isso precisa @qestar vazio. Por que não apenas fazer :wqa? Também quer saber como gerar um fractal no 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)

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.


Uau. Eu estava prestes a enviar uma resposta python de 56 bytes, haha
DJMcMayhem

@DJMcMayhem também bate lambda s:(len(s)*(s+s[::-1]))[:len(s)**2]em um byte.
Jonathan Allan

Eu consegui isso, 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))])mas é de 136 bytes de acordo com sys.sizeof, curiosamente, é o mesmo tamanho de #f = lambda s : ''.join([s[::1] if i%2 else s for i in range(len(s))])
Carel

12

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

5
Surpreendente. Você sempre me surpreende com o que essa linguagem pode fazer! : D
DJMcMayhem

10

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

1
o molde não precisa doL
Maltysen 15/09/16

@ Maltysen uau obrigado, você sabia que a partir do código fonte ou da experiência
miles

a partir da experiência, eu não sei Jelly, mas eu meio que adivinhou isso é o que o molde faria em um não-número, uma vez Jelly realmente não faz sobrecargas, também moldar meio me fez lembrar de remodelagem de J
Maltysen

Na verdade, o molde leva apenas iterables, mas projeta números inteiros para variar primeiro.
Dennis

1
Sim, eu tratei o molde como remodelar, então, habitualmente, dei um número. Há tantas guloseimas pouco nítidas em Jelly, como como uma matriz de strings é apenas automaticamente a saída como uma string concatenada
milhas

9

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

Eu esqueci completamente str_pad. Agradável!
Titus

8

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!


6

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!


Com a -pbandeira, você pode salvar 4 bytes:$_.reverse!;gsub(/./){$_.reverse!}
Jordan

@ Jordânia eu não precisaria de um pensamento .chompsobre o $_? parece incluir a nova linha no momento
Downgoat 15/09/16

Não se você fizer algo como ruby -pe '$_.reverse!;gsub(/./){$_.reverse!}' < file.txt, onde file.txté uma linha sem a nova linha de fuga: V De qualquer forma, se você decidir não fazer isso, você não precisa de parênteses na lambda tão ->sobras
Valor de tinta

@ValueInk, você pode fornecer uma entrada sem linha sem arquivo, se você a canalizar. Ou você mesmo pode digitá-lo manualmente, não apenas pressione Enter: i.stack.imgur.com/6luxM.png
manatwork

1
Você não precisa de parênteses em torno do argumento da lambda. Além disso, eu acho que você pode raspar um dos pontos de exclamação:s.gsub(/./){s.reverse!.reverse}
m-Chrzan

6

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.


Promovido o voto por encontrar uma solução que consome menos bytes que um built-in
MilkyWay90

6

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

Você pode salvar um byte encaixotando o comprimento<@#
miles

Uma solução de 8 bytes puro é #;@$];|.que a caixas inicial e inverter, remodela as cordas e encaixotados arrasa-los juntos
milha

@ Miles whoa, isso é muito legal.
Conor O'Brien

5

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?


1
Você pode usar s[n]?...intead den<s.length?...
Hedi

1
Você também pode salvar 3 bytes usando em [...s]vez des.split``
Huntro

sim 36 bytes idealmentef=(s,n=1)=>n==1?s:s+s.reverse(),n-1)
caub

um não recursiva f=(s,n=1)=>Array.from({length:n},(_,i)=>i%2?s.reverse():s).join``)que também ser melhor com um pouco melhor função de gama
caub

@caub: SyntaxError: Unexpected token )JS não possui reversão de string nativa. SyntaxError: Invalid or unexpected tokenpara sua segunda sugestão. Em que navegador isso funciona?
Titus

4

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.

4

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.

insira a descrição da imagem aqui


3

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)

3

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


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

3
Ou Pointfree um com o mesmo tamanho:(>>=fst).(iterate reverse>>=zip)
Damien

3

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

3

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

1
Com coreutils? Isso é batota! : P
Christian Rondeau

3

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

Eu gosto do uso inteligente de td!
DJMcMayhem

@DJMcMayhem Thanks! Eu tive o óbvio tnq:"primeiro, mas tn:"é um pouco de cheiro de código (veja esta dica de golfe do Matlab), então achei que tnq:poderia ser mais compacto também.
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)}

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.


Não conheço scala, mas você pode mudar i%2==1para i%2>0?
Destructible Lemon

@DestructibleWatermelon não tinha pensado nisso, sim, eu posso
Himself12794

3

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


Aqui está um de 24 bytes . A mesma lógica geral apenas comprimiu um pouco.
MickyT 21/03

@MickyT Eu me sentiria mal por receber crédito por 28 bytes de golfe. Publique você mesmo!
Giuseppe

3

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!



@ Somente ASCII 68 é possível com alguns ajustes.
gastropner 23/03

: P agora são 67 lol @gastropner
ASCII-only

@ ASCII-only 66 :-P
gastropner 23/03

@ Somente ASCII Infelizmente, a versão curta acaba não funcionando em certos casos.
gastropner 23/03

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 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!", ""));
}

Isso pode ser jogado um pouco mais: (s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?s:new StringBuffer(s).reverse();return r;};( 88 bytes ). Além disso, gostaria especificar que esta é Java 8.
Kevin Cruijssen

Na, é bom supor que ele está usando a versão mais recente do Java.
Shaun Wild

@KevinCruijssen O Java 7 não é mais suportado (exceto com grandes $$$). Não devemos precisar especificar a versão do Java. Além disso, se você escrever como Java 7, a maioria das respostas poderá ser escrita em Java 1.1 ou 1.2. Então você não deve escrever a versão mais baixa com a qual ela funciona? Se o código neste resposta foi Java 7 compatível, seria Java 1.2 compatível, e ... seria ainda trabalho em Java 8.
Olivier Grégoire

2

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

2

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

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

}

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


1
Olá, seja bem-vindo ao PPCG! Antes de tudo, eu gostaria de recomendar a leitura de Dicas para jogar golfe em Java . Quanto ao seu código, existem algumas coisas que ainda podem ser jogadas no golfe: Você pode remover o public staticmétodo before. Você pode remover os espaços entre eles t=new StringBuffer. Você pode remover os parênteses e colchetes desnecessários. E você pode trocar a verificação do módulo de ==1para <1(o que equivale a ==0números não negativos). Além disso, você pode mover i++o último uso para dentro do loop for.
Kevin Cruijssen 15/09/16

6
Assim, no total, torna-se: 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 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
        )
    )
;

2

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

2

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


2

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.

Por favor, explique um pouco do seu conhecimento. Além disso, talvez o espaço antes o eco pode ser removível, não sou qualificada na festa embora
Rohan Jhunjhunwala

@RohanJhunjhunwala Adicionou uma pequena explicação à resposta para talvez ajudar a esclarecer algumas coisas. Além disso: quando omitindo o doe donepalavras-chave em um forloop, você realmente não precisa que o espaço!
frames

+1 parece bom agora. Eu apenas comentei porque seu código desenhou um sinalizador automático de baixa qualidade. Respostas só de código se auto sinalizado
Rohan Jhunjhunwala

y=$1;for((;i<${#1};i++)){ printf $y;y=`rev<<<$y`;}... salvou alguns bytes
roblogic 23/03

2

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!



@ Shaygy Eu tentei usá-lo, mas para a minha vida, eu não consigo pegar o jeito. : P Muito obrigado pelo exemplo!
Nit

Desculpe, postou o link errado, na verdade são 6 bytes .
Shaggy


1
@ Shaggy, eu não me importaria, e é diferente o suficiente da resposta de Nit. Vá em frente, cara.
266 Oliver Oliver

2

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

1
vÂ}\J 5 bytes é igual ao seu código, mas com os recursos internos que você estava procurando. :)Âé Bifurcate (abreviação de Duplicate & Reverse, que é exatamente o que você está fazendo). \ exclui o item superior da pilha.
Kevin Cruijssen 24/10
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.