Dato un elenco o una stringa delimitata, genera un elenco o una stringa delimitata con il primo carattere di ogni parola una parola dopo.

Per questa sfida, una "parola" è composta solo da tutti i caratteri ASCII stampabili, tranne lo spazio, la nuova riga e il carattere di tabulazione.

Ad esempio, prendi la stringa "Buon pomeriggio, mondo!" (Delimitato da spazi):

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

Questo è code-golf , quindi vince il codice più corto!

Casi 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 byte

€ćÁ2ôJ

Spiegazione:

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

Provalo online!

Japt , 11 10 9 8 byte

Sfrutta il wrapping dell'indice di Japt e l'indicizzazione negativa.

ËhUgEÉ g

Provalo online

Spiegazione

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

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

Provalo online! Utilizza un elenco di stringhe per input e output.

Ricorda la prima lettera della parola precedente pe la rende ricorsivamente la prima lettera della parola corrente mentre invia la nuova prima lettera lungo la catena. La prima lettera precedente viene inizializzata come prima lettera dell'ultima parola.

Rubino, 85 77 63 byte

Abbastanza sicuro questo potrebbe essere molto più breve.

Modifica: grazie per @manatwork per raccogliere -> mappa

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

Gelatina , 6 byte

Ḣ€ṙ-;"

Provalo online!

Grazie a Dennis per aver letto le regole meglio di me, questo restituisce un elenco delle parole. Non funziona come un programma completo.

CJam , 12 10 9 byte

Salvato 1 byte grazie a jimmy23013

q~Sf+:()o

Accetta input come un elenco di parole.

Provalo online!

Spiegazione

     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 byte

Îxjp
{P

Provalo online!

Spiegazione:

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

Sfrutta il fatto che slice(-1)restituisce l'ultimo elemento di un array.

Frammento

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 byte

<C-v>GdjPGD{P

7 byte salvati grazie a @Wossname!

Accetta una parola per riga, ad es

Hello
world
and
good
day
to
you

Credo che questo dovrebbe andare bene poiché è consentito prendere l'input come elenco.

Provalo online!

> <> , 44 45 byte

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

Presuppone parole separate da spazi.

La correzione di Aaron ha aggiunto 1 byte

Python 2, 74 byte

Provalo online

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

-5 byte, grazie a @Rod

Haskell , 50 byte

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

Input e output sono come elenchi di parole.

PHP, 62 byte

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

C #, 78 77 byte

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

Compila per una Func<List<string>, IEnumerable<string>>versione completa / formattata:

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 byte

{hᵐ↻|bᵐ}ᶠzcᵐ

Provalo online!

Spiegazione

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 byte

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

Provalo online

2 byte salvati grazie a Giuseppe.

Input e output sono elenchi. Prende una sottostringa composta dalle prime lettere, sposta l'ultima in primo piano e la incolla insieme a una sottostringa del resto di ogni parola. Il passaggio in bicicletta è un assassino, ma non riesco a trovare un modo per ridurlo ulteriormente.

Python 2 + Numpy, 104 byte

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 byte

Prende matrice con una parola per colonna.

¯1∘⌽@1

Provalo online!

¯1∘⌽ ruota di un passo a destra

@ a

1 riga 1

Mathematica, 59 byte

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

Provalo online!

Prende e restituisce un elenco di parole.

Se preferisci prendere e restituire stringhe, questo funziona per 87 byte:

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

Retina, 46 37 31 byte

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

Provalo online

Continuando a giocare a golf ..

kdb +, 25 22 byte

Soluzione:

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

Esempio:

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

Spiegazione:

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 versione che accetta una stringa normale (37 byte):

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 byte

39 byte di codice + 1 per -a

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

Provalo online!

Retina , 25 20 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Ingresso e uscita sono separati dall'alimentazione di linea. La suite di test esegue la conversione I / O necessaria dalla separazione dello spazio.

Mathematica, 134 byte

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

Pyth, 12 byte

.b+hNtY.>Q1Q

Prende un elenco di parole e restituisce un elenco di parole.

Provalo!

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

Provalo online!

C, 106 77 byte

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 byte da scottinet

Modifica la stringa sul posto.

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 byte

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

Provalo online!

Buccia , 11 byte

Foz:ṙ_1TmΓ,

Input e output come un elenco di stringhe, provalo online!

_{(L'intestazione trasforma semplicemente l'input in un elenco di parole e unisce l'elenco di output con spazi.)}

Spiegazione

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 byte

§oz:ṙ_1m←mt

Provalo online!

AWK , 63 byte

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

Provalo online!

Sembra che ci dovrebbe essere un modo per ridurre la ridondanza, ma non la vedo.

Nota: il collegamento TIO ha 4 byte extra per consentire l'input multilinea.