Inversione di parole

30

Sona è a casa sua con la figlia di 10 anni. Deve andare a scuola per riportare un altro bambino da scuola, dato che la scuola è finita alle 14:00. Fa caldo fuori, quindi vuole lasciare il suo bambino più piccolo a casa.

Ha dato un sacco di corde a suo figlio per tenerla occupata mentre se ne è andata. Le chiese di invertire le parole nella stringa. Ci sono molte stringhe, quindi devi aiutare sua figlia a risolvere questo enorme compito.

Quindi, data una stringa che contiene parole separate da un singolo spazio, inverti le parole nella stringa. Puoi presumere che non ci siano spazi iniziali o finali.

La stringa conterrà solo [a-zA-z ], quindi non è necessario gestire la punteggiatura.

Ti verrà data una stringa come input e dovresti produrre una stringa.

Esempi di test:

Input:
Man bites dog 

Output: 
dog bites Man


Input:
The quick brown fox jumps over the lazy dog

Output:
dog lazy the over jumps fox brown quick The


Input:
Hello world

Output:
world Hello

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

code-golf string whitespace

— Cyoce
fonte

1

Relazionato.

— Martin Ender,

1

Possiamo prendere l'input come un elenco di parole? (es. ['man', 'bites', 'dog'])

— Rɪᴋᴇʀ

3

L'output può contenere spazi vuoti finali?

— Trauma digitale,

Risposte:

11

Retina , 7 byte

O$^`\w+

Provalo online!

Abbina tutte le parole ( \w+) ordinale con la chiave di ordinamento stringa vuota ( O$), il che significa che non verranno ordinate affatto, quindi inverti l'ordine ( ^).

— Martin Ender
fonte

Non hai mai usato Retina ma perché ti serve 0$? Non puoi semplicemente invertirlo?

— caird coinheringaahing

La modalità di ordinamento @RandomUser ( O) è attualmente l'unica modalità che ha questa opzione inversa.

— Martin Ender,

9

Haskell, 21 byte

unwords.reverse.words

Provalo online!

— Nome del modello
fonte

9

Python 3 , 29 byte

print(*input().split()[::-1])

Provalo online!

— asta
fonte

Che cosa *fa?

— OldBunny2800,

@ OldBunny2800 decomprime l'elenco

— Rod,

Ahh. Ha senso.

— OldBunny2800,

7

JavaScript (ES6), 31 byte

s=>s.split` `.reverse().join` `

Provalo

f=
s=>s.split` `.reverse().join` `
o.innerText=f(i.value="Man bites dog")
oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Espandi frammento

— ispido
fonte

1

Sono risposte come questa, che sono essenzialmente le stesse della mia risposta C # che mi fa odiare C # per il golf. Tutta la lanugine extra nella mia risposta quasi raddoppia il conteggio dei byte ... +1

— TheLethalCoder

Nota a margine: in C # se non passi nulla Splitsi divide su spazi bianchi per impostazione predefinita, puoi fare lo stesso qui?

— TheLethalCoder

1

Sfortunatamente no, @TheLethalCoder, se non fornisci una stringa / regex splitin JS, si dividerà su ogni singolo carattere o creerà un array con un singolo elemento contenente la stringa originale, a seconda della sintassi utilizzata.

— Shaggy,

7

Bash + utility Linux comuni, 21

printf "$1 "|tac -s\

Lascia uno spazio finale nella stringa di output - non sono sicuro che sia OK o meno.

— Trauma digitale
fonte

2

Complimenti per 50k !! Oggi tocca a te :-)

— Luis Mendo,

@LuisMendo Grazie!

— Digital Trauma,

6

R, 19 byte

cat(rev(scan(,'')))

legge la stringa da stdin. Per impostazione predefinita, scanlegge i token separati da spazi / newline, quindi legge le parole come un vettore. revinverte e catstampa gli elementi con spazi.

Provalo online!

— Giuseppe
fonte

6

Brachylog , 6 byte

ṇ₁↔~ṇ₁

Provalo online!

Spiegazione

ṇ₁        Split on spaces
  ↔       Reverse
   ~ṇ₁    Join with spaces

Si noti che sia "dividi negli spazi" che "unisci con gli spazi" usano lo stesso built-in, cioè ṇ₁appena usato in diverse "direzioni".

— Fatalize
fonte

5

Gelatina , 3 byte

ḲṚK

Provalo online!

Spiegazione:

Ḳ     Splits the input at spaces
Ṛ     Reverses the array
K     Joins the array, using spaces

— steenbergh
fonte

4

en.wikipedia.org/wiki/Krk

— QBrute,

4

C #, 58 byte

using System.Linq;s=>string.Join(" ",s.Split().Reverse());

— TheLethalCoder
fonte

3

Brainfuck , 74 byte

,[>++++[<-------->-],]<[>++++[->--------<]+>[[<]>[+>]<]<-[<]>[.>]<[[-]<]<]

Provalo online!

Questo codice crea il numero -32 in due posizioni diverse, ma sembra che ci siano meno byte rispetto al tentativo di mantenere un singolo -32.

Spiegazione

,[                        input first character
  >++++[<-------->-]      subtract 32 from current character (so space becomes zero)
,]                        repeat for all characters in input
<                         go to last character of last word
[                         while there are more words to display:
 >++++[->--------<]       create -32 two cells right of last letter
 +>                       increment trailing space cell (1 right of last letter) so the next loop works
 [[<]>[+>]<]              add 32 to all cells in word and trailing space cell
 <-                       subtract the previously added 1 from the trailing space
 [<]>                     move pointer to beginning of word
 [.>]<                    output word (with trailing space)
 [[-]<]                   erase word
 <                        move to last character of previous word
]

— Nitrodon
fonte

3

C, 54 48 byte

Utilizzo di argomenti come input, 48 byte

main(c,v)char**v;{while(--c)printf("%s ",v[c]);}

> ./a.out man bites dog

Utilizzando i puntatori, 84 byte

f(char*s){char*t=s;while(*t)t++;while(t-s){while(*t>32)t--;*t=0;printf("%s ",t+1);}}

Uso

main(){ f("man bites dog"); }

— Khaled.K
fonte

3

Japt , 11 10 7 4 byte

Il mio primo tentativo di Japt.

¸w ¸

Risparmiato 3 byte grazie a ETHproductions

Spiegazione

    :Implicit input of string U
¸   :Split on <space>
w   :Reverse
¸   :Join with <space>

Si prega di condividere i tuoi suggerimenti Japt qui .

— ispido
fonte

2

Grazie per aver usato Japt :-) Puoi usare ¸al posto di qS , il che dovrebbe farti risparmiare tre byte qui. (Vedi la sezione "Scorciatoie Unicode" dei documenti dell'interprete)

— ETHproductions

Bello! puoi salvare un byte se usi il -Sflag .

— Oliver,

Conto 2 byte, @obarakon. A meno che il flag non sia incluso nel conteggio dei byte, nel qual caso sarebbero 4 byte, no?

— Shaggy,

@Shaggy Ogni flag conta come un byte. Quindi -Ssarebbe +1 sul conteggio totale dei byte.

— Oliver,

Ah, capisco. È una cosa PPCG o una cosa Japt?

— Shaggy,

2

Python 2 , 34 byte

lambda s:' '.join(s.split()[::-1])

Provalo online!

— totallyhuman
fonte

Out-golfed. > _> Beh ... l'altro funziona solo in Python 3 ...

— totalmente umano

2

Pyth , 4 byte

jd_c

Provalo online!

— notjagan
fonte

2

05AB1E , 4 byte

#Rðý

Nota: funzionerà solo per 2 o più parole. +1 byte se non va bene.

Provalo online!

— Okx
fonte

Vedo unicode, sono davvero 4 byte?

— dice Val Reinstate Monica

Sì, 05AB1E utilizza una tabella codici

— kalsowerus,

#R¸»soluzione alternativa a 4 byte: P.

— Magic Octopus Urn,

2

PHP, 47 byte

<?=join(" ",array_reverse(explode(" ",$argn)));

Provalo online!

— Jörg Hülsermann
fonte

2

GNU Make , 62 byte

$(if $1,$(call $0,$(wordlist 2,$(words $1),$1)) $(word 1,$1),)

— eush77
fonte

2

Cubix , 48 byte

Quasi rinunciato a questo, ma finalmente ci siamo arrivati.

oU_;SW;@?ABu>):tS-?;\0$q^s.$;;<$|1osU!(;;...<#(1

Provalo online!

Questa mappa su un cubo con una lunghezza laterale di tre come segue

      o U _
      ; S W
      ; @ ?
A B u > ) : t S - ? ; \
0 $ q ^ s . $ ; ; < $ |
1 o s U ! ( ; ; . . . <
      # ( 1
      . . .
      . . .

I passaggi generali sono:

Ottieni tutti gli input A e invertiB stack
Sposta il negativo qin basso, aggiungi un contatore0 alla pila. un po 'di saltare qui dentro.
Trova spazio / fine ciclo, inoltre mette la pila nell'ordine di stampa corretto.
- Incrementa il contatore )e recupera l'elemento contatore dalla pilat
- È uno spazio o EOI S-?
- Ripetere in caso contrario
Stampa ciclo di parole
- Contatore decrementi (
- Uscita dal loop se contatore !U è 0
- Scambiare s segnalino con personaggio in pila
- Stampa opersonaggio e pop dalla pila;
- Ripeti il ciclo
Ottieni la lunghezza della pila #e il decremento(
Controlla ?se 0 e esci@ se è 0
Altrimenti stampa uno spazio Sopulito ;;e torna al primo ciclo.

Ho saltato una serie di passaggi superflui, ma puoi vederlo passo dopo passo

— MickyT
fonte

2

Mathematica, 35 byte

StringRiffle@Reverse@StringSplit@#&

Provalo online!

— J42161217
fonte

StringSplit[#]si divide automaticamente negli spazi bianchi, quindi non è necessario specificare il " ".

— Non un albero

2

corretta! -5 byte!

— J42161217

Ooh, e penso che puoi salvare un altro byte usando la composizione della funzione: StringRiffle@*Reverse@*StringSplit(chiamalo come StringRiffle@*Reverse@*StringSplit@"hello world")

— Non un albero

2

Röda , 27 25 byte

2 byte salvati grazie a @fergusq

{[[split()|reverse]&" "]}

Provalo online!

Questa funzione accetta input dal flusso di input.

Spiegazione (obsoleta)

{[[(_/" ")()|reverse]&" "]}           /* Anonymous function */
   (_/" ")                            /* Pull a value from the stream and split it on spaces */
          ()                          /* Push all the values in the resulting array to the stream */
            |reverse                  /* And reverse it */
  [                 ]                 /* Wrap the result into an array*/
                     &" "             /* Concatenate each of the strings in the array with a space */
 [                       ]            /* And push this result to the output stream */

— Kritixi Lithos
fonte

splitusa lo spazio come separatore predefinito, quindi split()è più breve di (_/" ")().

— Fergusq,

1

Ohm , 4 byte

z]Qù

Provalo online!

Spiegazione

z     Split the input on spaces.
 ]    Dump it onto the stack.
  Q   Reverse the stack.
   ù  Join the stack with spaces. Implicit output.

— Gatto di affari
fonte

1

CJam , 7 byte

qS/W%S*

Provalo online!

Spiegazione

q        e# Read input
 S/      e# Split on spaces
   W%    e# Reverse
     S*  e# Join with spaces

— Gatto di affari
fonte

1

k, 9 byte

" "/|" "\

Provalo nel tuo browser della varietà web!

     " "\ /split on spaces
    |     /reverse
" "/      /join with spaces

— zgrep
fonte

1

J , 6 byte

|.&.;:

Provalo online! Questo è reverse ( |.) sotto ( &.) words ( ;:). Cioè, dividi la frase in parole, invertila e unisciti nuovamente alla frase.

— Conor O'Brien
fonte

1

Gema, 29 personaggi

<W><s>=@set{o;$1 ${o;}}
\Z=$o

Esecuzione di esempio:

bash-4.4$ gema '<W><s>=@set{o;$1 ${o;}};\Z=$o' <<< 'Man bites dog'
dog bites Man

— uomo al lavoro
fonte

1

Java 8, 62 byte

s->{String r="";for(String x:s.split(" "))r=x+" "+r;return r;}

Java 7, 77 byte

String c(String s){String r="";for(String x:s.split(" "))r=x+" "+r;return r;}

— Kevin Cruijssen
fonte

1

Perl 6 , 14 byte

{~[R,] .words}

Allargato:

{              # lambda with implicit param $_

  ~            # stringify following (joins a list using spaces)

   [R,]        # reduce the following using the Reverse meta operator

        .words # call the words method on $_
}

— Brad Gilbert b2gills
fonte

1

Java 8, 53 57 byte

API Lambda + Stream

s->Stream.of(s.split(" ")).reduce("",(a,b)->b+" "+a)

Seguendo il suggerimento di Selim, abbiamo appena eliminato 4 byte

— user902383
fonte

1

Salva 4 byte usando Stream.ofinvece di Arrays.stream: -)

— Selim

1

Vim, 20 byte

:s/ /\r/g|g/^/m0<cr>vGJ

Questo è più breve dell'altra risposta di vim.

Provalo online!

— DJMcMayhem
fonte

1

Pyth, 3 byte

_cw

La mia prima risposta Pyth, un byte più breve della risposta di @ notjagan!

Ha spiegato:

 cw # Split the input by space (same as Python's string.split())
_   # Reverses the array
    # Pyth prints implicitly.

— OldBunny2800
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.