প্রদত্ত স্ট্রিংয়ের দৈর্ঘ্যের ডিকোডিংয়ের জন্য আপনার পছন্দের ভাষায় সবচেয়ে সংক্ষিপ্ত কোডটি লিখুন।
স্ট্রিংটি ফর্মের স্টিডিনে ইনপুট হিসাবে সরবরাহ করা হবে
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]
অবরুদ্ধ সংস্করণ:
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 এর পাইথন এসপিএল সংকলক ব্যবহার করছি , যার কয়েকটি বাগ রয়েছে (যার কারণ হিসাবে, আমি এর 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,'
এসপিএল একটি প্রগা es় প্রোগ্রামিং ভাষা যা প্রোগ্রামগুলি শেক্সপিয়ার নাটকের মতো দেখতে তৈরি করার জন্য ডিজাইন করা হয়েছে। এটি ভ্যারিয়েবল হিসাবে অক্ষর ব্যবহার করে এটি করে এবং অক্ষর একে অপরকে কিছু বলে রাখার মাধ্যমে প্রক্রিয়াজাত করা হয়।
The Decoding of the Lengths of Veronan Runs - A Drama of PPCG.
এটি নাটকের শিরোনাম; এটি সংকলক দ্বারা উপেক্ষা করা হয়।
Romeo, quite a character.
Juliet, Romeo's lover and multiplicand.
এখানে আমরা প্রোগ্রামের বাকী অংশে ব্যবহৃত ভেরিয়েবলগুলি ঘোষণা করছি। সবকিছু বেটওয়ান ,এবং. কম্পাইলার দ্বারা উপেক্ষা করা হয়। এই ক্ষেত্রে, আমরা ঘোষণা করি 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.
আর একটি দৃশ্যের ঘোষণা। দ্বিতীয় রান-লেংথটি ডিকোড করার জন্য দৃশ্য দ্বিতীয়টি লাফিয়ে উঠবে।
Juliet:
এই ঘোষণার ফর্মটির অর্থ জুলিয়েট কথা বলতে শুরু করবে। পরের দিন পর্যন্ত সবকিছুRomeo: , পর্যায়ের দিকনির্দেশ, বা দৃশ্য / অভিনয় ঘোষণার জুলিয়েটের বক্তৃতাযুক্ত একটি লাইন হবে এবং এভাবে "আমি" জুলিয়েটকে "আপনি" / "তুমি" রোমিওতে উল্লেখ করবে ইত্যাদি।
Open your mind.
এই কমান্ডটি STDIN ইন থেকে একক অক্ষরের অর্ডিনাল মান সঞ্চয় করে Romeo ।
Is my mother jollier than thou?
এসপিএলে, বিশেষ্যগুলি ইতিবাচক বা নেতিবাচক কিনা তার উপর নির্ভর করে 1 বা 1-তে অনুবাদ করে। এক্ষেত্রে,my mother ১ টি অনুবাদ করে 1. বিশেষণ (ধনাত্মক বা negativeণাত্মক) তাদের বিশেষ্যটিকে 2 দ্বারা গুণান।
এটি একটি প্রশ্ন; এতে জুলিয়েট জিজ্ঞাসা করেছে যে my mother( একে একে 1) রোমিওর চেয়ে "জোলিয়ার" কিনা। তুলনামূলক হয় হয় অনুবাদ less than(যদি তারা নেতিবাচক, মত worse) বা greater than(যদি তারা ইতিবাচক হয়, যেমন)jollier )। অতএব, এই প্রশ্নে উত্থিত হয় Is 1 greater than you?।
আমরা এই প্রশ্নটি করার কারণটি হ'ল ইনপুটটির শেষটি সনাক্ত করা। যেহেতু এর মানEOF প্ল্যাটফর্ম পরিবর্তিত হয় তবে সাধারণত এটি 1 এর চেয়ে কম হয়, আমরা এটি সনাক্ত করতে এটি ব্যবহার করি।
If so, we must proceed to scene IV.
পূর্ববর্তী প্রশ্নটি যদি মূল্যায়ন করা হয় true আমরা চতুর্থ দৃশ্যে ঝাঁপ দাও — যা কেবল প্রোগ্রামটির শেষ। সংক্ষেপে, আমরা যদি একটি ইওএফ সনাক্ত করি তবে আমরা প্রোগ্রামটি শেষ করি।
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 হয় তবে আমরা অন্য চরিত্রের রান-লেংথটি ডিকোড করতে দ্বিতীয় দৃশ্যে ফিরে আসি।
Let us return to scene III.
অন্যথায়, আমরা পুনরায় রোমিওর চরিত্রটি আউটপুট করতে তৃতীয় দৃশ্যে ফিরে এসেছি।
Scene IV: Finale.
[Exeunt]
এই চূড়ান্ত দৃশ্যের ঘোষণাটি প্রোগ্রামের শেষের জন্য কেবল একটি চিহ্নিতকারী। [Exeunt]মঞ্চ নির্দেশনা কম্পাইলার পেতে আসলে চূড়ান্ত দৃশ্য উৎপন্ন প্রয়োজন।
print<>=~s/(.)(.)/$1x$2/ger
print<>=~s/(.)(.)/$1x$2/ger। আমি মোটামুটি নিশ্চিত যে আপনি বোঝাতে চেয়েছিলেন $1x$2এবং অন্যভাবে নয়।
-pপতাকা ব্যবহার করে আপনাকে নামতে দিন printএবং <>, সুতরাং উত্তরটি কেবল সহজ হয়ে যাবে: -> 18-এরs/(.)(.)/$1x$2/ge জন্য +1 +1 চার্স +1 । -p
x=strsplit(readline(),"")[[1]];cat(rep(x[c(T,F)],x[c(F,T)]),sep="")
repধারণাগুলি timesঅক্ষর থেকে শুরু করে স্বয়ংক্রিয়ভাবে পূর্ণসংখ্যার দিকে যুক্তি জোর করে had উজ্জ্বল।
পাইথন 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- N/2ম্যাট্রিক্সে পরিণত করুন{⍺/⍨⍎⍵}/: ম্যাট্রিক্সের প্রতিটি সারিতে ( /), ( /) এর প্রথম অক্ষরটি ( ⍺) ⍎দ্বিতীয় বর্ণের ( ⍵) এর ( ) দ্বারা প্রতিলিপি করুন,/: প্রতিটি সারির আউটপুট একত্রিত করুন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 এ হ্রাস করা যেতে পারে\v0x0B\a0x07
\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
ওএস এক্স-তে প্রফুল্ল দিয়ে পরীক্ষা করা হয়েছে
print''.join([c*int(n)for c,n in zip(*[iter(raw_input())]*2)])
iterসেখানে দুর্দান্ত কৌশল ... আমি মনে করি এটি নিজেই ব্যবহার করব!
@ সি ugoren এর উত্তর সামান্য খাটো হয়, কিন্তু প্রয়োজন যে সঙ্গে এই উত্তরটি মেনে "স্ট্রিং উপর ইনপুট হিসাবে সরবরাহ করা হবে stdin ।"
n;main(c){for(;;){c=getchar(),n=getchar()-48;while(n--)putchar(c);}}
main(c,n){ ... }প্রোগ্রামটি চালিত হওয়ার পরে ডিফল্টরূপে 1 পাস করা হবে।
intআর্গের সুবিধা নিতে পারি , তবে সংকলক (গুলি) আমি অভিযোগ ব্যবহার error: second parameter of 'main' (argument array) must be of type 'char **'করি যাতে আমি এড়াতে পারি না main(c,n); আমি ব্যবহার করা আবশ্যক main(int c,char **n)। প্ল্যাটফর্ম বা জিসিসি জিনিস হতে পারে।
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আপনি যদি খুব চতুর মনে করেন তবে এটিও হতে পারে !
এই উত্তরের আকারটি সর্বোচ্চ পোস্টযোগ্য প্রোগ্রামের আকারের (এএইচ) ছাড়িয়ে গেছে, সুতরাং কোডটি আমার গিটহাব সংগ্রহস্থলে অবস্থিত ।
এটি একটি জটিল অংশ হতে পারে, কারণ নিষ্পাপ হাস্কেল দোভাষী এটি চালাতে যুগে যুগে সময় নেবে। টিআইওর কাছে শালীন মালবোগল আনশ্যাকল্ড দোভাষী রয়েছে, তবে দুঃখের বিষয় আমি এটি ব্যবহার করতে সক্ষম হবো না (সীমাবদ্ধতা)।
আমি যেটি খুঁজে পেতে পারি তার মধ্যে সেরাটি হ'ল স্থির 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ι`ÅΓ
-১ বাইট @ গ্রিমিকে ধন্যবাদ ।
অক্ষরের তালিকা হিসাবে আউটপুট।
রান-লেংথের ডিকোড বিল্টইন ছাড়াই ওল্ড 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 বিল্ট-ইন কোনও আরএলই চ্যালেঞ্জ না জিতলে দুঃখ হবে be
পাইথন, 78 72 66 চর
D = raw_input () "" মুদ্রণ করুন ([এক্স x ইন্ট (ডি [আমি + 1]) আই এর জন্য, এক্স ইনমুমারেটে (ডি) যদি ~ আমি এবং 1])
গুলি = raw_input () "" মুদ্রণ করুন (আই আই ইনট (জে) আই, জে জিপ ইন (এস [:: 2], এস [1 :: 2]))
2/{)15&*}/
এটি ড্যারেন স্টোনের অজগর সমাধান দ্বারা অনুপ্রাণিত - পুনরাবৃত্তির অপব্যবহার!
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)))))
এটি Clojure হওয়ার জন্য ব্যতিক্রমী দীর্ঘায়িত বোধ করে, যদি কেউ আরও ভাল করতে পারে তবে দয়া করে এটি পোস্ট করুন।