Inversion des mots

30

Sona est dans sa maison avec sa fille de 10 ans. Elle doit aller à l'école pour ramener un autre enfant de l'école, car l'école est finie à 14 heures. Il fait chaud dehors, alors elle veut laisser son plus jeune enfant à la maison.

Elle a donné un tas de cordes à son enfant pour l'occuper pendant son absence. Elle lui a demandé d'inverser les mots de la chaîne. Il y a beaucoup de chaînes, vous devez donc aider sa fille à résoudre cette énorme tâche.

Donc, étant donné une chaîne qui contient des mots séparés par un seul espace, inversez les mots de la chaîne. Vous pouvez supposer qu'il n'y a aucun espace de début ou de fin.

La chaîne contiendra uniquement [a-zA-z ], vous n'avez donc pas besoin de gérer la ponctuation.

Vous recevrez une chaîne en entrée et vous devrez sortir une chaîne.

Exemples de cas de 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

Notation

C'est du code-golf . La réponse la plus courte en octets gagne.

code-golf  string  whitespace 
— Cyoce
source
1
— Martin Ender
1
Pouvons-nous prendre l'entrée comme une liste de mots? (ie ['man', 'bites', 'dog'])
— Rɪᴋᴇʀ
3
La sortie peut-elle avoir un espace de fin?
— Digital Trauma

Réponses:

11

Rétine , 7 octets

O$^`\w+

Essayez-le en ligne!

Faites correspondre tous les mots ( \w+) triez-les avec la chaîne de clé vide ( O$), ce qui signifie qu'ils ne seront pas triés du tout, puis inversez leur ordre ( ^).

— Martin Ender
source
Je n'ai jamais utilisé Retina mais pourquoi en avez-vous besoin 0$? Tu ne peux pas simplement inverser la situation?
— caird coinheringaahing
@RandomUser sort mode ( O) est actuellement le seul mode qui a cette option inverse.
— Martin Ender
7

JavaScript (ES6), 31 octets

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

Essayez-le

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>
Développer l'extrait

— Hirsute
source
1
Ce sont des réponses comme celle-ci, qui sont essentiellement les mêmes que ma réponse C # qui me fait détester le C # pour le golf. Tout le fluff supplémentaire dans ma réponse double presque le nombre d'octets ... +1
— TheLethalCoder
Note latérale: En C # si vous ne lui passez rien Splitpar défaut sur les espaces blancs par défaut, pouvez-vous faire la même chose ici?
— TheLethalCoder
1
Malheureusement non, @TheLethalCoder, si vous ne fournissez pas de chaîne / expression régulière splitdans JS, il se divisera sur chaque caractère individuel ou créera un tableau avec un seul élément contenant la chaîne d'origine, selon la syntaxe utilisée.
— Shaggy
6

R, 19 octets

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

lit la chaîne depuis stdin. Par défaut, scanlit les jetons séparés par des espaces / retours à la ligne, il lit donc les mots comme vecteur. revinverse et catimprime les éléments avec des espaces.

Essayez-le en ligne!

— Giuseppe
source
6

Brachylog , 6 octets

ṇ₁↔~ṇ₁

Essayez-le en ligne!

Explication

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

Notez que "diviser sur les espaces" et "joindre avec des espaces" utilisent le même intégré, c'est-à-dire qu'ils sont ṇ₁juste utilisés dans des "directions" différentes.

— Fatalize
source
3

brainfuck , 74 octets

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

Essayez-le en ligne!

Ce code crée le nombre -32 à deux endroits différents, mais cela semble être moins d'octets que d'essayer de maintenir un seul -32.

Explication

,[                        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
source
3

C, 54 48 octets

Utilisation d'arguments en entrée, 48 octets

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

Essayez en ligne

> ./a.out man bites dog

Utilisation de pointeurs, 84 octets

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

Utilisation

main(){ f("man bites dog"); }
— Khaled.K
source
3

Japt , 11 10 7 4 octets

Ma première tentative à Japt.

¸w ¸

Essayez-le en ligne

Explication

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

Veuillez partager vos conseils Japt ici .

— Hirsute
source
2
Merci d'utiliser Japt :-) Vous pouvez utiliser ¸à la place de qS , ce qui devrait vous faire économiser trois octets ici. (Voir la section "Raccourcis Unicode" de la documentation de l'interprète)
— ETHproductions
Agréable! vous pouvez enregistrer un octet si vous utilisez l' -Sindicateur .
— Oliver
Je compte 2 octets, @obarakon. À moins que le drapeau ne soit inclus dans le nombre d'octets, auquel cas ce serait 4 octets, non?
— Shaggy
@Shaggy Chaque indicateur compte pour un octet. Il en -Sserait de même de +1 sur votre nombre total d'octets.
— Oliver
Ah, je vois. Est-ce une chose PPCG ou une chose Japt?
— Shaggy
2

Cubix , 48 octets

Presque abandonné celui-ci, mais finalement arrivé.

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

Essayez-le en ligne!

Cela correspond à un cube avec une longueur de côté de trois comme suit

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

Les étapes générales sont les suivantes:

  • Obtenez toutes les entrées Aet inversezB pile
  • Déplacez le négatif qvers le bas, ajoutez un compteur 0à la pile. un peu de sauter ici.
  • Recherche espace / boucle de fin, met également la pile dans l'ordre d'impression correct.
    • Incrémenter le compteur )et récupérer l'élément de compteur dans la pilet
    • Est-ce un espace ou une EOI S-?
    • Répétez sinon
  • Boucle de mot d'impression
    • Décrémenter le compteur (
    • Boucle de sortie si le compteur !Uest à 0
    • Échanger le scompteur avec le personnage sur la pile
    • Imprimer le opersonnage et le sortir de la pile;
    • Répéter la boucle
  • Obtenez la longueur de la pile #et décrémentez(
  • Vérifiez ?si 0 et quittez @si c'est 0
  • Sinon, imprimez un Sonettoyage d' espace ;;et revenez à la première boucle.

J'ai sauté un certain nombre d'étapes superflues, mais vous pouvez le voir étape par étape

— MickyT
source
2

Mathematica, 35 octets

StringRiffle@Reverse@StringSplit@#&

Essayez-le en ligne!

— J42161217
source
StringSplit[#]se divise automatiquement sur les espaces, vous n'avez donc pas besoin de spécifier le " ".
— Pas un arbre
2
correct! -5 octets!
— J42161217
Ooh, et je pense que vous pouvez enregistrer un autre octet en utilisant la composition de fonction: StringRiffle@*Reverse@*StringSplit(appelez-le comme StringRiffle@*Reverse@*StringSplit@"hello world")
— Pas un arbre
2

Röda , 27 25 octets

2 octets économisés grâce à @fergusq

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

Essayez-le en ligne!

Cette fonction prend l'entrée du flux d'entrée.

Explication (obsolète)

{[[(_/" ")()|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
source
splitutilise l'espace comme séparateur par défaut, il split()est donc plus court que (_/" ")().
— fergusq
1

Gema, 29 caractères

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

Exemple d'exécution:

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

Perl 6 , 14 octets

{~[R,] .words}

Essayez-le

Étendu:

{              # 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
source
1

Java 8, 53 57 octets

API Lambda + Stream

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

Suite à la suggestion de Selim, nous venons de laisser tomber 4 octets

— user902383
source
1
Économisez 4 octets en utilisant Stream.ofau lieu de Arrays.stream: -)
— Selim
1

Pyth, 3 octets

_cw

Ma première réponse Pyth, un octet plus court que la réponse de @ notjagan!

Expliqué:

 cw # Split the input by space (same as Python's string.split())
_   # Reverses the array
    # Pyth prints implicitly.
— OldBunny2800
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.