दिए गए स्ट्रिंग की डिकोडिंग चलाने के लिए अपनी पसंद की भाषा में सबसे छोटा कोड लिखें।
स्ट्रिंग के रूप में आपूर्ति की जाएगी stdin पर इनपुट के रूप में
CNCNCNCNCNCNCNCN
जहां प्रत्येक Cकोई मुद्रण योग्य ASCII वर्ण हो सकता है और प्रत्येक (समावेशी) के लिए Nएक अंक 1है 9।
नमूना इनपुट:
:144,1'1
संगत उत्पादन:
:4444,'
जवाबों:
,[>,>++++++[<-------->-]<[<.>-]<,]
.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Scene II:.
Ford:
Open your mind.Is sky nicer than you?If so, let us return to scene IV.
Ajax:
Open your mind.You is sum you and sum big big big big big big pig and big big big big cat!
Scene III:.
Ford:
Speak thy mind.
Ajax:
You is sum you and pig!Is you as big as zero?If so, let us return to scene II.Let us return to scene III.
Scene IV:.
[Exeunt]
Ungolfed संस्करण:
The Decoding of the Lengths of Veronan Runs - A Drama of PPCG.
Romeo, quite a character.
Juliet, Romeo's lover and multiplicand.
Act I: In which the lengths of runs are decoded.
Scene I: A silent entrance.
[Enter Romeo and Juliet]
Scene II: In which neither Romeo nor Juliet believes the other open-minded.
Juliet:
Open your mind. Is my mother jollier than thou? If so,
we must proceed to scene IV.
Romeo:
Open your mind. Thou art the sum of thyself and the sum of my good aunt and
the difference between nothing and the quotient of the square of twice the sum
of thy foul fat-kidneyed goat and thy death and thy evil variable!
Scene III: In which Romeo snaps and brutally insults Juliet.
Juliet:
Speak thy mind.
Romeo:
Thou art the sum of thyself and a hog! Art thou as rotten as nothing? If so,
let us return to scene II. Let us return to scene III.
Scene IV: Finale.
[Exeunt]
मैं drsam94 के Python SPL संकलक का उपयोग कर रहा हूं , जिसमें कुछ कीड़े हैं (इसलिए, उदाहरण के लिए, मैं Open your mindइसके बजाय उपयोग करता हूंOpen thy mind गोल्फ संस्करण में करता हूं)।
इस कार्यक्रम को चलाने के लिए, उपयोग करें:
$ python splc.py rld.spl > rld.c
$ gcc rld.c -o rld.exe
$ echo -n ":144,1'1" | ./rld
:4444,'
एसपीएल एक गूढ़ प्रोग्रामिंग भाषा है जिसे कार्यक्रमों को शेक्सपियर नाटकों की तरह बनाया गया है। यह वर्णों को चर के रूप में उपयोग करके करता है, और वर्णों को एक दूसरे से बातें कहने के द्वारा प्रसंस्करण किया जाता है।
The Decoding of the Lengths of Veronan Runs - A Drama of PPCG.
यह नाटक का शीर्षक है; यह संकलक द्वारा नजरअंदाज कर दिया है।
Romeo, quite a character.
Juliet, Romeo's lover and multiplicand.
यहां हम बाकी प्रोग्राम में इस्तेमाल किए गए वेरिएबल्स को घोषित कर रहे हैं। सब कुछ betwen ,और .संकलक द्वारा नजरअंदाज कर दिया है। इस मामले में, हम घोषणा करते हैं Romeo, चरित्र को डिकोड किया जा रहा है, और Juliet, चरित्र की रन लंबाई को धारण करने के लिए उपयोग किया जाता है।
Act I: In which the lengths of runs are decoded.
यहां हम कार्यक्रम में पहली और एकमात्र कार्रवाई की घोषणा करते हैं। अधिनियम और दृश्य लेबल की तरह हैं; वे किसी भी समय let us return to scene IIया उस के कुछ प्रकार का उपयोग करके कूद सकते हैं । हम केवल एक अधिनियम का उपयोग करते हैं, क्योंकि यह हमारी आवश्यकताओं के लिए पर्याप्त है। फिर से, बीच में कुछ भी :और .संकलक द्वारा नजरअंदाज कर दिया जाता है।
Scene I: A silent entrance.
यहां हम पहला दृश्य घोषित करते हैं। दृश्य रोमन अंकों में गिने जाते हैं: पहला है Scene I, दूसरा Scene II, और इसी तरह।
[Enter Romeo and Juliet]
यह एक चरण की दिशा है; इसमें, हम "चरण" पर आने के लिए चर Romeoऔर Julietचर बताते हैं। केवल दो चर "मंच" पर एक बार में हो सकते हैं; मंच का उपयोग किया जाता है ताकि संकलक यह पता लगा सके कि किस चर को संबोधित किया जा रहा है जब वे बोलते हैं। क्योंकि हमारे पास केवल दो चर हैं, रोमियो और जूलियट कार्यक्रम की लंबाई के लिए मंच पर रहेंगे।
Scene II: In which neither Romeo nor Juliet believes the other open-minded.
एक और दृश्य घोषणा। एक और रन-लंबाई को डिकोड करने के लिए सीन II को जंप किया जाएगा।
Juliet:
घोषणा के इस रूप का मतलब है कि जूलियट ने बोलना शुरू किया है। अगले Romeo:, मंच की दिशा, या दृश्य / अभिनय घोषणा तक सब कुछ जूलियट द्वारा बोली जाने वाली एक पंक्ति होगी, और इस तरह "मुझे" जूलियट, "आप" / "तू" रोमियो, आदि के लिए संदर्भित करेगा।
Open your mind.
यह कमांड STDIN से एकल वर्ण के क्रमिक मूल्य को संग्रहीत करता है Romeo।
Is my mother jollier than thou?
एसपीएल में, संज्ञाएं 1 या -1 का अनुवाद करती हैं, इस पर निर्भर करता है कि वे सकारात्मक हैं या नकारात्मक। इस मामले में, my mother1 से अनुवाद। विशेषण (सकारात्मक या नकारात्मक) उनकी संज्ञा को 2 से गुणा करते हैं।
यह एक प्रश्न है; इसमें, जूलियट पूछता है कि क्या my mother(AKA 1) रोमियो की तुलना में "जूलियर" है। तुलनाएं या तो अनुवाद करती हैं less than(यदि वे नकारात्मक हैं, जैसे worse) या greater than(यदि वे सकारात्मक हैं, जैसे jollier)। इसलिए, यह सवाल उबलता है Is 1 greater than you?।
इस प्रश्न को पूछने का कारण इनपुट के अंत का पता लगाना है। चूंकि EOFप्लेटफ़ॉर्म द्वारा भिन्न होता है, लेकिन आमतौर पर 1 से कम होता है, इसलिए हम इसका पता लगाने के लिए इसका उपयोग करते हैं।
If so, we must proceed to scene IV.
यदि पूर्ववर्ती प्रश्न का मूल्यांकन किया जाता है true, तो हम IV पर जाते हैं - जो कि कार्यक्रम का अंत है। संक्षेप में, यदि हम एक ईओएफ का पता लगाते हैं, तो हम कार्यक्रम को समाप्त करते हैं।
Romeo:
यह अब रोमियो की पंक्ति है: "मैं" और "आप" क्रमशः रोमियो और जूलियट को संदर्भित करते हैं।
Open your mind.
फिर, यह कथन एसटीडीआईएन से जूलियट में एकल चरित्र के क्रमिक मूल्य को रखता है, जो इस मामले में संग्रहीत चरित्र की रन-लंबाई है Romeo।
Thou art the sum of thyself and the sum of my good aunt and the difference
between nothing and the quotient of the square of twice the sum of thy foul
fat-kidneyed goat and thy death and thy evil variable!
यह बहुत विस्तार में जाने के लिए बहुत लंबा है, लेकिन बस मुझ पर भरोसा है कि यह अनुवाद करता है Juliet -= 48। हम ऐसा इसलिए करते हैं क्योंकि जूलियट एक अंक के ASCII मूल्य रखती है, और ord('0') == 48; 48 को घटाते हुए, हम एक संख्या के ASCII मान से संख्या में ही अनुवाद करते हैं।
Scene III: In which Romeo snaps and brutally insults Juliet.
एक और दृश्य घोषणा। यह एक पाश जिसमें हम बार-बार के चरित्र मूल्य प्रिंट के लिए है Romeo, Julietकई बार।
Juliet:
Speak thy mind.
यह कथन रोमियो को एक चरित्र के रूप में उनके मूल्य को मुद्रित करने का कारण बनता है; यानी रोमियो में जो भी कैरेक्टर वैल्यू पहले स्टोर की गई थी, अब आउटपुट है।
Romeo:
Thou art the sum of thyself and a hog!
हॉग एक नकारात्मक संज्ञा है, इसलिए a hog-1 में अनुवाद करता है; इसलिए, यह कथन मूल्यांकन करता है Juliet -= 1।
Art thou as rotten as nothing?
रोमियो यहां पूछता है कि क्या जूलियट "के रूप में सड़ा हुआ है", या इसके बराबर, 0।
If so, let us return to scene II.
यदि जूलियट का मान 0 है, तो हम दूसरे दृश्य के रन-लेंथ को डिकोड करने के लिए II पर वापस आते हैं।
Let us return to scene III.
वरना, हम रोम के चरित्र को फिर से प्रोड्यूस करने के लिए III पर वापस आते हैं।
Scene IV: Finale.
[Exeunt]
यह अंतिम दृश्य घोषणा कार्यक्रम के अंत के लिए सिर्फ एक मार्कर है। [Exeunt]चरण दिशा संकलक पाने के लिए करने के लिए वास्तव में अंतिम दृश्य उत्पन्न आवश्यक है।
print<>=~s/(.)(.)/$1x$2/ger
print<>=~s/(.)(.)/$1x$2/ger:। मुझे भी पूरा यकीन है कि आपका मतलब था $1x$2, और दूसरे तरीके से नहीं।
-pध्वज का उपयोग करने से आप गिर जाते हैं printऔर <>, इसलिए उत्तर बस बन जाएगा: s/(.)(.)/$1x$2/ge-> 17chars +1 के लिए -p-> 18 ।
पायथन 3 मुझे अपने दो पायथन 2 समाधानों के दृष्टिकोण को मर्ज करने की अनुमति देता है।
s=input()
t=''
while s:a,b,*s=s;t+=a*int(b)
print(t)
raw_inputपायथन 3 से मेल खाता है input। द्वारा तो पहली पंक्ति चाहिएs=input()
s=input() while s:a,b,*s=s;print(a*int(b),end='')
,/{⍺/⍨⍎⍵}/↑T⊂⍨~⎕D∊⍨T←⍞
स्पष्टीकरण:
T←⍞: इनपुट इनपुट इन करें TT⊂⍨~⎕D∊⍨T: Tउन वर्णों पर विभाजित करें जो अंक नहीं हैं↑: इसे 2-by- N/2मैट्रिक्स में बदल दें{⍺/⍨⍎⍵}/: मैट्रिक्स की प्रत्येक पंक्ति पर ( /), दूसरे वर्ण के eval ( ) द्वारा /पहला वर्ण ( ⍺) पहला ⍎अक्षर ( ⍵),/: प्रत्येक पंक्ति के आउटपुट को संक्षिप्त करें8086 विधानसभा, 106 98 वर्ण
l:
mov ah,8
int 21h
mov bl,al
int 21h
sub al,48
mov cl,al
xor ch,ch
mov al,bl
mov ah,14
p:
int 10h
loop p
jmp l
यदि इनपुट स्ट्रीम में वर्णों से पहले संख्याएँ थीं, तो दो पंक्तियों (18 वर्णों) को इससे दूर किया जा सकता है।
dq 21cdc38821cd08b4 d888ed30c188482c e8ebfce210cd14b453 वर्णों के बारे में क्या ? मैं यह नहीं देखता कि यह गैर-अपरकेस वर्ण या
#n
s/.*/\n&\a987654321\v\v\v\v\v\v\v\v\v/
:a
s/\n(.)(.)(.*\a.*\2.{9}(.*))/\1\n\4\3/
tb
bc
:b
s/(.)\n\v/\1\1\n/
tb
ba
:c
P
के साथ चलाने के होने की जरूरत है -rझंडा
बदल कर 110 + 2 तक कम किया जा सकता है \vगंदा साथ 0x0Bऔर \aसाथ0x07
\2.{9}एक शानदार विचार है) शानदार!
एक पैरामीटर के रूप में इनपुट प्राप्त करता है।
main(p,v)char*p,**v;{
for(p=v[1];*p;--p[1]<49?p+=2:0)putchar(*p);
}
error: first parameter of 'main' (argument count) must be of type 'int'। क्या कमांड लाइन स्विच है?
BEGIN KEY KEY 48 - 0 DO DUP EMIT LOOP 0 UNTIL
OS X पर pforth के साथ परीक्षण किया गया।
print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])
iterवहाँ के साथ अच्छा चाल ... मुझे लगता है कि मैं इसका इस्तेमाल खुद करूँगा!
@ सी में ugoren का उत्तर थोड़ा कम है, लेकिन यह उत्तर इस आवश्यकता का अनुपालन करता है कि "स्ट्रिंग को एडिन पर इनपुट के रूप में आपूर्ति की जाएगी ।"
n;main(c){for(;;){c=getchar(),n=getchar()-48;while(n--)putchar(c);}}
main(c,n){ ... }प्रोग्राम चलने पर डिफ़ॉल्ट रूप से 1 पास किया जाएगा।
intarg का लाभ उठा सकता हूं , लेकिन कंपाइलर (s) मैं शिकायत का उपयोग करता error: second parameter of 'main' (argument array) must be of type 'char **'हूं, इसलिए मैं इससे दूर नहीं हो सकता main(c,n); मुझे अवश्य उपयोग करना चाहिए main(int c,char **n)। एक मंच या gcc चीज हो सकती है।
n;main(c)लेकिन नहीं main(n,c)- काफी अच्छा! :)
f[]=[]
f(x:y:s)=replicate(read[y])x++f s
main=interact$f
कुछ भी गोल्फिंग में मेरा पहला वास्तविक प्रयास है, इसलिए शायद यहां कुछ सुधार किया जाना है।
read[y]दो पात्रों को बचाता है
replicate x yके साथ [1..x]>>[y]। इस प्रकार आपकी दूसरी लाइन को बदला जा सकता है f(x:y:s)=(['1'..y]>>[x])++f s, जो इसे 53 बाइट्स तक ले जाती है।
-P , 8 बाइट्सएक वर्ण के रूप में इनपुट, एक स्ट्रिंग के रूप में आउटपुट।
ò crÈpY°
ò crÈpYn :Implicit input of character array
ò :Groups of 2
r :Reduce each pair
È :By passing them through the following function as [X,Y]
p : Repeat X
Yn : Y, converted to an integer, times
:Implicitly join and output
ò crÏ°îXअगर आपको यह बहुत डरावना लगता है!
इस उत्तर का आकार अधिकतम पोस्ट करने योग्य प्रोग्राम आकार (eh) से अधिक है, इसलिए कोड मेरे GitHub रिपॉजिटरी में स्थित है ।
यह एक मुश्किल हिस्सा हो सकता है, क्योंकि भोले हास्कल दुभाषिया इसे चलाने के लिए उम्र पर उम्र ले लेंगे। TIO में अच्छे Malbogle Unshackled दुभाषिया हैं, लेकिन दुख की बात है कि मैं इसका उपयोग नहीं कर पाऊंगा (सीमाएं)।
सबसे अच्छा एक जो मैं पा सकता था वह है 20-ट्रिट रोटेशन चौड़ाई वाला वैरिएंट, जो बहुत अच्छा प्रदर्शन करता है, प्रति घंटे 360 बाइट्स को डिकम्प्रेस करके। ।
दुभाषिया को थोड़ा तेज करने के लिए, मैंने माथियास लुटर के मालब्लोज अनकशल्ड इंटरप्रेटर से सभी चेक हटा दिए हैं।
मेरा संशोधित संस्करण लगभग 6,3% तेजी से चल सकता है।
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
"OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";
typedef struct Word {
unsigned int area;
unsigned int high;
unsigned int low;
} Word;
void word2string(Word w, char* s, int min_length) {
if (!s) return;
if (min_length < 1) min_length = 1;
if (min_length > 20) min_length = 20;
s[0] = (w.area%3) + '0';
s[1] = 't';
char tmp[20];
int i;
for (i=0;i<10;i++) {
tmp[19-i] = (w.low % 3) + '0';
w.low /= 3;
}
for (i=0;i<10;i++) {
tmp[9-i] = (w.high % 3) + '0';
w.high /= 3;
}
i = 0;
while (tmp[i] == s[0] && i < 20 - min_length) i++;
int j = 2;
while (i < 20) {
s[j] = tmp[i];
i++;
j++;
}
s[j] = 0;
}
unsigned int crazy_low(unsigned int a, unsigned int d){
unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
int position = 0;
unsigned int output = 0;
while (position < 10){
unsigned int i = a%3;
unsigned int j = d%3;
unsigned int out = crz[i+3*j];
unsigned int multiple = 1;
int k;
for (k=0;k<position;k++)
multiple *= 3;
output += multiple*out;
a /= 3;
d /= 3;
position++;
}
return output;
}
Word zero() {
Word result = {0, 0, 0};
return result;
}
Word increment(Word d) {
d.low++;
if (d.low >= 59049) {
d.low = 0;
d.high++;
if (d.high >= 59049) {
fprintf(stderr,"error: overflow\n");
exit(1);
}
}
return d;
}
Word decrement(Word d) {
if (d.low == 0) {
d.low = 59048;
d.high--;
}else{
d.low--;
}
return d;
}
Word crazy(Word a, Word d){
Word output;
unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
output.area = crz[a.area+3*d.area];
output.high = crazy_low(a.high, d.high);
output.low = crazy_low(a.low, d.low);
return output;
}
Word rotate_r(Word d){
unsigned int carry_h = d.high%3;
unsigned int carry_l = d.low%3;
d.high = 19683 * carry_l + d.high / 3;
d.low = 19683 * carry_h + d.low / 3;
return d;
}
// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
if ((mem[d.area])[d.high]) {
return &(((mem[d.area])[d.high])[d.low]);
}
(mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
if (!(mem[d.area])[d.high]) {
fprintf(stderr,"error: out of memory.\n");
exit(1);
}
if (last_initialized) {
Word repitition[6];
repitition[(last_initialized-1) % 6] =
((mem[0])[(last_initialized-1) / 59049])
[(last_initialized-1) % 59049];
repitition[(last_initialized) % 6] =
((mem[0])[last_initialized / 59049])
[last_initialized % 59049];
unsigned int i;
for (i=0;i<6;i++) {
repitition[(last_initialized+1+i) % 6] =
crazy(repitition[(last_initialized+i) % 6],
repitition[(last_initialized-1+i) % 6]);
}
unsigned int offset = (59049*d.high) % 6;
i = 0;
while (1){
((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
if (i == 59048) {
break;
}
i++;
}
}
return &(((mem[d.area])[d.high])[d.low]);
}
unsigned int get_instruction(Word** mem[], Word c,
unsigned int last_initialized,
int ignore_invalid) {
Word* instr = ptr_to(mem, c, last_initialized);
unsigned int instruction = instr->low;
instruction = (instruction+c.low + 59049 * c.high
+ (c.area==1?52:(c.area==2?10:0)))%94;
return instruction;
}
int main(int argc, char* argv[]) {
Word** memory[3];
int i,j;
for (i=0; i<3; i++) {
memory[i] = (Word**)malloc(59049 * sizeof(Word*));
if (!memory) {
fprintf(stderr,"not enough memory.\n");
return 1;
}
for (j=0; j<59049; j++) {
(memory[i])[j] = 0;
}
}
Word a, c, d;
unsigned int result;
FILE* file;
if (argc < 2) {
// read program code from STDIN
file = stdin;
}else{
file = fopen(argv[1],"rb");
}
if (file == NULL) {
fprintf(stderr, "File not found: %s\n",argv[1]);
return 1;
}
a = zero();
c = zero();
d = zero();
result = 0;
while (!feof(file)){
unsigned int instr;
Word* cell = ptr_to(memory, d, 0);
(*cell) = zero();
result = fread(&cell->low,1,1,file);
if (result > 1)
return 1;
if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
break;
instr = (cell->low + d.low + 59049*d.high)%94;
if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
|| cell->low == '\n');
else if (cell->low >= 33 && cell->low < 127 &&
(instr == 4 || instr == 5 || instr == 23 || instr == 39
|| instr == 40 || instr == 62 || instr == 68
|| instr == 81)) {
d = increment(d);
}
}
if (file != stdin) {
fclose(file);
}
unsigned int last_initialized = 0;
while (1){
*ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
*ptr_to(memory, decrement(decrement(d)), 0));
last_initialized = d.low + 59049*d.high;
if (d.low == 59048) {
break;
}
d = increment(d);
}
d = zero();
unsigned int step = 0;
while (1) {
unsigned int instruction = get_instruction(memory, c,
last_initialized, 0);
step++;
switch (instruction){
case 4:
c = *ptr_to(memory,d,last_initialized);
break;
case 5:
if (!a.area) {
printf("%c",(char)(a.low + 59049*a.high));
}else if (a.area == 2 && a.low == 59047
&& a.high == 59048) {
printf("\n");
}
break;
case 23:
a = zero();
a.low = getchar();
if (a.low == EOF) {
a.low = 59048;
a.high = 59048;
a.area = 2;
}else if (a.low == '\n'){
a.low = 59047;
a.high = 59048;
a.area = 2;
}
break;
case 39:
a = (*ptr_to(memory,d,last_initialized)
= rotate_r(*ptr_to(memory,d,last_initialized)));
break;
case 40:
d = *ptr_to(memory,d,last_initialized);
break;
case 62:
a = (*ptr_to(memory,d,last_initialized)
= crazy(a, *ptr_to(memory,d,last_initialized)));
break;
case 81:
return 0;
case 68:
default:
break;
}
Word* mem_c = ptr_to(memory, c, last_initialized);
mem_c->low = translation[mem_c->low - 33];
c = increment(c);
d = increment(d);
}
return 0;
}
2ι`ÅΓ
-1 बाइट @ ग्रीम को धन्यवाद ।
वर्णों की सूची के रूप में आउटपुट।
पुराने 6 बाइट्स रन-लंबाई डिकोड बिना निर्मित उत्तर:
2ôε`×?
स्पष्टीकरण:
2ι # Uninterleave the (implicit) input-string in two parts
# i.e. ":144,1'3" → [":4,'","1413"]
` # Push both separated to the stack
ÅΓ # Run-length decode
# i.e. ":4,'" and "1413" → [":","4","4","4","4",",","'","'","'"]
# (after which the result is output implicitly)
2ô # Split the (implicit) input-string into parts of size 2
# i.e. ":144,1'3" → [":1","44",",1","'3"]
ε # Loop over each of these pairs:
` # Push both characters separated to the stack
× # Repeat the first character the digit amount of times as string
# i.e. "'" and "3" → "'''"
? # And print it without trailing newline2ι`ÅΓ5 बाइट्स है। यदि RLE निर्मित में RLE चुनौती नहीं मिली, तो दुख होगा।
पायथन, 78 72 66 चार
d = raw_input () प्रिंट ""। ज्वाइन ([x * int (d [i + 1]) i के लिए, x इन्यूमरेट में (d) अगर ~ i & 1])
एस = raw_input () प्रिंट ""। ज्वाइन करें (i * int (j) i के लिए, j in zip (s [:: 2], s [1 :: 2)))
यह डैरेन स्टोन के अजगर समाधान से प्रेरित है - पुनरावृत्त दुरुपयोग!
x=iter(raw_input())
print''.join(a*int(next(x))for a in x)
यह मेरा मूल समाधान है (60 वर्ण)
s=raw_input()
t=''
while s:t+=s[0]*int(s[1]);s=s[2:]
print t
एक अलग दृष्टिकोण 3 वर्ण लंबा है:
f=lambda a,b,*x:a*int(b)+(x and f(*x)or'')
print f(raw_input())
जावा: 285 चरस
import java.util.Scanner;public class A{public static void main(String args[]){Scanner s = new Scanner(System.in);while(s.hasNext()){String t=s.next();for(int i=0;i<t.length();i++) {for(int j=0; j<(Byte.valueOf(t.substring(i+1,i+2)));j++){System.out.print(t.substring(i,i+1));}i++;}}}}
LSSSLSSSSLSLSTLTSTTTSLSSSSTSSSSLTSSTLTTTTLSSSSLSLSTLTSTTTSSSTTSSSSLTSSTLSSSSLSLSLTSTLSSSTLTSSTSTSSTLTLSSLSLSSLLSSTLSLLSLLLSLSLLSSTTLLLL
(स्पेस, टैब, लाइनफीड पात्रों के साथ एस, टी, एल बदलें।)
इसे ऑनलाइन [यहाँ] आज़माएँ ।
स्पष्टीकरण:
"assembly" whitespace stack
---------- ---------- -----
s: LSS SL ;input loop []
push 0 SS SSL [0]
dup SLS [0,0]
getc TLTS ;input & store char c [0]
rcl TTT ;recall c [c]
dup SLS [c,c]
push 16 SS STSSSSL [c,c,16]
sub TSST [c,c-16]
jlt tt LTT TTL ;exit if ord(c) < 16 [c]
push 0 SS SSL [c,0]
dup SLS [c,0,0]
getc TLTS ;input & store char n [c,0]
rcl TTT ;recall n [c,n]
push 48 SS STTSSSSL ;convert n to m = ord(n)-ord('0') [c,n,48]
sub TSST [c,m]
ss: LSS SSL ;inner loop outputs c, m times [c,m]
dup SLS [c,m,m]
jeq t LTS TL ;if m==0, stop outputting this c [c,m]
push 1 SS STL ;otherwise decr m [c,m,1]
sub TSST [c,m-1]
copy 1 STS STL ;copy c to tos [c,m-1,c]
putc TLSS ;output this c [c,m-1]
jmp ss LSL SSL ;loop back to output this c again [c,m-1]
t: LSS TL [c,m]
pop SLL [c]
pop SLL []
jmp s LSL SL ;loop back to get the next c,n []
tt: LSS TTL [c]
end LLL ;exit
क्लोजर (107)
(pr(apply str(map #(apply str(repeat(Integer/parseInt(str(second %)))(first %)))(partition 2(read-line)))))
यह क्लोजर होने के लिए असाधारण रूप से लंबा लगता है, अगर कोई बेहतर कर सकता है, तो कृपया इसे पोस्ट करें।