Étant donné une liste ou une chaîne délimitée, affichez une liste ou une chaîne délimitée avec le premier caractère de chaque mot un mot plus tard.

Pour ce défi, un «mot» se compose uniquement de tous les caractères ASCII imprimables, à l'exception de l'espace, de la nouvelle ligne et du caractère de tabulation.

Par exemple, prenez la chaîne "Bonjour, monde!" (délimité par des espaces):

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

C'est le code-golf , donc le code le plus court gagne!

Cas de test:

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 octets

€ćÁ2ôJ

Explication:

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

Essayez-le en ligne!

Japt , 11 10 9 8 octets

Profite de l'habillage d'index et de l'indexation négative de Japt.

ËhUgEÉ g

Essayez-le en ligne

Explication

        :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 octets

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

Essayez-le en ligne! Utilise une liste de chaînes pour l'entrée et la sortie.

Se souvient de la première lettre du mot précédent pet en fait récursivement la première lettre du mot actuel lors de l'envoi de la nouvelle première lettre dans la chaîne. La première lettre précédente est initialisée en tant que première lettre du dernier mot.

Rubis, 85 77 63 octets

Je suis sûr que cela pourrait être beaucoup plus court.

Edit: Merci pour @manatwork pour collecter -> carte

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

Gelée , 6 octets

Ḣ€ṙ-;"

Essayez-le en ligne!

Merci à Dennis d' avoir lu les règles mieux que moi, cela renvoie une liste de mots. Cela ne fonctionne pas comme un programme complet.

CJam , 12 10 9 octets

1 octet enregistré grâce à jimmy23013

q~Sf+:()o

Prend la saisie sous forme de liste de mots.

Essayez-le en ligne!

Explication

     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 octets

Îxjp
{P

Essayez-le en ligne!

Explication:

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

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

Profite du fait que slice(-1)renvoie le dernier élément d'un tableau.

Fragment

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 octets

<C-v>GdjPGD{P

7 octets enregistrés grâce à @Wossname!

Prend un mot par ligne, par exemple

Hello
world
and
good
day
to
you

Je pense que cela devrait être correct, car la prise de l'entrée en tant que liste est autorisée.

Essayez-le en ligne!

> <> , 44 45 octets

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

Suppose des mots séparés par des espaces.

Correction par Aaron ajouté 1 octet

Python 2, 74 octets

Essayez-le en ligne

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

-5 octets, grâce à @Rod

Haskell , 50 octets

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

L'entrée et la sortie sont des listes de mots.

PHP, 62 octets

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

C #, 78 77 octets

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

Compile en une Func<List<string>, IEnumerable<string>>version complète / formatée:

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 octets

{hᵐ↻|bᵐ}ᶠzcᵐ

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne

2 octets enregistrés grâce à Giuseppe.

L'entrée et la sortie sont des listes. Prend une sous-chaîne composée des premières lettres, fait défiler la dernière vers l'avant et la colle avec une sous-chaîne du reste de chaque mot. L'étape du cyclisme est un tueur, mais je ne peux pas trouver un moyen de le réduire davantage.

Python 2 + Numpy, 104 octets

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 octets

Prend la matrice avec un mot par colonne.

¯1∘⌽@1

Essayez-le en ligne!

¯1∘⌽ tourner d'un pas vers la droite

@ à

1 ligne 1

Mathematica, 59 octets

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

Essayez-le en ligne!

Prend et renvoie une liste de mots.

Si vous préférez prendre et renvoyer des chaînes, cela fonctionne pour 87 octets:

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

Rétine, 46 37 31 octets

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

Essayez-le en ligne

Toujours en cours de golf ..

kdb +, 25 22 octets

Solution:

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

Exemple:

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

Explication:

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

Supplémentaire:

Une version qui prend une chaîne régulière (37 octets):

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 octets

39 octets de code + 1 pour -a

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

Essayez-le en ligne!

Rétine , 25 20 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

L'entrée et la sortie sont séparées par un saut de ligne. La suite de tests effectue la conversion d'E / S nécessaire à partir de la séparation d'espace.

Mathematica, 134 octets

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

Pyth, 12 octets

.b+hNtY.>Q1Q

Prend une liste de mots et renvoie une liste de mots.

Essayez!

Java (OpenJDK 8) , 97 octets

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

Essayez-le en ligne!

C, 106 77 octets

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 octets de scottinet

Modifie la chaîne sur place.

Non golfé:

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 octets

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

Essayez-le en ligne!

Husk , 11 octets

Foz:ṙ_1TmΓ,

Entrée et sortie sous forme de liste de chaînes, essayez-le en ligne!

_{(L'en-tête transforme simplement l'entrée en une liste de mots et joint la liste de sortie avec des espaces.)}

Explication

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 octets

§oz:ṙ_1m←mt

Essayez-le en ligne!

AWK , 63 octets

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

Essayez-le en ligne!

Il semble qu'il devrait y avoir un moyen de réduire la redondance, mais je ne le vois pas.

Remarque: la liaison TIO dispose de 4 octets supplémentaires pour permettre l'entrée multiligne.