여기에는 비교적 간단한 도전이 있습니다.

길이의 문자열이 주어 N 문자열 전달 후 거꾸로하고 전달하고 거꾸로 출력 등 ... N의 시간. 예를 들어 입력이

Hello!

다음을 출력해야합니다.

Hello!!olleHHello!!olleHHello!!olleH

선택적으로 후행 줄 바꿈 하나를 출력 할 수도 있습니다.

제출은 전체 프로그램 또는 기능 일 수 있으며, 합리적인 형식으로 입력 및 출력 할 수 있습니다 . 예를 들어, STDIN / STDOUT, 함수 인수 및 리턴 값, 파일 등에서 IO를 가져올 수 있습니다. 입력 문자열이 비어 있지 않고 인쇄 가능한 ASCII 만 포함한다고 가정 할 수 있습니다. 당신은 반드시 한 줄에 출력 새 문자열을. 예를 들어 마지막 예의 출력이

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

이것은 유효한 해결책 이 아닙니다 !

다음은 몇 가지 테스트 사례입니다.

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

리더 보드

이것은 코드 골프 도전이므로 표준 허점 은 금지되며 바이트 단위의 최단 답변이 이깁니다! 그러나 이것은 특정 언어에서 가장 짧은 답변을 얻는 경쟁 이기도 합니다. Java 응답이 perl 또는 일부 골프 언어의 응답을 이길 가능성은 없지만 Java 응답이 가장 짧은 것이 여전히 인상적입니다. 이 리더 보드를 사용하여 둘 다 볼 수 있습니다.

1. 모든 언어 중에서 가장 짧은 답변

2. 각 개별 언어에서 가장 짧은 답변.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

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

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

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

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](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 키 스트로크

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

@Lynn 덕분에 5 바이트가 절약되었습니다!

여기에 생방송의 gif가 있습니다 : (이 gif는 아직 다시 녹음 할 시간이 없었기 때문에 이전 버전입니다).

작동 방식에 대한 설명은 다음과 같습니다.

: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

참고로, Y추가 개행을 잡습니다. 보통은 눈에 띄지 않는 기능입니다. 실제로 몇 바이트를 절약 한 것은 이번이 처음입니다!

파이썬, 40 바이트

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

재귀 함수 s카운터 i가 길이를 초과 할 때까지 입력 문자열 을 반전 기능 앞에 추가합니다 s.

Brain-Flak , 418 378 228 바이트

이것은 내 Brain-Flak 걸작입니다. 골프는 잘되지 않았지만 도전은 내가 경험 한 것 중 가장 어렵다.

온라인으로 사용해보십시오!

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

설명

이 설명은 이제 약간 구식이지만 여전히 프로그램을 설명하는 데 아주 효과적입니다.

이 설명은 정기적 인 설명 과정과 약간 다릅니다. 결과를 순서대로 설명하는 대신이 결과에 대해 어떻게 설명했는지 설명하겠습니다. 여기 간다:

롤러

문제를 해결 한 후이 코드를 생각해 냈습니다.

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

이 코드 (여기서 n은 숫자의 리터럴입니다. 예 ()())는 스택의 맨 위에있는 항목을 가져 와서 n 단계 아래로 이동합니다. n을 스택 높이로 사용하면 스택 "롤"이 수행됩니다. 즉, 맨 위 항목을 스택 맨 아래로 이동하십시오. 작동 방식은 다음과 같습니다.

우리는 아이템을 옮길 곳을 스택에서 빼기 위해 놓았습니다. 왜 빼기? 나는 그것이 그렇게 작동한다는 것을 모른다.

(n[()])

그런 다음이 숫자가 0으로 루프를 추적하면서 0에 도달 할 때까지 반복합니다 ().

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

루프 할 때마다 맨 위 항목을 집어 들고 그 아래 항목을 다른 스택으로 옮깁니다. 이것은 그 자리에 번호를 넣습니다.

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

우리가 지금해야 할 일은 우리가 옮긴 숫자를 넣는 것입니다. 우리는 오프 스택으로 전환하고 루프의 실행 횟수를 푸시합니다.

(...<>)

새로 푸시 된 숫자가 0에 도달 할 때까지 감소시킵니다. 우리는 하나의 숫자를 뒤로 움직일 때마다.

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

역

다음으로 전체 스택을 뒤집기 위해 롤을 수정했습니다.

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

다시 한번 n은 역의 깊이를 나타낸다. 즉, 스택의 상위 n 개 항목이 반대로됩니다. 작동 방식 :

그 반대는 단지 환상적으로 감겨 진 롤러입니다. 우리는 단순히 스택의 상단을 n 번 굴려서 롤의 깊이를 매번 하나씩 줄입니다.

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

복제

그 자리에서 중복은 어렵다. 정말 열심히. 스택을 뒤집는 방법을 알아 낸 후에도 여전히 중복 알고리즘을 고안하는 데 많은 노력이 필요했습니다.

여기있어:

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

약간 큰 것이지만 작동 방법은 다음과 같습니다.

n을 눌러 시작하십시오. n은 복제 깊이입니다. 우리는 또한 두 개의 괄호를 엽니 다. 이를 통해 우리는 다시 필요할 때까지 범위의 n 값을 저장할 수 있습니다.

(((n)<

다음으로 스택의 최상위 값을 오프 스택으로 두 번 밀어 넣을 때마다 n 번 반복합니다. 이렇게하면 스택의 각 숫자에 대한 초기 복제본이 만들어집니다.

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

이제 우리는 오프 스택에 각 번호의 사본 두 개를 가지고 있습니다. 이를 두 그룹으로 분리해야합니다.

따라서 우리는 오프 스택으로 전환하고 처음에 저장 한 n 중 하나를 호출합니다.

<>>)

우리는 n 번 반복합니다.

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

매번 복사본을 메인 스택으로 옮길 때마다.

({}<>)<>

한 장을 더미의 맨 아래로 굴립니다. (이것은 스택이 깨끗하지 않게하기 위해 오프 스택이 비어 있다고 가정합니다)

([][()])ROLLER

이 작업이 완료되면 원본을 "원본"과 오프 스택의 사본 두 그룹으로 나눕니다 (사본은 실제로 반대입니다). 복사본을 주 스택으로 옮기면됩니다.

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

스켈레톤 프로그램

이제 프로그램의 모든 부분을 만들었으므로 프레임에 삽입하면됩니다.

프레임은 텍스트를 스택 높이보다 1 배 적은 두 배로 만듭니다. 복제 사용.

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

그런 다음 초기 스택 높이를 n ^ 2-n에서 0으로 감소시키면서 스택을 뒤집습니다.

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

젤리 , 4 3 바이트

,Ṛṁ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

@ Maltysen 덕분에 바이트를 저장했습니다 .

설명

,Ṛṁ  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 바이트

(49 바이트이지만 문자열에 '0'이 있으면 작동하지 않습니다.)

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

(52 바이트)

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

(54 바이트)

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

2sable , 3 바이트

암호:

gGÂ

설명:

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

루비, 39 바이트

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

나는 루비를 빨아 먹는다. 골프 도움을 부탁드립니다.

루비는 이것 때문에 정말 좋은 언어입니다. .reverse!

설명

나는 그것이 다음과 같이 간단하다고 기대했다.

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

상용구 / 도전 제한으로 인해 더 길어졌습니다.

s.reverse!매우 유용한 것은 무엇입니까? s.reverse!기본적으로 s = s.reverse!, 그것은 또한 변이를 의미합니다 s.

프로그램의 각 섹션이 수행하는 작업은 다음과 같습니다.

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

그것에 대한 s.reverse!좋은 점은 매번 문자열이 뒤집히는 것으로 평가 될 때입니다. 문자열을 대체합니다. s수정되었습니다!

펄, 24 바이트

에 +2 포함 -lp

STDIN에 입력하십시오 :

rev.pl <<< Hello!

rev.pl:

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

놀랍게도 이것은 내장 reverse연산자를 사용하지 않습니다 . 그 이름은 너무 길어서 내가 생각할 수있는 모든 솔루션 reverse은 적어도 1 바이트 더 깁니다.

J, 13 8 바이트

마일 덕분에 5 바이트를 절약했습니다!

#;@$];|.

이 동사는 다음 동사가 포함 된 5 개 열차입니다.

# ;@$ ] ; |.

내부 포크는 ](정체성), ;(링크) 및 |.(역방향)으로 구성됩니다. 관찰 :

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

바깥 두 동사는 나머지 열차를 만듭니다. #이 경우 인수의 크기, 즉 길이입니다. 이러한 연결 동사는 ;@$, 또는 ravel이상 reshape. 관찰 :

   # '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

오래된 해결책.

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

충분히 간단합니다. |.거꾸로하고 ^:힘을 합쳐서 왼쪽 동사 (오른손)를 여러 번 반복합니다. 올바른 인수가 동사 인 경우 해당 동사가 인수에서 호출됩니다. 이 경우 오른쪽 동사의 범위는 0 i.에서 길이 ( #)입니다. 배열로 올라가면 중간 결과가 유지됩니다. 해야 할 일은로 배열을 평평하게하는 것입니다 ,.

중간 결과

   (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

자바 스크립트 (ES 6), 59 50 바이트

Hedi와 Huntro 덕분에 9 바이트.

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

재귀 함수.

문자열을 뒤집는 것은 크기의 거의 절반을 차지합니다 ( 25 22 바이트!) ...
왜 기본 방법이 없습니까?

Minkolang , 17 바이트 :

$oId$z$Dz[rz[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.

8088 어셈블리, IBM PC DOS, 29 28 바이트

조립, xxd덤프 :

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

조립되지 않은 리스팅 :

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

독립형 PC DOS 실행 프로그램. 명령 행을 통한 입력 문자열, 출력은 콘솔입니다.

핍 , 11 10 바이트

L#aORVRV:a

온라인으로 사용해보십시오!

설명:

            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)

하스켈, 40 36 32 바이트

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

예:

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

더 짧아짐 (Damien의 신용) :

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

s >> [s, reverse s] 사이클 [ "abc", "cba", ...] 올바른 크기로 압축되고 fst로 concatMap'ped

펄 6 ,  31  30 바이트

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

을 잘못 사용하여 1 바이트를 저장 .ords하면 서수 목록이 반환되고 암시 적으로 숫자로 변환하여 범위를 만듭니다.

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

설명:

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

용법:

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 번의 키 스트로크

너무 많은 Vim 답변을 가질 수 없습니다.

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

설명

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 바이트

모든 요소를 ​​푸시하고 결국 결합합니다.

td"tP]&h

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

온라인으로 사용해보십시오!

이전 버전 :

다음을 기반으로하는 완전히 다른 접근 방식 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

템플릿 문자열을 뒤집은 버전

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

스칼라, 73 72 71 바이트

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

이것은 코드 골프에 대한 나의 첫 번째 시도이므로, 수많은 개선이있을 것입니다.

최신 정보:

괄호를 제거하여 1 바이트를 버렸습니다.

제안에 대한 Destructible Watermelon 덕분에 바이트가 줄었습니다.

Cubix , 52 바이트

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

큐브에서 :

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

이것은 재미 있었다; 이것으로부터 여전히 골을 넣을 바이트가 있지만 이것은 확실히 작동합니다.

온라인으로 사용해보십시오!

설명:

입력 ABC

• /A: 북쪽으로 가서 모든 입력을 문자로 읽습니다. -1바닥에있을 것입니다
• p\;.: -1스택에서 제거
• u# : 문자열 길이 (스택의 항목 수)를 누릅니다.
• \:\:qq : 문자열 길이를 두 번 두 번 쌓아 두 장을 스택 맨 아래로 밀어 넣습니다.

• 고리:

  • soq(?/<u : 스택 맨 위, 스택 맨 위 ASCII로, 맨 위 (레터)를 맨 아래로 밀고, 맨 위를 내린 후 오른쪽으로 돌리고, 완료되지 않은 경우 IP를 올바른 위치로 옮깁니다.
  • 루프가 끝나면 스택은 다음과 같이 보입니다. C B A 3 3 0

• ;u : 스택의 상단 C B A 3 3

• B : 역 스택 3 3 A B C
• p( : 아래에서 위로 이동 및 감소 3 A B C 2
• ?상단이 0이면 바로 가서 @종료하십시오.
• 그밖에
  • psq:uq : 아래에서 위로 이동, 위로 교체 및 위로 이동 3 2 A B C 3
  • $u : 건너 뛰기 u
  • < 우리를 루프로 되돌립니다.

통역사

C (gcc) , 88 87 85 83 68 66 83 82 78 바이트

ceilingcat 덕분에 -1

구 버전

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

온라인으로 사용해보십시오!

더 짧은 버전 (약간 깨짐)

의견 에 ASCII 전용 으로 76 바이트 접근 방식을 찢어 내고 조정 한 -1 바이트.

편집 :이 버전은 모든 문자열 앞에 NULL 바이트가 있다고 가정한다는 점에서 약간 깨졌습니다. 항상 참이 아닙니다. (링크의 마지막 테스트 사례를 참조하십시오). 지금은 83 바이트 버전으로 되돌립니다.

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

온라인으로 사용해보십시오!

자바, 127 (111) 88 바이트

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

언 골프 테스트 프로그램

    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 바이트

입력이 각 문자에 대해 공백 또는 개행 문자로 구분되어 있다고 가정합니다.

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

일부 테스트 사례 :

> 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 바이트

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

문자열 길이를 얻거나 뒤집을 수있는 확실한 방법은 없으므로 꽤 길다.

input을 가져오고 $a루프를 반복 1합니다 $a.length( $x나중에 사용하기 위해 저장 됨). 각 반복은 우리 의 입력 번호가 홀수 / 짝수인지에 따라 의사 삼항을 사용하여 하나 $a또는 $a[$x..0]( 또는 반대로) 배열로 색인 합니다 [$_%2]. 이것들은 모두 parens로 캡슐화되어 -join하나로 묶여 단일 문자열을 형성합니다. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

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

자바, 151 바이트

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

}

언 골프 드 :

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 바이트

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

메소드의 경우 76 바이트 + LINQ 가져 오기의 경우 18 바이트

작동 방식 :

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 바이트

l_,({_W%}*

온라인으로 사용해보십시오!

설명

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

옥타브, 39 35 바이트

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

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

설명:

@(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

Luis 덕분에 4 바이트를 절약했습니다. 1 바이트 ~x대신 0*x저장 (x의 모든 요소가 0이 아니기 때문에 작동합니다. 다른 2 바이트 flip를 flipud저장하는 대신 ( flip존재 하지 않았습니다 ).

bash + util-linux, 68 58 53 바이트

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

설명

for루프 와 함께 두 가지 :

• 작성 명백히 문서화되지 않은 방법이 for하나가 대체 루프 do와 done중괄호와 키워드를 {하고 }. 첫 번째 대괄호 뒤에 공백이 필요 하고 끝에 세미콜론 도 필요합니다.
• "C- 스타일" for루프에서는 i;을 사용 하는 대신 초기화 할 수 있습니다 i=0;.
• ${#1}조건 의 일부는 i < ${#1}입력 길이 (첫 번째 매개 변수 $1)를 나타냅니다. 일반적으로 ${#foo}문자열 크기를 검색하는 데 사용할 수 있습니다 $foo.

또한 :

• rev util-linux에서 문자열을 바꾸는 도구입니다.
• 줄 바꿈을 제거 하려면 -n플래그 를 전달해야합니다 echo.
• 식은 rev<<<$y불리며 여기 스트링 (볼 이 중요한 tldp.org 페이지 가변 전달), $y표준 입력을 rev.

Japt , 11 바이트

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

온라인으로 사용해보십시오!

05AB1E , 7 바이트

vDR}v}J

온라인으로 사용해보십시오!

계속해서 노력하겠습니다. 나는 "v}"부분이 마음에 들지 않으며 아마도 바이트를 절약 할 수있을 것이다.

설명

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