Давши список або обмежений рядок, виведіть список або розділений рядок із першим символом кожного слова одним словом пізніше.

Для цього завдання "слово" складається лише з усіх друкованих символів 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!"

Це код-гольф , тому найкоротший код виграє!

Тестові приклади:

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 байт

Ḣ€ṙ-;"

Спробуйте в Інтернеті!

Завдяки Деннісу за те, що він прочитав правила краще за мене, це повертає список слів. Це не працює як повноцінна програма.

CJam , 12 10 9 байт

Збережено 1 байт завдяки jimmy23013

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)

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

7 байт збережено завдяки @Wossname!

Бере введення по одному слову на рядок, наприклад

Hello
world
and
good
day
to
you

Я вважаю, що це повинно бути добре, оскільки дозволено приймати дані як список.

Спробуйте в Інтернеті!

> <> , 44 45 байт

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

Передбачає розділені пробілом слова.

Корекція Аароном додала 1 байт

Python 2, 74 байти

Спробуйте в Інтернеті

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

-5 байт, завдяки @Rod

Haskell , 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();
    }
}

Брахілог , 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 bytes

Takes matrix with one word per column.

¯1∘⌽@1

Try it online!

¯1∘⌽ rotate one step right

@ at

1 row 1

Mathematica, 59 bytes

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

Try it online!

Takes and returns a list of words.

If you prefer to take and return strings, this works for 87 bytes:

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

Retina, 46 37 31 bytes

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

Try it Online

Still being golfed..

kdb+, 25 22 bytes

Solution:

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

Example:

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

Explanation:

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

Extra:

A version that takes a regular string (37 bytes):

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

Perl 5, 40 bytes

39 bytes of code + 1 for -a

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

Try it online!

Retina, 25 20 bytes

Byte count assumes ISO 8859-1 encoding.

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

Try it online!

Input and output are linefeed-separated. The test suite performs the necessary I/O conversion from space-separation.

Mathematica, 134 bytes

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

Pyth, 12 bytes

.b+hNtY.>Q1Q

Takes a list of words and returns a list of words.

Try it!

Java (OpenJDK 8), 97 bytes

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

Try it online!

C, 106 77 bytes

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

-29 bytes from scottinet

Modifies the string in-place.

Ungolfed:

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 bytes

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

Try it online!

Husk, 11 bytes

Foz:ṙ_1TmΓ,

Input and output as a list of strings, try it online!

_{(The header just transforms the input to a list of words and joins the output list with spaces.)}

Explanation

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!"]

Alternative, 11 bytes

§oz:ṙ_1m←mt

Try it online!

AWK, 63 bytes

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

Try it online!

It seems like there should be a way to reduce the redundancy, but I'm not seeing it.

Note: the TIO link has 4 extra bytes to allow for multiline input.