목록 또는 구분 된 문자열이 제공되면 한 단어 후에 각 단어의 첫 문자가 포함 된 목록 또는 구분 된 문자열을 출력하십시오.

이 문제를 해결하기 위해 "단어"는 공백, 줄 바꿈 및 탭 문자를 제외한 인쇄 가능한 모든 ASCII 문자로만 구성됩니다.

예를 들어, "좋은 오후, 세계!"라는 문자열을 사용하십시오. (공백으로 구분) :

1. String
"Good afternoon, World!"

2. Get the first characters:
"[G]ood [a]fternoon, [W]orld!"

3. Move the characters over. The character at the end gets moved to the beginning.
"[W]ood [G]fternoon, [a]orld!"

4. Final string
"Wood Gfternoon, aorld!"

이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

테스트 사례 :

Input -> output (space-delimited)

"Good afternoon, World!" -> "Wood Gfternoon, aorld!"
"This is a long sentence." -> "shis Ts i aong lentence."
"Programming Puzzles and Code Golf" -> Grogramming Puzzles Pnd aode Colf"
"Input -> output" -> "onput I> -utput"
"The quick brown fox jumped over the lazy dog." -> "dhe Tuick qrown box fumped jver ohe tazy log."
"good green grass grows." -> "good green grass grows."

05AB1E , 7 6 바이트

€ćÁ2ôJ

설명:

€ć      Extract head of each
  Á     Rotate to the right
    2ô  Split into pieces of length two
      J Join

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

Japt , 11 10 9 8 바이트

Japt의 인덱스 줄 바꿈 및 음수 인덱싱을 활용합니다.

ËhUgEÉ g

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

설명

        :Implicit input of array U (each element is an individual word).
Ë       :Map over the array.
h       :Replace the first character of the current element (word) ...
Ug      :  with the word in the array at index ...
EÉ      :    current index (E) -1's ...
g       :  first character.
        :Implicit output of array of modified words

하스켈 , 43 바이트

p%((a:b):r)=(p:b):a%r
_%e=e
(%)=<<head.last

온라인으로 사용해보십시오! 입력 및 출력에 문자열 목록을 사용합니다.

이전 단어의 첫 글자를 기억하고 p새로운 첫 글자를 체인으로 보내면서 재귀 적으로 현재 단어의 첫 글자를 만듭니다. 이전 첫 글자는 마지막 단어의 첫 글자로 초기화됩니다.

루비, 85 77 63 바이트

이것이 훨씬 짧을 수 있습니다.

편집 : 수집에 대한 @manatwork 감사합니다->지도

a=gets.split;$><<a.zip(a.rotate -1).map{|x,y|y[0]+x[1..-1]}*' '

젤리 , 6 바이트

Ḣ€ṙ-;"

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

나보다 규칙을 잘 읽은 Dennis 에게 감사 의 말을 전합니다. 전체 프로그램으로 작동하지 않습니다.

CJam , 12 10 9 바이트

jimmy23013 덕분에 1 바이트 절약

q~Sf+:()o

단어 목록으로 입력을받습니다.

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

설명

     e# Example input: ["Good" "afternoon," "World!"]
q~   e# Read and eval the input.
     e# STACK: [["Good" "afternoon," "World!"]]
Sf+  e# Append a space to each word.
     e# STACK: [["Good " "afternoon, " "World! "]]
:(   e# Remove the first character from each substring.
     e# STACK: [["ood " 'G "fternoon, " 'a "orld! " 'W]]
)o   e# Remove and print the last element of the array.
     e# STACK: [["ood " 'G "fternoon, " 'a "orld! "]]
     e# Implicitly join the remaining array with no separator and output.

V , 7 바이트

Îxjp
{P

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

설명:

Î       " On every line:
 x      "   Delete the first character
  j     "   Move down a line
   p    "   And paste a character (into column 2)
{       " Move to the beginning of the input
 P      " And paste the last thing we deleted (into column 1)

자바 스크립트 (ES6), 46 바이트

s=>s.map((k,i)=>s.slice(i-1)[0][0]+k.slice(1))

slice(-1)배열의 마지막 요소 를 반환 한다는 사실을 이용 합니다.

단편

f =

s=>s.map((k,i)=>s.slice(i-1)[0][0]+k.slice(1))

console.log(f(['Good', 'afternoon,', 'World!']));
console.log(f(['This', 'is', 'a', 'long', 'sentence.']));
console.log(f(['Programming', 'Puzzles', 'and', 'Code', 'Golf']));
console.log(f(['Input', '->', 'output']));
console.log(f(['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog.']));
console.log(f(['good', 'green', 'grass', 'grows.']));

Vim, 16 , 9 바이트

<C-v>GdjPGD{P

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

한 줄에 한 단어 씩 입력합니다. 예 :

Hello
world
and
good
day
to
you

나는 목록을 입력하는 것이 허용되기 때문에 이것이 잘되어야한다고 생각합니다.

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

> <> , 44 45 바이트

90.f3+0.>&i&01.>~r&l0=?;o20.
 i:" "=?^:1+ ?!^

공백으로 구분 된 단어를 가정합니다.

Aaron에 의한 수정에 1 바이트가 추가됨

파이썬 2, 74 바이트

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

S=input().split()
print' '.join(b[0]+a[1:]for a,b in zip(S,S[-1:]+S[:-1]))

@Rod 덕분에 -5 바이트

하스켈 , 50 바이트

f=zipWith(:).((:).last<*>init).map head<*>map tail

입력과 출력은 단어 목록입니다.

PHP, 62 바이트

$c=end($_GET);foreach($_GET as$g)echo$g|$g[0]=$c^$g^$c=$g,' ';

C #, 78 77 바이트

using System.Linq;a=>a.Select((s,i)=>a[i-->0?i:a.Count-1][0]+s.Substring(1));

Func<List<string>, IEnumerable<string>>전체 / 형식화 된 버전으로 컴파일합니다 .

using System;
using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        Func<List<string>, IEnumerable<string>> f = a =>
                a.Select((s, i) => a[i-- > 0 ? i : a.Count - 1][0] + s.Substring(1));

        Console.WriteLine(string.Join(" ", f(new List<string>() { "Good", "afternoon,", "World!" })));
        Console.WriteLine(string.Join(" ", f(new List<string>() { "This", "is", "a", "long", "sentence." })));

        Console.ReadLine();
    }
}

Brachylog , 12 바이트

{hᵐ↻|bᵐ}ᶠzcᵐ

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

설명

Example input: ["Good","afternoon,","World!"]

{      }ᶠ       Find: [["W","G","a"],["ood","fternoon,","orld!"]]
 hᵐ↻              Take the head of each string, cyclically permute them
    |             (and)
     bᵐ           Get the strings without their heads
         z      Zip: [["W","ood"],["G","fternoon,"],["a","orld!"]]
          cᵐ    Map concatenate on each list: ["Wood","Gfternoon,","aorld!"]

R, 72 70 바이트

function(x)paste0(substr(x,1,1)[c(y<-length(x),2:y-1)],substring(x,2))

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

주세페 덕분에 2 바이트가 절약되었습니다.

입력과 출력은 목록입니다. 첫 글자로 구성된 부분 문자열을 가져 와서 마지막 문자를 앞뒤로 순환시킨 다음 나머지 단어의 부분 문자열과 함께 붙여 넣습니다. 자전거 단계는 살인자이지만 더 이상 줄일 수있는 방법을 알 수 없습니다.

Python 2 + Numpy, 104 바이트

from numpy import *
s=fromstring(input(),"b")
m=roll(s==32,1)
m[0]=1
s[m]=roll(s[m],1)
print s.tobytes()

APL (Dyalog) , 6 바이트

열당 한 단어로 행렬을 가져옵니다.

¯1∘⌽@1

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

¯1∘⌽ 한 단계 오른쪽으로 회전

@ ...에서

1 행 1

수학, 59 바이트

""<>#&/@Thread@{RotateRight@#~StringTake~1,#~StringDrop~1}&

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

단어 목록을 가져 와서 반환합니다.

문자열을 가져오고 반환하는 것을 선호하는 경우 87 바이트에서 작동합니다.

StringRiffle[Thread@{RotateRight@#~StringTake~1,#~StringDrop~1}&@StringSplit@#," ",""]&

망막, 46 37 31 바이트

(\S)(\S* +)
$2$1
(.* .)(.)
$2$1

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

아직 골프를 치고 있습니다 ..

kdb +, 25 22 바이트

해결책:

rotate[-1;1#'a],'1_'a:

예:

q)rotate[-1;1#'a],'1_'a:("The";"quick";"brown";"fox";"jumped";"over";"the";"lazy";"dog.")
"dhe"
"Tuick"
"qrown"
"box"
"fumped"
"jver"
"ohe"
"tazy"
"log."

설명:

1_'a:             // (y) drop first character of each element of a
,'                // join each left with each right
rotate[-1;1#'a]   // (x) take first character of each element of a, rotate backwards 1 char

특별한:

일반 문자열 (37 바이트)을 사용하는 버전 :

q){" "sv rotate[-1;1#'a],'1_'a:" "vs x}"The quick brown fox jumped over the lazy dog."
"dhe Tuick qrown box fumped jver ohe tazy log."

펄 5 , 40 바이트

39 바이트 코드 + 1 -a

$F[-1]=~/./;$a=$&,s/./$a/ for@F;say"@F"

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

망막 , 25 20 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

Om$`^.((?=.*¶))?
$#1

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

입력과 출력은 줄 바꿈으로 구분됩니다. 테스트 스위트는 공간 분리에서 필요한 I / O 변환을 수행합니다.

수학, 134 바이트

(w=Characters@StringSplit@#;d=Drop[w,0,1];StringRiffle[StringJoin/@Table[PrependTo[d[[i]],RotateRight[First/@w][[i]]],{i,Length@w}]])&

Pyth, 12 바이트

.b+hNtY.>Q1Q

단어 목록을 가져 와서 단어 목록을 반환합니다.

시도 해봐!

자바 (OpenJDK 8) , 97 바이트

for(int n=s.length,i=0,j=n-1;i<n;j%=n)System.out.print(s[j++].charAt(0)+s[i++].substring(1)+" ");

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

C, 106 77 바이트

i,a,b;f(char*o){a=*o;for(i=0;o[i++];)if(o[i]==32){b=o[++i];o[i]=a;a=b;}*o=a;}

scottinet에서 -29 바이트

현재 위치에서 문자열을 수정합니다.

언 골프 드 :

char *f(char *o){
    char a=*o,b; // start with a as the first character of the first word
    for(int i=0;++i<strlen(o);){
        // iterate through the string with i as the index
        if(o[i]==32){ // if the current character is a space, 
                      // i.e. if a word begins after this character
            b=o[++i]; // store the beginning of the next word in b
            o[i]=a; // set the beginning of the next word to a
            a=b; // set a to what the beginning of the next work used to be
        }
    }
    *o=a; 
    // set the beginning of the first word to the old beginning of the last word
}

J , 34 바이트

;@(,.~_1|.])~/@|:@(split;.2)@,&' '

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

껍질 , 11 바이트

Foz:ṙ_1TmΓ,

문자열 목록으로 입력 및 출력 하고 온라인으로 시도하십시오!

_{(헤더는 입력을 단어 목록으로 변환하고 출력 목록을 공백으로 결합합니다.)}

설명

F(z:ṙ_1)TmΓ,  -- example input: ["Good" "afternoon,","World!"]
         m    -- map the following (example on "Good")
          Γ   -- | pattern match head & tail: 'G' "ood"
           ,  -- | construct tuple: ('G',"ood")
              -- : [('G',"ood"),('a',"fternoon,"),('W',"orld!")]
        T     -- unzip: ("GaW",["ood","fternoon,","orld!"])
F(     )      -- apply the function to the pair
    ṙ_1       -- | rotate first argument by 1 (to right): "WGa"
  z:          -- | zip the two by (example with 'W' and "ood")
              -- | | cons/(re)construct string: "Wood"
              -- :-: ["Wood","Gfternoon,","aorld!"]

대체, 11 바이트

§oz:ṙ_1m←mt

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

AWK , 63 바이트

{for(R=substr($NF,1,1);++j<=NF;R=r)sub(r=substr($j,1,1),R,$j)}1

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

중복성을 줄일 수있는 방법이 있어야하지만 보이지는 않습니다.

참고 : TIO 링크에는 멀티 라인 입력이 가능하도록 4 바이트의 추가 바이트가 있습니다.