पत्रों की गति

Question

इनपुट के रूप में एक स्ट्रिंग को देखते हुए, अपने संबंधित वर्णमाला सूचकांक द्वारा दाईं ओर धकेल दिए गए प्रत्येक अक्षर के साथ एक नया स्ट्रिंग प्रिंट करें।

हम सभी जानते हैं कि A एक धीमा है और Z एक तेज़ अक्षर है। इसका मतलब है कि Z 25 स्थानों पर दाईं ओर शिफ्ट हो जाता है, A बिल्कुल भी स्थानांतरित नहीं होता है और B 1 स्थान से स्थानांतरित हो जाता है।

आपके कार्यक्रम को केवल AZ से अपरकेस अक्षरों को संभालना है, और कोई अन्य वर्ण, कोई व्हाट्सएप, कोई विराम चिह्न नहीं है।

ध्यान दें कि यदि स्थानांतरण के बाद 2 या अधिक अक्षर एक ही स्थान पर आते हैं, तो नवीनतम वर्ण का उपयोग किया जाएगा। (उदाहरण: BA->  A)

उदाहरण

"AZ" -> "A                         Z"

"ABC" -> "A B C"

"ACE" -> "A  C  E"

"CBA" -> "  A"

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

नियम

• यह कोड-गोल्फ है , इसलिए किसी भी भाषा के बाइट्स में सबसे छोटा कोड जीत जाता है।

• मानक खामियों को मना किया जाता है।

• इनपुट एक स्ट्रिंग के रूप में प्राप्त किया जाना चाहिए।

• आप परिणाम को प्रिंट कर सकते हैं stdoutया एक स्ट्रिंग वापस कर सकते हैं।
• एक एकल अनुगामी व्हाट्सएप और / या न्यूलाइन की अनुमति है।
• आप इनपुट या आउटपुट के रूप में लोअरकेस अक्षरों का भी उपयोग कर सकते हैं, लेकिन केवल मामले का उपयोग करें।

Comments

अनुगामी व्हाट्सएप ठीक है?

— ओकेक्स

@ ओकेएक्स हां, मेरी पिछली टिप्पणी पर ध्यान दें।

— इयान एच।

बहुत सारे अनुगामी स्थानों के बारे में क्या?

— ओकेक्स

@ ऑक्स निषिद्ध, एक आप सभी को मिलता है।

— इयान एच।

मुझे लगता है कि हम इसके बजाय लोअरकेस अक्षरों का उपयोग कर सकते हैं?

— श्री एक्सकोडर

Answer 1

पायथन 2 , 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 2

MATL , 11 बाइट्स

''jtfy65-+(

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

MATL इंडेक्सिंग 1-आधारित है। इस गोल्फिंग ट्रिक का उपयोग यहां किया जाता है। इस दूसरे का उपयोग नहीं किया जा सकता है क्योंकि हमें एक खाली स्ट्रिंग की आवश्यकता है, न कि एक खाली संख्यात्मक सारणी की।

'ACE'उदाहरण के रूप में इनपुट पर विचार करें । स्टैक सामग्री को नीचे से ऊपर तक दिखाया गया है।

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

Comments

(: अच्छा

— बिलिन

@EriktheOutgolfer मुझे लगता है कि यह 05AB1E के समान है ǝ? आह, लेकिन यह दूसरे / तीसरे इनपुट पर लुस करने के लिए प्रतीत नहीं होता है

— लुइस मेंडो

वास्तव में यह अद्वितीय क्यों है: पी और यह भी कि कैसे MATL ऑटो 0एस भरता है और 0अंतरिक्ष के रूप में प्रदर्शित करता है।

— आउटगॉल्फ

@LuisMendo अच्छा जवाब। जिज्ञासा से बाहर, और यह प्रश्न संभवतः सबसे अधिक स्टैक आधारित लैंग्स पर लागू होता है, जब आप MATL में लिखते हैं तो क्या आपको स्टैक का ट्रैक रखने की आवश्यकता है (जैसे, कोड के ऊपर एक पंक्ति में, या कागज का एक टुकड़ा, आदि) जैसा कि आप कोड लिखें? या यह आपके लिए पर्याप्त स्वाभाविक हो गया है कि आप नहीं?

— योना

हेह - आज कुछ नया सीखा; आप MATL (AB) में किसी भी समस्या के बिना एक ही स्थिति में दो बार अनुक्रमित कर सकते हैं। मैंने पहले ही एक जटिल लूप-आधारित उत्तर लिखना शुरू कर दिया था क्योंकि मुझे लगता था कि यह अन्यथा एक त्रुटि देगा।

— सांचे

Answer 3

आर , 140 133 129 129 बाइट्स

एक बाइट का एक टन सहेजा गया है, जो सभी की तरह ASCII मूल्य दृष्टिकोण को प्रदर्शित करता है। दुख की बात है कि मैं इसके बारे में पहले नहीं सोचा था :(

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

इसे ऑनलाइन आज़माएं!

मूल उत्तर, 129 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

oरिक्त स्थान की बहुत लंबी सूची बनाता है , फिर इसके माध्यम से पुनरावृत्ति करता है s, मानों oको सही मान और अद्यतन करने के साथ, सबसे सही Fचरित्र की स्थिति बनाता है। फिर उनके बीच कोई विभाजक नहीं Fके oसाथ पहले तत्वों को प्रिंट करता है।

Answer 4

05AB1E , 20 16 बाइट्स

-4 बाइट्स एमिग्ना के लिए धन्यवाद

ð₄×svyAuykN+ǝ}ðÜ

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आप कम ð₄×svyAuykN+ǝ}ðÜसे कम छोटा कर सकते हैं । इसके अलावा, क्या कोई गारंटी है कि इनपुट स्ट्रिंग को स्थानांतरित किया गया है 1000 वर्णों से बड़ा नहीं है? यदि नहीं, g₂+ð×तो काम करना चाहिए।

— एमिगॉन

Answer 5

जावास्क्रिप्ट (ईएस 6), 81 बाइट्स

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

रिक हिचकॉक के अधूरे जवाब से कुछ हद तक बनता है लेकिन अलग-अलग हो गया।

एक खाली सरणी के पात्रों को अपने संबंधित सूचकांक में रखता है, फिर [...a]लापता तत्वों को बदलने के लिए सरणी प्रसार ( ) का उपयोग करता है undefined, जिससे mapरिक्त तत्वों को एक स्थान के साथ बदलने की अनुमति मिलती है।

परीक्षण के मामलों

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)}"`))

Comments

बहुत अच्छा! मैं एक 88-बाइट समाधान पोस्ट करने वाला था, लेकिन आपका बहुत बेहतर है।

— रिक हिचकॉक

Answer 6

पर्ल 5, 42 बाइट्स

41 बाइट्स कोड + 1 के लिए -p। \x1bकोड में रों शाब्दिक भागने पात्र हैं।

एएनएसआई एस्केप सिक्वेंस पर निर्भर करता है ताकि कर्सर को स्थान दिया जा सके और इसलिए टीआईओ पर काम नहीं करता है।

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

प्रयोग

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

Comments

यहाँ एक है जो TIO पर काम करता है, लेकिन एक बाइट अधिक (41 बाइट्स ऑफ़ कोड + 2 फॉर -F) में आता है: इसे ऑनलाइन आज़माएं!

— Xcali

@Xcali आपको पोस्ट करना चाहिए ताकि मैं इसे उखाड़ सकूं :)

— लिन

@Xcali लिन के साथ सहमत बहुत अधिक पोस्ट महान हैं। मुझे भाषा प्रतियोगिता भी पसंद है!

— डोम हेस्टिंग्स

Answer 7

जावा (ओपनजेडके 8) , 207 191 189 183 178 174 173 170 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 8

पर्ल 5 , 41 + ( -F) = 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बस @ लिलन के लिए

Answer 9

ब्रेनफक , 127 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Answer 10

प्रोटॉन , 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लिन के समाधान को चित्रित करके 69 बाइट्स: x=>{t=[]i=65for k:x{t+=[' ']*26t[ord(k)-i]=k;i--}"".join(t).rstrip()}

Answer 11

जेली , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 12

हास्केल , 90 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

@ लिकोनी ओह खतरे, मैं गलत है कि। ठीक हो जाएगा ...

— ज़र्गब

खैर, अब यह कम नहीं है। : /

— जरगब

Answer 13

जाप , 23 बाइट्स

;iB ç
Ng £=hX10nY+XnG
U

इसे ऑनलाइन टेस्ट करें!

पहला प्रयास, कामचलाऊ हो सकता है ...

Comments

ऐसा लगता है कि आपको Vइसके बजाय प्रारंभिक स्ट्रिंग को निर्दिष्ट करके एक बाइट को बचाने में सक्षम होना चाहिए U: ethproductions.github.io/japt/…

— शैगी

Answer 14

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 76 बाइट्स

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

इनपुट के रूप में वर्णों की एक सूची लेता है। यह कुछ त्रुटि संदेश उत्पन्न करता है जिन्हें अनदेखा करना सुरक्षित है।

मैंने शामिल किया Printऔर Characterउपयोग में आसानी के लिए TIO लिंक के पाद लेख में आदेश दिया। ( Characterकमांड केवल एक स्ट्रिंग को वर्णों की सूची में परिवर्तित करता है)

इसे ऑनलाइन आज़माएं!

Comments

LetterNumberवर्णमाला के एक अक्षर की स्थिति को खोजने के लिए एक अंतर्निहित है? पवित्र बकवास, यह हास्यास्पद है।

— नंबरमानस

Answer 15

जे, 37 31 बाइट्स

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

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

-6 बाइट्स FrownyFrog के लिए धन्यवाद

व्याख्या

पूरी बात एक हुक है:

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

दाईं ओर सभी अक्षरों के लिए नए अनुक्रमित की गणना करता है।

बाईं ओर }पहले आवश्यक स्थानों की एक स्ट्रिंग बनाने के लिए अमेंड के गेरुंड रूप का उपयोग करता है (' '#~(1+>./)@]):। और फिर ऑल-स्पेस स्ट्रिंग के भीतर मूल स्ट्रिंग के प्रत्येक अक्षर को उसके उपयुक्त सूचकांक में रखने के लिए।

इसे ऑनलाइन आज़माएं!

Comments

(i.@#+65-~a.&i.)-> (i.@#+65-~3&u:)-> (i.@#-65-3&u:)-> (#\-66-3&u:)

— FrownyFrog

आप कोष्ठक भी छोड़ सकते हैं।

— फरोनीफ्रॉग

@FrownyFrog tyvm मैं उन दोनों गोल्फ चाल के बारे में भूल गया था।

— योना

आप 3 बाइट बचा सकते हैं(]' '#~1+>./)

— मील

@miles। अच्छा लगा। मुझे अपने नियमित टूलबॉक्स का डायडिक हुक बनाने की आवश्यकता है, मैंने देखा कि आपने उन्हें आज सुबह से उस संशोधन में भी इस्तेमाल किया है।

— योना

Answer 16

हास्केल , 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

हास्केल, 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

qइनपुट स्ट्रिंग (एक ऑफसेट के साथ 65) के अक्षरों के अंतिम सूचकांकों की सूची है । सभी सूचकांकों के माध्यम से लूप करें (शुरुआत में 65) और इसके लिए सभी पत्र ढूंढें, एक स्थान को तैयार करना। आखिरी ले लो।

Comments

फिर भी एक और 88 बाइट हास्केल समाधान, यहां और यहां देखें ।

— nimi

Answer 18

सी # (.NET कोर) , 117 110 84 बाइट्स

Ayb4tu की बदौलत 7 बाइट्स बचाए ।

26 बाइट्स को बचाने के stringलिए बदले हुए प्रकार से वापसी char[]।

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

इसे ऑनलाइन आज़माएं!

Comments

आप को बदलने के द्वारा 7 बाइट्स बचा सकते हैं t[i+((int)n[i]-65)]करने के लिए t[i+n[i]-65]।

— Ayb4btu

@ Ayb4btu धन्यवाद भूल गए कि char -> intरूपांतरण निहित हैं।

— इयान एच।

Answer 19

C # .NET, 89 बाइट्स 87 बाइट्स

लैन बाइट के लिए -2 बाइट्स धन्यवाद ।

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

इसे ऑनलाइन आज़माएं!

Comments

साइट पर आपका स्वागत है! :)

— डीजेमेकमेमे

धन्यवाद! मुझे आशा है कि एक ही भाषा में कई उत्तर पोस्ट करना ठीक है

— एमिलियानो

आप for-2 बाइट्स के लिए अपने -loop में घुंघराले कोष्ठक को छोड़ सकते हैं ।

— इयान एच।

Answer 20

कोटलिन, 207 बाइट्स 189 बाइट्स 187 बाइट्स 177 बाइट्स

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

अगर प्रमुख खाली रहना चाहिए, तो मैं trimEnd()इसके बजाय बस फोन करूंगा trim()।

unminified:

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

---

शायद कोटलिन कोड गोल्फिंग के लिए सबसे अच्छी भाषा नहीं है, लेकिन मुझे चुनौती पसंद है और मैं खुद को कोटलिन के मानक पुस्तकालय से परिचित कराना चाहता था।

Answer 21

क्यू / केडीबी +, ३tes बाइट्स

उपाय:

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

उदाहरण:

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"

स्पष्टीकरण:

मुझे लगता है कि यह जे समाधान के समान है, इनपुट सरणी के लिए सही सूचकांकों की गणना करें और फिर उन्हें सही लंबाई के खाली स्ट्रिंग पर असाइन करें:

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

Answer 22

Jq 1.5 , 91 बाइट्स

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

विस्तारित

  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

इसे ऑनलाइन आज़माएं!

Answer 23

चारकोल , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｐ                   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

Answer 24

एपीएल (डायलॉग) , 26 बाइट्स

अनाम उपसर्ग लंबोदर जो इनपुट स्ट्रिंग को तर्क के रूप में लेता है और आउटपुट स्ट्रिंग लौटाता है। मानता है ⎕IO( I ndex O rigin) 0, जो कई प्रणालियों पर डिफ़ॉल्ट है।

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

इसे ऑनलाइन आज़माएं!

{… } गुमनाम लंबोदर; ⍵तर्क का प्रतिनिधित्व करता है

 ≢⍵ तर्क का मिलान

 ⍳ कई many नेचर से (0… लंबाईऑफअर्गमेंट -1)

 (… )+ प्लस:

  ⎕A⍳⍵ अपरकेस में तर्क के संकेत एक वर्णमाला

 i← में i( मैं ndices के लिए)

 ⌈/ अधिकतम (कमी)

 1+ एक जोड़ें

 ''↑⍨ खाली स्ट्रिंग से कई अक्षर लें, आवश्यकतानुसार रिक्त स्थान के साथ पैडिंग करें

 ⊢ उपज है कि (सर्व अलग करने के लिए iसे '')

 ⍵@i संशोधन कि तर्क पत्र के साथ मेंi सूचकांक

Answer 25

SOGL V0.12 , 10 बाइट्स

ā,{ZFWē+1ž

यह कोशिश करो!

स्पष्टीकरण:

ā           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

Answer 26

पायथ , 44 38 बाइट्स

_{स्ट्राइक आउट 44 अभी भी 44 :( है}

खूनी पायथ शुरुआत।

@Mr की बदौलत 6 बाइट्स बचाए। Xcoder।

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

इसे ऑनलाइन आज़माएं!

---

कैसे?

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

Comments

38 बाइट्सK*d+lz26Vlz K=XK-C@zN-65N@zN;.WqeHdPZK :। WqeKd K=PK;Kद्वारा प्रतिस्थापित किया गया है .W(जबकि कार्यात्मक) और उसके तर्क, और FNrZlzप्रतिस्थापित किया जा सकता है VrZlz, लेकिन rZ...इसका मतलब है U..., और Uस्वचालित रूप से उत्पन्न होता है V। तो FNrZlzबन जाता हैVlz

— श्री एक्सकोडर

Answer 27

बैच, 418 331 बाइट्स

केवल बड़े अक्षरों के साथ काम करता है और लंबे समय तक तार के लिए कुछ सेकंड लेगा।

यहां नए ट्रिक्स सीखे, ASCII के मूल्य रूपांतरण का उपयोग करते हुए चरित्र %=exitcodeAscii%। इसके अलावा, if definedऔर "सरणी" का उपयोग करके पहुंच call। इसके अलावा, लगभग 100 बाइट्स में गोल्फ अच्छा बैच कोड गोल्फ प्रशिक्षण था।

में पीछे की जगह पर ध्यान दें 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%

Answer 28

रूबी , 68 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 29

आईबीएम पीसी डॉस 8088 विधानसभा ,34 33 बाइट्स

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

अघोषित (असंबद्ध):

    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

यह एक पूर्ण पीसी डॉस निष्पादन योग्य है जो कमांड लाइन से इनपुट स्ट्रिंग लेता है और स्क्रीन पर नए "तेज" संस्करण को प्रिंट करता है। न्यूनतम डॉस 1.0 की आवश्यकता है ... उम्मीद है कि आपको कम से कम मिल गया है।

उत्पादन

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

Answer 30

PHP, 127 123 बाइट्स

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

इसे ऑनलाइन आज़माएं

एक बग को ठीक करना था जो 'ए' आउटपुट नहीं करेगा ...

Comments

किसने-कभी डाउनवोट किया: आपने शायद गलत बटन क्लिक किया। कृपया सही करें, या मुझे एक लाइन ड्रॉप करें कि नीचे की

— तरफ