Wenn Sie eine Liste oder eine durch Trennzeichen getrennte Zeichenfolge angegeben haben, geben Sie eine Liste oder eine durch Trennzeichen getrennte Zeichenfolge mit dem ersten Zeichen jedes Wortes ein Wort später aus.

Für diese Herausforderung besteht ein "Wort" nur aus druckbaren ASCII-Zeichen mit Ausnahme des Leerzeichens, des Zeilenumbruchs und des Tabulators.

Nehmen Sie zum Beispiel die Zeichenfolge "Guten Tag, Welt!" (durch Leerzeichen getrennt):

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

Das ist Code-Golf , also gewinnt der kürzeste Code!

Testfälle:

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 Bytes

€ćÁ2ôJ

Erläuterung:

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

Probieren Sie es online!

Japt , 11 10 9 8 Bytes

Nutzt den Indexumbruch und die negative Indizierung von Japt.

ËhUgEÉ g

Probieren Sie es online aus

Erläuterung

        :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

Haskell , 43 Bytes

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

Probieren Sie es online! Verwendet eine Liste von Zeichenfolgen für die Eingabe und Ausgabe.

Erinnert sich an den ersten Buchstaben des vorherigen Wortes pund macht ihn rekursiv zum ersten Buchstaben des aktuellen Wortes, während der neue erste Buchstabe die Kette entlang gesendet wird. Der vorherige erste Buchstabe wird als der erste Buchstabe des letzten Wortes initialisiert.

Ruby, 85 77 63 Bytes

Ich bin mir ziemlich sicher, dass dies viel kürzer sein könnte.

Edit: Danke für @manatwork zum Sammeln -> Karte

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

Gelee , 6 Bytes

Ḣ€ṙ-;"

Probieren Sie es online!

Dank an Dennis , der die Regeln besser gelesen hat als ich, wird eine Liste der Wörter zurückgegeben. Es funktioniert nicht als vollständiges Programm.

CJam , 12 10 9 Bytes

1 Byte dank jimmy23013 gespeichert

q~Sf+:()o

Nimmt die Eingabe als eine Liste von Wörtern.

Probieren Sie es online!

Erläuterung

     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 Bytes

Îxjp
{P

Probieren Sie es online!

Erläuterung:

Î       " 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 Byte

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

Nutzt die Tatsache, dass slice(-1)das letzte Element eines Arrays zurückgegeben wird.

Ausschnitt

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 Bytes

<C-v>GdjPGD{P

7 Bytes gespart dank @Wossname!

Nimmt die Eingabe eines Wortes pro Zeile vor, z

Hello
world
and
good
day
to
you

Ich denke, das sollte in Ordnung sein, da die Eingabe als Liste erlaubt ist.

Probieren Sie es online!

> <> , 44 45 Bytes

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

Nimmt durch Leerzeichen getrennte Wörter an.

Korrektur von Aaron hinzugefügt 1 Byte

Python 2, 74 Bytes

Probieren Sie es online aus

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

-5 Bytes, danke an @Rod

Haskell , 50 Bytes

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

Eingabe und Ausgabe erfolgen als Wortlisten.

PHP, 62 Bytes

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

C #, 78 77 Bytes

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

Kompiliert zu einer Voll- Func<List<string>, IEnumerable<string>>/ Formatierten Version:

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 Bytes

{hᵐ↻|bᵐ}ᶠzcᵐ

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online aus

2 Bytes gespart dank Giuseppe.

Ein- und Ausgabe sind Listen. Nimmt einen Teilstring, der aus den ersten Buchstaben besteht, fügt den letzten Teilstring in den Vordergrund ein und fügt ihn zusammen mit einem Teilstring des restlichen Wortes ein. Der Radrennschritt ist ein Killer, aber ich kann keinen Weg finden, ihn weiter zu reduzieren.

Python 2 + Numpy, 104 Bytes

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

Nimmt eine Matrix mit einem Wort pro Spalte.

¯1∘⌽@1

Probieren Sie es online!

¯1∘⌽ einen schritt nach rechts drehen

@ beim

1 Reihe 1

Mathematica, 59 Bytes

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

Probieren Sie es online!

Nimmt und gibt eine Liste von Wörtern zurück.

Wenn Sie es vorziehen, Zeichenfolgen zu nehmen und zurückzugeben, funktioniert dies für 87 Bytes:

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

Retina, 46 37 31 Bytes

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

Probieren Sie es online

Wird noch golfen ..

kdb +, 25 22 Bytes

Lösung:

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

Beispiel:

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

Erläuterung:

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:

Eine Version, die eine reguläre Zeichenfolge (37 Byte) benötigt:

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 Byte Code + 1 für -a

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

Probieren Sie es online!

Netzhaut , 25 bis 20 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Eingang und Ausgang sind zeilenweise getrennt. Die Testsuite führt die erforderliche E / A-Konvertierung aus der Raumtrennung durch.

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

Nimmt eine Liste von Wörtern und gibt eine Liste von Wörtern zurück.

Versuch es!

Java (OpenJDK 8) , 97 Byte

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

Probieren Sie es 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 von Scottinet

Ändert die Zeichenfolge an Ort und Stelle.

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)@,&' '

Probieren Sie es online!

Schale , 11 Bytes

Foz:ṙ_1TmΓ,

Eingabe und Ausgabe als Liste von Strings, probieren Sie es online!

_{(Die Kopfzeile wandelt die Eingabe nur in eine Wortliste um und fügt der Ausgabeliste Leerzeichen hinzu.)}

Erläuterung

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

Probieren Sie es online!

AWK , 63 Bytes

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

Probieren Sie es online!

Es scheint, dass es einen Weg geben sollte, die Redundanz zu reduzieren, aber ich sehe es nicht.

Hinweis: Die TIO-Verbindung verfügt über 4 zusätzliche Bytes, um eine mehrzeilige Eingabe zu ermöglichen.