Reversão de palavras

30

Sona está em sua casa com sua filha de 10 anos. Ela precisa ir à escola para trazer outra criança da escola, pois a escola termina às 14h. Está quente lá fora, então ela quer deixar seu filho mais novo em casa.

Ela deu um monte de cordas ao filho para mantê-lo ocupado enquanto ela estava fora. Ela pediu a ela para reverter as palavras na corda. Existem muitas seqüências de caracteres, então você precisa ajudar a filha a resolver essa tarefa enorme.

Portanto, dada uma sequência que contém palavras separadas por espaço único, inverta as palavras na sequência. Você pode assumir que não há espaços à esquerda ou à direita.

A cadeia conterá apenas [a-zA-z ], portanto, você não precisa manipular a pontuação.

Você receberá uma string como entrada e deverá produzir uma string.

Casos de teste de amostra:

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

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

code-golf string whitespace

— Cyoce
fonte

1

Relacionado.

— Martin Ender

1

Podemos considerar a entrada como uma lista de palavras? (ie ['man', 'bites', 'dog'])

— Rɪᴋᴇʀ 17/05/19

3

A saída pode ter espaços em branco à direita?

— Digital Trauma

Respostas:

11

Retina , 7 bytes

O$^`\w+

Experimente online!

Combine todas as palavras ( \w+) e classifique-as com a chave de classificação vazia ( O$), o que significa que elas não serão classificadas e inverta a ordem ( ^).

— Martin Ender
fonte

Nunca usei Retina, mas por que você precisa 0$? Você não pode simplesmente reverter isso?

— caird coinheringaahing

O modo de classificação @RandomUser ( O) atualmente é o único modo que tem essa opção reversa.

— Martin Ender

9

Haskell, 21 bytes

unwords.reverse.words

Experimente online!

— nimi
fonte

9

Python 3 , 29 bytes

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

Experimente online!

— Cajado
fonte

O que *faz?

— OldBunny2800

@ OldBunny2800 descompacte a lista

— Rod

Ahh Faz sentido.

— OldBunny2800

7

JavaScript (ES6), 31 bytes

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

Tente

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>

Expandir snippet

— Shaggy
fonte

1

São respostas como essa, que são essencialmente as mesmas da minha resposta em C # que me fazem odiar C # por jogar golfe. Todo o fluff extra na minha resposta quase dobra a contagem de bytes ... +1

— TheLethalCoder 17/17/17

Nota lateral: No C #, se você não passar nada para Splitele, divide-se no espaço em branco por padrão, pode fazer o mesmo aqui?

— TheLethalCoder

1

Infelizmente, @TheLethalCoder, se você não fornecer uma string / regex splitem JS, ele será dividido em cada caractere individual ou criará uma matriz com um único elemento contendo a string original, dependendo da sintaxe usada.

— Shaggy

7

Bash + utilitários comuns do Linux, 21

printf "$1 "|tac -s\

Deixa um espaço à direita na sequência de saída - não tenho certeza se está tudo bem ou não.

— Trauma Digital
fonte

2

Parabéns por 50k !! Sua vez hoje :-)

— Luis Mendo

@LuisMendo Thanks!

— Digital Trauma

6

R, 19 bytes

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

lê a string de stdin. Por padrão, scanlê tokens separados por espaços / novas linhas, e lê as palavras como um vetor. revinverte e catimprime os elementos com espaços.

Experimente online!

— Giuseppe
fonte

6

Braquilog , 6 bytes

ṇ₁↔~ṇ₁

Experimente online!

Explicação

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

Observe que "dividir em espaços" e "unir-se a espaços" usam o mesmo recurso interno, ou seja ṇ₁, são usados apenas em "direções" diferentes.

— Fatalizar
fonte

5

Gelatina , 3 bytes

ḲṚK

Experimente online!

Explicação:

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

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

— TheLethalCoder
fonte

3

brainfuck , 74 bytes

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

Experimente online!

Esse código cria o número -32 em dois lugares diferentes, mas isso parece ser menos bytes do que tentar manter um único -32.

Explicação

,[                        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 bytes

Usando argumentos como entrada, 48 bytes

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

Experimente on-line

> ./a.out man bites dog

Usando ponteiros, 84 bytes

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

Usar

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

— Khaled.K
fonte

3

Japonês , 11 10 7 4 bytes

Minha primeira tentativa no Japt.

¸w ¸

Experimente online

Economizou 3 bytes graças a ETHproductions

Explicação

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

Compartilhe suas dicas de Japt aqui .

— Shaggy
fonte

2

Obrigado por usar o Japt :-) Você pode usar ¸no lugar de qS , o que deve economizar três bytes aqui. (Consulte a seção "Atalhos Unicode" dos documentos do intérprete)

— ETHproductions

Agradável! você pode salvar um byte se usar o -Ssinalizador .

— Oliver

Eu conto 2 bytes, @obarakon. A menos que o sinalizador seja incluído na contagem de bytes, nesse caso, seriam 4 bytes, não?

— Shaggy

@Shaggy Cada sinalizador conta como um byte. Assim, -Sseria +1 na sua contagem total de bytes.

— Oliver

Ah entendo. Isso é coisa do PPCG ou do Japt?

— Shaggy

2

Python 2 , 34 bytes

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

Experimente online!

— totalmente humano
fonte

Fora de golfe. > _> Bem ... o outro só funciona em Python 3 ...

— totallyhuman 17/17/17

2

Pitão , 4 bytes

jd_c

Experimente online!

— notjagan
fonte

2

05AB1E , 4 bytes

#Rðý

Nota: Funcionará apenas para 2 ou mais palavras. +1 byte se isso não estiver correto.

Experimente online!

— Okx
fonte

Eu vejo unicode, é realmente 4 bytes?

— val diz Reinstate Monica

Sim, 05AB1E usa um personalizado página de códigos

— kalsowerus

#R¸»solução alternativa de 4 bytes: P.

— Magic Octopus Urn

2

PHP, 47 bytes

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

Experimente online!

— Jörg Hülsermann
fonte

2

Marca GNU , 62 bytes

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

— eush77
fonte

2

Cubix , 48 bytes

Quase desisti deste, mas finalmente cheguei lá.

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

Experimente online!

Ele é mapeado para um cubo com um comprimento lateral de três da seguinte maneira

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

As etapas gerais são:

Obtenha toda a entrada Ae Bpilha reversa
Mova o negativo qpara o fundo, adicione um contador 0à pilha. um pouco de pular por aqui.
Encontrar espaço / loop final, também coloca a pilha na ordem correta de impressão.
- Incrementar contador )e buscar o item de contador da pilhat
- É um espaço ou EOI S-?
- Repita se não
Imprimir palavra loop
- Contador de diminuição (
- Laço de saída se o contador !Ufor 0
- Trocar scontador com caracteres na pilha
- Imprima o ocaractere e solte-o da pilha;
- Repetir loop
Obter o comprimento da pilha #e diminuir(
Verifique ?se 0 e saia @se for 0
Caso contrário, imprima uma Solimpeza de espaço ;;e volte ao primeiro loop.

Eu pulei várias etapas supérfluas, mas você pode vê-la passo a passo

— MickyT
fonte

2

Mathematica, 35 bytes

StringRiffle@Reverse@StringSplit@#&

Experimente online!

— J42161217
fonte

StringSplit[#]divide automaticamente em espaço em branco, para que você não precise especificar o " ".

— Não é uma árvore

2

corrigir! -5 bytes!

— J42161217 #

Ooh, e acho que você pode salvar outro byte usando a composição da função: StringRiffle@*Reverse@*StringSplit(chame como StringRiffle@*Reverse@*StringSplit@"hello world")

— Not a tree

2

Röda , 27 25 bytes

2 bytes salvos graças a @fergusq

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

Experimente online!

Esta função recebe entrada do fluxo de entrada.

Explicação (desatualizada)

{[[(_/" ")()|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 espaço como o separador padrão, então split()é menor que (_/" ")().

— Fergusq 19/05

1

Ohm , 4 bytes

z]Qù

Experimente online!

Explicação

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

— Gato de negócios
fonte

1

CJam , 7 bytes

qS/W%S*

Experimente online!

Explicação

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

— Gato de negócios
fonte

1

k, 9 bytes

" "/|" "\

Experimente no seu navegador da variedade web!

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

— zgrep
fonte

1

J , 6 bytes

|.&.;:

Experimente online! Isso é reverso ( |.) em ( &.) palavras ( ;:). Ou seja, divida a frase em palavras, inverta-a e junte-se à frase novamente.

— Conor O'Brien
fonte

1

Gema, 29 caracteres

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

Exemplo de execução:

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

— homem a trabalhar
fonte

1

Java 8, 62 bytes

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

Experimente aqui.

Java 7, 77 bytes

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

Experimente aqui.

— Kevin Cruijssen
fonte

1

Perl 6 , 14 bytes

{~[R,] .words}

Expandido:

{              # 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 bytes

API do Lambda + Stream

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

Seguindo a sugestão do Selim, deixamos cair 4 bytes

— user902383
fonte

1

Salve 4 bytes usando em Stream.ofvez de Arrays.stream: -)

— Selim

1

Vim, 20 bytes

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

Isso é mais curto que a outra resposta do vim.

Experimente online!

— DJMcMayhem
fonte

1

Pitão, 3 bytes

_cw

Minha primeira resposta Pyth, um byte menor que a resposta de @ notjagan!

Explicado:

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

— OldBunny2800
fonte

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.

Licensed under cc by-sa 3.0 with attribution required.