Dada una lista o cadena delimitada, envíe una lista o cadena delimitada con el primer carácter de cada palabra una palabra más tarde.

Para este desafío, una "palabra" consta de todos los caracteres ASCII imprimibles, excepto el espacio, la nueva línea y el carácter de tabulación.

Por ejemplo, tome la cadena "¡Buenas tardes, mundo!" (delimitado por espacios):

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

Este es el código de golf , ¡el código más corto gana!

Casos de prueba:

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

Explicación:

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

Pruébalo en línea!

Japt , 11 10 9 8 bytes

Aprovecha el ajuste de índice de Japt y la indexación negativa.

ËhUgEÉ g

Pruébalo en línea

Explicación

        :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

Pruébalo en línea! Utiliza una lista de cadenas para entrada y salida.

Recuerda la primera letra de la palabra anterior. p y la convierte recursivamente en la primera letra de la palabra actual mientras envía la nueva primera letra por la cadena. La primera letra anterior se inicializa como la primera letra de la última palabra.

Ruby, 85 77 63 bytes

Estoy bastante seguro de que esto podría ser mucho más corto.

Editar: Gracias por @manatwork para recoger -> mapa

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

Jalea , 6 bytes

Ḣ€ṙ-;"

Pruébalo en línea!

Gracias a Dennis por leer las reglas mejor que yo, esto devuelve una lista de las palabras. No funciona como un programa completo.

CJam , 12 10 9 bytes

Guardado 1 byte gracias a jimmy23013

q~Sf+:()o

Toma entrada como una lista de palabras.

Pruébalo en línea!

Explicación

     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

Pruébalo en línea!

Explicación:

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

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

Aprovecha el hecho de que slice(-1)devuelve el último elemento de una matriz.

Retazo

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 guardados gracias a @Wossname!

Toma entrada una palabra por línea, por ejemplo

Hello
world
and
good
day
to
you

Creo que esto debería estar bien ya que tomar la entrada como una lista está permitida.

Pruébalo en línea!

> <> , 44 45 bytes

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

Asume palabras separadas por espacios.

Corrección de Aaron agregó 1 byte

Python 2, 74 bytes

Pruébalo en línea

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

-5 bytes, gracias a @Rod

Haskell , 50 bytes

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

La entrada y la salida son como listas de palabras.

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

Compila a una Func<List<string>, IEnumerable<string>>versión completa / formateada:

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ᵐ

Pruébalo en línea!

Explicación

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

Pruébalo en línea

2 bytes guardados gracias a Giuseppe.

Entrada y salida son listas. Toma una subcadena que consta de las primeras letras, alterna la última al frente y la pega junto con una subcadena del resto de cada palabra. El paso en bicicleta es un asesino, pero no puedo encontrar una manera de reducirlo más.

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

Toma matriz con una palabra por columna.

¯1∘⌽@1

Pruébalo en línea!

¯1∘⌽ girar un paso a la derecha

@ a

1 fila 1

Mathematica, 59 bytes

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

Pruébalo en línea!

Toma y devuelve una lista de palabras.

Si prefiere tomar y devolver cadenas, esto funciona para 87 bytes:

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

Retina, 46 37 31 bytes

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

Pruébalo en línea

Todavía siendo golf.

kdb +, 25 22 bytes

Solución:

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

Ejemplo:

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

Explicación:

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:

Una versión que toma una cadena regular (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 de código + 1 para -a

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

Pruébalo en línea!

Retina , 25 20 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

La entrada y la salida están separadas por salto de línea. El conjunto de pruebas realiza la conversión de E / S necesaria desde la separación de espacios.

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

Toma una lista de palabras y devuelve una lista de palabras.

¡Intentalo!

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

Pruébalo en línea!

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 desde scottinet

Modifica la cadena en el lugar.

Sin 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 bytes

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

Pruébalo en línea!

Casco , 11 bytes

Foz:ṙ_1TmΓ,

Entrada y salida como una lista de cadenas, ¡ pruébelo en línea!

_{(El encabezado simplemente transforma la entrada en una lista de palabras y une la lista de salida con espacios).}

Explicación

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

Alternativa, 11 bytes

§oz:ṙ_1m←mt

Pruébalo en línea!

AWK , 63 bytes

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

Pruébalo en línea!

Parece que debería haber una forma de reducir la redundancia, pero no lo veo.

Nota: el enlace TIO tiene 4 bytes adicionales para permitir la entrada multilínea.