Avec une chaîne en entrée, imprimez une nouvelle chaîne avec chaque lettre poussée à droite par son index alphabet respectif.

Nous savons tous que A est un lent et Z une lettre rapide. Cela signifie que Z est décalé vers la droite de 25 espaces, que A ne se déplace pas du tout et que B est décalé de 1 espace.

Votre programme doit uniquement gérer les lettres majuscules de A à Z, et aucun autre caractère, aucun espace, aucun signe de ponctuation.

Notez que si 2 lettres ou plus tombent sur le même espace après le décalage, le dernier caractère sera utilisé. (Exemple: BA->  A)

Exemples

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

"HELLOWORLD" -> "     E H    DLL   OLO   R  W"

Règles

• C'est du code-golf , donc le code le plus court parmi tous les octets de la langue gagne.

• Les échappatoires standard sont interdites.

• L'entrée doit être reçue sous forme de chaîne.

• Vous pouvez imprimer le résultat stdoutou renvoyer une chaîne.
• Un seul espace et / ou nouvelle ligne de fin est autorisé.
• Vous pouvez également utiliser des lettres minuscules comme entrée ou sortie, mais n'utilisez que les deux cas.

Python 2 , 81 octets

t=[]
i=65
for c in input():t+=[' ']*26;t[ord(c)-i]=c;i-=1
print`t`[2::5].rstrip()

Essayez-le en ligne!

MATL , 11 octets

''jtfy65-+(

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

L'indexation MATL est basée sur 1. Cette astuce de golf est utilisée ici. Cet autre ne peut pas être utilisé car nous avons besoin d'une chaîne vide, pas d'un tableau numérique vide.

Considérez l'entrée 'ACE'comme un exemple. Le contenu de la pile est affiché de bas en haut.

''     % Push empty string
       %   Stack: ''
j      % Input string
       %   Stack: '', 'ACE'
t      % Duplicate
       %   Stack: '', 'ACE', 'ACE'
f      % Indices of nonzero entries. Gives [1 2 ... n] where n is input length
       %   Stack: '', 'ACE', [1 2 3]
y      % Duplicate from below
       %   Stack: '', 'ACE', [1 2 3], 'ACE'
65     % Push 65
       %   Stack: '', 'ACE', [1 2 3], 'ACE', 65
-      % Subtract, element-wise. Characters are converted to codepoints
       %   Stack: '', 'ACE', [1 2 3], [0 2 4]
+      % Add, element-wise
       %   Stack: '', 'ACE', [1 4 7]
(      % Fill string '' with values 'ACE' at positions [1 4 7]. The original
       % empty string is extended. Non-existing values are filled with char 0,
       % which is displayed as space. Implicitly display
       %   Stack: 'A  C  E'

R , 140 133 129 74 octets

Sauvegardé une tonne d'octets portant une approche de valeur ASCII comme tout le monde. Triste, je n'y avais pas pensé avant :(

function(s){F[X-65+1:sum(X|1)]=X=utf8ToInt(s)
F[is.na(F)]=32
intToUtf8(F)}

Essayez-le en ligne!

réponse originale, 129 octets:

function(s){o=rep(' ',(n=nchar(s))+25)
for(i in 1:n){k=substr(s,i,i)
o[x<-i+match(k,LETTERS)-1]=k
F=max(F,x)}
cat(o[1:F],sep='')}

Essayez-le en ligne!

génère une liste od'espaces trop longue , puis itère s, en remplaçant les valeurs opar la valeur correcte et en mettant à jour Fla position du caractère le plus à droite. Ensuite, affiche les premiers Féléments osans séparateurs.

05AB1E , 20 16 octets

-4 octets grâce à Emigna

ð₄×svyAuykN+ǝ}ðÜ

Essayez-le en ligne!

JavaScript (ES6), 81 octets

s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``

Un peu à partir de la réponse incomplète de Rick Hitchcock mais finalement assez différent.

Place les caractères dans leur index respectif d'un tableau vide, puis utilise array spread ( [...a]) pour transformer les éléments manquants en undefinedpermettant mapde remplacer les éléments vides par un espace.

Cas de test

let f=
s=>[...s].map((c,i)=>a[i+parseInt(c,36)-10]=c,a=[])&&[...a].map(c=>c||" ").join``

;["AZ", "ABC", "ACE", "CBA", "HELLOWORLD"]
.forEach(t=>console.log(`"${t}"`, "=>", `"${f(t)}"`))

Perl 5, 42 octets

Code de 41 octets + 1 pour -p. Les \x1bs dans le code sont des caractères d'échappement littéraux.

S'appuie sur les séquences d'échappement ANSI pour positionner le curseur et ne fonctionne donc pas sur TIO.

s/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge

Usage

perl -pe 's/./($-=-65+ord$&)?"\x1b[$-C$&\x1b[--$-D":$&/ge' <<< 'HELLOWORLD'
     E H    DLL   OLO   R  W

Java (OpenJDK 8) , 207 191 189 183 178 178 174 173 170 octets

s->{char i=0,l,c[]=new char[s.chars().map(j->j+s.lastIndexOf(j)).max().getAsInt()-64];for(;i<s.length();c[i+l-66]=l)l=s.charAt(i++);return"".valueOf(c).replace('',' ');}

Essayez-le en ligne!

Perl 5 , 41 + ( -F) = 43 octets

map$r[$i++-65+ord]=$_,@F;print$_||$"for@r

Essayez-le en ligne!

Juste pour @lynn

brainfuck , 127 octets

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

Essayez-le en ligne!

Explication

,[                    Take input and start main loop
  [-<+<+>>]             Make two copies of input byte
  ----[----<<->>]<<-    Subtract 64 from one of them to get position in alphabet

                        There are two zero cells between the input and the
                        remaining output cells; we wish to move these zeroes
                        to indicate where the letter is to be moved

  [                     A number of times equal to the position in the alphabet:
    [>]                   Go to current position in output string
    >++++>                Create 4 (as part of creating a space if needed)
    [-<[-]<+>>]           Move output byte back two cells; zero the previous 4 if output existed
    <[-<++++++++>]        Otherwise move a space (32) into that position
    <[<]>-                Move back to counter and decrement
  ]
  >[>]<[-]              Delete last moved byte to make room for input byte
  +[<]>-                Initialize slot at 1 so it is always nonzero in this loop
  [[>]<+[<]>-]          Move input byte into slot
  >.[-]                 Output next output byte and clear
  >[>]<                 Move to space vacated in preparation to remove gap
                        (Moves to end instead if input was A; this causes no problems)
  [[->>+<<]<]           Move values two cells right until zero reached
  >,                    Get into position and take another byte of input
]
>>[.>]                Output characters beyond end of input

Proton , 78 octets

x=>{t=[' ']*26*(q=len(x))for i:0..q{t[i+ord(k=x[i])-65]=k}"".join(t).rstrip()}

Essayez-le en ligne!

69 octets en portant la solution de Lynn: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Gelée , 20 octets

ØAiЀ+JṬ€a"⁸Zḟ€0Ṫ€o⁶

Essayez-le en ligne!

Haskell , 90 88 octets

d=drop 1
[a]#s|s<"A"=a:d s|0<1=s
b#s=(s++" ")!!0:d b#d s
f(c:t)=['A'..c]#(' ':f t)
f s=s

Essayez-le en ligne!

Japt , 23 octets

;iB ç
Ng £=hX10nY+XnG
U

Testez-le en ligne!

Première tentative, peut être améliorable ...

Wolfram Language (Mathematica) , 76 octets

SparseArray[Reverse@MapIndexed[#&@@#2+LetterNumber@#-1->#&,#]]<>""/. 0->" "&

Prend une liste de caractères en entrée. Cela génère des messages d'erreur qu'il est prudent d'ignorer.

J'ai inclus Printet Charactercommande dans le pied de page du lien TIO pour la facilité d'utilisation. ( Charactercommande convertit simplement une chaîne en une liste de caractères)

Essayez-le en ligne!

J, 37 31 octets

[`]`(' '#~(1+>./)@])}(i.@#+65-~a.&i.)

[`]`(' '#~(1+>./)@])}#\-66-3&u:

-6 octets grâce à FrownyFrog

explication

La chose entière est un crochet:

[`]`(' '#~(1+>./)@])}  #\-66-3&u:

Le côté droit calcule les nouveaux index pour toutes les lettres.

Le côté gauche utilise la forme de gérondif Modifier d' }abord pour créer une chaîne du nombre nécessaire d'espaces: (' '#~(1+>./)@]). Et ensuite, placez chaque lettre de la chaîne d'origine dans son index approprié dans la chaîne tout espace.

Essayez-le en ligne!

Haskell , 88 octets

foldr(\c->(((['B'..c]>>" ")++[c])#).(' ':))[]
(x:r)#(y:t)|y>' '=y:r#t|1<3=x:r#t
r#t=r++t

Essayez-le en ligne!

Haskell, 88 octets

f s|q<-zipWith((+).fromEnum)s[0..]=[last$' ':[c|(c,i)<-zip s q,i==p]|p<-[65..maximum q]]

Essayez-le en ligne!

qest la liste des indices finaux des lettres de la chaîne d'entrée (avec un décalage de 65). Parcourez tous les index (à partir de 65) et trouvez toutes les lettres correspondantes, en ajoutant un espace. Prenez le dernier.

C # (.NET Core) , 117 110 84 octets

7 octets sauvés grâce à Ayb4tu .

Type de retour modifié de stringà char[]pour sauvegarder 26 octets.

n=>{int i=0,l=n.Length;var t=new char[l+26];for(;i<l;)t[i+n[i]-65]=n[i++];return t;}

Essayez-le en ligne!

C # .NET, 89 octets 87 octets

-2 octets grâce à Lan H.

f=>{var s=new char[f.Length+26];for(int i=0;i<f.Length;i++)s[f[i]+i-65]=f[i];return s;}

Essayez-le en ligne!

Kotlin, 207 octets 189 octets 187 octets 177 octets

fun main(){val i=(readLine()+" ".repeat(26)).toCharArray();for(x in(i.size-1) downTo 0){if(i[x]!=' '){i[x+i[x].toInt()-65]=i[x];i[x]=' '}};print(i.joinToString("").trim())}

Si l’espace au début devait rester, j’appellerais trimEnd()au lieu de trim().

Non minée:

fun main() {
    val m = (readLine() + " ".repeat(26)).toCharArray()
    for (x in (m.size - 1) downTo 0) {
        if(m[x] != ' ') {
            m[x + m[x].toInt() - 65] = m[x]
            m[x] = ' '
        }
    }

    print(m.joinToString("").trim())
}

Kotlin n'est peut-être pas la meilleure langue pour le code-golf, mais j'ai aimé le défi et je voulais me familiariser davantage avec la bibliothèque standard de Kotlin.

q / kdb +, 37 octets

Solution:

@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:

Exemples:

q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"AZ"
"A                         Z"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ABC"
"A B C"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"ACE"
"A  C  E"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"CBA"
"  A"
q)@[max[1+m]#" ";m:!:[x#:]+.Q.A?x;:;]x:"HELLOWORLD"
"     E H    DLL   OLO   R  W"

Explication:

Je pense que c'est la même idée que la solution J, calculez les index corrects pour le tableau en entrée, puis affectez-les à une chaîne vide de longueur correcte:

@[max[1+m]#" ";m:til[count x]+.Q.A?x;:;]x: / ungolfed solution
                                        x: / save input as x
@[            ;                     ; ;]   / apply[variable;indices;function;parameters]
                                     :     / assignment
                              .Q.A?x       / location of x in uppercase alphabet
                             +             / added to
                     count x               / length of input
                 til[       ]              / range, 0..n
               m:                          / save as m
  max[   ]                                 / maximum of list
      1+m                                  / m + 1
          #" "                             / take " ", creates empty character list

Jq 1.5 , 91 octets

reduce(explode|[.,keys]|transpose[]|.[1]+=.[0]-65)as[$c,$p]([];.[$p]=$c)|map(.//32)|implode

Étendu

  reduce(  explode         # convert string to array of ordinals
         | [.,keys]        # [ [v0,v1,...], [0,1,2,...] ]
         | transpose[]     # [ [v0,0], [v1,1], [v2,2]...]
         | .[1]+=.[0]-65   # adjust position of each value
  ) as[$c,$p] (
    []
  ; .[$p]=$c               # store each value at its position
  )
| map(.//32)               # map null values to spaces
| implode                  # convert back to string

Essayez-le en ligne!

Charbon de bois , 16 octets

Ｐ ＦＳ«Ｍ⌕αι→ιＭ⌕αι←

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

Ｐ                   Output a space to force the indent
   Ｓ                Input string
  Ｆ «               Loop over each letter
       α            Uppercase letters predefined variable
      ⌕ ι           Find index of current letter
     Ｍ   →          Move that many characters right
          ι         Implicitly print the current letter
           Ｍ⌕αι←    Move the same number of characters left

APL (Dyalog) , 26 octets

Préfixe anonyme lambda qui prend la chaîne d'entrée en argument et renvoie la chaîne de sortie. Suppose ⎕IO( I ndex O rigin) 0, qui est la valeur par défaut sur de nombreux systèmes.

{⍵@i⊢''↑⍨1+⌈/i←(⎕A⍳⍵)+⍳≢⍵}

Essayez-le en ligne!

{… } Lambda anonyme; ⍵représente l'argument

 ≢⍵ décompte de l'argument

 ⍳ que beaucoup ɩ ntegers (0 ... LengthOfArgument-1)

 (… )+ Plus:

  ⎕A⍳⍵ les indices de l'argument en majuscule Un alphabet

 i← strore en i(pour i ndices)

 ⌈/ maximum (réduction)

 1+ ajoute un

 ''↑⍨ prenez autant de caractères de la chaîne vide, en ajoutant des espaces si nécessaire

 ⊢ céder que (sert à séparer ide '')

 ⍵@i modifier que les lettres d'argument à des iindices

SOGL V0.12 , 10 octets

ā,{ZFWē+1ž

Essayez-le ici!

Explication:

ā           push an empty array
 ,{         for each char in the input
   ZFW        get its index in the uppercase alphabet
      ē+      add to that the 0-indexed counter
        1ž    at [pop; 1] insert in the array the current character

Pyth , 44 38 octets

_{Striked out 44 est toujours 44 :(}

Bloody Pyth débutant.

Sauvegardé 6 octets grâce à @Mr. Xcoder.

K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK

Essayez-le en ligne!

Comment?

K*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK          Full program

K*d+lz26                                        Assign a string consisting of 
                                                  (26 + input.length) whitespaces to K
        Vlz                                     For-loop from 0 to input.length
                -C@zN-65N                       Calculate the index for the current letter
                         @zN                    The current letter
            K=XK                                Insert the current letter into K at
                                                  position i
                            ;                   End statement
                             .WqeHdPZK          While the last character of H is not a 
                                                  whitespace, pop the last character off K

Lot, 418 331 octets

Fonctionne uniquement avec des lettres majuscules et prendra quelques secondes pour les chaînes plus longues.

J'ai appris de nouvelles astuces ici, la conversion de valeur de caractère en caractère ASCII à l'aide de %=exitcodeAscii%. Aussi, if definedet "array" accéder en utilisant call. De plus, jouer au golf sur près de 100 octets était une bonne formation pour le golf en lot.

Notez la fin de l'espace dans set z=set.

@echo off
setlocal EnableDelayedExpansion
set z=set 
%z%a=%1
:a
%z%v=64
:b
%z%/Av+=1
cmd/Cexit %v%
if %=exitcodeAscii% neq %a:~0,1% goto b
%z%/Ao=v+c
%z%a%o%=%a:~0,1%
if %o%. geq %m%. %z%m=%o%
%z%/Ac+=1
%z%a=%a:~1%
if %a%. neq . goto a
for /l %%n in (65,1,%m%)do (
if defined a%%n (call %z%r=%%r%%%%a%%n%%
)else %z%r=!r! )
echo %r%

Ruby , 68 octets

->s{r,w="",-66;s.bytes{|b|r[(b+w+=1).times{|a|r[a]||=" "}]=b.chr};r}

Essayez-le en ligne!

Assemblage IBM PC DOS 8088 ,34 33 octets

b403 cd10 be80 00ad 8bc8 32ed ac8b de02 d880 ebc4 8ad3 b402 cd10 b40e cd10 e2ec c3

Ungolfed (non assemblé):

    MOV  AH, 03H        ; get current cursor position row into DH
    INT  10H
    MOV  SI, 80H        ; point SI to PSP
    LODSW               ; fetch length into AL, increment SI to 82H
    MOV  CX, AX         ; move to CX
    XOR  CH, CH         ; clear CH
OUTPUT:
    LODSB               ; load DS:SI into AL
    MOV  BX, SI         ; input string offset into BX (so doesn't overwrite DH)
    ADD  BL, AL         ; add ASCII value of char
    SUB  BL, 'A'+83H    ; convert to numeric val (A=0, Z=25)
    MOV  DL, BL         ; DL is column number
    MOV  AH, 02H        ; BIOS set cursor position function    
    INT  10H            ; move to column
    MOV  AH, 0EH        ; BIOS display char function in AL
    INT  10H            ; write to screen
    LOOP OUTPUT
    RET                 ; return to DOS

Il s'agit d'un exécutable complet sous DOS qui extrait la chaîne de saisie de la ligne de commande et imprime la nouvelle version "plus rapide" à l'écran. Nécessite un minimum de DOS 1.0 ... espérons que vous avez au moins cela.

Sortie

A>SPEED.COM ABC
A B C
A>SPEED.COM AZ
A                         Z
A>SPEED.COM CBA
  A
A>SPEED.COM HELLOWORLD
     E H    DLL   OLO   R  W

PHP, 127 123 octets

function b($i){for($q=0;$q<strlen($i);$q++){$n[ord($i[$q])-65]=$i[$q];}while($x++<26){$m.=$n[$x-1]?$n[$x-1]:" ";}return$m;}

Essayez-le en ligne

Devait corriger un bug qui ne produirait pas 'A' ...