चुनौती

कंसोल इनपुट से पढ़े गए किसी अक्षर से वर्णमाला प्रदर्शित करें। यदि पत्र अपरकेस है, तो आपको वर्णमाला अपरकेस प्रदर्शित करना होगा। मुद्रित वर्णमाला एक सम्मिलित के पूर्ववर्ती अक्षर में समाप्त होनी चाहिए। यदि एक अतिरिक्त पैरामीटर इनपुट (एक साधारण बिंदु .) में जोड़ा जाता है, तो वर्णमाला को प्रत्येक पंक्ति में एक अक्षर मुद्रित किया जाना चाहिए। अन्यथा, वर्णमाला को एक साधारण स्थान से अलग करके एक ही पंक्ति में मुद्रित किया जाना चाहिए। यदि गलत इनपुट प्रोग्राम को भेजा जाता है तो यह कुछ भी प्रिंट नहीं करेगा।

इनपुट उदाहरण:

इनपुट:

कार्यक्रम का ouput:

d e f g h i j k l m n o p q r s t u v w x y z a b

इनपुट

H.

कार्यक्रम का ouput:

I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
A
B
C
D
E
F
G

code-golf string

— Averroes
स्रोत

सेज नोटबुक "कंसोल स्तर" पर संचालित होता है, तो क्या इस मामले में "कंसोल इनपुट" आवश्यक है केवल इनपुट को वर्कशीट सेल में टाइप करना है?

— res

सबसे छोटा कोड जीतता है?

— arnnew

@ardnew हाँ, सबसे छोटा कोड जीतता है।

— Averroes

@ मुझे लगता है कि जब आपको किसी तरह से इनपुट रीडिंग को कोड करने की आवश्यकता होती है, तो यह नियम के दृष्टिकोण से उचित हो सकता है।

— Averroes

6

@ एवर्रोस गोल्फस्क्रिप्ट का उपयोग करने के लिए जुर्माना एक भाषा सीखने में लगने वाला समय है, जिसका इस तरह की प्रतियोगिता के बाहर कोई वास्तविक उपयोग नहीं है। मुझे नहीं लगता कि नौकरी के लिए सही उपकरण का उपयोग करने के लिए लोगों को दंडित करना बहुत उत्पादक होने जा रहा है।

— गैरेथ

12

गोल्फस्क्रिप्ट 48 75 73 70 67 66 63 57 53

(91,65>.+.{32+}%+.@?>(;25<''+.,1>*\['''.']?[' 'n 0]=*

ऑनलाइन डेमो:

अपडेट करें:

अब अंतिम नियम भी लागू हो गया है। मुद्दे को इंगित करने के लिए वेंटरो को धन्यवाद ।

अपडेट करें:

मैंने कोड को स्क्रैच से फिर से लिखा और इसे और भी छोटा करने के नए तरीके ढूंढे।

संशोधनों का इतिहास:

.,3<\(:x;:§['''.']?)and{91,65>.+.{32+}%+.x?).{>25<''+{§n' 'if}%}{;;}if}''if
.,3<\(:x;:§['''.']?)*{91,65>.+.{32+}%+.x?).{>25<''+{§n' 'if}%}{;;}if}''if
.,3<\(:x;:§['''.']?)*{91,65>.+.{32+}%+.x?).!!@@>25<''+{§n' 'if}%*}''if
.,3<\(:x;:§['''.']?)*!!91,65>.+.{32+}%+.x?).!!@@>25<''+{§n' 'if}%**
.,3<\(:x;:§['''.']?)*91,65>.+.{32+}%+.x?).@@>25<''+{§n' 'if}%@@*!!* 
.(@,3<@:§['''.']?)*91,65>.+.{32+}%+@1$?).@@>25<''+{§n' 'if}%@@*!!*
.(@,3<@:§['''.']?)*91,65>.+.{32+}%+@1$?):x>25<''+{§n' 'if}%\x*!!*
.(@,3<@:§['''.']?)*91,65>.+.{32+}%+@1$?):x>25<''+§n' 'if*\x*!!*
(\:§['''.']?)91,65>.+.{32+}%+@1$?):x>25<''+§n' 'if*\x*!!*
(91,65>.+.{32+}%+.@?>(;25<''+.,1>*\['''.']?[' 'n 0]=*

— क्रिस्टियन लुपस्कू
स्रोत

2

यह समाधान अंतिम आवश्यकता का पालन नहीं करता है:If wrong input is send to the program it will not print anything.

— वेंटरो

@ वेंटरो राइट। मैं इसे ठीक कर दूंगा।

— क्रिस्टियन लुपस्कू

63 - अच्छा, हम हेड 2 हेड हैं :), काश मैं गोल्फस्क्रिप्ट समझ पाता;)

— बुआ

मुझे Q. महान काम के बारे में ऐसा ही लगता है! ;-)

— क्रिस्टियन लुपस्कू

+1 का कमाल! 50 को तोड़ने के लिए तैयार ;-)

— बुआ

10

सी, 135 129 128 चरस

लानत है, इतने सारे अलग-अलग मैजिक नंबर, लेकिन इनसे छुटकारा पाने का कोई तरीका नहीं।

प्रोग्राम पैरामीटर के रूप में इनपुट के साथ चलाया जाना है। अब "गलत इनपुट" आवश्यकता का अनुसरण करता है।

c;main(a,b)char**b;{if(a==2&&isalpha(**++b)&&!(c=1[*b])||c==46&&!2[*b])for(;++a<28;)printf("%c%c",**b-=**b+6&31?-1:25,c?10:32);}

स्पष्टीकरण:

c;                   // Variable that will be used later
main(a,b)char**b;{   // There's one parameter => a = 2, b[1] = the parameter
                     // Wrong input checks: We want...
  if(
     a==2 &&         // 1 parameter and ...
     isalpha(**++b)  // lower- or uppercase letter as parameter,
                     // increase b so we can access it better
     &&              // and ...
     !(c=1[*b]) ||   //   either no further character,
                     //     save the character in c, or...
     (c==46&&!2[*b]) //   a dot as next character and no further characters
    )                // if check succeeded, execute the for loop, else do nothing
  for(;++a<28;)      // This will loop 26 times (2..27)
    printf("%c%c",   // Print two characters
                     // First character to print:
      **b            // We'll print the first character of the parameter,
       -=            // but decrement it before printing
       **b+6&31?     // if the last five bits (31 = 11111b) are not 26 (6 == -26 mod 32)
        -1           //   decrement it by -1 (aka increment it)
        :25,         //   else (char=z/Z) decrement by 25, so we start over at a/A
                     // Second character to print:
      c?             // c is either ASCII 0 or a dot (ASCII 46)
       10            //   dot     -> print a newline
       :32);         //   ASCII 0 -> print a space (ASCII 32)
}

**b+6&31हिस्सा तथ्य यह है कि लोअरकेस / अपरकेस चरित्र के लिए ASCII कोड एक ही हैं, तो केवल पिछले 5 बिट्स देख रही है और शेष 5 बिट्स रेंज 1..26 में हैं उपयोग करता है।

"गलत इनपुट" आवश्यकता के बिना संस्करण (82 वर्ण):

main(a,b)char**b;{for(b++;++a<28;)printf("%c%c",**b-=**b+6&31?-1:25,1[*b]?10:32);}

— schnaader
स्रोत

इसे संकलित करने के बारे में कोई निर्देश? मुझे रनिंग के दौरान सेगमेंटेशन फॉल्ट मिलता है।

— मैनटवर्क

@manatwork इनपुट को पैरामीटर के रूप में लेता है।

— शियोना

हां, वास्तव में, स्पष्ट करने के लिए संपादित किया गया। जैसे यदि प्रोग्राम का नाम है test, तो इसे कॉल करें test cयाtest X.

— schnaader

धन्यवाद, मिल गया। मेरी सी मुझे लगता है की तुलना में जंग लग रहा है।

— manatwork

2

कश्मीर और आर परिभाषा शैली मदद कर सकते हैं main(a,b)char**b;{:। इसके अलावा, कोई b++आपको प्रतिस्थापित करेगा *b[1]-> **bऔर b[1][1]-> 1[*b]।

— बदसूरत

7

रूबी, 72 71 61 अक्षर

gets;25.times{$><<$_=$_.succ[0]+=$1?$/:' '}if~/^[a-z](\.)?$/i

यह माणिक संस्करण इनपुट को सत्यापित करने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है। सौभाग्य से, रूबी स्ट्रिंग विधि succहमारे लिए अधिकांश काम करती है (रैप-अराउंड सहित)।

संपादित करें: क्रोन और वेंटरो की मदद से 61 वर्ण ।

— हावर्ड
स्रोत

अलग से पोस्टिंग को परेशान करने के लिए मेरा भी आपके समान रास्ता समाप्त हो गया। एक ही दृष्टिकोण, लेकिन कुछ अक्षर कम (65):c=gets[0];25.times{$><<c.next![-1]+($1?$/:' ')}if~/^[a-z](\.)?$/i

— पॉल प्रेस्टिज

2

और यह 62 है: gets;25.times{$><<$_=$_.next[0]+($1?$/:' ')}if~/^[a-z](\.)?$/i- मूल रूप से आपके जैसा ही गाली देना $_और$/

— पॉल प्रेस्टिज

2

@ तुल्यकालन: +=इसके बजाय +, आप कोष्ठकों को चारों ओर छोड़ सकते हैं $1?$/:' '।

— वेंतोरो

@ सिंक्रोनस और वेंटरो: धन्यवाद। मेरे समाधान के लिए अपना कोड जोड़ा।

— हावर्ड

6

रूबी: 127 113 92 (?) अक्षर

(मैं उपयोग करने पर दंड स्कोर के बारे में नियम नहीं पा सकता हूं -p। अभी के लिए 1 जोड़ा गया। यदि गलत है, तो कृपया मुझे सुधारें।)

$_=if ~/^([a-z])(\.)?$/i;s,e=$1>?Z?[?a,?z]:[?A,?Z];[*$1.succ..e,*s...$1]*($2==?.?$/:" ")end

नमूना रन:

bash-4.2$ ruby -pe '$_=if ~/^([a-z])(\.)?$/i;s,e=$1>?Z?[?a,?z]:[?A,?Z];[*$1.succ..e,*s...$1]*($2==?.?$/:" ")end' <<< c
d e f g h i j k l m n o p q r s t u v w x y z a b

bash-4.2$ ruby -pe '$_=if ~/^([a-z])(\.)?$/i;s,e=$1>?Z?[?a,?z]:[?A,?Z];[*$1.succ..e,*s...$1]*($2==?.?$/:" ")end' <<< H.
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
A
B
C
D
E
F
G

bash-4.2$ ruby -pe '$_=if ~/^([a-z])(\.)?$/i;s,e=$1>?Z?[?a,?z]:[?A,?Z];[*$1.succ..e,*s...$1]*($2==?.?$/:" ")end' <<< seven

— आदमी काम पर है
स्रोत

6

रूबी, 101 95

i,d=gets.split''
[*?a..?z].join[/#{i}/i]
($'+$`).chars{|c|$><<(i>?Z?c:c.upcase)+(d==?.?$/:' ')}

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

— defhlt
स्रोत

का पालन नहीं करता है "यदि गलत इनपुट प्रोग्राम को भेजा जाता है तो यह कुछ भी प्रिंट नहीं करेगा।"

— मैट

('a'..'z').to_a=>[*?a..?z]

— पॉल प्रेस्टिज

@ तुल्यकालित धन्यवाद! मुझे यह कैसे याद आ सकता है ..

— defhlt

6

गोल्फस्क्रिप्ट, 80 72 वर्ण

.).46={;)}*25,{65+.32+}%?)\""=*!!\([{)..31&26-!26*-}25*;]n+\"."=n" "if**

कोड के बहुत सारे वैध इनपुट और "प्रिंट नथिंग" -ओपेशन के लिए परीक्षण कर रहे हैं। वास्तविक तर्क केवल 37 वर्णों का है।

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

— हावर्ड
स्रोत

6

q / k4 66 64 63 60 58 56 + 2 जुर्माना

वैश्विक चर init के लिए दंड, एल्गोरिथ्म नीचे के रूप में 56 है:

56:

if[&/x in".",l:(a;A)90>*x;1@/1_,/|_[0,l?x;l,'"  \n"@#x]]

58:

if[&/x in".",l:(a;A)90>*x;1@/(1_,/|_[0,l?x;l]),'"  \n"@#x]

यदि कोड को पुनर्गठित करने और "से छुटकारा पाने के लिए अनुमति दी गई है तो अन्य से परिवर्तन"; अतं मै

60:

1@/$[&/x in".",l:(a;A)90>*x;1_,/|_[0,l?x;l];" "],'"  \n"@#x;

अंततः इस निरर्थक जाँच से छुटकारा पा लिया

63:

1@/$[&/x in".",l:(a;A)90>*x;1_,/|_[0,l?x;l];" "],'" \n""."in x;

एक पूरी वस्तु के बजाय पुनरावर्ती रूप से प्रिंट करें
अभी भी पहचान में कमी नहीं कर सकता x "।" दो स्थानों पर ...:
अंत में अर्धविराम की आवश्यकता होती है, अन्यथा प्रिंट फ़ंक्शन (1 @) प्रिंट होता है जो स्टडआउट को वापस मूल्य देगा .... लानत है

64:

2@,/$[&/x in".",l:(a;A)90>*x;1_,/|_[0,l?x;l];" "],'" \n""."in x;

संपादित करें:

ग्लोबल इनिशियलाइज़ेशन के लिए 2 का जुर्माना जोड़ा गया (x :), उसी तरह अगर कोष्ठक (जैसे कि स्लैकवेयर सुझाए गए) में रैपिंग फंक्शन हो
तो निश्चित नहीं कि अगर नाम बदलने के साथ ही सजा भी दी जाए ... तो यह एक और 3 है

(.Q`a`A) instead of (a;A)

उदाहरण:

q)\         - switch interpreter to k4
 \d .Q     - change to native namespace
  x:"c"
  if[&/x in".",l:(a;A)90>*x;1@/1_,/|_[0,l?x;l,'"  \n"@#x]]
d e f g h i j k l m n o p q r s t u v w x y z a b

  x:"@"
  if[&/x in".",l:(a;A)90>*x;1@/1_,/|_[0,l?x;l,'"  \n"@#x]]    
  x:"H."
  if[&/x in".",l:(a;A)90>*x;1@/1_,/|_[0,l?x;l,'"  \n"@#x]]
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
A
B
C
D
E
F
G
  x:...

— बुआ
स्रोत

+1 अच्छी प्रगति। मैं अब अपने कोड को छोटा करने का एक और तरीका खोजने की कोशिश करूंगा।

— क्रिस्टियन लुपस्कू

क्या इसे वास्तव में वैध k कहा जा सकता है यदि यह qk में परिभाषाओं का उपयोग कर रहा है? ;-) इसके अलावा, यदि आप इसे किसी फ़ंक्शन में लपेटते हैं, तो आप x को छोड़ सकते हैं: "a" सेटअप चरण, उदा {$ [...]}

— skeevey

@ स्लैकवियर आप सही हैं, इसीलिए इसे q / k4 ;-) कहा जाता है।

— बुआ २४'१२

6

पर्ल, 131 127 117 112 106 104 102 98 96 92 91 90 93 71 66 65 64 58 अक्षरों

s!^([a-z])(\.?)$!print chop,$2?$/:$"for($1..az)[1..25]!ie

उपयोग:

perl -ne 's!^([a-z])(\.?)$!print chop,$2?$/:$"for($1..az)[1..25]!ie'

के लिए गिनती में एक वर्ण जोड़ा गया है nविकल्प के है।

जॉन पेडी के जवाब++ में पात्रों के व्यवहार को देखने के कारण ही सबसे बड़ी कटौती संभव थी ।

— गैरेथ
स्रोत

आप अंतिम 2 अर्धविरामों को हटाकर एक जोड़े को दाढ़ी बना सकते हैं

— ardnew

@ हार्दिक धन्यवाद। :-)

— गारेथ

1

यह बात प्रभावशाली है

— bua

@bua धन्यवाद, मैं अभी भी पात्रों को खोजने की कोशिश कर रहा हूं ताकि मैं आपको और w0lf को पकड़ सकूं। :-)

— गैरेथ

s/a.$1/az/2 और बचाने के लिए। chop().($2?$/:$")-> chop,$2?$/:$"4 और के लिए

— भीड़ दें

5

पर्ल, 149 , 167

अपडेट करें

जोड़ा गया स्वच्छता चैक।
विभाजक आवेदन के बारे में महत्वपूर्ण सुझाव लिया।

exit if $ARGV[0] !~ /[a-z]\.?/i;    # sanity check input
($x,$d)=split //,$ARGV[0];          # split input arguments
@l=65..90;                          # define uc letter range
push @l,splice @l,0,ord(uc $x)-64;  # rotate letter range
pop @l;                             # remove the argument letter
print join $d?$/:$",                # print the joined list
  map {ord($x)>90?lc chr:chr} @l;   # map chr and lc as appropriate

— थोर
स्रोत

आप के $s=($d)?"\n":" ";साथ बदल सकते हैं $s=$d?$/:$";और हो सकता है कि बस $sपूरी तरह से छुटकारा

— पाएं

4

पायथन, 83

r=raw_input()
i=ord(r[0])
exec"i+=1-26*(i%%32>25);print chr(i)%s;"%","["."in r:]*26

— gRC
स्रोत

मैं इस प्रतिबंध का प्रशंसक नहीं हूं, लेकिन यह मौजूद है और आप कार्यक्रम का पालन नहीं करते हैं: "यदि गलत इनपुट कार्यक्रम में भेजा जाता है तो यह कुछ भी प्रिंट नहीं करेगा।"

— मैट

इसके अलावा, ऐसा लगता है कि आप एक से अधिक चरित्रों को प्रिंट करते हैं जो आपको चाहिए। उदाहरण आउटपुट 25 वर्ण है।

— मैट

4

पीएचपी, 120 119 113

<?$v=fgets(STDIN);$f=$c=$v[0];ctype_alpha($c++)||die;for(;$c[0]!=$f;$c=$c[0],$c++)echo$c[0],$v[1]=='.'?"\n":" ";

— lortabac
स्रोत

1

यह एक कोड-गोल्फ चुनौती है, इसलिए गति और संसाधन उपयोग अनुकूलन की आवश्यकता नहीं है। $v[1]=='.'?"\n":" "चर $ s में परिणाम के भंडारण के बजाय , PHP को echoकथन में हर बार इसकी गणना करने दें। इस तरह आप 6 अक्षरों को छोड़ सकते हैं।

— manatwork

1

@manatwork धन्यवाद, मैंने इसे बदल दिया।

— lortabac

4

गणितज्ञ 158 159 204 199 183 167 165 162

कोड

f@h_ := Most@RotateLeft[#, Position[#, h][[1, 1]]] &[FromCharacterCode /@ 
        (65~Range~90 + 32 Boole@LowerCaseQ@h)];
g = Characters@# /. {{p_} :> Row[f@p, " "], {p_, "."} :> Column@f@p, _ -> ""} &

प्रयोग

g["c"]
g["H"]
g["H."]
g["seven"]

प्रयोग

— DavidC
स्रोत

तीसरा उपयोग मामला f ["H"] या f ["H" है]?

— Averroes

मुझे ""। की हैंडलिंग को ठीक करना था, कोड में 50 चार्ट जोड़ना। लेकिन यह अब निर्देशों के अनुसार काम करता है

— डेविड

3

जे ४३

|:1j1#(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0

उदाहरण:

|:1j1#(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 's'

tuvwxyzabcdefghijklmn opqr

|:1j1#(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 's.'

t
u
v
w
x
y
z
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r

|:1j1#(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 '['

यह समाधान जे प्रोग्रामिंग फोरम पर विकसित हुआ: http://jsoftware.com/pipermail/programming/2012-August/0290.html

लेखक: AlvordBossCerovskiCyrEllerHuiLambertMcCormickMillerQuintanaSchottSherlockTaylorTherriault

व्याख्या

जे वाक्यांशों को सही पर शुरू किया जाता है, ऑन-गोइंग परिणाम को बाईं ओर से गुजरता है क्योंकि इसका मूल्यांकन किया जाता है। चूंकि यह इंटरैक्टिव है, हम उन्हें बेहतर ढंग से समझने के लिए अलगाव में समाधान के टुकड़ों को देख सकते हैं।

मध्य भाग यूनिकोड में ऊपरी और निचले मामले की वर्णमाला उत्पन्न करता है:

   u:,2#65 97+/i.26
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

"U:" क्रिया यूनिकोड वर्णों के लिए अपने संख्यात्मक सही तर्क को रूपांतरित करती है। संख्यात्मक तर्क एएससीआईआई मानों के लिए ऊपरी और निचले मामलों के पात्रों के लिए "ए" और "ए" के लिए संख्याओं को जोड़कर उत्पन्न होता है, जो प्रत्येक मान 0 से 25 तक "i.26" द्वारा उत्पन्न होता है:

   65 97+/i.26
65 66 67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

दाहिने हाथ का भाग,

   ((>:@i.}.[)])"0

ऊपर (i।) दाईं ओर के तर्क की स्थिति () को बाईं ओर ([) - जो कि ऊपर दिए गए अक्षरों का वेक्टर है - और ड्रॉप्स (}) उस संख्या की तुलना में एक अधिक (>:) है। '' 0 'इस वाक्यांश को 0-आयामी (स्केलर) तर्कों पर लागू करता है।

   ('123H999' (>:@i.}.[)])"0 'H'
999

"25 {" वाक्यांश वेक्टर के पहले 25 तत्वों को दाईं ओर ले जाता है।

बाईं ओर का "वाक्यांश 1j1 #" बाईं ओर की संख्या के अनुसार अपने सही तर्क को दोहराता है। एक साधारण संख्या एक सरल प्रतिकृति है:

   2 # 'ABCD'
AABBCCDD

हालांकि, एक जटिल संख्या - जिसे वास्तविक और काल्पनिक भागों के बीच "जे" द्वारा इंगित किया गया है - काल्पनिक भाग के अनुसार एक भरण तत्व सम्मिलित करता है। यहां हम "जे" के दाईं ओर एक भरने वाले तत्व को इंगित करते हैं।

   2j1 # 'ABCD'
AA BB CC DD

अधिकांश जे आदिम के साथ, प्रतिकृति क्रिया (#) एक एनालागस अंदाज में संख्यात्मक सरणियों पर काम करती है कि यह चरित्र सरणियों पर कैसे काम करती है। जैसा यहाँ दिखाया गया है,

   1j1 # 1 2 3
1 0 2 0 3 0

हम देखते हैं कि डिफ़ॉल्ट संख्यात्मक भरण तत्व शून्य है जबकि वर्णों के लिए यह अंतरिक्ष वर्ण है।

अंत में, बाईं ओर का टोकन ":" "पूर्ववर्ती क्रियाओं के परिणाम को उसके दाईं ओर स्थानांतरित करता है।

डिवॉन मैककॉर्मिक द्वारा प्रदान किया गया स्पष्टीकरण। थैंक्स देवोन।

— बॉब थेरेपी
स्रोत

+1 वास्तव में अच्छा समाधान और स्पष्टीकरण। मैंने इसे J में आज़माने पर विचार किया, लेकिन यह जाँचने के लिए कि इनपुट मान्य था, एक अच्छा तरीका (एक छोटा तरीका) समझ नहीं सका। मुझे लगता है कि मेरा समय कम से कम दो बार होता।

— गैरेथ

धन्यवाद गैरेथ, यदि आप चर्चा लिंक में शुरुआती समाधानों को देखते हैं, तो आप देखेंगे कि हमारी कई शुरुआत लम्बी थी। हमारे द्वारा पाई गई साफ-सुथरी चीजों में से एक है जो हम जे। चीयर्स,

— बोब

3

ब्रेनफक, 303

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

वर्तमान में यह If wrong input is send to the program it will not print anythingभाग का समर्थन नहीं करता है , और यह शायद कम हो सकता है। मैं इसे बाद में ठीक करने की योजना बना रहा हूं। अभी मेरा मस्तिष्क भी जारी रखने के लिए **** एड है।

— गत्ते के डिब्बे का बक्सा
स्रोत

2

सी, 110

कभी-कभी अक्षरों के बीच "रिक्त स्थान" प्रिंट करता है, कभी-कभी नहीं।

i,j;main(int c,char*l){gets(l);l[1]&=10;j=*l%32;c=*l&~31;for(i=j;i<j+25;i++){l[0]=c+i%26+1;printf("%2s",l);}}

धीरे-धीरे अधिक पठनीय:

i,j;
main(int c,char*l)
{
  gets(l);
  l[1]&=10;          // makes . to line feed and some other chars to "start of text" 
                     // which looks like space in some cases 
                     // (the byte can become either 0, 2, 8 or 10)

  j=*l%32;           // 0b 000c cccc, these five bits code which letter was chosen
  c=*l&~31;          // 0b ccc0 0000, these three bits code upper/lowercase

                     // 0b ccc0 0000 + (0b 000c cccc + [0..24])%26 + 1
  for(i=j;i<j+25;i++){l[0]=c+i%26+1;printf("%2s",l);}
}

रन:

$ ./a.out
G
 H I J K L M N O P Q R S T U V W X Y Z A B C D E F

$ ./a.out
p.
q
r
s
t
u
v
w
x
y
z
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o

— shiona
स्रोत

2

जावास्क्रिप्ट, 137

दुर्भाग्य से थोड़ी सी क्रिया ( String.fromCharCodeऔर charCodeAt)।

for(x=b=(n=prompt(m={122:97,90:65})).charCodeAt(r='');/^[a-z]\.?$/i.test(n)&&(x=m[x]||x+1)!=b;)r+=String.fromCharCode(x)+(n[1]?"\n":" ");

— pimvdb
स्रोत

2

पर्ल, 77 76 70 68

chomp(($a,$b)=split//,<>);$"=$/if$b;map{++$a=~/(.)$/}1..25;print"@a"

संपादन:

के बजाय regex का उपयोग कर एक चरित्र सहेजा गया substr।
के mapबजाय का उपयोग कर 6 वर्ण सहेजे गए for।
अंतिम नई पंक्ति को छोड़ कर 2 वर्ण सहेजे गए।

— जॉन पंडी
स्रोत

3

अच्छा है, लेकिन जैसा कि आपने बताया है कि यह आवश्यकता को पूरा नहीं करता है कि अमान्य इनपुट कोई आउटपुट नहीं देता है। उसे ठीक करो और तुम मेरा उत्थान करोगे।

— गैरेथ

प्रतीत नहीं होता है मेरे लिए काम पर perl 5.14.2। मुझे यह भी विश्वास नहीं है कि \nआपके फाइनल printकी आवश्यकता है, जो एक जोड़े को

— बचाएगी

@ardnew: मैंने इसे अपने कार्य कंप्यूटर पर लिखा है, जिसमें 5.12.3 है। मार देंगे \n, धन्यवाद।

— जॉन पूर्डी

2

आर, 219

बदसूरत, लंबा ... अभी भी काम करता है।

f=function(l){if(!nchar(l)%in%c(1,2))invisible()else{s=ifelse(nchar(l)==1," ","\n");l=substr(l,1,1);v=letters;if(l%in%v){}else v=LETTERS;l=grep(l,v);if(l==26)cat(v[1:25],sep=s)else cat(c(v[l+1:(26-l)],v[1:l-1]),sep=s)}}

उपयोग:

f("a")
f("c.")
f("H")
f("z")
f("Z.")
f("seven")

— पाओलो
स्रोत

2

सी, 146 वर्ण (भयानक)

main(){char b[100];gets(b);for(char a=b[0],c=a,d=a&223,e=b[1];++c!=a&64<d&d<91&(!e|e==46&!b[2]);(c&31)>26?(c&=96):(putchar(c),putchar(e?10:32)));}

मैं सी में बहुत अनुभवी नहीं हूं, जो शायद दिखाता है ...>। <मुझे लग रहा था कि पूर्णांक बनने में मददगार होंगे, लेकिन यह वास्तव में एक बड़े प्रभाव के रूप में प्रतीत नहीं हुआ जैसा कि मुझे उम्मीद थी ... मैं अपने प्रयास को यहाँ छोड़ दूँगा, हालांकि सुधार का सुझाव देने के लिए स्वतंत्र महसूस करता हूँ।

निर्विवाद संस्करण:

main() {
  char b[999]; // assume that the line will fit in 999 chars...
  gets(b);

  // a is the char we start on, c is the char that we iterate,
  // d is toUppercase(a), e is just an alias for the second char.
  for (char a = b[0], c = a, d = a&223, e=b[1];
      // increment c, make sure that we haven't reached a yet.
      // also check the other conditions (first char is letter, second char
      // is either '.' or NULL, third char is NULL if second char was '.').
      ++c != a & 64 < d & d < 91 & (!e | e == 46 & !b[2]);
      (c&31) > 26     // check if we need to wrap around
        ? (c &= 96)   // if so, wrap
        : (putchar(c), putchar(e?10:32))  // otherwise, print char & separator
  );
}

— जुगनू
स्रोत

2

VBA 225

तत्काल विंडो से चलाने का प्रारूप:

s=InputBox(""):n=Asc(Left(s,1)):l=Len(s):p=IIf(l<3,IIf(l=2,IIf(Right(s,1)=".",vbCr,"")," "),""):c=IIf(n>64 And n<91,65,IIf(n>96 And n<123,97,99)):o=n-c+1:If o>0 And p<>"" Then For i=o To o+24:x=x & Chr(i Mod 26+c) & p:Next:?x

अलग-अलग लाइनों में टूट गया ( Subब्लॉक से घिरा होना चाहिए और printमॉड्यूल में काम करने के लिए एक अलग विधि की आवश्यकता होती है , इस प्रकार कोड अधिक लंबा होता है):

s=InputBox("")
n=Asc(Left(s,1))
l=Len(s)
p=IIf(l<3,IIf(l=2,IIf(Right(s,1)=".",vbCr,"")," "),"")    
c=IIf(n>64 And n<91,65,IIf(n>96 And n<123,97,99))
o=n-c+1
If o>0 And p<>"" Then 
For i=o To o+24
x=x & Chr(i Mod 26+c) & p
Next
End If 'Not needed when completed in single line format
MsgBox x

— Gaffi
स्रोत

2

जावा 8, 127 बाइट्स

a->{String r="",d=a.length>1?"\n":" ";char c=a[0],C=c;for(;++c<(c<97?91:123);r+=c+d);for(c=C<97?64:'`';++c<C;r+=c+d);return r;}

स्पष्टीकरण:

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

a->{                        // Method with character-array parameter and String return-type
  String r="",              //  Result-String, starting empty
         d=a.length>1?      //  If the length of the input is larger than 1
            "\n"            //   Set the delimiter to a new-line
           :                //  Else:
            " ";            //   Set the delimiter to a space
  char c=a[0],              //  Get the input letter
       C=c;                 //  And create a copy of it
  for(;++c<(c<97?91:123);   //  Loop from this letter + 1 to (and including) 'Z'/'z'
    r+=c+d);                //   And append the result with a letter + the delimiter
  for(c=C<97?64:'`';++c<C;  //  Loop again from 'A'/'a' to (and excluding) the input-letter
    r+=c+d);                //   And append the result with a letter + the delimiter
  return r;}                //  Return the result

— केविन क्रूज़सेन
स्रोत

1

मम्प्स, 91 , 86 , 82 , 79 , 76

r t i t?1A.1"." s a=$A(t),p=a>90*32+65 f i=1:1:25 w *(a+i-p#26+p) w:t["." !

ऐसी कोई आधुनिक भाषा नहीं है;) मुझे यकीन है कि थोड़ा सा अनुकूलन स्थान बचा है।

स्पष्टीकरण:

r t

इनपुट पढ़ें

i t?1A.1"."

जांचें कि क्या टी आवश्यक इनपुट से मेल खाता है

s a=$A(t),p=a>90*32+65 f i=1:1:25 { w *(a+i-p#26+p) w:t["." !}

वर्णमाला के माध्यम से लूप के लिए बुनियादी। ध्यान दें कि मम्प्स सख्ती से बाएं से दाएं मूल्यांकन कर रहा है। True = 1, इसलिए आपको p के परिणामस्वरूप 65 या 97 मिलते हैं, # modulo ऑपरेटर है

परीक्षण:

USER>d ^golf
d.e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
a
b
c

USER>d ^golf
tuvwxyzabcdefghijklmnopqrs
USER>d ^golf
h.i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
a
b
c
d
e
f
g

USER>d ^golf
hallo
USER>

(इसको चलाने के लिए आपको एक mumps runtime env की आवश्यकता होगी, अर्थात Caché)

संपादित करें: बोल्ड हेडिंग

संपादित करें: एक गलत समाधान था, अब ठीक किया गया है। इसे इंगित करने के लिए rtfs और Averroees का धन्यवाद

— kazamatzuri
स्रोत

कोड लंबाई में 79 वर्णों का प्रतीत होता है, 80 में नहीं

— क्रिस्टियान लुपस्कु

दुर्भाग्य से पहला स्थान वैकल्पिक नहीं है, इसलिए मैंने सोचा कि मुझे इसे गिनना होगा।

— kazamatzuri

परीक्षण के मामले पैरामीटर के रूप में पारित किए गए एक के पूर्ववर्ती पत्र में समाप्त नहीं होते हैं, उन्हें करता है?

— Averroes

1

जावास्क्रिप्ट: 141

c="",b=c[0].charCodeAt()<91,a="abcdefghijklmnopqrstuvwxyz",b&&(a=a.toUpperCase()),a=a.split(c[0]),a=a[1]+a[0],a=c[1]?a.split("").join("\n"):a

टिप्पणी संस्करण:

c="", //write input here (examples "a", "B", "c.", "D.")
b=c[0].charCodeAt()<91, //true for upperC, false for lowerC
a="abcdefghijklmnopqrstuvwxyz", //the abc
b&&(a=a.toUpperCase()), //if upper, turn main string to upperC
a=a.split(c[0]), //split by the first char of input
a=a[1]+a[0], //swap the two parts
a=c[1]?a.split("").join("\n"):a //if input second char, add breaklines in between
//the output is inside 'a'

jsField DEMO

— ajax333221
स्रोत

0

यहाँ एपीएल के साथ इस पर मेरा पहला प्रयास है।

⍞{1 1≡(2⌈⍴⍺)⍴⍺∊'.',⍵:⊃(~=/2⍴⍺)⌷(,X,' ')(X←25 1⍴1↓(X⍳⊃⍺)⌽X←(⎕A∊⍨⊃⍺)⌷2 26⍴⍵)}6↓26⌽⎕UCS 65+⍳58

यदि मैं एक एकल वैश्विक चर का उपयोग कर सकता हूं A←2 26⍴6↓26⌽⎕UCS 65+⍳58तो मैं नीचे दिए गए को निम्न में से छोटा कर सकता हूं:

{1 1≡(2⌈⍴⍵)⍴⍵∊'.',,A:⊃(~=/2⍴⍵)⌷(,X,' ')(X←25 1⍴1↓(X⍳⊃⍵)⌽X←(⎕A∊⍨⊃⍵)⌷A)}⍞

— हारून डब्ल्यू ह्सू
स्रोत

0

सी ++ 11

#include <iostream>
#include <vector>
#include <cstdio>

int main(int argc, const char * argv[])
{
    std::vector<char> list1,list2;
    for( char c = 'a'; c <='z'; c++ )
    {
        list1.push_back( c );
        list2.push_back( toupper( c ) );
    }
    char c = getchar();
    auto f = [ c ]( std::vector<char> list )
    {
        auto i = std::find( list.begin(), list.end(), c );
        if( i == list.end() )
            return;
        auto c = i;
        for( ;; )
        {
            c++;
            if( c == list.end() ) c = list.begin();
            if( c == i )break;
            std::cout<<*c<<"\n";
        }
    };
    f( list1 );f(list2);
    return 0;
}

— कार्ल
स्रोत

0

सी (111)

main(int i, char**c){if(isalpha(*c[1]))for(i=0;i<25;i++) printf("%c",isalpha((*c[1])+1)?++*c[1]:(*c[1]-=25));}

विच्छेदन

if(isalpha(*c[1])) // start with char-check.

for(i=0;i<25;i++) // we need 25 values, excluding input char. reusing i.

printf("%c", // print char. ofcourse.

isalpha((*c[1])+1) ? ++*c[1] : (*c[1]-=25)); 
//check if we are past z/Z and fall back to a/A. 
//make that available to print.

काम करता है] $ ./est 5

काम करता है] $ ./est W XYZABCDEFGHIJKLMNOPQRSTUV

काम करता है] $ ./est M NOPQRSTUVWXYZABCDEFGHIJKL

काम करता है] $ ./est g hijklmnopqrstuvwxyzabcdef

कार्य करता है]

काम करता है] $ ./est a bcdefghijklmnopqrstuvwxyz

काम करता है] $ ./est Z ABCDEFGHIJKLMNOPQRSTUVWXY

विचार के लिए कुछ खाने के लिए धन्यवाद।

— essbeev
स्रोत

यदि आप 'ए' में नई भूमिका नहीं जोड़ रहे हैं। दिया हुआ है। यदि इनपुट सही नहीं है [A-Za-z]\.?, तो भी, आपको कुछ भी आउटपुट नहीं करना चाहिए , अगर मैं प्रश्न को सही समझ रहा हूं।

— मारिनस

# 1। ओह! मैं कोड कम बनाने में तल्लीन था .. # 2। 'परीक्षण [' के उत्पादन को देखें यह कुछ नहीं छापता है। @marinus

— Essbeev

0

पर्ल, 226 वर्ण

die "Invalid input " if $ARGV[0] !~ /[a-z]\.?/i;
@listA=(a...z);
$index=ord(lc(substr($ARGV[0],0,1)))-97;
print join(substr($ARGV[0],1) ? "\n" : " ",map{$ARGV[0] =~ /[A-Z]/?uc $_:$_}(@listA[$index+1...25],@listA[0...$index]));

— beginnerProg
स्रोत

आप अपने पाठ को कोड ब्लॉक के रूप में प्रदर्शित करने के लिए प्रारूपित कर सकते हैं। अपनी पोस्ट को फॉर्मेट करने के लिए यहां गाइड पढ़ें । इसके अलावा, आप एकल वर्ण चर नामों का उपयोग करके कुछ पात्रों को बचा सकते हैं।

— गारेथ

1

एक अमान्य इनपुट को कुछ भी नहीं छापना चाहिए, इसलिए आपके dieकथन को कम किया जा सकता है, जिससे एक गुच्छा

— बच जाएगा

0

सी # 170

using System.Linq;namespace N{class P{static void Main(string[]a){foreach(char e in"abcdefghijklmnopqrstuvwxyz".ToCharArray().Where(o =>o>'c'))System.Console.Write(e);}}}

असम्पीडित

using System.Linq;
namespace N {
    class P {
        static void Main(string[]a){
            foreach (char e in "abcdefghijklmnopqrstuvwxyz".ToCharArray().Where(o => o > 'c'))
                System.Console.Write(e);
        }
    }
}

— PauloHDSousa
स्रोत

अपने उत्तर में स्पष्टीकरण जोड़ना न भूलें।

— जस्टिन

यह कार्यक्रम नियमों द्वारा खेलने की कोशिश तक नहीं करता है। 1: यदि पत्र अपरकेस है, तो आपको वर्णमाला अपरकेस प्रदर्शित करनी होगी। 2: मुद्रित वर्णमाला को सम्मिलित किए गए के पहले के अक्षर में समाप्त होना चाहिए। 3: यदि एक अतिरिक्त पैरामीटर इनपुट (एक साधारण डॉट) में जोड़ा जाता है, तो वर्णमाला को प्रत्येक पंक्ति में एक अक्षर मुद्रित किया जाना चाहिए। अन्यथा, वर्णमाला को एक ही स्थान पर मुद्रित किया जाना चाहिए, एक साधारण स्थान द्वारा अलग किया जाना चाहिए। 4: यदि गलत इनपुट प्रोग्राम को भेजा जाता है तो वह कुछ भी प्रिंट नहीं करेगा। यह 4 में से 4 मिस है।

— 1

^ से है कि मैं आप से आग्रह करता हूं मेरी पहले की गई टिप्पणियां देखें लेने के लिए अन्य यहाँ । आप बदल सकते हैं charके साथ var, अपने स्कोर की और दाढ़ी 1 अंक ढीला .ToCharArray()(एक string है , खो एक चार-सरणी आप पहले से ही पुनरावृति से अधिक! कर सकते हैं) string[] aके बाद से आप कमांडलाइन तर्क के साथ काम नहीं कर रहे हैं, नाम स्थान खो देते हैं, आपका निरंतर 'सी' कंसोल इनपुट से पढ़ा जाना चाहिए, वर्णमाला स्ट्रिंग खोना और इसके बजाय ASCII का उपयोग करना आदि। यह बहुत अच्छा है कि आप खेलते हैं, लेकिन कृपया एक सभ्य प्रयास करने की कोशिश करें; आप की अधिकांश प्रस्तुतियाँ केवल ट्रोलिंग लगती हैं।

— RobIII

0

सी, 117

main(c,s,d){d=c=getchar(),s=getchar();for(s=s<0?32:s^46?0:10;d+=d+6&31?1:-25,s&&isalpha(c)&&d^c;printf("%c%c",d,s));}

D + 6 और 31 चाल के लिए schnaader को क्रेडिट।

http://ideone.com/ts1Gs9

— mattnewport
स्रोत

0

बैश: 110 बाइट्स

(([[ $1 =~ [a-z] ]]&&echo {a..z})||([[ $1 =~ [A-Z] ]]&&echo {A..Z}))|([ "${1:1:1}" = . ]&&sed 's/ /\n/g'||cat)

स्पष्टीकरण के संदर्भ में, यह बहुत सरल है, कोई जादू की चाल नहीं है - यह सिर्फ एक चीज है जो बाश आंतरिक रूप से अच्छी तरह से अनुकूल है। गैर-स्पष्ट बिट्स के संदर्भ में:

{a..z}बैश में एक बहुत ही अप्रयुक्त चाल है - यह फैलता है a b c d...। आप संख्यात्मक अनुक्रम उत्पन्न करने के लिए ऐसा ही कर सकते हैं।
बैश रेगेक्स मैचिंग कर सकता है, [[ $1 =~ [a-z] ]]ए से जेड तक के पात्रों के लिए पहले प्रोग्राम तर्क के खिलाफ एक रेगेक्स मैच चलाता है। इसी तरह ऐज़ के लिए। आपको इसके लिए दोहरे वर्गाकार कोष्ठक की आवश्यकता है, हालांकि यह [नहीं कर सकता।
${1:1:1}$ 1 (पहला तर्क) का एक विकल्प मिलता है, एक वर्ण में, एक वर्ण लंबा - अर्थात्, यह स्ट्रिंग का दूसरा वर्ण लौटाता है, जो हम होने की उम्मीद करते हैं .।
sed 's/ /\n/g'सरल रेगेक्स: नए स्थानों के साथ रिक्त स्थान खोजता है और प्रतिस्थापित करता है। यदि .स्ट्रिंग का दूसरा चरित्र है, तो हम इस पर इनपुट करते हैं, या अन्यथा ...
cat यहाँ अंतिम चाल है - यदि हम रिक्त स्थान को नए सिरे से बदलना नहीं चाहते हैं, तो हम स्टड को बिल्ली के बजाय खिलाते हैं जो इसे फिर से आउटपुट करता है।

— दंगा
स्रोत

एक स्पष्टीकरण जोड़ने के लिए मत भूलना।

— जस्टिन

कस्टम वर्णमाला प्रिंट करें

चुनौती

गोल्फस्क्रिप्ट 48 75 73 70 67 66 63 57 53

अपडेट करें:

अपडेट करें:

संशोधनों का इतिहास:

सी, 135 129 128 चरस

रूबी, 72 71 61 अक्षर

रूबी: 127 113 92 (?) अक्षर

रूबी, 101 95

गोल्फस्क्रिप्ट, 80 72 वर्ण

q / k4 66 64 63 60 58 56 + 2 जुर्माना

पर्ल, 131 127 117 112 106 104 102 98 96 92 91 90 93 71 66 65 64 58 अक्षरों

पर्ल, 149 , 167

अपडेट करें

पायथन, 83

पीएचपी, 120 119 113

गणितज्ञ 158 159 204 199 183 167 165 162

जे ४३

उदाहरण:

व्याख्या

ब्रेनफक, 303

सी, 110

जावास्क्रिप्ट, 137

पर्ल, 77 76 70 68

आर, 219

सी, 146 वर्ण (भयानक)

VBA 225

जावा 8, 127 बाइट्स

मम्प्स, 91 , 86 , 82 , 79 , 76

विच्छेदन

पर्ल, 226 वर्ण

सी, 117

बैश: 110 बाइट्स