Helloellolloloo Worldorldrldldd

50

Créez un programme qui prend le mot que vous avez entré et ajoute ce mot à l’arrière de lui-même moins sa première lettre, puis se répète jusqu’à ce que toutes les lettres aient disparu. Par exemple, catdeviendrait catattet hellodeviendrait helloellolloloo.

Entrez l’
une des 26 lettres de l’alphabet anglais. Il peut y avoir plusieurs mots séparés par des espaces, et le changement doit être appliqué à chaque mot.

Sortie
Le (s) mot (s) saisi (s), chaque mot étant suivi de sa première lettre, puis de sa deuxième lettre, et ainsi de suite jusqu'à ce qu'il ne reste plus aucune lettre à ajouter.

Plus d'exemples:

ill eel les sorties illlll eelell

laser bat les sorties laserasersererr batatt

darth vader les sorties dartharthrththh vaderaderdererr

C'est le code de golf, donc le code le plus court gagne.

Précision:
vous pouvez traiter l’entrée ou la sortie comme une liste. Vous pouvez séparer les mots en utilisant une nouvelle ligne au lieu de l’espace. Vous pouvez ajouter un espace de fin à l'entrée.

code-golf  string 
— Qazwsx
source
22
Honnêtement, le problème des mots multiples est un peu gênant. Tout ce qu’il fait est d’exiger une scission, d’appliquer la fonction à chaque mot, puis de les rejoindre. C'est aussi assez débilitant pour beaucoup d'esolangs qui doivent vérifier manuellement l'espace disponible
— Jo King
4
Pouvons-nous prendre en entrée une liste de mots et une sortie en tant que telle?
— Quintec
4
Quelle longueur de mots avez-vous besoin de manipuler?
— MickyT
5
Est-il acceptable que les mots soient séparés par une nouvelle ligne dans la sortie (au lieu d'un espace)?
— JayCe
10
1.Veuillez mettre à jour les spécifications avec les nouvelles allocations (E / S de tableau, espace de fin, etc.). 2.Veuillez informer les solutions existantes au cas où l'une d'entre elles pourrait économiser des octets en en tirant parti.
— Shaggy

Réponses:

34

Japt -m, 6 3 octets

L'entrée et la sortie sont des tableaux de mots.

£sY

L'essayer

Explication

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y
— Hirsute
source
1
C'est vraiment compact. Agréable!
— qazwsx
9
@qazwsx: Maintenant 50% plus compact!
— Shaggy
1
N'est-ce pas £deux octets en UTF-8?
— Vi.
7
@Vi, je n'utilise pas UTF-8 ici.
— Shaggy
36

brainfuck , 60 56 octets

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

Essayez-le en ligne!

Requiert un espace de fin et imprime un espace de début. Les deux peuvent être contournés, mais cela aboutit à 112 octets .

Explication

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input
— Jo King
source
21

Haskell, 36 21 octets

map$concat.scanr(:)""

Essayez-le en ligne!

Edit: -15 octets, à cause du nouveau format IO (liste de mots au lieu de mots séparés par des espaces)

— nimi
source
Vous pouvez supprimer 5 caractères en les remplaçant scanr (:) ""par tails.
— Frerich Raabe
1
@FrerichRaabe: oui, mais cela nécessiterait un import Data.Listqui ajoute 17 octets à la partition.
— nimi
18

Perl -p, 36 25 23 octets

s!\b|\S!$'=~s/ .*//r!eg

Essayez-le en ligne!

Ceci est un simple regsub. Tout d'abord, il correspond à toutes les limites de mots ou aux caractères non-espaces:

[][H][e][l][l][o] [][W][o][r][l][d]

Notez que chacune de ces correspondances doit être remplacée par le reste du mot:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

Nous pouvons accomplir cela avec la variable spéciale $', qui stocke la partie de la chaîne après la correspondance. Cependant, nous devons y appliquer le regsub imbriqué s/ .*//, qui supprime tout ce qui se trouve au-delà du premier espace $', afin de supprimer les mots restants dans l'entrée.

Merci à @nwellnhof pour 2 octets.

— Poignée de porte
source
Vous pouvez remplacer [^ ]avec \S.
— nwellnhof
17

Python 3 , 49 octets

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

Essayez-le en ligne!

Cela tire parti du fait que "".split()retourne un tableau vide, ce qui sert de contrôle pour le cas de base dans la récursivité.

— Cameron Aavik
source
17

Gelée , 3 octets

ḊƬ€

Essayez-le en ligne!

Vous n'avez plus besoin du Ks puisque l'entrée / sortie du tableau est maintenant autorisée.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.
— Dylnan
source
Je pense que vous avez besoin ḊƬẎ)(ou ḊƬF), si vous préférez).
— Erik l'Outgolfer
@EriktheOutgolfer Je ne le pense pas. Chaque mot est représenté par un tableau séparé dans la sortie
— dylnan
1
Je ne suis pas sûr que vous puissiez affirmer cela, puisque les tableaux sont imbriqués et que rien n'est spécifié dans la question pour le permettre.
— Erik l'Outgolfer
15

APL (Dyalog), 19 9 octets

{⌽∊,\⌽⍵}¨

grâce à @ H.PWiz pour avoir fait du jogging dans mon cerveau

Cela fonctionne car toutes les chaînes dans APL sont des tableaux de caractères.

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

— Quintec
source
15

JavaScript (ES6), 33 octets

Enregistré 1 octet grâce à @ShieruAsakoto

Format I / O: tableau de mots.

a=>a.map(g=w=>w&&w+g(w.slice(1)))

Essayez-le en ligne!

JavaScript (ES6), 35 octets

Format I / O: tableau de mots.

a=>a.map(w=>w.replace(/./g,"$&$'"))

Essayez-le en ligne!

— Arnauld
source
2
44:s=>s.replace(/\S+/g,g=s=>s&&s+g(s.slice(1)))
— Shieru Asakoto
1
Merci pour mon "quelque chose de nouveau" pour aujourd'hui; jamais su à propos de $'(ou $<backtick>).
— Shaggy
13

R , 82 75 67 octets

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

Essayez-le en ligne!

Plusieurs octets sauvés grâce à JayCe

Séparer la sortie avec des nouvelles lignes.

L' sapply(...)expression génère un vecteur matrice / colonne des sous-chaînes appropriées, en complétant ""si nécessaire. writeaffiche ensuite les éléments de la matrice, ypar ligne, en les séparant par "".

— Giuseppe
source
4
Golf une approche différente tout en tenant un bébé endormi; ajoutera une explication plus tard.
— Giuseppe
2
Si la longueur des mots est restreinte, par exemple 99 caractères ou ~ 1e6, vous pouvez frapper un tas d'octets avec ...substring,1:1e6,1e6)...ou similaire
— MickyT
2
Si vous pouvez séparer les mots par une nouvelle ligne: tio . Je l'ai demandé dans un commentaire. Peut travailler avec le commentaire de @ MickyT
— JayCe
@JayCe semble que cela pourrait être 67 octets avant d'intégrer la suggestion de MickyT
— Giuseppe
8

brainfuck , 94 93 octets

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

Essayez-le en ligne!

  • Un octet sauvé grâce à Nitrodon - golfing.[-]>[.>]<[<]> to [.>]<[<]>[-]>.

Explication

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

Essayez-le en ligne!

Attribution

La collection constante de brainfuck d'Esolang a été utilisée pour la charge d'espace initiale.

— Jonathan Frech
source
Cela ne semble pas se terminer. Est-ce prévu?
— Jo King
1
@JoKing Oui. Dans certaines implémentations, il dépasserait la limite de bande, en sortant par erreur.
— Jonathan Frech
6

05AB1E , 5 octets

€.síJ

Essayez-le en ligne!

Explication

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes
— Emigna
source
1
Alternative ennuyeuse à 5 octets: í€ηJí(puisque les préfixes est un codet intégré de 1 octet au lieu de 2 octets comme les suffixes; nécessite toujours une inversion inversée mais au début, le nombre d'octets reste donc 5).
— Kevin Cruijssen le
6

Vim , 47 octets (38 touches)

Commencez avec votre entrée comme seule ligne dans un tampon Vim.

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

Explication

Cela met chaque mot sur sa propre ligne, itère sur chaque ligne, puis les rejoint tous. Se casse si les mots contiennent plus de 99 caractères ou si votre saisie en contient plus de 99.

  1. :s/<Space>/\r/g<CR> remplace les espaces par de nouvelles lignes ( \r)
  2. gg positionne le curseur au début de la première ligne
  3. qacommence l'enregistrement de la macro a :
    • yw tire le reste du mot
    • P le met derrière le curseur
    • lx supprime la première lettre de ce dernier mot
    • qarrête d'enregistrer une macro
  4. qbcommence l'enregistrement de la macro b :
    • 99@amacro exécute un quatre-vingt-neuf fois (introduit la limite de caractères)
    • j0 positionne le curseur au début de la ligne suivante
    • qarrête d'enregistrer la macro b
  5. 99@bexécute la macro b quatre-vingt-dix-neuf fois (introduit la limite de mots)
  6. gg positionne le curseur sur la première ligne
  7. 99J joint les 99 lignes suivantes avec des espaces (limite de mot à nouveau)

Pour 2 autres octets (2 touches), vous pouvez étendre la limite de mots à 999. 4 autres octets, 9999, etc.

— chambln
source
6

Husk , 6 4 octets

-2 octets grâce à Jonathan Allan (en prenant la liste comme entrée)!

moΣṫ

Essayez-le en ligne!

Explication

Prend l'entrée en tant que liste de chaînes et mappe la fonction suivante:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"
— ბიმო
source
La scission et la jointure ne sont peut-être plus nécessaires, cette spécification est actuellement dans un commentaire.
— Jonathan Allan
5

Retina 0.8.2 , 15 octets

 
¶
.
$&$%'
¶

Essayez-le en ligne! Remarque: espaces de fin. Explication:

Split sur des espaces.

.
$&$%'

Ajoutez son suffixe à chaque lettre. Les %moyens que nous obtenons que le suffixe du mot.

Rejoindre avec des espaces.

— Neil
source
5

Pepe , 167 153 octets

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Essayez-le en ligne!

— indéfini
source
5

Code d'assemblage 16 bits x86, 24 octets

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

Appel avec si = pointeur sur la chaîne source, di = pointeur sur le tampon de sortie.
La chaîne source nécessite un octet nul pour la terminer.
Le code est le même en 16, 32 ou 64 bits (si / di devient soiti / edi ou rsi / rdi).
Le code 32 bits a une taille plus grande de deux octets en raison de l'appel étendu.
Le code 64 bits est encore plus grand de trois octets, car les augmentations / diminutions de rsi / rdi attirent un préfixe (mais si on sait qu'elles se trouvent dans un espace mémoire de 32 bits, elles peuvent être à nouveau esi / edi pour éviter cette pénalité) .

— Peter Ferrie
source
4

MATL , 18 16 octets

"@gXH"HX@Jh)]0&h

L'entrée est un tableau de mots de cellules. Essayez-le en ligne!

Explication

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display
— Luis Mendo
source
4

C ++ (clang) , 174 octets

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

Essayez-le en ligne!

C'est ma première soumission, et je ne savais pas si retourner de la chaîne au lieu de l'imprimer était correct :)

— QJot
source
2
Bienvenue chez PPCG! Oui, renvoyer une chaîne est acceptable. J'espère que vous restez!
— Jo King
Vous pouvez utiliser la symétrie de l'opérateur d'inégalité pour supprimer un espace et économiser ainsi un octet - return w!=""?peut l'être return""!=w?.
— Jonathan Frech
3

Charbon de bois , 14 octets

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹

Essayez-le en ligne! Remarque: espace de fuite. Le lien est vers la version verbeuse du code. Explication:

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print
— Neil
source
3

Pip -s , 11 octets

J_@>,#_Mq^s

Prend la liste de mots séparés par des espaces de stdin. Essayez-le en ligne!

Explication

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator
— DLosc
source
3

C #, 111 90 octets

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

Essayez-le en ligne!

En modifiant les entrées et les sorties en tableaux, j'ai économisé quelques octets:

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

Essayez-le en ligne!

— LiefdeWen
source
3

K (oK) , 17 à 13 octets

{,/|:'|,\|x}'

Essayez-le en ligne!

Préfixe fonction anonyme; L'entrée est considérée comme une liste de chaînes, qui sont à leur tour des listes de caractères.

Merci @streetster pour 4 octets.

Comment:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")
— J. Sallé
source
Vous pouvez retourner une liste, aussi jeter un oeil à ma oK solution
— Streetster
@streetster oh, bien. Je suis encore en train d'apprendre K, mes solutions ne seront donc pas aussi courtes ni aussi élégantes que je le voudrais. Merci pour l'information!
— J. Sallé
Aplatir avant d'inverser vous permet d'omettre le "inverser-chaque", le ramenant à 10 octets: {|,/,\|x}'
— hoosierEE
3

Common Lisp , 179 octets

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

Essayez-le en ligne!

Ceci est mon premier essai au golf, toutes les modifications sont les bienvenues

— JRowan
source
Bonjour et bienvenue sur PPCG. La suppression des espaces peut vous faire économiser 29 octets .
— Jonathan Frech
@Johnathan Frech merci je viens de mettre à jour sans espaces
— JRowan
Je pense que vous avez manqué quatre espaces superflus.
— Jonathan Frech
Vous pouvez aussi probablement utiliser carau lieu de firstet cdrau lieu de restcontinuer à jouer au golf votre soumission.
— Jonathan Frech
Na, je suis bien avec ça maintenant haha, peut-être que le malade reviendra et foiré avec plus tard. Je viens d'apprendre à parler de mon mari maintenant que mon professeur m'a dit de ne jamais utiliser voiture et cdr, ils étaient donc hors de ma tête alors que je le faisais
— JRowan
3

Lua , 70 octets

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

Essayez-le en ligne!

Explication

Les arguments dans Lua sont stockés dans la table à argpartir de l'index 1. L'opérateur unaire #retourne la taille de la table et la fonction s:sub(a,b)renvoie une sous-chaîne basée sur une chaîne sdélimitée par des entiers aet b, si b n'est pas passé, il retournera le reste de la chaîne.

Je devais utiliser io.write()au lieu d' print()éviter les sauts de ligne, et ajouté print()à la fin pour la raison opposée.

— Marcio Medeiros
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.