বিজয়ী (বেশ স্পষ্টতই) ডেনিস who, যিনি 10 বাইটের সাহায্যে জেলি ব্যবহার করেছিলেন!

এই চ্যালেঞ্জটি এখানে এখনও থাকবে, তবে ফলাফল আর নেওয়া হবে না।

একটি সংখ্যার পাওয়ারট্রেন জন কনওয়ের একটি ধারণা (যিনি কনওয়ের গেম অফ লাইফ তৈরির জন্যও উল্লেখযোগ্য, তবে এটি বিন্দু নয়)। এটি তাই হিসাবে সংজ্ঞায়িত করা হয়:

যে কোনও সংখ্যার ... জন্য, সংখ্যার পাওয়ার ট্রেন হ'ল ... (বাম থেকে ডান প্রতি প্রতিটি দ্বিতীয় সংখ্যা , তার আগে অঙ্কের শক্তি) ফলাফলটি একক অঙ্ক না হওয়া পর্যন্ত এই প্রক্রিয়াটি পুনরাবৃত্তি হয়।

উদাহরণ:

2592 => (2^5)(9^2) = 2592 <= Cannot be further decomposed 135 => (1^3)5 = 5 1234 => (1^2)(3^4) = 81 => (8^1) = 8 1100 => (1^1)(0^0) = 1 # (0^0) = 1 -42 => -42 # Negative numbers output the input

আপনার চ্যালেঞ্জটি হ'ল ইনপুটটির যে কোনও সংখ্যার জন্য n, আউটপুট হিসাবে ফিরে powertrain(n)(অর্থাত্ nবিদ্যুত্রের পচন শেষ হওয়ার পরে)।

এটি কোড গল্ফ, তাই সংক্ষিপ্ত পরিমাণে বাইট জিতেছে।

DISCLAIMER পড়ুন-জিনিস:

আপনার ইনপুটটিতে একটি বিজোড় সংখ্যক সংখ্যা থাকতে পারে, শেষ অঙ্কটিতে কেবল শক্তি থাকবে না।
0 ^ 0 হল 1, কারণ এটি যদি 0 হয় তবে প্রচুর সংখ্যা তাত্ক্ষণিকভাবে 0 বা 1 এ নেমে যায়।
যদি গণনা প্রক্রিয়াটির কোনও অংশে সংখ্যাটি অবিনাশী হয় (উদাহরণস্বরূপ এটি যদি শেষ হয় 2592), তবে আপনি কেবল সংখ্যাটি আউটপুট করতে পারবেন।
যদি ইনপুটটি < 10(যেমন সমস্ত একক সংখ্যা এবং sণাত্মক) হয় তবে ইনপুটটিকে আউটপুট দিন।

আমি সম্ভবত কয়েক ~~ঘন্টা~~ পরে একটি বিজয়ী ঘোষণা করব ।

বর্তমান লিডারবোর্ড:

জেলি ( ডেনিস ♦ ): 10

পাইথ ( ডেনারএফি ): 16

এমএটিএল ( ডন মুসেলি ): 21

পার্ল ( টন হসপেল ): 42

হাস্কেল ( দামিয়েন ): 64

জাভাস্ক্রিপ্ট ES6 ( edc65 ): 71

গণিত ( মার্ফি ): 74

ম্যাথমেটিকা ( লেজিওন ম্যামাল978 ) এবং হাস্কেল ( রেঞ্জি ): 77

পাইথন 2 ( ম্যাথমান্ডান ): 111

পাইথন 3 ( এরওয়ান ): 161

জাভা 8 ( নীল ): 229

ওরাকল এসকিউএল 11.2 ( জেটো ): 456

বেফুঞ্জ '93 ( লেক্স ): 490

code-golf math

— clismique
সূত্র

আরও কিছু পরীক্ষার কেস প্রশংসিত হবে।

— মেগো

তাহলে ইনপুটটিতে সর্বোচ্চ 4 ডিজিট থাকবে?

— ডেনকার

7

যদি কোনও চক্র পৌঁছে যায় তবে চক্রের সময়কাল 1 না হয় বা ইনপুট সংখ্যাটি চক্রটির অংশ না হয় তবে?

— feersum

1

"আমি নিশ্চিত যে সম্ভাব্যতার ক্ষেত্রগুলির মধ্যে কোনওটি নেই"। আমরা কি ধরে নিতে পারি যে এটি কখনই ঘটবে না? I> 1 পিরিয়ডের চক্রটি পৌঁছে গেলে লুপটি চিরতরে চলে যাওয়ার অনুমতি দেয়?

— স্টিভি গ্রিফিন

6

প্রস্তাবিত পরীক্ষার কেসগুলি: 1100এবং -42যদি পরীক্ষার ক্ষেত্রে দেখা না যায় তবে এজ প্রান্ত সম্পর্কিত নিয়মগুলি মিস করা সহজ।

— ডেনিস

4

জেলি, 15 14 12 10 বাইট

Ds2*/€Pµ³¡

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

Ds2*/€Pµ³¡  Main link. Argument: n

D           Convert n into the array of its decimal digits.
 s2         Split into pairs of digits.
   */€      Reduce each pair by exponentiation.
      P     Take the product of the resulting powers.
       µ    Push the preceding chain as a link, and start a new one.
        ³¡  Execute the link n times and return the last result.

— ডেনিস
সূত্র

এটি কেবল পুনরাবৃত্তি nবার দ্বারা সংক্ষিপ্ত করা যেতে পারে , তবে আমার কাছে প্রমাণ নেই যে এটি সমস্ত সম্ভাব্য ইনপুটগুলির জন্য কাজ করে।

— ডেনিস

1

আপনার যেকোন যুক্তিসঙ্গত সংখ্যার জন্য ঠিক থাকতে হবে। প্রকৃতপক্ষে আপনি 16 টি পুনরাবৃত্তি ব্যবহার করে যে কোনও সংখ্যার পক্ষে প্রায় অবশ্যই ঠিক আছেন : oeis.org/A133503

— টন হসপেল

@ ডেনিস এইচএম, আমি আমার উত্তরে যা করছি

— লুইস মেন্ডো

1

@ ডোনমুসলি এবং এখন যে আমি এটি সম্পর্কে চিন্তা করেছি, এটি সম্ভবত কার্যকর হয় works 0 এবং একটি বিজোড় সূচক পাওয়ার

— ডেনিস

আধুনিক জেলিতে, এটি 7 বাইটে করা যেতে পারে:D*2/Pµ¡

— ডেনিস

5

হাস্কেল, 67 64 বাইট

(>> = (==)) >> = অবধি। p.show একটি নামবিহীন ফাংশন হিসাবে ইনপুট হিসাবে কোনও পূর্ণসংখ্যা গ্রহণ করে এবং তার পাওয়ার ট্রেনটি ফেরত দেয়।

Zgarb ধন্যবাদ 3 বাইট সংরক্ষণ করা

p(x:y:r)=p[x]^p[y]*p r;p[]=1;p x=read x
(>>=(==))>>=until$p.show

— ডেমিয়েন
সূত্র

1

((==)=<<g)সংরক্ষণ দুই বাইট (\n->g n==n)।

— জাগারব

বাহ, আমি মোনাডের ((->) র) সাথে পরিচিত নই। কৌতুক জন্য ধন্যবাদ।

— ড্যামিয়েন

বিরাম চিহ্নের এই ব্যারেজটি (>>=(==))>>=সত্যিই ট্রেনের মতো দেখাচ্ছে!

— Andreï Kostyrka

4

পার্ল, 42 48 বাইট

এর জন্য +2 অন্তর্ভুক্ত করুন -lp(আপনি খুব ড্রপ করতে পারেন -lতবে আমি নিউলাইন পছন্দ করি)

STDIN এ ইনপুট দিয়ে চালান, যেমন

perl -lp powertrain.pl <<< 1234

powertrain.pl:

s/\B/1&pos?"**":"*"/eg until++$.>($_=eval)

(পুরানো পার্লসগুলিতে আপনি রেজেক্সের মধ্যে এবং অবধি স্থানও ফেলে দিতে পারেন)

এটি স্থির পয়েন্টটি পরিচালনা করতে সক্ষম হবে না 24547284284866560000000000তবে বড় মান কোনওভাবেই কাজ করবে না কারণ ততক্ষণে পার্ল তাত্পর্যপূর্ণ স্বরলিপিটিতে চলে গেছে।

উপরে সংস্করণ ফাস্ট আসলে কাজ (অধিকতম মধ্যে ইচ্ছা 2592সমস্ত নম্বর যে Perl সূচকীয় স্বরলিপি ব্যবহার না করেই উপস্থাপন করতে পারেন জন্য লুপ) যেহেতু প্রমান করা কোন ঠিক করা হয়েছে যে মধ্যবর্তী পয়েন্ট 2592এবং 24547284284866560000000000( https://oeis.org/A135385 )

এটি অবশ্য এখনও কিছু অপ্রমাণিত হিসাবে ধরে নেয়। নীতিগতভাবে এমন একটি হ্রাস হতে পারে যা X=10^7পদক্ষেপের চেয়ে বেশি গ্রহণ করে (এটি অনুমান করা হয় যে কোনও স্থির বিন্দু 16 টিরও বেশি পদক্ষেপ নেয় না, https://oeis.org/A133503 ) যার মান নীচে X(তবে উপরে 10^7) পরে যায় এবং তারপরে উপরে যায় আবার। যদি এটি হয় তবে আমাকে অবশ্যই এখানে ফিরে যেতে হবে:

s/\B/1&pos?"**":"*"/eg until$s{$_=eval}++||/-/

ব্যাখ্যা

কোডটি অঙ্কগুলির মধ্যে রেখে **এবং *(বিকল্প) কাজ করে

s/\B/1&pos?"**":"*"/eg

তাই 2592হয়ে 2**5*9**2এবং 12345হয়ে 1**2*3**4*5। এগুলি বৈধ পার্ল এক্সপ্রেশন যা দিয়ে মূল্যায়ন করা যেতে পারে

$_ = eval

( 0**0হয় 1Perl মধ্যে)। তারপরে কেবল একটি কাউন্টারের সাথে এটির একটি লুপ রাখুন যা এটির মেয়াদ শেষ হয়ে যায়। যেহেতু নির্ধারিত পয়েন্টগুলি ব্যতীত মানগুলি খুব দ্রুত নিচে নেমে যায় কাউন্টারের সত্যিকারের দিকে যাওয়ার সুযোগ পাওয়ার আগে পাওয়ার ট্রেন সিরিজ রূপান্তরিত হয়

— টন হসপেল
সূত্র

3

পাইথ, 25 18 11 16 বাইট

?<Q0Qu*F^McjGT2Q

এখানে চেষ্টা করুন!

7 জ্যাকেট থেকে সাহায্যের সাথে 14 বাইট সংরক্ষণ করা হয়েছে

ব্যাখ্যা

? <Q0Qu * F ^ McjGT2Q # Q = eval (ইনপুট)

? <Q0Q # ইনপুটটি যদি নেতিবাচক প্রত্যাবর্তন হয় Q
     u Q # নীচের ফাংশনটি প্রয়োগ করুন যতক্ষণ না আমরা একটি চক্রের কাছে পৌঁছান               
                   # আরম্ভের মান হ'ল Q এবং বর্তমান মান জি
           অঙ্কের তালিকায় jGT # বিভক্ত ইনপুট
          গ 2 # 2 জোড়ায় বিভক্ত
        Pair এম # প্রতিটি জোড়ার জন্য শক্তি গণনা করুন
      * F # সমস্ত শক্তির পণ্য গণনা করুন

— Denker
সূত্র

1

পাইথ কি মূলত পাইথনের একটি গল্ফড সংস্করণ, সামান্য পরিবর্তন ছাড়া?

— ক্লিষ্টিক

1

@ জাকুব ইঙ্গিতগুলির জন্য ধন্যবাদ! :) এখনও আমার জন্য খুব ভোরে ...

— ডেনকার

নিবন্ধ আপনি যদি এটি সম্পর্কে জানতে চান তবে ডক্সটিতে একবার দেখুন ।

— ডেনকার

সমস্যা নেই. ;-)

— জাকুবে

4

@ ডেরফেসপাইট পাইথন পাইথ শুরু হয়েছিল "সংক্ষিপ্ত পাইথন" হিসাবে, তবে এটি এখন সংজ্ঞাহীন বলে অভিহিত করবে। পাইথনটি পাইথন থেকে উল্লেখযোগ্যভাবে সরিয়ে নিয়েছে।

— মেগো

3

পাইথন 2, 111 বাইট

def p(n,b=0,o=''):
 if n<1:return n
 for c in str(n):o+=c+'**'[b:];b=~b
 j=eval(o+'1');return p(j)if j-n else j

ধারণাটি এমন একটি স্ট্রিং তৈরি করা হবে যেখানে অঙ্কগুলি অঙ্কগুলি nঅপারেশন দ্বারা পৃথক করা হয় যা বিকল্প *এবং **এবং পরে evalসেই স্ট্রিংয়ের মধ্যে থাকে। (অন্যান্য সমাধানগুলি একই ধারণাটি ব্যবহার করে; উদাহরণস্বরূপ টন হসপেলের পার্ল উত্তর দেখুন ))

সুতরাং, অপারেশন পিছনে পিছনে পিছনে পিছনে '**'[0:], যা হয় **, এবং '**'[-1:]যা ঠিক *।

যাইহোক, for-লুপের শেষে , স্ট্রিংটি একটি অপারেশন (এক বা অন্য) দিয়ে শেষ হয়, সুতরাং স্ট্রিংটি বোঝার জন্য আমাদের হয় শেষ অপারেশনটি ফেলে দেওয়া উচিত, অথবা অন্য একটি সংখ্যা যুক্ত করতে হবে।

ভাগ্যক্রমে, শেষে একটি সংযোজন 1কোনও অপারেশন শেষ কিনা তা কার্যকর হবে। (যদি আপনি চান, 1তবে গুণ এবং ক্ষয়ক্ষতি উভয়ই ডান দিক থেকে একতরফা পরিচয়। এটি বলার আর একটি উপায় হ'ল এটি সবার powertrain(n) == powertrain(10*n + 1)জন্য n>0))

অবশেষে, যদি ফলাফলগুলির ফলাফলটি evalইনপুটটির মতো হয় (দৈর্ঘ্য- 1চক্র হিসাবে), ফাংশনটি সমাপ্ত হয়। অন্যথায়, ফাংশন ফলাফল নিজেই কল। (এটি যে কোনও দৈর্ঘ্যের চক্রের জন্য চিরকাল স্থির থাকবে > 1, তবে ওপি'র মন্তব্য অনুসারে আমি ধরে নেওয়ার অনুমতি পাচ্ছি যে এরকম কোনও চক্র নেই))

(দ্রষ্টব্য: উপরের ব্যাখ্যাটি একক-অঙ্কের ধনাত্মক পূর্ণসংখ্যার জন্য কাজ করে, যেহেতু একক-অঙ্কের ইনপুট nসম্পূর্ণ হবে n**1যার ফলস্বরূপ এক- 1সাইকেলের ফলাফল ঘটবে However তবে, আমাদের অ-ধনাত্মক ইনপুট গ্রহণ করাও দরকার, সুতরাং শর্তে একটি শর্ত রয়েছে শর্ট সার্কিটগুলি শুরু করুন যদি ইনপুটটি কম হয় 1। তবে আমরা ইনপুটটি অ-নেতিবাচক হওয়ার নিশ্চয়তা দিলে আমরা সেই লাইনটি সরিয়ে ফেলতে পারি এবং 17 বাইট সংরক্ষণ করতে পারি))

— mathmandan
সূত্র

এটি পক্ষপাতদুষ্ট শোনায়, তবে ... পাইথন ২ হওয়ার জন্য উর্ধ্বে।

— ক্লিমেজিক

টুইটারে (আমার ধারণা এটি পাইথন 3

— তেও

3

জাভা 8, 265 244 229 বাইট

এটি আমার প্রথম উত্তর, তবে আমি এই সাইটটি কিছুক্ষণ পড়ছি এবং মনে করি আমি জানি আমি কী করছি। অন্তত এটি befunge এবং এসকিউএল মার ...

দুর্ভাগ্যক্রমে, অন্যান্য উত্তরের মতো, বড় জেনার কীভাবে পেতে পারে তার বিধিনিষেধে নির্মিত জাভা'র কারণে এইটি 24547284284866560000000000 এর জন্য কাজ করে না।

@ জ্যাকআ্যামমোকে ধন্যবাদ 36 টি বাইট সংরক্ষণ করা

public int p(int n){if(n<10)return n;int i=1,t=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){int a=(int)Math.pow(10,i);r[s-i++]=n%a/(a/10);}for(i=0;i<s-1;i++)t*=Math.pow(r[i],r[++i]);if(s%2==1)t*=r[s-1];return n==t?n:p(t);}

অবহেলিত ব্যাখ্যা

public int powertrain(int input){
    //handles negative and 1-digit cases
    if(input<10)return input;
    //initialize output variable       
    int total=1;
    // get "length" of number. Shorter than getting length of string representation
    int size=(int)Math.log10(input)+1;
    //initialize array to store digits
    int[] array=new int[size];
    //Now, because Java doesn't have support
    // for the "**" operation, and the way of turning
    // an integer into a string takes too many bytes,
    // I decided just to put every digit into an array with
    // math and iterate from there
    for(int i=1;i<=size;){
        int place=(int)Math.pow(10,i);
        //crazy math. Saved 1 byte by incrementing i when accessed
        array[size-i++]=input%place/(place/10);
    }
    for(int i=0;i<size-1;i++)
        //This is where the train happens.
        //Saved 1 byte by incrementing while accessing 
        //again, instead of i+=2 and i+1
        total*=Math.pow(array[i],array[++i]);
    //Make sure last number isn't left out if size is odd
    if(size%2==1)
        total*=array[size-1];
    //if we end up with same number, stop.
    //otherwise, keep recurring
    return input==total?input:powertrain(total);
}

— নীল
সূত্র

আপনার প্রথমটি যদি ... অন্যথায় if(n<10)return n;else{...}যুক্তিযুক্ত না যেহেতু অন্য কোনও ব্লকের সমস্ত কিছু কেবল তখনই চলত যখন এন <10 টি মিথ্যা থাকে। অন্যটি এবং 2 টি মিলে যাওয়া বন্ধনীগুলি সরিয়ে ফেলা আপনাকে 6 বাইট সংরক্ষণ করবে। আপনার শেষের সাথে একই রকম পরিস্থিতি রয়েছে যদি ... if(n==t)return n;else return p(t);অন্য 5 টি বাইট সংরক্ষণ করার জন্য অন্যটি এবং স্থানটি এর পরে সরিয়ে ফেলুন। আপনি যদি ট্রাইডিক অপারেটরটি ব্যবহার করেন তবে আপনি যদি আরও ছোট করে তুলতে পারেন তবে অন্যটি পছন্দ করুনreturn n==t?n:p(t);

— জ্যাক আম্মো

আপনি টি, এস, আর এবং লুপের একসাথে ঘোষণা করে আরও কয়েকটি বাইট (17 আমি মনে করি) সংরক্ষণ করতে পারিint t=i=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){...}for(i=0;...)...

— জ্যাক আম্মো

@ জ্যাকআ্যাম্মো আমি সচেতন ছিলাম না ভেরিয়েবলগুলি এর মতো ঘোষিত হতে পারে, আমাকে এটি চেষ্টা করতে হবে। আপনার সাহায্যের জন্য ধন্যবাদ!

— নীল

হ্যাঁ, আপনি অন্যটিকে আরম্ভ করার জন্য যদি একজনকে ব্যবহার করছেন তবে তাদের ঘোষণার ক্রমটি সম্পর্কে আপনাকে অবশ্যই সতর্কতা অবলম্বন করতে হবে (যেমন এর দৈর্ঘ্য নির্ধারণ করতে r কীভাবে ব্যবহার করে)

— জ্যাক আম্মো

স্বেচ্ছাসেবী সংখ্যক জন্য, আপনি জাভা এর বিগইন্টিজার ক্লাস ডক্স.উরাকল.com

— জ্যাক আম্মো

2

জাভাস্ক্রিপ্ট (ES6) 71

একটি পুনরাবৃত্তি ফাংশন, পুনরাবৃত্তি পাওয়া গেলে থামছে ping এটি দীর্ঘ লুপগুলির জন্য কাজ করতে পারে না (2 বা ততোধিক মান পুনরাবৃত্তি করে) তবে মনে হয় এটি ঘটতে পারে নি, কমপক্ষে জাভাস্ক্রিপ্ট সংখ্যা সংক্ষিপ্ততার সীমিত পরিসরে (17 ডিজিট)

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

পরীক্ষা

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

function go()
{
  v=+I.value
  R.textContent=f(v)
}  

go()

<input id=I value="1234"><button onclick="go()">Go</button>
<span id=R></span>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

যে নিস +'1'এক ঢিলে দুই পাখি মারা করুন!

— নীল

আপনি এটি ইতিমধ্যে তদন্ত করেছেন কিনা তা আমি জানি না তবে সবচেয়ে ভাল আমি যা করতে পারি replaceতা 1 বাইট দীর্ঘ ছিল:f=n=>`${n}1`.replace(/../g,([x,y])=>r*=Math.pow(x,y),r=1)&&n-r?f(r):n

— নীল

@ নীল আমি খুব চেষ্টা করেছি, তবে সেই টেম্পলেট স্ট্রিংটি একটি নতুন ধারণা ...

— edc65

1

গণিত, 77 বাইট

Times@@(If[#2<1,1,#^#2]&)@@@Partition[IntegerDigits@#,2,2,1,1]&~FixedPoint~#&

বেনামে ফাংশন। খুব জটিল নয়।

— LegionMammal978
সূত্র

তবুও, আমি কি এখনও একটি ব্যাখ্যা থাকতে পারি?

— ক্লিমিক

1

বেফঞ্জ 720 490 বাইট

আমাকে কখনই প্রতিকূল বিষয়টি বলবেন না তার পরে আরও কিছু করার জন্য প্রতিরোধ করতে পারেনি । সুতরাং, আমি আগেরটির "ASCII-fier" অনুকূলিত করেছি। এক্ষেত্রে আমি নির্দেশের পয়েন্টারটি পড়ার জন্য অঙ্কগুলি চালিয়ে যাওয়ার দরকার নেই, তাই আমি তাদের মানব পাঠযোগ্য করে তোলার চেষ্টা করিনি। সুতরাং এটি এখন একটি ডিজিটিফায়ার আরও।

আবার, যদি আপনি ছেলেরা কোনও ব্যাখ্যা চান, তবে আমাকে মন্তব্যগুলিতে জানুন, আমি কিছু সহায়ক বিবরণ তৈরি করার চেষ্টা করব। আপনি ইন্টারপ্লেটারে কোডটি পেস্ট করতে পারেন । আমি খুঁজে পেয়েছি যে 24547284284866560000000000 আউটপুট 0, তবে গ্রিডের একটি বিন্দু থেকে এত বড় মূল্য পাওয়ার ক্ষেত্রে এটি একটি সমস্যা বলে মনে হচ্ছে, কারণ আপনি চূড়ান্ত পদক্ষেপে সঠিক মানটি সঞ্চিত দেখতে পাচ্ছেন।

v                                                    //top row is used for "variables"
>&:0`#v_.@                                           //initialize the counter                          
v     <                           g01_v#-p01:  <     //on our way back to the digitifier, check if we're done
>::>210p>55+%:10g0p-55+/:v            >10g.@         //digitifier, creates a series of ASCII characters at the top line, one for each digit in the source
        ^p01+1g01    _v#:<
v1$$                  <                              //forget some remainders of the digitifier, put 1 on the stack as a base of calculation
                      v p0-1g01-1g0-1g01*g0g01<      //taking powers of each pair of digit
>10g2-!#v_10g1-!#v_  1>                10g1-0g|
^                                  p01-2g01  *<
        >10g0g*  >                             ^     //extra multiplication with last digit if the number of digits was odd

এই সংস্করণটি নেতিবাচক ইনপুটকে সমর্থন করে। এটি পূর্ববর্তী সংস্করণে একটি দুর্দান্ত উন্নতি, যদি আমি নিজেরাই বলি। কমপক্ষে 1 বাগ স্থির করা হয়েছিল এবং আকারটি হ্রাস পেয়েছে।

— rael_kid
সূত্র

নেতিবাচক সংখ্যার ইনপুট করতে জিনিসটির জন্য আরও কতগুলি বাইট লাগবে?

— ক্লিমিক

আমি সৎ হওয়ার ব্যাপারে নিশ্চিত নই। নেতিবাচক সংখ্যাগুলি নিয়ে এবং গ্রিডে কোথাও লিখতে আমার কিছু সমস্যা হয়েছিল। আমি আবার চেষ্টা করব।

— rael_kid

আমি আরও একটি বাগ খুঁজে পেয়েছি। আমি নেতিবাচক সংখ্যার জন্য সমর্থন যোগ করতে পরিচালিত করেছি। আমি শীঘ্রই একটি আপডেট পোস্ট করব! এটি সম্ভবত সমান পরিমাণ বাইট হবে, যেহেতু আমি পুরো গ্রিডটি গণনা করি।

— rael_kid

1

হাস্কেল, 100 79 77 বাইট

g x|x==h x=x|1<2=g$h x;h=i.map(read.(:[])).show;i[]=1;i[a]=a;i(a:b:c)=a^b*i c

গল্ফড নয়:

g x|x==h x=x|1<2=g$h x
h=i.map(read.(:[])).show
i[]=1
i[a]=a
i(a:b:c)=a^b*i c

এই ফাংশনটি ইনপুটটিকে অঙ্কগুলিতে বিভক্ত করে এবং এর মাধ্যমে কৌতুক করে i।

সম্পাদনা: কিছু টিপসের জন্য নিমিকে ধন্যবাদ।

— Renzeee
সূত্র

কয়েক টিপস: ক) i(a:[])=aহয় i[a]=a, খ) জন্য কোন প্রয়োজন max 1, কারণ 0^0 = 1Haskell, গ) প্রতিস্থাপন মধ্যে (:[])দিয়ে pure, ঘ) সরানো letমধ্যে gএকটি পৃথক ফাংশন মধ্যে এবং প্রতিস্থাপন if ... then ... elseরক্ষীদের সঙ্গেh=i.map(read.pure).show ; g x|x==h x=x|1<2=h x

— nimi

pureপ্রিলেডে নেই, তবে টিপসের বাকী অংশগুলি ধন্যবাদ, ধন্যবাদ। আমি প্রহরীদের সাথে এটি করার চেষ্টা করছিলাম, তবে ;গার্ডের আগে ব্যবহার শেষ হয়েছিল এবং এটি কার্যকর হয়নি, তবে এখন আমি জানি এটি কীভাবে কাজ করা উচিত।

— রেঞ্জি

pureবেস-৪.৮.২.০ নিয়ে আসে এমন প্রিলিওডে রয়েছে। কখন এটি চালু হয়েছিল জানি না। আপনি প্রয়োজন হবে না ( )যে i([a])=a।

— নিমি

1

গণিত, 74 বাইট

0~f~0=f[]=1
f@n_=n
f[a_,b_,c___]:=f[c]a^b
#//.i_/;i>0:>f@@IntegerDigits@i&

ব্যাখ্যা

এই সমাধানটি একটি সহায়ক ফাংশন ব্যবহার করে f, যা সংখ্যার অঙ্কগুলি আর্গুমেন্ট হিসাবে গ্রহণ করে এবং পাওয়ার ট্রেন অপারেশনটির একটি পুনরাবৃত্তি প্রয়োগ করে। শেষ লাইনটি একটি খাঁটি ফাংশন যা ফাংশনটি শোষণ করার জন্য তৈরি করা ReplaceRepeatedহয় (বা //.সংক্ষেপে), যা কোনও অভিব্যক্তির নিয়ম প্রয়োগ করে (এই ক্ষেত্রে #খাঁটি ফাংশনের যুক্তি ) যতক্ষণ না এটি পরিবর্তন হয় না। বিধিটি তার দশমিক অঙ্কগুলিতে প্রয়োগ করা i_/;i>0:>f@@IntegerDigits@iফাংশনটির সাথে অ-নেতিবাচক যে কোনও কিছুকে প্রতিস্থাপন করে f।

— মারফি
সূত্র

লাইন 2 কাজ করে না (ব্যবহার করুন :=)

— ক্যালকুলেটরফ্লাইন

ব্যাখ্যা, দয়া করে?

— ক্লিমিক

@ ক্যাটস আরেফ্লফী আমি আপনার লাইন ২ এর সমস্যাটি দেখতে পাচ্ছি না এটি আমার পক্ষে ভাল কাজ করে!

— মার্ফি

SetDelayed::write: Tag Times in n f[a_,b_,c___] is Protected. >>, Set::write: Tag Times in 1 f[n_] is Protected. >>যখন আমি :=বনাম ব্যবহার করি তখন দ্বিতীয় ত্রুটি অদৃশ্য হয়ে যায় =।

— ক্যালকুলেটরফ্লাইন

দুঃখিত, ত্রুটিটি পুনরুত্পাদন করতে পারে না। তবে আপনার আউটপুট ইঙ্গিত দেয় যে লাইন-ব্রেকগুলি সমস্যার একটি অংশ। দয়া করে ;লাইন-ব্রেকগুলির পরিবর্তে s এর সাথে সংস্করণটি ব্যবহার করে দেখুন:0~f~0=f[]=1;f@n_=n;f[a_,b_,c___]:=f[c]a^b;#//.i_/;i>0:>f@@IntegerDigits@i&

— মার্ফি

1

এমএটিএল , 21 বাইট

tt0>*:"V!UtQgv9L2#)^p

আউটপুট উত্পাদন করতে কয়েক সেকেন্ড সময় লাগতে পারে।

সম্পাদনা (30 জুলাই, 2016): লিঙ্কযুক্ত কোডটি ভাষার সাম্প্রতিক পরিবর্তনের সাথে খাপ খাইয়ে প্রতিস্থাপন 9Lকরে 1L।

এটি অনলাইন চেষ্টা করুন!

কোড কার্যকারিতা ব্যয় করে বাইট গণনা হ্রাস করতে এটি নিম্নলিখিত দুটি কৌশল ব্যবহার করে:

nএকটি চক্র পাওয়া না যাওয়া পর্যন্ত অপেক্ষা করার পরিবর্তে বার বার Iterate । এটি ওপির মন্তব্য অনুসারে গ্রহণযোগ্য।
একটি বিজোড় সংখ্যার জন্য 1চূড়ান্ত পাওয়ার ক্রিয়াকলাপ শেষ করতে একটি ফাইনাল যুক্ত করতে হবে। পরিবর্তে, 1সংখ্যার সংখ্যা হ'ল অঙ্কের সংখ্যা। এটি একটি সমান সংখ্যা নিশ্চিত করে, তাই সমস্ত পাওয়ার অপারেশন করা যেতে পারে (যদিও শেষগুলি অপ্রয়োজনীয় 1^1ক্রিয়াকলাপ হয়)।

কোড:

t         % implicitly take input x. Duplicate
t0>*      % duplicate. Is it greater than 0? Multiply. This gives 0 if input is negative,
          % or leaves the input unchanged otherwise
:         % Generate array [1,2,...,x]
"         % for each (repeat x times)
  V       %   convert x to string
  !       %   transpose into column char array
  U       %   convert each char into number
  tQg     %   duplicate. Add 1 so that no entry is zero. Convert to logical: gives ones
  v       %   concatenate vertically
  9L2#)   %   separate odd-indexed and even-indexed entries
  ^       %   element-wise power
  p       %   product of all entries
          % implicitly end for each
          % implicitly display

— লুইস মেন্ডো
সূত্র

উহ ... হি হে হেহ ... আমি যখন "সংখ্যার লুপ" বললাম তখন আমি বোঝাতে চেয়েছি এমন সংখ্যাগুলি - a, b, a, bবিজ্ঞাপন ইনফিনিটাম (একাধিক শব্দ)। যদি একটি শব্দটি পুনরাবৃত্তি হয়, তবে আপনার সেই সংখ্যাটি আউটপুট করা উচিত। সত্যিই যদি এটি পরিষ্কার না হত তবে দুঃখিত।

— ক্লিশিক

যদি একটি পদ পুনরাবৃত্তি হয়, আমি সেই সংখ্যাটি আউটপুট করছি। আমি ফলাফলটি বহু পুনরাবৃত্তির পরে আউটপুট করি

— লুইস মেন্ডো

ওহ, আমি এখন বুঝতে পেরেছি ... শুধু জিজ্ঞাসা করছি, এটির কতগুলি পুনরাবৃত্তি হবে (প্রায়)? কারণ আমি যখন ইনপুটটিতে টাইপ করি তখন 2592মনে হয় না যে বেশ কিছুক্ষণ আউটপুট হবে।

— ক্লিমেমিক

পুনরাবৃত্তির সংখ্যা হ'ল ইনপুট সংখ্যা, সুতরাং সেই ক্ষেত্রে 2592। হ্যাঁ, এটি কিছুক্ষণ সময় নেয়

— লুইস মেন্ডো

0

পাইথন 3, 169 161 বাইট

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s];s+='1'*(len(s)%2==1);r=1;
  for i,j in zip(s[::2],s[1::2]):r*=int(i)**int(j);s=str(r);
 return o[-1]

Ungoldfed

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s]
  s+='1'*(len(s)%2==1)
  r=1
  for i,j in zip(s[::2],s[1::2]):
   r*=int(i)**int(j)
  s=str(r)
 return o[-1]

ফলাফল

>>> [f(i) for i in ['135', '1234', '642', '2592', '-15']]
['5', '8', '2592', '2592', '-15']

— Erwan
সূত্র

@ পিটারটেলর স্থির!

— এরওয়ান

আপনি যদি একাধিক বিবৃতি একটি লাইনে রেখে দিতে পারেন তবে যদি আপনি সেগুলি আলাদা করে রাখেন তবে আপনি ;আপনার উদ্দেশ্য হ্রাসের স্থানটি সংরক্ষণ করুন। এছাড়াও আপনি একই লাইনটির জন্য লুপটির দেহটি রাখতে পারেন।

— ডেনকার

প্রস্তাবিত গল্ফিং:def f(s,o=[['1',s]["-"in s]],n=int): while s not in o: o+=[s];s+=1*(len(s)%2<1);r=1 for i,j in zip(s[::2],s[1::2]):r*=n(i)**n(j) s=str(r) return o[-1]

— ক্যালকুলেটরফ্লাইন

@CatsAreFluffy o=[['1',s]["-"in s]]ডিফল্ট যুক্তি আমার জন্য কাজ করে না, এটি একটি ত্রুটি বাড়াতে `গুলি defined` না

— Erwan

ওফ, পরের লাইনে o সরান।

— ক্যালকুলেটরফ্লাইন

0

ওরাকল এসকিউএল 11.2, 456 বাইট

WITH v(n,c,i,f,t)AS(SELECT:1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL UNION ALL SELECT DECODE(SIGN(c-i+1),-1,t,n),DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),DECODE(SIGN(c-i+1),-1,1,i+1),DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))FROM v,XMLTABLE(f)WHERE i<=c+2 AND:1>9)CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

আন golfed

WITH v(n,c,i,f,t) AS
(
  SELECT :1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL
  UNION ALL
  SELECT DECODE(SIGN(c-i+1),-1,t,n),
         DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),
         DECODE(SIGN(c-i+1),-1,1,i+1),
         DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),
         DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))
  FROM v,XMLTABLE(f) WHERE i<=c+2 AND :1>9 
)  
CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0
SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

v একটি পুনরাবৃত্ত ভিউ, পরামিতিগুলি

n: 2 সংখ্যার অংশে বিভক্ত করতে সংখ্যা

সি: 2 সংখ্যার অংশের সংখ্যা

i: গণনা করতে বর্তমান 2 ডিজিটের অংশ

f: স্ট্রিং * বিভাজক হিসাবে শক্তিগুলি সাথে যুক্ত করে

t: চ এর মূল্যায়ন

বর্তমান সংখ্যার সমস্ত অংশ সম্পন্ন হয়ে গেলে ডিক্যোডগুলি বিভাজন এবং গণনা করতে পরবর্তী সংখ্যাটিতে স্যুইচ করে।

এক্সএমএলটিবল (চ) একটি সিগনো "কলাম_মূল্য" ছদ্ম কলামে ফলাফল স্থাপন করে এটির মূল্যায়ন করে একটি এক্সপ্রেশন নেয়। এটি http://tkyte.blogspot.fr/2010/04/evaluating-expression- Like-calculator.html এর গল্ফযুক্ত সংস্করণ

সাইকাইলে চক্র সনাক্তকরণে ওরাকল বিল্ড এবং প্রস্থান শর্ত হিসাবে ব্যবহৃত হয়।

যেহেতু ফলাফলগুলির জন্য: 1 <10 হ'ল: 1 এবং ভি এই ক্ষেত্রেগুলির জন্য কোনও সারি দেয় না, তাই স্যুম মান হিসাবে NULL সহ একটি সারিকে চাপায়। এনভিএল প্রত্যাবর্তন করে: 1 সারিটি শূন্য হলে ফলাফল হিসাবে 1।

— Jeto
সূত্র

ব্যাখ্যা কোথায়?

— ক্লাইমিক

পাওয়ারট্রেইন সন্ধান করুন!

বিজয়ী (বেশ স্পষ্টতই) ডেনিস who, যিনি 10 বাইটের সাহায্যে জেলি ব্যবহার করেছিলেন!

জেলি, 15 14 12 10 বাইট

কিভাবে এটা কাজ করে

হাস্কেল, 67 64 বাইট

পার্ল, 42 48 বাইট

ব্যাখ্যা

পাইথ, 25 18 11 16 বাইট

ব্যাখ্যা

পাইথন 2, 111 বাইট

জাভা 8, 265 244 229 বাইট

জাভাস্ক্রিপ্ট (ES6) 71

গণিত, 77 বাইট

বেফঞ্জ 720 490 বাইট

হাস্কেল, 100 79 77 বাইট

গণিত, 74 বাইট

এমএটিএল , 21 বাইট

পাইথন 3, 169 161 বাইট

ফলাফল

ওরাকল এসকিউএল 11.2, 456 বাইট