'এক্স' এর বিবর্তন

15

প্রদত্ত হ'ল সর্বোচ্চ আকারের 5 গুণ 5 ক্ষেত্র সহ ভেরিয়েবল সাইজের একটি বোর্ড। প্রতিটি ক্ষেত্র ক্যান একটি 'এক্স' দিয়ে পূর্ণ হতে পারে। যদি এটি একটি 'x' দিয়ে ভরাট না হয় তবে এটি একটি 'ও' দিয়ে পূর্ণ হয়।

প্রতিটি বোর্ডের সূচনা অবস্থা দেওয়া হয় (নীচে দেখুন)। প্রতিটি বোর্ডের সাথে 10 রাউন্ড খেলতে হয় (সর্বাধিক, শর্তাবলী: নীচে দেখুন) এবং এক্স এর বিবর্তন অবশ্যই দেখতে হবে।

এক রাউন্ড নিম্নলিখিত পদ্ধতিতে কাজ করে:

  1. প্রতিটি 'এক্স' orthogonally সীমান্ত ক্ষেত্রগুলিতে ছড়িয়ে পড়ে, তবে নিজেই অদৃশ্য হয়ে যায়
  2. প্রতিবার দুটি 'এক্স' এক ক্ষেত্রে থাকে, তারা একে অপরকে নিরপেক্ষ করে

প্রতিটি রাউন্ডের সমস্ত 'এক্স' এর বিবর্তন একই সাথে ঘটতে হবে। উদাহরণ:

    o o o            o x o
    o x o     ->     x o x
    o o o            o x o

বিবর্তনের প্রতিটি রাউন্ডের সাথে আপনাকে দেখতে হবে যে বোর্ডটি 'x' খালি করে। এটি কি খালি নয়, একটি পুনরাবৃত্তি প্যাটার্ন উপস্থিত হতে পারে। যদি এটি না হয় তবে আমরা বিবর্তনের বিশ্লেষণটি ত্যাগ করি। অতিরিক্তভাবে আপনাকে প্রতিটি প্রারম্ভিক বোর্ডের জন্য সর্বাধিক শতাংশের ক্ষেত্রের মুদ্রণ করতে হবে (পুরো সংখ্যায় গোল করে)।

ইনপুট:

ইনপুট ডেটা এখানে পাওয়া যাবে (পাস্তবিন) এই ডেটাতে 100 টি শুরু করার অবস্থা রয়েছে। ইতিমধ্যে উল্লিখিত হিসাবে, বোর্ড আকারে পৃথক হয়। 1 থেকে 5 পর্যন্ত এন সংখ্যার সাথে সারিগুলির সংখ্যা বর্ণিত হয়, তারপরে এন সারিগুলির পরে কেবল 'x' এবং 'o' থাকে, প্রারম্ভিক প্যাটার্নটি উপস্থাপন করে। বোর্ডের প্রতিটি সারিতে 1 থেকে 5 টি ক্ষেত্র রয়েছে।

আউটপুট:

নিম্নলিখিত ফলাফলটি প্রতিটি প্রারম্ভিক বোর্ডের জন্য নিম্নলিখিত ফর্মের জন্য একটি মুদ্রিত সারি মুদ্রিত করতে হবে:

    Round {0-10}: {repetition/empty/giveup}, {0-100} percent maximum-fill

উদাহরণ:

উদাহরণ 1:

    Input: 2       Starting state: x o x
           xox                     x x
           xx

                          Round 1: x x o
                                   o x

                          Round 2: x o x
                                   o x

                          Round 3: o x o
                                   o o

                          Round 4: x o x   -> The pattern repeats:
                                   o x        It is the same as in round 2,
                                              therefore we stop. Maximum fill was
                                              in the starting state with four times 'x'
                                              of 5 fields altogether,
                                              so we have 4/5 = 80 %.

    Output: Round 4: repetition, 80 percent maximum-fill

উদাহরণ 2:

    Input: 1       Starting state: x x
           xx                      

                          Round 1: x x    ->  We already have a repetition, because
                                              the pattern is the same as in the starting
                                              state. The board is always filled 100 %.

    Output: Round 1: repetition, 100 percent maximum-fill

আট দিনের দিন পরে আমি বিজয়ী হিসাবে কয়েকটি চরিত্রের সাথে কাজের উত্তরটি চিহ্নিত করব। অতিরিক্তভাবে আমি 100 প্রারম্ভিক বোর্ডগুলির জন্য সঠিক আউটপুট পোস্ট করব (ইনপুট)।

আপনি আপনার পছন্দসই (প্রোগ্রামিং / স্ক্রিপ্টিং / যাই হোক না কেন) ভাষা ব্যবহার করতে পারেন।

আনন্দ কর!

পিএস: আপনার যদি প্রশ্ন থাকে তবে নির্দ্বিধায় জিজ্ঞাসা করুন।

পিপিএস: মূল নির্মাতাদের সম্মানের ক্ষেত্রে: জার্মান ভাষায় কথা বলতে সক্ষম লোকদের জন্য, প্রশ্নটি ক্লিক করবেন না যদি আপনি এখানে স্পিকারদের চান না তবে প্রশ্নটি নেওয়া হয়েছিল । যেহেতু চ্যালেঞ্জটি শেষ করার আনুষ্ঠানিক সময় শেষ হয়েছে, তাই আমি দেখতে চেয়েছিলাম যে কেউ একটি সংক্ষিপ্ত এবং মার্জিত সমাধান নিয়ে আসতে পারে কিনা।

22.04.2014:

চ্যালেঞ্জ শেষ! বিজয়ী স্বীকৃত হিসাবে চিহ্নিত সঠিক আউটপুট:

    Round 10: giveup, 50 percent maximum-fill
    Round 5: empty, 66 percent maximum-fill
    Round 1: repetition, 100 percent maximum-fill
    Round 1: empty, 100 percent maximum-fill
    Round 4: repetition, 100 percent maximum-fill
    Round 4: repetition, 70 percent maximum-fill
    Round 2: repetition, 60 percent maximum-fill
    Round 4: empty, 88 percent maximum-fill
    Round 10: giveup, 50 percent maximum-fill
    Round 5: repetition, 80 percent maximum-fill
    Round 10: repetition, 80 percent maximum-fill
    Round 1: empty, 80 percent maximum-fill
    Round 3: repetition, 60 percent maximum-fill
    Round 4: repetition, 48 percent maximum-fill
    Round 9: empty, 41 percent maximum-fill
    Round 10: giveup, 92 percent maximum-fill
    Round 10: giveup, 53 percent maximum-fill
    Round 10: giveup, 66 percent maximum-fill
    Round 6: repetition, 50 percent maximum-fill
    Round 10: giveup, 88 percent maximum-fill
    Round 10: giveup, 76 percent maximum-fill
    Round 10: giveup, 68 percent maximum-fill
    Round 10: giveup, 40 percent maximum-fill
    Round 10: giveup, 100 percent maximum-fill
    Round 10: giveup, 71 percent maximum-fill
    Round 2: empty, 81 percent maximum-fill
    Round 6: repetition, 36 percent maximum-fill
    Round 10: giveup, 61 percent maximum-fill
    Round 10: giveup, 60 percent maximum-fill
    Round 4: repetition, 66 percent maximum-fill
    Round 10: giveup, 72 percent maximum-fill
    Round 3: empty, 80 percent maximum-fill
    Round 10: giveup, 50 percent maximum-fill
    Round 10: giveup, 83 percent maximum-fill
    Round 7: repetition, 37 percent maximum-fill
    Round 9: repetition, 85 percent maximum-fill
    Round 5: repetition, 40 percent maximum-fill
    Round 5: repetition, 60 percent maximum-fill
    Round 4: empty, 80 percent maximum-fill
    Round 10: giveup, 60 percent maximum-fill
    Round 4: repetition, 46 percent maximum-fill
    Round 6: repetition, 42 percent maximum-fill
    Round 10: giveup, 72 percent maximum-fill
    Round 4: repetition, 70 percent maximum-fill
    Round 4: repetition, 80 percent maximum-fill
    Round 6: repetition, 50 percent maximum-fill
    Round 4: repetition, 56 percent maximum-fill
    Round 10: giveup, 60 percent maximum-fill
    Round 10: giveup, 54 percent maximum-fill
    Round 10: giveup, 66 percent maximum-fill
    Round 2: repetition, 40 percent maximum-fill
    Round 2: repetition, 40 percent maximum-fill
    Round 6: repetition, 75 percent maximum-fill
    Round 7: empty, 85 percent maximum-fill
    Round 10: giveup, 50 percent maximum-fill
    Round 6: repetition, 70 percent maximum-fill
    Round 2: empty, 66 percent maximum-fill
    Round 1: empty, 66 percent maximum-fill
    Round 3: empty, 100 percent maximum-fill
    Round 3: empty, 66 percent maximum-fill
    Round 8: repetition, 42 percent maximum-fill
    Round 1: empty, 60 percent maximum-fill
    Round 2: repetition, 100 percent maximum-fill
    Round 2: repetition, 83 percent maximum-fill
    Round 4: repetition, 66 percent maximum-fill
    Round 6: repetition, 75 percent maximum-fill
    Round 4: empty, 66 percent maximum-fill
    Round 10: giveup, 61 percent maximum-fill
    Round 10: giveup, 56 percent maximum-fill
    Round 4: empty, 66 percent maximum-fill
    Round 6: repetition, 33 percent maximum-fill
    Round 3: empty, 57 percent maximum-fill
    Round 3: repetition, 100 percent maximum-fill
    Round 6: repetition, 73 percent maximum-fill
    Round 10: giveup, 50 percent maximum-fill
    Round 6: repetition, 50 percent maximum-fill
    Round 10: giveup, 73 percent maximum-fill
    Round 5: empty, 80 percent maximum-fill
    Round 10: giveup, 61 percent maximum-fill
    Round 3: repetition, 53 percent maximum-fill
    Round 10: giveup, 33 percent maximum-fill
    Round 10: giveup, 80 percent maximum-fill
    Round 10: giveup, 63 percent maximum-fill
    Round 10: giveup, 70 percent maximum-fill
    Round 10: giveup, 84 percent maximum-fill
    Round 7: repetition, 70 percent maximum-fill
    Round 10: repetition, 57 percent maximum-fill
    Round 10: giveup, 55 percent maximum-fill
    Round 6: repetition, 36 percent maximum-fill
    Round 4: repetition, 75 percent maximum-fill
    Round 10: giveup, 72 percent maximum-fill
    Round 10: giveup, 64 percent maximum-fill
    Round 10: giveup, 84 percent maximum-fill
    Round 10: giveup, 58 percent maximum-fill
    Round 10: giveup, 60 percent maximum-fill
    Round 10: giveup, 53 percent maximum-fill
    Round 4: repetition, 40 percent maximum-fill
    Round 4: empty, 40 percent maximum-fill
    Round 10: giveup, 50 percent maximum-fill
    Round 10: giveup, 68 percent maximum-fill
code-golf 
— plocks
সূত্র
কোড-গল্ফ বা কোড-চ্যালেঞ্জ দুটি হিসাবে ট্যাগ করুন তবে দুটি নয়। (এই ক্ষেত্রে এটি কোড-গল্ফ হওয়া উচিত)।
— ব্যবহারকারী 80551
1
কারও এটিকে একটি ভাল সংজ্ঞায়িত সেলুলার অটোমেটনে পরিবর্তন করা উচিত। :-)
— জাস্টিন

উত্তর:

4

পার্ল, 308, 304, 305, 293, 264 , 262

সম্পাদনা করুন: সাম্প্রতিক সম্পাদনার পরে একটি বাগ ক্রিপ্ট হয়ে খালি বোর্ডগুলির জন্য ভুল আউটপুট সৃষ্টি করে (পরীক্ষার স্যুট আউটপুট ঠিক ছিল)। থেকেRound 0 প্রদত্ত আউটপুট বিন্যাসের অর্থ কেবলমাত্র ইনপুটটিতে ফাঁকা বোর্ড থাকতে পারে (যদিও কোনও টেস্ট স্যুটে নেই), তাই বাগটি ঠিক করতে হয়েছিল। কুইক ফিক্স মানে বাইট কাউন্ট বৃদ্ধি (1 দ্বারা, আসলে) - অবশ্যই কোনও বিকল্প নয়। অতএব, আমি এটি আরও কিছুটা গল্ফ করতে হয়েছিল।

চালান -p(+1 গণনায় যোগ করা হয়েছে), STDIN থেকে পড়ে। rবিকল্প পরিবর্তনের কারণে 5.014 প্রয়োজন ।

(@a,%h,$m)=('',map<>=~y/ox\n/\0!/rd,1..$_);for$n(0..10){$_="Round $n: ".($h{$_="@a"}++?repetition:(($.=100*y/!///y/ //c)<$m?$.:$m=$.)?giveup:empty).", $m percent maximum-fill\n";@a=/g/?map{$_=$a[$i=$_];y//!/cr&(s/.//r.P^P.s/.$//r^$a[$i+1]^$a[$i-1])}0..$#a:last}

অর্থাত

# '-p' switch wraps code into the 'while(<>){....}continue{print}' loop, 
# which reads a line from STDIN into $_, executes '....' and prints contents 
# of $_. We use it to read board height and print current board's result.

# First line reads board's state into @a array, a line per element, at the same 
# time replacing 'o' with 'x00', 'x' with '!' and chomping trailing newlines. 
# '!' was chosen because it's just like 'x01' except 5th bit (which is not important)
# but saves several characters in source code.

# Note: array is prepended with an empty line, which automatically remains in this 
# state during evolution, but saves us trouble of checking if actual (any non-empty)
# line has neighboring line below.

# %h hash and $m hold seen states and maximum fill percentage for current board,
# they are initialized to undef i.e empty and 0.

(@a,%h,$m)=('',map<>=~y/ox\n/\0!/rd,1..$_);

# /
# Then do required number of evolutions:

for$n(0..10){

# Stringify board state, i.e. concatenate lines with spaces ($") as separators.
# Calculate fill percentage - divide number of '!' by number of non-spaces. 
# Note: using $. magick variable automatically takes care of rounding.
# Construct output string. It's not used if loop gets to next iteration. 
# Check if current state was already seen (at the same time add it to %h) 
# and if fill percentage is 0.

$_="Round $n: "
    .($h{$_="@a"}++?repetition:(($.=100*y/!///y/ //c)<$m?$.:$m=$.)?giveup:empty)
    .", $m percent maximum-fill\n";

# /
# Next is funny: if output string contains 'g' (of 'giveup' word), then evolve 
# further, otherwise break-out of the loop.

    @a=/g/
        ?map{

# Do evolution round. Act of evolution for a given line is none other than 
# XOR-ing 4 strings: itself shifted right, itself shifted left, line above, line 
# below. Result of this operation is truncated to original length using bitwise '&'. 
# Note, when shifting string right or left we prepend (append) not an ascii-0, 
# but 'P' character. It's shorter, and 4th and 6th bits will be annihilated anyway.

            $_=$a[$i=$_];
            y//!/cr
            &(s/.//r.P
            ^P.s/.$//r
            ^$a[$i+1]
            ^$a[$i-1])
        }0..$#a
        :last
}
— user2846289
সূত্র
বাহ, এত দ্রুত একটি সমাধান। আমি অবাক। যেহেতু আমি পার্লের সাথে পরিচিত নই (যদিও আমি এটি ইনস্টল করেছি) তাই কীভাবে আমি আমার ইনপুট ডেটা দিয়ে আপনার স্ক্রিপ্টটি শুরু করব?
— 16
2
@ দেওয়ানলোপার, উদাহরণস্বরূপ, perl -p x.pl < input.txtযদি কোনও ফাইলে ডেটা থাকে, বা perl -p x.plএকক প্রবেশ পরীক্ষা করার জন্য লাইনে ফিড লাইন থাকে ( ctrl-D( ctrl-Z) দিয়ে শেষ )। আপনার পার্লটি আরও 5.014নতুন কিনা তা পরীক্ষা করে দেখুন ।
— ব্যবহারকারী 2846289
ধন্যবাদ ভাদিমআর, এখন এটি চলছে। তবে মুদ্রিত পূরণের শতাংশ সম্পর্কে আমার দুটি লাইনে আলাদা ফলাফল রয়েছে। তবে এটি গোলাকার ত্রুটি হতে পারে।
— পকেট করেছে
1
@ দেওয়ানলোপার, দুঃখিত, এটি আমার ত্রুটি, শতাংশটি আগের পুনরাবৃত্তির থেকে নেওয়া হয়েছে। আমি শীঘ্রই এটি ঠিক করব।
— ব্যবহারকারী 2846289
1
বাগ ঠিক করা, + কিছু বাইট ফেলে দেওয়া হয়। লিঙ্কযুক্ত সাইট থেকে পরীক্ষার ফলাফলগুলি মিলে। প্রযুক্তিগতভাবে, 11 টি রাউন্ড চালানো হয় তবে শেষ রাউন্ডের অবস্থা পরীক্ষা করা হয় না বা ব্যবহৃত হয় না। এটা সব বংশবৃদ্ধির জন্য। আমি 1 \n oইনপুট ধরতে শুরুতে লুপ ব্রেকিং শর্ত রেখেছি ।
— ব্যবহারকারী 2846289
3

সি # - 1164 অক্ষর

কোড-গল্ফে এটি আমার প্রথম অংশগ্রহণ তাই দয়া করে উপভোগ করুন ;-)

আমি জানি, আমি সেরা ফলাফল থেকে দূরে আছি - উপায় দ্বারা সত্যিই আশ্চর্যজনক!

তবে আমি ভেবেছিলাম যে আমি আমার সমাধানটি # তে ভাগ করে নেব।

using System;using System.Collections.Generic;using System.IO;using System.Linq;using System.Net;class Program{static void Main(string[] args){new WebClient().DownloadFile("http://mc.capgemini.de/challenge/in.txt",@"D:\in.txt");var a=File.ReadAllLines(@"D:\in.txt");int l=0;while(l<a.Length){int n=Int32.Parse(a[l]);var b=a.Skip(l+1).Take(n).ToArray();var f=new List<string[]>{b};var d=0;string g=null;while(d<10){var s=f.Last();if(s.All(e=>e.All(c=>c=='o'))){g="empty";break;}var h=new string[n];for(int r=0;r<n;r++){var k="";for(int c=0;c<b[r].Length;c++){int x=0;try{if(s[r][c-1]=='x')x++;}catch{}try{if(s[r][c+1]=='x')x++;}catch{}try{if(s[r-1][c]=='x')x++;}catch{}try{if(s[r+1][c]=='x')x++;}catch{}k+=((x%2)==1)?'x':'o';}h[r]=k;}d++;f.Add(h);var w=false;for(int i=0;i<f.Count-1;i++){var m=f[i];if (!h.Where((t,y)=>t!=m[y]).Any())w=true;}if(w){g="repetition";break;}}if(d==10&&g==null)g="giveup";File.AppendAllLines(@"D:\out.txt",new[]{string.Format("Round {0}: {1}, {2} percent maximum-fill",d,g,f.Select(z=>{int t=0;int x=0;foreach(var c in z.SelectMany(s=>s)){t++;if(c=='x')x++;}return(int)Math.Floor((double)x/t*100);}).Concat(new[]{0}).Max())});l=l+n+1;}}}

সম্পূর্ণরূপে ব্যবহারের দিকনির্দেশগুলি ইতিমধ্যে 97 টি অক্ষর গণনা করেছে - তাই আমি মনে করি 200 টিরও কম অক্ষরের মধ্যে বাকী অংশটি অর্জন করা বেশ কঠিন হতে চলেছে।

এটি বেশিরভাগ জায়গায় LINQ ব্যবহার করে মোটামুটি পুনরাবৃত্তি পদ্ধতি approach আমি ইনপুট ফাইল ডাউনলোড করা এবং কোডে আউটপুট ফাইল লেখাও অন্তর্ভুক্ত করেছিলাম।

এখানে আরও একটি পাঠযোগ্য সংস্করণ:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;

class Program
{
    static void Main(string[] args)
    {
        // Download the file
        new WebClient().DownloadFile("http://mc.capgemini.de/challenge/in.txt", @"D:\in.txt");
        // Read of lines of downloaded file
        var a = File.ReadAllLines(@"D:\in.txt");
        // Line index in input file
        int l = 0;
        while (l < a.Length)
        {
            // Parse number of rows to take
            int n = Int32.Parse(a[l]);

            // Take the n rows
            var b = a.Skip(l + 1).Take(n).ToArray();
            var f = new List<string[]> { b };
            var d = 0;
            string g = null;
            while (d < 10)
            {
                // Last state consists only of o's? -> 
                var s = f.Last();
                if (s.All(e => e.All(c => c == 'o')))
                {
                    g = "empty";
                    break;
                }
                // In h we will build up the new state
                var h = new string[n];
                // Loop through all rows of initial state
                for (int r = 0; r < n; r++)
                {
                    // This is our new row we will build up for the current state
                    var k = "";
                    // Count number of orthogonal adjacent x's
                    // And catch potential OutOfRangeExceptions
                    for (int c = 0; c < b[r].Length; c++)
                    {
                        int x = 0;
                        try { if (s[r][c - 1] == 'x') x++; }
                        catch { }
                        try { if (s[r][c + 1] == 'x') x++; }
                        catch { }
                        try { if (s[r - 1][c] == 'x') x++; }
                        catch { }
                        try { if (s[r + 1][c] == 'x') x++; }
                        catch { }
                        // Is number of adjacent x's odd? -> character will be 'x'
                        // otherwise -> 'o'
                        k += ((x % 2) == 1) ? 'x' : 'o';
                    }
                    // Add the new row to the current state
                    h[r] = k;
                }
                // Increase round count
                d++;
                // Add the new state to our state collection
                f.Add(h);
                // Now check, whether it is a repetition by comparing the last state (h) with all other states
                bool w = false;
                for (int i = 0; i < f.Count - 1; i++)
                {
                    var m = f[i];
                    if (!h.Where((t, y) => t != m[y]).Any())
                        w = true;
                }
                if (w)
                {
                    g = "repetition";
                    break;
                }
            }
            // Check whether we reached maximum AND the last round wasn't a repetition
            if (d == 10 && g == null)
                g = "giveup";
            // Now we append the final output row to our text file
            File.AppendAllLines(@"D:\out.txt",
                new[]
                    {
                        string.Format("Round {0}: {1}, {2} percent maximum-fill",
                        d,
                        g,
                        // Here we select all rates of x's per state
                        // and then grab the maximum of those rates
                        f.Select(z =>
                            {
                                int t=0;
                                int x=0;
                                foreach (char c in z.SelectMany(s => s))
                                {
                                    t++;
                                    if(c=='x')
                                        x++;
                                }
                                return (int) Math.Floor((double) x / t *100);
                            }).Concat(new[] {0}).Max())
                    });
            // finally we shift our index to the next (expected) number n in the input file
            l = l + n + 1;
        }
    }
}
— বেন শ
সূত্র
1
সংক্ষিপ্ত, খাটো, বেন এর সমাধান। আপনি সি # পদগুলিতে সমাধানের এমন একটি মাইক্রো তৈরি করেছেন ...
— পল ফ্যাক্লাম
2

জে - 275 চর

ওহ, এই সমস্ত I / O নির্দিষ্টকরণ! শেষ পর্যন্ত জেসের পক্ষে এমন লজ্জাজনকভাবে বড় স্কোর। একটি পেছনের নিউলাইন দিয়ে STDIN এ ইনপুট নেয় এবং ধরে নেওয়া হয় যে ইনপুটটিতে কোনও গাড়ীর রিটার্ন নেই ( \r)। প্রশ্নটির নমুনা ইনপুট ফাইলটিতে এটি প্রয়োগের ফলাফল এখানে।

stdout;,&LF&.>}:(".@{~&0(('Round ',":@(#->/@t),': ',(empty`repetition`giveup{::~2<.#.@t=.11&=@#,0={:),', ',' percent maximum-fill',~0":>./)@(100*1&=%&(+/"1)_&~:)@,.@(a=:(a@,`[@.(e.~+.10<#@[)(_*_&=)+[:~:/((,-)(,:|.)0 1)|.!.0=&1){:)@,:@('ox'&i.^_:)@{.;$: ::]@}.)}.)];._2[1!:1]3

অবহেলিত: (আমি পরে আরও বিশদ এবং জে-নবাগত-বান্ধব ব্যাখ্যা যুক্ত করতে পারি explanation)

input   =: ];._2 [ 1!:1]3
convert =: 'ox'&i. ^ _:               NB. 'x'=>1  'o'=>0  else=>infinity
spread  =: ((,-)(,:|.)0 1) |.!.0 =&1  NB. x spreading outwards
cover   =: (_*_&=) + [: ~:/ spread    NB. collecting x`s and removing tiles not on board
iterate =: (iterate@, ` [ @. (e.~ +. 10<#@[) cover) {:
percent =: 100 * 1&= %&(+/"1) _&~:    NB. percentage of x at each step
max     =: 0 ": >./
stat    =: 11&=@# , 0={:              NB. information about the simulation
ending  =: empty`repetition`giveup {::~ 2 <. #.@stat   NB. how simulation ended
round   =: ": @ (# - >/@stat)         NB. round number
format  =: 'Round ', round, ': ', ending, ', ', ' percent maximum-fill',~ max
evolvex =: format @ percent@,. @ iterate@,: @ convert
joinln  =: ,&LF &.>
nlines  =: ". @ {~&0
remain  =: }.
stdout ; joinln }: (nlines (evolvex@{. ; $: ::]@}.) remain) input

$:অংশ আবেদন, ইনপুট উপর প্রধান অঙ্গ recurse (জে বিশ্লেষণ করতে একটি ভয়ঙ্কর অসুবিধাজনক ফর্ম) তোলে @প্রতিটি বিভাগে উপর ডেজি-শৃঙ্খল। nlinesপরবর্তী বোর্ডের জন্য রেখার সংখ্যাটি সন্ধান করে।

প্রতিটি বোর্ডে ( evolvex) অ্যাকশনটি ঝরঝরে: iterate( aগল্ফ বলা হয়) সিমুলেশনের প্রতিটি পুনরাবৃত্তির একটি তালিকা তৈরি করে যতক্ষণ না আমরা আগে বা খুব বেশি পদক্ষেপে দেখা কিছুকে আঘাত করি। তারপরে percent@,.প্রতিটি ফলাফলে ভরাট স্কোয়ারের শতাংশ গণনা করে এবং সিমুলেশনটি কীভাবে শেষ হয়েছিল, কোনটি শতাংশটি সবচেয়ে বড় এবং এই জাতীয় স্ট্রিংয়ে ফর্ম্যাট করার আগে formatকিছু পরিসংখ্যান ( যা গল্ফ statনামে পরিচিত t) চালায়।

অবশেষে, পৃথক বোর্ডের আউটপুটগুলিতে একটি নতুন লাইনের দ্বারা পৃথক স্ট্রিংয়ের সাথে যোগ }:দেওয়ার আগে কিছু আবর্জনার যত্ন নেয় ; joinln।

— algorithmshark
সূত্র
হাই অ্যালগরিদমশর্ক, আপনি দয়া করে ইনপুট প্যারামিটার হিসাবে একটি টেক্সট ফাইল দিয়ে কমান্ড লাইন থেকে আপনার স্ক্রিপ্টটি কীভাবে শুরু করবেন সে সম্পর্কে নির্দেশাবলী সরবরাহ করতে পারেন? ধন্যবাদ!
— প্যাক করে
1
@ দেওয়ানলোপার যা আমাকে মনে করিয়ে দেয়, আমি এটিকে আউটপুট স্টাডাউটে পরিণত করতে ভুলে গেছি; সংশোধন যোগ। এটা তোলে আদর্শ উপায় এখন কাজ করা উচিত: jconsole golf.ijs < input.txt।
— অ্যালগরিদমশর্ক
তথ্যের জন্য ধন্যবাদ, তবে এটি এখনও আপনার কোড পরিবর্তিত হয়েও আমার জন্য কোনও আউটপুট মুদ্রণ করে না।
— প্লট করে
@ দেওয়ানলোপার সমস্যাটি আমার vনাম হিসাবে ব্যবহার হিসাবে দেখা যাচ্ছে, যা কারণেই স্ক্রিপ্টগুলিতে অনুমোদিত নয়। (আমি আরইপিএলে স্নিপেটটি চালিয়ে যাচ্ছিলাম)) এটি পরিবর্তন করে aকাজ করার জন্য মনে হচ্ছে।
— অ্যালগরিদমশর্ক
@ অ্যালগোশার্ক এটি আমার হতে পারে তবে আমি এখনও কিছু মুদ্রণ করতে পারি না।
— পকেট করে
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.