Đưa ra một chuỗi làm đầu vào, in một chuỗi mới với mỗi chữ cái được đẩy sang phải theo chỉ số bảng chữ cái tương ứng.

Chúng ta đều biết rằng A là một chữ chậm và Z là một chữ cái nhanh. Điều này có nghĩa là Z bị dịch chuyển sang phải 25 khoảng trắng, A hoàn toàn không bị dịch chuyển và B bị dịch chuyển bởi 1 khoảng trắng.

Chương trình của bạn chỉ phải xử lý các chữ cái viết hoa từ AZ, và không có ký tự nào khác, không có khoảng trắng, không có dấu chấm câu.

Lưu ý rằng nếu 2 hoặc nhiều chữ cái rơi vào cùng một khoảng trắng sau khi dịch chuyển, ký tự mới nhất sẽ được sử dụng. (Ví dụ: BA->  A)

Ví dụ

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

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

Quy tắc

• Đây là mã golf , vì vậy mã ngắn nhất trong bất kỳ byte ngôn ngữ nào sẽ thắng.

• Sơ hở tiêu chuẩn bị cấm.

• Đầu vào phải được nhận dưới dạng một chuỗi.

• Bạn có thể in kết quả đến stdouthoặc trả về một chuỗi.
• Một khoảng trắng duy nhất và / hoặc dòng mới được cho phép.
• Bạn cũng có thể sử dụng chữ cái viết thường làm đầu vào hoặc đầu ra, nhưng chỉ sử dụng một trong hai trường hợp.

Python 2 , 81 byte

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

Hãy thử trực tuyến!

MATL , 11 byte

''jtfy65-+(

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Lập chỉ mục MATL là dựa trên 1. Thủ thuật đánh gôn này được sử dụng ở đây. Cái này không thể được sử dụng bởi vì chúng ta cần một chuỗi rỗng, không phải là một mảng số trống.

Hãy xem xét đầu vào 'ACE'là một ví dụ. Nội dung ngăn xếp được hiển thị từ dưới lên trên.

''     % 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 byte

Đã lưu một tấn byte chuyển cách tiếp cận giá trị ASCII như mọi người khác. Buồn thay tôi đã không nghĩ về nó trước đây :(

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

Hãy thử trực tuyến!

câu trả lời gốc, 129 byte:

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='')}

Hãy thử trực tuyến!

tạo ra một danh sách quá dài ocác khoảng trắng, sau đó lặp qua s, thay thế các giá trị obằng giá trị chính xác và cập nhật F, vị trí của ký tự ngoài cùng bên phải. Sau đó in ra các Fyếu tố đầu tiên okhông có dấu phân cách giữa chúng.

05AB1E , 20 16 byte

-4 byte nhờ Emigna

ð₄×svyAuykN+ǝ}ðÜ

Hãy thử trực tuyến!

JavaScript (ES6), 81 byte

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

Phần nào đó được xây dựng từ câu trả lời không đầy đủ của Rick Hitchcock nhưng cuối cùng lại khác.

Đặt các ký tự vào chỉ mục tương ứng của một mảng trống, sau đó sử dụng mảng lây lan ( [...a]) để biến các phần tử bị thiếu thành undefined, cho phép mapthay thế các phần tử trống bằng một khoảng trắng.

Các trường hợp thử nghiệm

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 byte

Mã 41 byte + 1 cho -p. Các \x1bs trong mã là các ký tự thoát theo nghĩa đen.

Dựa vào các chuỗi thoát ANSI để định vị con trỏ và do đó không hoạt động trên TIO.

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

Sử dụng

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 174 173 170 byte

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('',' ');}

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Chỉ dành cho @lynn

Brainfuck , 127 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

69 byte bằng cách chuyển giải pháp của Lynn: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Thạch , 20 byte

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

Hãy thử trực tuyến!

Haskell , 90 88 byte

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

Hãy thử trực tuyến!

Japt , 23 byte

;iB ç
Ng £=hX10nY+XnG
U

Kiểm tra nó trực tuyến!

Nỗ lực đầu tiên, có thể là ngẫu hứng ...

Ngôn ngữ Wolfram (Mathicala) , 76 byte

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

Đưa ra một danh sách các ký tự làm đầu vào. Điều này tạo ra một số thông báo lỗi an toàn để bỏ qua.

Tôi đã bao gồm Printvà Characterchỉ huy trong phần chân trang của liên kết TIO để dễ sử dụng. ( Characterlệnh chỉ đơn giản là chuyển đổi một chuỗi thành một danh sách các ký tự)

Hãy thử trực tuyến!

J, 37 31 byte

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

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

-6 byte nhờ FrownyFrog

giải trình

Toàn bộ điều là một cái móc:

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

Phía bên phải tính toán các chỉ mục mới cho tất cả các chữ cái.

Phía bên trái sử dụng hình thức gerund của Amend }trước để tạo một chuỗi số lượng không gian cần thiết : (' '#~(1+>./)@]). Và sau đó để đặt từng chữ cái của chuỗi gốc vào chỉ mục thích hợp của nó trong chuỗi toàn không gian.

Hãy thử trực tuyến!

Haskell , 88 byte

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

Hãy thử trực tuyến!

Haskell, 88 byte

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

Hãy thử trực tuyến!

qlà danh sách các chỉ số cuối cùng của các chữ cái của chuỗi đầu vào (có độ lệch là 65). Lặp lại tất cả các chỉ số (bắt đầu từ 65) và tìm tất cả các chữ cái cho nó, chuẩn bị một khoảng trắng. Đi cuối cùng.

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

Đã lưu 7 byte nhờ Ayb4tu .

Thay đổi kiểu trả về từ stringđể char[]tiết kiệm 26 byte.

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;}

Hãy thử trực tuyến!

C # .NET, 89 byte 87 byte

-2 byte nhờ 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;}

Hãy thử trực tuyến!

Kotlin, 207 byte 189 byte 187 byte 177 byte

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())}

Nếu trống hàng đầu vẫn còn tôi sẽ chỉ gọi trimEnd()thay vì trim().

Chưa hoàn thành:

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())
}

Có thể Kotlin không phải là ngôn ngữ tốt nhất để chơi golf mã nhưng tôi thích thử thách này và tôi muốn làm quen với thư viện tiêu chuẩn của Kotlin.

q / kdb +, 37 byte

Giải pháp:

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

Ví dụ:

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"

Giải trình:

Tôi nghĩ rằng đây là ý tưởng tương tự như giải pháp J, tính toán các chỉ số chính xác cho mảng đầu vào và sau đó gán chúng cho một chuỗi trống có độ dài chính xác:

@[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 byte

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

Mở rộng

  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

Hãy thử trực tuyến!

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｐ                   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 byte

Tiền tố ẩn danh lambda lấy chuỗi đầu vào làm đối số và trả về chuỗi đầu ra. Giả sử ⎕IO( I ndex O rigin) 0, được mặc định trên nhiều hệ thống.

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

Hãy thử trực tuyến!

{... } lambda vô danh; ⍵đại diện cho lập luận

 ≢⍵ kiểm đếm tranh luận

 ⍳ hơn nhiều ntegers (0 độ dàiOfArgument-1)

 (... )+ cộng thêm:

  ⎕A⍳⍵ các chỉ số của đối số trong chữ hoa A lph.us

 i← bước vào i(cho tôi ndices)

 ⌈/ tối đa (giảm)

 1+ cộng một

 ''↑⍨ lấy nhiều ký tự từ chuỗi trống, đệm với khoảng trắng khi cần

 ⊢ mang lại (phục vụ để tách ikhỏi '')

 ⍵@i sửa đổi điều đó với các chữ cái đối số tại các ichỉ số

SOGL V0.12 , 10 byte

ā,{ZFWē+1ž

Hãy thử nó ở đây!

Giải trình:

ā           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

Bình thường , 44 38 byte

_{Striked out 44 vẫn là 44 :(}

Bloody Pyth mới bắt đầu.

Đã lưu 6 byte nhờ @Mr. Xcoder.

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

Hãy thử trực tuyến!

Làm sao?

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

Batch, 418 331 byte

Chỉ hoạt động với các chữ cái viết hoa và sẽ mất vài giây cho các chuỗi dài hơn.

Đã học các thủ thuật mới ở đây, sử dụng ký tự chuyển đổi giá trị ASCII %=exitcodeAscii%. Ngoài ra, if definedvà truy cập "mảng" bằng cách sử dụng call. Ngoài ra, chơi golf gần 100 byte là đào tạo golf hàng loạt mã tốt.

Lưu ý không gian dấu trong 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 byte

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

Hãy thử trực tuyến!

Hội đồng IBM PC DOS 8088 ,34 33 byte

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

Ungolfed (chưa được lắp ráp):

    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

Đây là một tệp thực thi PC DOS hoàn chỉnh, lấy chuỗi đầu vào từ dòng lệnh và in phiên bản "nhanh hơn" mới ra màn hình. Yêu cầu tối thiểu DOS 1.0 ... hy vọng bạn đã có ít nhất điều đó.

Đầu ra

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 byte

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;}

Dùng thử trực tuyến

Phải sửa một lỗi không xuất ra 'A' ...