xkcd চ্যালেঞ্জ: "[x] রঙের পর্দার শতাংশ"


57

সুতরাং আমি মনে করি আমরা সম্ভবত এই এক্সকেসিডি কমিকটি দেখেছি :

http://imgs.xkcd.com/comics/self_description.png:

এটি হয় খুব সাধারণ বা খুব কঠিন হতে পারে, আমি নিশ্চিত নই। তবে চ্যালেঞ্জটি হ'ল যে কোনও ভাষায় এমন একটি প্রোগ্রাম তৈরি করা যাতে একটি উইন্ডো তৈরি হয় যাতে কমপক্ষে 2 টি রঙ থাকে এবং ইংরেজী শব্দগুলিতে প্রদর্শিত হয় যে পর্দার প্রতিটি শতাংশ প্রতিটি রঙের কত শতাংশ।

প্রাক্তন। সবচেয়ে সহজ সমাধানটি হ'ল কালো বর্ণ সহ একটি সাদা পটভূমি যা "এই চিত্রের শতাংশ যেটি কালো: [x]% read" পড়েছে white সাদা রঙের এই চিত্রটির শতাংশ: [y]% "

আপনি যতটা পাগল বা আপনি চান হিসাবে সহজ যেতে পারেন; সরল পাঠ্যটি একটি বৈধ সমাধান তবে আপনি যদি এক্সকেসিডি কমিকের মতো আকর্ষণীয় চিত্রগুলি তৈরি করেন তবে এটি আরও ভাল! বিজয়ী সবচেয়ে মজাদার এবং সৃজনশীল সমাধান যা সর্বাধিক ভোট পায়। সুতরাং এগিয়ে যান এবং মজাদার এবং xkcd এর যোগ্য কিছু করুন! :)

তাই আপনি কি মনে করেন? মজার চ্যালেঞ্জের মতো শোনাচ্ছে? :)

আপনার উত্তর চলমান আপনার প্রোগ্রামের একটি স্ক্রিনশট অন্তর্ভুক্ত করুন :)


6
একটি "এই প্রোগ্রামটিতে 64 এ, 4 বি, ... এবং উত্স কোডে 34 টি ডাবল উদ্ধৃতি রয়েছে" প্রোগ্রামটি আরও আকর্ষণীয় হবে :-)
জন ডিভোরাক

2
ঠিক আছে ... উদ্দেশ্যজয়ী মানদণ্ডগুলি কী কী? কোনও নির্দিষ্ট আউটপুট বৈধ কিনা আপনি কীভাবে নির্ধারণ করবেন? এটি কি যথেষ্ট যে এটি সত্য এবং এটি নিজের সম্পত্তিটিকে সংখ্যাগতভাবে বর্ণনা করে?
জন ডিভোরাক

@ জনডভোরাক ওহ, এটি একটি ভাল! বর্ণমালা প্রোগ্রামটি আসলে আমাকে মূলত এটি সম্পর্কে ভাবতে বাধ্য করেছিল, তবে আমি এতে উত্স কোড উপাদান যুক্ত করার বিষয়টি বিবেচনা করি নি! আপনার এটি প্রশ্ন হিসাবে পোস্ট করা উচিত :) হ্যাঁ, এটি যথেষ্ট যে এটি সত্য এবং নিজের বিবরণ দিয়েছেন। হুম, আপনি ঠিকই বলেছেন, আমি কীভাবে চূড়ান্ত ফলাফলগুলি সঠিক প্রমাণ করব তা নিয়ে ভাবিনি। আমি মনে করি ফলাফলের চিত্রটিতে প্রতিটি রঙের সমস্ত পিক্সেল গণনা করার জন্য আমার একটি উপায় প্রয়োজন হবে I আমি এখন এটি তদন্ত করতে যাব। (দুঃখিত আমার প্রথম প্রশ্নটিতে সমস্যা ছিল ... আমি চেষ্টা করেছি তবে আমি এতে নতুন! ধন্যবাদ :))
WendiKidd

যদি সত্যতা এবং স্ব-উল্লেখটি পর্যাপ্ত মানদণ্ড হয় তবে এখানে আমার গল্ফস্ক্রিপ্ট প্রতিযোগী: "/.*/"(পড়ুন: [উত্স কোড] কোনও নতুন লাইন ধারণ করে না)
জন ডভোরাক

@ জনডভোরাক হুম, আমি আপনার কোডটি এখানে চেষ্টা করেছিলাম এবং আউটপুটটি কোট ব্যতীত কোডের মতোই ছিল। দুঃখিত, আমি এই অধিকারটি ব্যাখ্যা করছি না, দুঃখিত। কমপক্ষে 2 টি রঙ উত্পন্ন হতে হবে এবং একটি ইংরেজি বাক্যের কোনও আকারে আউটপুটে অবশ্যই সত্য শব্দ তৈরি করতে হবে যা বর্ণের প্রতিটি রঙের কত শতাংশের স্ক্রিন দখল করে তা বর্ণনা করে। সম্ভবত এটি একটি নির্বোধ ধারণা ছিল। আমি ভেবেছিলাম এটি মজাদার হবে তবে এটি অনুশীলনে কাজ করবে না :)
WendiKidd

উত্তর:


35

বেদারুজাতীয় বৃক্ষবিশেষ

কেউ এই লুপোলটি এখনও ব্যবহার করতে দেখেনি: ডেমো

import Color exposing (hsl)
import Graphics.Element exposing (..)
import Mouse
import Text
import Window

msg a = centered <| Text.color a (Text.fromString "half the screen is this color")

type Pos = Upper | Lower

screen (w,h) (x,y) = 
  let (dx,dy) = (toFloat x - toFloat w / 2, toFloat h / 2 - toFloat y)
      ang = hsl (atan2 dy dx) 0.7 0.5
      ang' = hsl (atan2 dx dy) 0.7 0.5
      box c = case c of
        Upper -> container w (h // 2) middle (msg ang) |> color ang'
        Lower -> container w (h // 2) middle (msg ang') |> color ang
  in  flow down [box Upper, box Lower]

main = Signal.map2 screen Window.dimensions Mouse.position

এখানে চিত্র বর্ণনা লিখুন


3
দুর্দান্ত লুফোল!
টিমটেক

আমি এটা ভালোবাসি!!! অন্তত এখন জন্য, আপনি নিখুঁত চালাক পয়েন্ট জন্য চেকমার্ক পাবেন। এটা ভালবাসা!
WendiKidd

13
সর্বোত্তম অংশটি হ'ল, আমি এখনও নিশ্চিত নই যে কোন বাক্যটি কোন রঙের বিষয়ে কথা বলছে।
ব্রিলিয়ান্ড

3
view sourceShare-elm.com দ্বারা সেখানে রাখা এবং কম্পাইল জাতীয় / HTML এর অংশ নয়।
hoosierEE

1
@ এমএল এটি "এটি" শব্দের সুযোগের উপর নির্ভর করে। জাভাস্ক্রিপ্ট প্রোগ্রামারদের বুঝতে ...
hoosierEE

37

এইচটিএমএল সহ জাভাস্ক্রিপ্ট

আমি মূল কমিকটি আরও স্পষ্টভাবে পুনরুত্পাদন করার চেষ্টা করেছি। এইচটিএমএল 2 ক্যানভাস লাইব্রেরি ব্যবহার করে একটি স্ক্রিনশট নেওয়া হয়েছে। সংখ্যাগুলি বারবার গণনা করা হয়, যাতে আপনি উইন্ডোটির আকার পরিবর্তন করতে পারেন বা এমনকি রিয়েল টাইমে পৃষ্ঠায় কিছু যুক্ত করতে পারেন।

এটি অনলাইনে ব্যবহার করে দেখুন: http://copy.sh/xkcd-688.html

এখানে একটি স্ক্রিনশট:

এখানে চিত্র বর্ণনা লিখুন

<html contenteditable>
<script src=http://html2canvas.hertzen.com/build/html2canvas.js></script>
<script>
onload = function() {
    setInterval(k, 750);
    k();
}
function k() {
    html2canvas(document.body, { onrendered: t });
}
function t(c) {
    z.getContext("2d").drawImage(c, 0, 0, 300, 150);
    c = c.getContext("2d").getImageData(0, 0, c.width, c.height).data;

    for(i = y = 0; i < c.length;) 
        y += c[i++];

    y /= c.length * 255;

    x.textContent = (y * 100).toFixed(6) + "% of this website is white";

    q = g.getContext("2d");

    q.fillStyle = "#eee";
    q.beginPath();
    q.moveTo(75, 75);
    q.arc(75,75,75,0,7,false);
    q.lineTo(75,75);
    q.fill();

    q.fillStyle = "#000";
    q.beginPath();
    q.moveTo(75, 75);
    q.arc(75,75,75,0,6.28319*(1-y),false);
    q.lineTo(75,75);
    q.fill();
}
</script>
<center>
<h2 id=x></h2>
<hr>
<table><tr>
<td>Fraction of<br>this website<br>which is white _/
<td><canvas width=150 id=g></canvas>
<td>&nbsp; Fraction of<br>- this website<br>&nbsp; which is black
</table>
<hr>
0
<canvas style="border-width: 0 0 1px 1px; border-style: solid" id=z></canvas>
<h4>Location of coloured pixels in this website</h4>

নিস !! এক্সকেসিডি কমিকের সাথে মিলগুলি এবং আমি পাঠ্যটি পরিবর্তন করতে পারি। ঝরঝরে! : ডি
ওয়েন্দিকিড

1
চিত্তাকর্ষক কাজ ও
ইজাবেরে

নিফ্টি ... তবে আমি মনে করি এটি একটি "সমাধান" হতে স্থিতিশীল হতে হবে। এটি সম্পূর্ণরূপে চিন্তা করে নি - তবে অঙ্কের গ্লিফগুলির একটি সীমিত সেট থেকে অঙ্কন করার সময় স্বেচ্ছাসেবীর নির্ভুলতার জন্য কোনও সমাধান প্রয়োজন নেই বলে উচ্চতর নির্ভুলতায় সমাধান না করতে পারলে আপনাকে নির্ভুলতার পিছনে ফিরে যেতে হবে আপনি চেষ্টা করছেন আমি কল্পনা করেছি যে কোনও মনোস্পেস ফন্ট ব্যবহার করে যা আপনি কালো / সাদা পিক্সেলের প্রাক-গণনা করেন তাও প্রয়োজনীয় হবে।
ডঃ রেবমু

আপনি 3 টি রঙ ব্যবহার করছেন, তাই ধূসর জন্য শতাংশ কোথায়? ;)
এমএল

26

প্রসেসিং, 222 টি অক্ষর

http://i.imgur.com/eQzMGzk.png

আমি সর্বদা সেই কমিক স্ট্রিপের নিজস্ব সংস্করণটি তৈরি করতে চেয়েছিলাম! আমি এটি করার সবচেয়ে সহজ উপায় (কেবল?) উপায়টি ছিল পরীক্ষা এবং ত্রুটি - কিছু আঁকুন, গণনা করুন, আবার আঁকুন ...

এই প্রোগ্রামটি কয়েক সেকেন্ড পরে একটি নির্ভুল শতাংশের জন্য স্থির হয়। এটি খুব সুন্দর নয়, তবে এটি ইন্টারেক্টিভ ; আপনি উইন্ডোর আকার পরিবর্তন করতে পারেন এবং এটি পুনরায় গণনা শুরু হবে।

পাঠযোগ্যতার জন্য কিছু নতুন লাইন যুক্ত হয়েছে:

float s,S,n;
int i;
void draw(){
frame.setResizable(true);
background(255);
fill(s=i=0);
text(String.format("%.2f%% of this is white",S/++n*100),10,10);
loadPixels();
while(i<width*height)if(pixels[i++]==-1)s++;
S+=s/height/width;
}

এটি কেবল সাদা পিক্সেলের শতাংশ দেখায়; পাঠ্যের অ্যান্টিঅ্যালাইজিংয়ের কারণে, অ-সাদা পিক্সেলগুলি অগত্যা কালো নয়। এটি যত বেশি সময় চালাচ্ছে তার নিজেকে পুনরায় আকারে আপডেট করার প্রয়োজন হবে।

সম্পাদনা:

সুতরাং, এটি একটি কোড-চ্যালেঞ্জ; আমি বাছাই করে যাইহোক। পরে আমি কিছু ধরণের গ্রাফ যোগ করতে পারলাম, তবে সাধারণ নীতিটি একই থাকবে। মিথস্ক্রিয়াটি আমার মনে হয় ঝরঝরে অংশ।


খুব সুন্দর!! আমি মনে করি আপনি ইন্টারঅ্যাক্টিভিটির জন্য অতিরিক্ত ক্রেডিট পাবেন; আমি উইন্ডো আকার পরিবর্তন মজা ছিল! খুব দুর্দান্ত :) এবং আপনি আমার প্রথম প্রতিক্রিয়া! আমি জানি না যে কেউ খেলতে চায় কিনা, তাই ধন্যবাদ। তুমি আমার দিনটিকে মধুর করে দিলে. : ডি +1! (যদিও আমি কৌতূহলী, সময় বাড়ার সাথে সাথে কেন এটি ধীর হয়ে যায় এবং এটি সঠিক শতাংশে পৌঁছানোর কাছাকাছি আসে? কী ঘটছে সে সম্পর্কে আমি কেবল কৌতূহলী, আমি এই ভাষাটি আগে কখনও দেখিনি। আমি একটি এই সাইটের চারপাশে প্রচুর নতুন জিনিস
পোঁকছে

হেডডেস্ক বাদে আমি দুর্ঘটনাক্রমে +1 ক্লিক করতে ভুলে গেছি। এখন +1 ... হা হা। দুঃখিত!
ওয়েন্ডিকিড

1
আপনি আরও একটি ক্রিয়াকলাপ যোগ করতে পারেন যা ব্যবহারকারীদের মাউসের সাহায্যে এটির সাথে ইন্টারঅ্যাক্টিভিটি যুক্ত করার অনুমতি দেয়।
এজেম্যানসফিল্ড

7
হলি বক্সের ছায়া, ব্যাটম্যান
বোজ্যাংলেস

আপনি যদি গল্ফ করতে চান তবে আপনি এর background(-1)পরিবর্তে ব্যবহার করতে পারেনbackground(255)
ক্রিটিক্সি লিথোস

20

দুর্দান্ত চ্যালেঞ্জ। এখানে আমার সমাধান। আমি মূল কমিকের যতটা সম্ভব কাছাকাছি যাওয়ার চেষ্টা করেছি, এমনকি আমি xkcd ফন্টও ব্যবহার করেছি ।

এটি একটি ডাব্লুপিএফ অ্যাপ্লিকেশন, তবে আমি System.Drawingআঁকার অংশগুলি করতাম কারণ আমি অলস।

বেসিক ধারণা: ডাব্লুপিএফ-তে উইন্ডোজগুলি হয় Visuals, যার অর্থ তারা রেন্ডার করা যায়। আমি পুরো উইন্ডো উদাহরণটি একটি বিটম্যাপে রেন্ডার করছি, কালো এবং সম্পূর্ণ কালো বা সাদা (ফন্ট স্মুথিং এবং স্টাফের গ্রেগুলিকে উপেক্ষা করে) গণনা করব এবং এগুলি প্রতিটি তৃতীয় চিত্রের জন্য গণনা করব (প্রতিটি প্যানেলের জন্য)। তারপরে আমি এটি আবার টাইমার দিয়ে করি। এটি এক বা দুটি মধ্যেই ভারসাম্য অর্জন করে reaches

ডাউনলোড করুন:

মেগা সর্বদা আপনার ভাইরাস ইত্যাদির জন্য ডাউনলোড করা ফাইলগুলি পরীক্ষা করে দেখুন etc.

উপরের ফন্টটি আপনার সিস্টেমে ইনস্টল করতে হবে যদি আপনি এটি দেখতে চান তবে অন্যথায় এটি ডাব্লুপিএফ ডিফল্ট।

XAML:

<Window
 x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="xkcd: 688" Height="300" Width="1000" WindowStyle="ToolWindow">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="0.3*"/>
            <ColumnDefinition Width="0.3*"/>
            <ColumnDefinition Width="0.3*"/>
        </Grid.ColumnDefinitions>

        <Border BorderBrush="Black" x:Name="bFirstPanel" BorderThickness="3" Padding="10px" Margin="0 0 10px 0">
            <Grid>
                <Label FontSize="18" FontFamily="xkcd" VerticalAlignment="Top">Fraction of this window that is white</Label>
                <Label FontSize="18" FontFamily="xkcd" VerticalAlignment="Bottom">Fraction of this window that is black</Label>
                <Image x:Name="imgFirstPanel"></Image>
            </Grid>
        </Border>
        <Border Grid.Column="1" x:Name="bSecondPanel" BorderBrush="Black" BorderThickness="3" Padding="10px" Margin="10px 0">
            <Grid>
                <TextBlock FontSize="18" FontFamily="xkcd" VerticalAlignment="Top" HorizontalAlignment="Left">Amount of <LineBreak></LineBreak>black ink <LineBreak></LineBreak>by panel:</TextBlock>
                <Image x:Name="imgSecondPanel"></Image>
            </Grid>
        </Border>
        <Border Grid.Column="2" x:Name="bThirdPanel" BorderBrush="Black" BorderThickness="3" Padding="10px" Margin="10px 0 0 0">
            <Grid>
                <TextBlock FontSize="18" FontFamily="xkcd" VerticalAlignment="Top" HorizontalAlignment="Left">Location of <LineBreak></LineBreak>black ink <LineBreak></LineBreak>in this window:</TextBlock>
                <Image x:Name="imgThirdPanel"></Image>
            </Grid>
        </Border>

    </Grid>
</Window>

কোড:

using System;
using System.Drawing;
using System.Timers;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Brushes = System.Drawing.Brushes;

namespace WpfApplication1
{
    public partial class MainWindow : Window
    {
        private Timer mainTimer = new Timer();
        public MainWindow()
        {
            InitializeComponent();

            Loaded += (o1,e1) =>
                          {
                              mainTimer = new Timer(1000/10);
                              mainTimer.Elapsed += (o, e) => {
                                  try
                                  {
                                      Dispatcher.Invoke(Refresh);
                                  } catch(Exception ex)
                                  {
                                      // Nope
                                  }
                              };
                              mainTimer.Start();
                          };
        }

        private void Refresh()
        {
            var actualh = this.RenderSize.Height;
            var actualw = this.RenderSize.Width;

            var renderTarget = new RenderTargetBitmap((int) actualw, (int) actualh, 96, 96, PixelFormats.Pbgra32);
            var sourceBrush = new VisualBrush(this);

            var visual = new DrawingVisual();
            var context = visual.RenderOpen();

            // Render the window onto the target bitmap
            using (context)
            {
                context.DrawRectangle(sourceBrush, null, new Rect(0,0, actualw, actualh));
            }
            renderTarget.Render(visual);

            // Create an array with all of the pixel data
            var stride = (int) actualw*4;
            var data = new byte[stride * (int)actualh];
            renderTarget.CopyPixels(data, stride, 0);

            var blackness = 0f;
            var total = 0f;

            var blacknessFirstPanel = 0f;
            var blacknessSecondPanel = 0f;
            var blacknessThirdPanel = 0f;
            var totalFirstPanel = 0f;
            var totalSecondPanel = 0f;
            var totalThirdPanel = 0f;

            // Count all of the things
            for (var i = 0; i < data.Length; i += 4)
            {
                var b = data[i];
                var g = data[i + 1];
                var r = data[i + 2];

                if (r == 0 && r == g && g == b)
                {
                    blackness += 1;
                    total += 1;

                    var x = i%(actualw*4) / 4;

                    if(x < actualw / 3f)
                    {
                        blacknessFirstPanel += 1;
                        totalFirstPanel += 1;
                    } else if (x < actualw * (2f / 3f))
                    {
                        blacknessSecondPanel += 1;
                        totalSecondPanel += 1;
                    }
                    else if (x < actualw)
                    {
                        blacknessThirdPanel += 1;
                        totalThirdPanel += 1;
                    }
                } else if (r == 255 && r == g && g == b)
                {
                    total += 1;

                    var x = i % (actualw * 4) / 4;

                    if (x < actualw / 3f)
                    {
                        totalFirstPanel += 1;
                    }
                    else if (x < actualw * (2f / 3f))
                    {
                        totalSecondPanel += 1;
                    }
                    else if (x < actualw)
                    {
                        totalThirdPanel += 1;
                    }
                }
            }

            var black = blackness/total;

            Redraw(black, blacknessFirstPanel, blacknessSecondPanel, blacknessThirdPanel, blackness, renderTarget);
        }

        private void Redraw(double black, double firstpanel, double secondpanel, double thirdpanel, double totalpanels, ImageSource window)
        {
            DrawPieChart(black);
            DrawBarChart(firstpanel, secondpanel, thirdpanel, totalpanels);
            DrawImage(window);
        }

        void DrawPieChart(double black)
        {
            var w = (float)bFirstPanel.ActualWidth;
            var h = (float)bFirstPanel.ActualHeight;
            var padding = 0.1f;

            var b = new Bitmap((int)w, (int)h);
            var g = Graphics.FromImage(b);

            var px = padding*w;
            var py = padding*h;

            var pw = w - (2*px);
            var ph = h - (2*py);

            g.DrawEllipse(Pens.Black, px,py,pw,ph);

            g.FillPie(Brushes.Black, px, py, pw, ph, 120, (float)black * 360);

            g.DrawLine(Pens.Black, 30f, h * 0.1f, w / 2 + w * 0.1f, h / 2 - h * 0.1f);
            g.DrawLine(Pens.Black, 30f, h - h * 0.1f, w / 2 - w * 0.2f, h / 2 + h * 0.2f);

            imgFirstPanel.Source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(b.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromWidthAndHeight(b.Width, b.Height));
        }

        void DrawBarChart(double b1, double b2, double b3, double btotal)
        {
            var w = (float)bFirstPanel.ActualWidth;
            var h = (float)bFirstPanel.ActualHeight;
            var padding = 0.1f;

            var b = new Bitmap((int)w, (int)h);
            var g = Graphics.FromImage(b);

            var px = padding * w;
            var py = padding * h;

            var pw = w - (2 * px);
            var ph = h - (2 * py);

            g.DrawLine(Pens.Black, px, py, px, ph+py);
            g.DrawLine(Pens.Black, px, py + ph, px+pw, py+ph);

            var fdrawbar = new Action<int, double>((number, value) =>
                {
                    var height = ph*(float) value/(float) btotal;
                    var width = pw/3f - 4f;

                    var x = px + (pw/3f)*(number-1);
                    var y = py + (ph - height);

                    g.FillRectangle(Brushes.Black, x, y, width, height);
                });

            fdrawbar(1, b1);
            fdrawbar(2, b2);
            fdrawbar(3, b3);

            imgSecondPanel.Source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(b.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromWidthAndHeight(b.Width, b.Height));
        }

        void DrawImage(ImageSource window)
        {
            imgThirdPanel.Source = window;
        }
    }
}

কোডটি পরিষ্কার করা হয়নি, তবে এটি কিছুটা পঠনযোগ্য হওয়া উচিত, দুঃখিত।


2
দেরীতে প্রবেশ, তবে অন্যতম সেরা।
প্রিমো

14

সি (এসডিএল এবং এসডিএল_টিটিএফ সহ): গ্রেস্কেল সমাধান

গ্রেসকেলে পিক্সেল রঙের সম্পূর্ণ বর্ণালী ক্যাপচার জন্য পাই চার্ট ফর্মটির সুবিধা গ্রহণ করে এমন একটি সমাধান এখানে দেওয়া হয়েছে যা কেবল 100 লাইনের নীচে আটকে থাকে।

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "SDL.h"
#include "SDL_ttf.h"

int main(void)
{
    SDL_Surface *screen, *buffer, *caption;
    SDL_Color pal[256];
    SDL_Rect rect;
    SDL_Event event;
    TTF_Font *font;
    int levels[256], plev[256];
    Uint8 *p;
    float g;
    int cr, redraw, hoffset, h, n, v, w, x, y;

    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();
    screen = SDL_SetVideoMode(640, 480, 0, SDL_ANYFORMAT | SDL_RESIZABLE);
    font = TTF_OpenFont(FONTPATH, 24);
    buffer = 0;
    for (;;) {
        if (!buffer) {
            buffer = SDL_CreateRGBSurface(SDL_SWSURFACE, screen->w, screen->h,
                                          8, 0, 0, 0, 0);
            for (n = 0 ; n < 256 ; ++n)
                pal[n].r = pal[n].g = pal[n].b = n;
            SDL_SetColors(buffer, pal, 0, 256);
        }
        memcpy(plev, levels, sizeof levels);
        memset(levels, 0, sizeof levels);
        SDL_LockSurface(buffer);
        p = buffer->pixels;
        for (h = 0 ; h < buffer->h ; ++h) {
            for (w = 0 ; w < buffer->w ; ++w)
                ++levels[p[w]];
            p += buffer->pitch;
        }
        for (n = 1 ; n < 256 ; ++n)
            levels[n] += levels[n - 1];
        redraw = memcmp(levels, plev, sizeof levels);
        if (redraw) {
            SDL_UnlockSurface(buffer);
            SDL_FillRect(buffer, NULL, 255);
            caption = TTF_RenderText_Shaded(font,
                        "Distribution of pixel color in this image",
                        pal[0], pal[255]);
            rect.x = (buffer->w - caption->w) / 2;
            rect.y = 4;
            hoffset = caption->h + 4;
            SDL_BlitSurface(caption, NULL, buffer, &rect);
            SDL_FreeSurface(caption);
            SDL_LockSurface(buffer);
            cr = buffer->h - hoffset;
            cr = (cr < buffer->w ? cr : buffer->w) / 2 - 4;
            p = buffer->pixels;
            for (h = 0 ; h < buffer->h ; ++h) {
                y = h - (screen->h + hoffset) / 2;
                for (w = 0 ; w < buffer->w ; ++w) {
                    x = w - buffer->w / 2;
                    g = sqrtf(x * x + y * y);
                    if (g < cr - 1) {
                        g = atanf((float)y / (x + g));
                        v = levels[255] * (g / M_PI + 0.5);
                        for (n = 0 ; n < 255 && levels[n] < v ; ++n) ;
                        p[w] = n;
                    } else if (g < cr + 1) {
                        p[w] = (int)(128.0 * fabs(g - cr));
                    }
                }
                p += buffer->pitch;
            }
        }
        SDL_UnlockSurface(buffer);
        SDL_BlitSurface(buffer, NULL, screen, NULL);
        SDL_UpdateRect(screen, 0, 0, 0, 0);
        if (redraw ? SDL_PollEvent(&event) : SDL_WaitEvent(&event)) {
            if (event.type == SDL_QUIT)
                break;
            if (event.type == SDL_VIDEORESIZE) {
                SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
                                 SDL_ANYFORMAT | SDL_RESIZABLE);
                SDL_FreeSurface(buffer);
                buffer = 0;
            }
        }
    }
    SDL_Quit();
    TTF_Quit();
    return 0;
}

আমার আগের সমাধান হিসাবে, হরফ ফাইলের পথটি হয় উত্সটিতে হার্ডকোড করা বা বিল্ড কমান্ডে যুক্ত করা প্রয়োজন, যেমন:

gcc -Wall -o xkcdgolf `sdl-config --cflags`
    -DFONTPATH=`fc-match --format='"%{file}"' :bold`
    xkcdgolf.c -lSDL_ttf `sdl-config --libs` -lm

প্রোগ্রামটির আউটপুটটি এরকম দেখাচ্ছে:

পাই চার্ট পূর্ণ গ্রেস্কেল পিক্সেল রঙ বিতরণ দেখাচ্ছে

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

কোডটি বর্তমান চিত্রটিতে প্রতিটি পিক্সেল রঙের জনসংখ্যা গণনা করে কাজ করে। এই জনসংখ্যার গণনা যদি শেষের সাথে মেলে না, তবে এটি চিত্রটি আবার আঁকবে। কোডটি প্রতিটি পিক্সেলের উপরে পুনরাবৃত্তি হয়, তবে এটি x, y স্থানাঙ্ককে মেরু স্থানাঙ্কে রূপান্তরিত করে প্রথমে ব্যাসার্ধকে গণনা করে (চিত্রটির কেন্দ্রস্থলটিকে উত্স হিসাবে ব্যবহার করে)। যদি ব্যাসার্ধ পাই চার্ট অঞ্চলের মধ্যে থাকে তবে এটি থিয়েটার গণনা করে। থিটা জনসংখ্যার গণনায় সহজেই মাপা যায় যা পিক্সেলের রঙ নির্ধারণ করে। অন্যদিকে, যদি পাই চার্টের সীমানায় ব্যাসার্ধটি ঠিক থাকে, তবে চার্টের বাইরের চারদিকে বৃত্ত আঁকতে একটি অ্যান্টি-এলিয়াসড মান গণনা করা হয়। মেরু সমন্বয়গুলি সবকিছু সহজ করে দেয়!


আপনি বেশিরভাগ ব্যবহার করছেন floatগণিত-গ্রন্থাগার ফাংশন সংস্করণ, কিন্তু তারপর করা উচিত নয় fabsহতে fabsf?
লুসার droog

প্রযুক্তিগতভাবে, সম্ভবত, তবে fabs()এটি আরও বহনযোগ্য।
ব্রেডবক্স

সত্য, লাইব্রেরিতে উপস্থিত থাকার পরেও শিরোনামে এটি সংজ্ঞায়িত না করা নিয়ে আমার সমস্যা হয়েছিল। এছাড়াও ট্রান্সসেন্টেন্টালের চেয়ে কম পারফরম্যান্স অর্জন করতে হবে। :)
লুসার droog

10

সি (এসডিএল এবং এসডিএল_টিটিএফ সহ)

সি কোডের প্রায় 60 লাইনে এটি একটি খুব সাধারণ বাস্তবায়ন:

#include <stdio.h>
#include "SDL.h"
#include "SDL_ttf.h"

int main(void)
{
    char buf[64];
    SDL_Surface *screen, *text;
    SDL_Rect rect;
    SDL_Color black;
    SDL_Event event;
    TTF_Font *font;
    Uint32 blackval, *p;
    int size, b, prevb, h, i;

    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();
    screen = SDL_SetVideoMode(640, 480, 32, SDL_ANYFORMAT | SDL_RESIZABLE);
    font = TTF_OpenFont(FONTPATH, 32);
    black.r = black.g = black.b = 0;
    blackval = SDL_MapRGB(screen->format, 0, 0, 0);

    b = -1;
    for (;;) {
        prevb = b;
        b = 0;
        SDL_LockSurface(screen);
        p = screen->pixels;
        for (h = screen->h ; h ; --h) {
            for (i = 0 ; i < screen->w ; ++i)
                b += p[i] == blackval;
            p = (Uint32*)((Uint8*)p + screen->pitch);
        }
        SDL_UnlockSurface(screen);
        size = screen->w * screen->h;
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
        sprintf(buf, "This image is %.2f%% black pixels", (100.0 * b) / size);
        text = TTF_RenderText_Solid(font, buf, black);
        rect.x = (screen->w - text->w) / 2;
        rect.y = screen->h / 2 - text->h;
        SDL_BlitSurface(text, NULL, screen, &rect);
        SDL_FreeSurface(text);
        sprintf(buf, "and %.2f%% white pixels.", (100.0 * (size - b)) / size);
        text = TTF_RenderText_Solid(font, buf, black);
        rect.x = (screen->w - text->w) / 2;
        rect.y = screen->h / 2;
        SDL_BlitSurface(text, NULL, screen, &rect);
        SDL_FreeSurface(text);
        SDL_UpdateRect(screen, 0, 0, 0, 0);
        if (b == prevb ? SDL_WaitEvent(&event) : SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT)
                break;
            if (event.type == SDL_VIDEORESIZE)
                SDL_SetVideoMode(event.resize.w, event.resize.h, 32,
                                 SDL_ANYFORMAT | SDL_RESIZABLE);
        }
    }

    TTF_Quit();
    SDL_Quit();
    return 0;
}

এটি সংকলন করতে, আপনাকে FONTPATHফন্টের একটি .tf ফাইলটি ব্যবহার করতে নির্দেশ করতে হবে:

gcc -Wall -o xkcdgolf `sdl-config --cflags`
    -DFONTPATH='"/usr/share/fonts/truetype/freefont/FreeSansBold.ttf"'
    xkcdgolf.c -lSDL_ttf `sdl-config --libs`

বেশিরভাগ আধুনিক লিনাক্স মেশিনে আপনি fc-matchফন্টের অবস্থানগুলি সন্ধান করতে ইউটিলিটিটি ব্যবহার করতে পারেন , তাই কম্পাইল কমান্ডটি হয়ে যায়:

gcc -Wall -o xkcdgolf `sdl-config --cflags`
    -DFONTPATH=`fc-match --format='"%{file}"' :bold`
    xkcdgolf.c -lSDL_ttf `sdl-config --libs`

(অবশ্যই আপনি অনুরোধ করা ফন্টটি আপনার ব্যক্তিগত পছন্দের সাথে প্রতিস্থাপন করতে পারেন))

কোডটিতে বিশেষত কোনও অ্যান্টি-এলিয়জিংয়ের অনুরোধ করা হয়নি, যাতে উইন্ডোটিতে কেবল কালো এবং সাদা পিক্সেল থাকে।

অবশেষে, আমি উইন্ডো পুনরায় আকার দেওয়ার অনুমতি দেওয়ার জন্য @ ড্যানিরোর মার্জিত সমাধান দ্বারা অনুপ্রাণিত হয়েছি। আপনি দেখতে পাবেন যে কখনও কখনও প্রোগ্রামটি একটি সংখ্যক কক্ষপথে আটকে থাকে যা এটি কখনও পৌঁছাতে পারে না attract যখন এটি হয়ে যায়, উইন্ডোটি থামার আগ পর্যন্ত সামান্য আকার পরিবর্তন করুন।

এবং, প্রতি অনুরোধ হিসাবে, আমি আমার সিস্টেমে এটি চালানোর সময় দেখতে দেখতে দেখতে এটি কী:

এই চিত্রটি 3.36% কালো পিক্সেল এবং 96.64% সাদা পিক্সেল।

পরিশেষে, আমি অনুভব করি যে আমার উল্লেখ করা উচিত, যদি এখানে কেউ ইতিমধ্যে এটি না দেখে থাকে তবে এমএএ রেন্ডাল মুনরোয়ের সাথে একটি সাক্ষাত্কার প্রকাশ করেছে যাতে তিনি কার্টুন # 688 সম্পর্কে কিছুটা বিশদ আলোচনা করেছেন।


1
খুব সুন্দর সমাধান। @ দানিরোর পোস্ট বন্ধ করে আপনি কি প্রোগ্রামের চলমান কিছু স্ক্রিনশট স্থাপন করতে পারবেন? :)
অ্যালেক্স ব্রুকস

+1, খুব সুন্দর! স্ক্রিনশট যুক্ত করার জন্য ধন্যবাদ :) এবং সাক্ষাত্কারের লিঙ্কটি আকর্ষণীয়, ধন্যবাদ!
ওয়েন্দিকিড

9

এখানে চিত্র বর্ণনা লিখুন

চিত্রটি 100x100 এবং সংখ্যাগুলি হুবহু এবং আমার অর্থ হ'ল - আমি একটি 10000 পিক্সেল চিত্র বেছে নিয়েছি যাতে শতাংশটি দশমিক দুটি স্থানে প্রকাশ করা যায়। পদ্ধতিটি ছিল কিছুটা গণিত, কিছুটা অনুমান করা, এবং পাইথনে কিছু সংখ্যক ক্রাঞ্চিং।

আমি আগে থেকেই জানতাম যে শতাংশটি 4 টি সংখ্যায় প্রকাশ করা যেতে পারে, আমি গণনা করেছি যে 0 পয়েন্ট 9 থেকে 9 এর মধ্যে প্রতিটি অঙ্কে কতগুলি কালো পিক্সেল ছিল, 8 পিক্সেল উচ্চ আরিয়ালে, যা টেক্সটটিতে লেখা ছিল আমি এটি লিখেছিলাম দ্রুত ফাংশন weightযা আপনাকে জানায় যে প্রদত্ত সংখ্যাটি লিখতে কত পিক্সেল প্রয়োজন, বাম প্যাডে জিরো সহ 4 টি সংখ্যা রয়েছে:

def weight(x):
    total = 4 * px[0]
    while x > 0:
       total = total - px[0] + px[x % 10]
       x = x / 10
    return total

pxপ্রয়োজনীয় পিক্সেলের সংখ্যায় একটি অ্যারে ম্যাপিংয়ের সংখ্যা। বি যদি কালো পিক্সেলের সংখ্যা হয় এবং ডাব্লু সাদা পিক্সেলের সংখ্যা হয় তবে B + W = 10000আমাদের দরকার আছে এবং আমাদের প্রয়োজন:

B = 423 + weight(B) + weight(W)
W = 9577 - weight(B) - weight(W)

কোথা থেকে কোথা থেকে এসেছিল? 423 হল কালো পিক্সেলের "প্রাথমিক" সংখ্যা, সংখ্যা ছাড়াই পাঠ্যের কালো পিক্সেলের সংখ্যা। 9577 হল প্রাথমিক সাদা পিক্সেলের সংখ্যা। উপরের সিস্টেমে এমনকি সমাধান রয়েছে এমন ধ্রুবকগুলি অর্জন করতে পেরে আমাকে বেশ কয়েকবার প্রাথমিক কালো পিক্সেলের পরিমাণ সামঞ্জস্য করতে হয়েছিল। অনুমান করে এবং আমার আঙ্গুলগুলি পেরিয়ে এটি করা হয়েছিল।

উপরের সিস্টেমটি মারাত্মকভাবে অ-রৈখিক, সুতরাং স্পষ্টতই আপনি এটি প্রতীকীভাবে সমাধানের বিষয়টি ভুলে যেতে পারেন, তবে আপনি যা করতে পারেন তা হ'ল বি এর প্রতিটি মানকে লুপ করে ডাব্লু = 10000 - বি সেট করুন এবং সমীকরণগুলি স্পষ্টভাবে পরীক্ষা করুন।

>>> for b in range(10000 + 1):
...     if b == weight(b) + weight(10000 - b)+423: print b;
...
562
564

হতে পারে একটি 250 x 400 চিত্র করুন যাতে আপনি এটি 3 দশমিক স্থানে পেতে পারেন এবং এর মধ্যে আরও পাঠ্য প্রদর্শন করতে পারেন।
জো জে।

খুব সুন্দর সমাধান, কিছু বর্বর গণিত সবসময় এই জাতীয় সমস্যা সমাধান করতে পারে!
সিসিপি

6

QBasic

কারণ আমাদের নস্টালজিয়া।

এবং যেহেতু আমি সত্যিই জানি না যে কোনও চিত্র লাইব্রেরি হ'ল আধুনিক ভাষা।

SCREEN 9

CONST screenWidth = 640
CONST screenHeight = 350
CONST totalPixels# = screenWidth * screenHeight

accuracy = 6

newWhite# = 0
newGreen# = 0
newBlack# = totalPixels#

DO
    CLS
    white# = newWhite#
    green# = newGreen#
    black# = newBlack#

    ' Change the precision of the percentages every once in a while
    ' This helps in finding values that converge
    IF RND < .1 THEN accuracy = INT(RND * 4) + 2
    format$ = "###." + LEFT$("######", accuracy) + "%"

    ' Display text
    LOCATE 1
    PRINT "Percentage of the screen which is white:";
    PRINT USING format$; pct(white#)
    LOCATE 4
    PRINT white#; "/"; totalPixels#; "pixels"
    LOCATE 7
    PRINT "Percentage of the screen which is black:";
    PRINT USING format$; pct(black#)
    LOCATE 10
    PRINT black#; "/"; totalPixels#; "pixels"
    LOCATE 13
    PRINT "Percentage of the screen which is green:";
    PRINT USING format$; pct(green#)
    LOCATE 16
    PRINT green#; "/"; totalPixels#; "pixels"

    ' Display bar graphs
    LINE (0, 16)-(pct(white#) / 100 * screenWidth, 36), 2, BF
    LINE (0, 100)-(pct(black#) / 100 * screenWidth, 120), 2, BF
    LINE (0, 184)-(pct(green#) / 100 * screenWidth, 204), 2, BF

    newBlack# = pixels#(0)
    newGreen# = pixels#(2)
    newWhite# = pixels#(15)
LOOP UNTIL black# = newBlack# AND white# = newWhite# AND green# = newGreen#

' Wait for user keypress before ending program: otherwise the "Press any
' key to continue" message would instantly make the results incorrect!
x$ = INPUT$(1)


FUNCTION pixels# (colr)
' Counts how many pixels of the given color are on the screen

pixels# = 0

FOR i = 0 TO screenWidth - 1
    FOR j = 0 TO screenHeight - 1
        IF POINT(i, j) = colr THEN pixels# = pixels# + 1
    NEXT j
NEXT i

END FUNCTION

FUNCTION pct (numPixels#)
' Returns percentage, given a number of pixels

pct = numPixels# / totalPixels# * 100

END FUNCTION

বেশ সোজা সোজা আউটপুট-গণনা-পুনরাবৃত্তি পদ্ধতি। মূল "আকর্ষণীয়" বিষয়টি হ'ল প্রোগ্রামটি এলোমেলোভাবে শতাংশের জন্য বিভিন্ন নির্ভুলতার চেষ্টা করে - আমি দেখেছি যে এটি সর্বদা অন্যথায় রূপান্তরিত হয় না।

এবং আউটপুট ( কিউবি 64 তে পরীক্ষিত ):

কিউ বেসিক মেটাগ্রাফ


3

awk

... নেটপবিএম এবং অন্যান্য সহায়ক সহ

'এক্স' ফাইল:

BEGIN {
        FS=""
        n++
        while(n!=m) {
                c="printf '%s\n' '"m"% black pixels'"
                c=c" '"100-m"% white pixels'"
                c=c" | pbmtext -space 1 -lspace 1 | pnmtoplainpnm | tee x.pbm"
                n=m
                delete P
                nr=0
                while(c|getline==1) if(++nr>2) for(i=1;i<=NF;i++) P[$i]++
                close(c)
                m=100*P[1]/(P[0]+P[1])
                print m"%"
        }
}

রান:

$ awk -f x
4.44242%
5.2424%
5.04953%
5.42649%
5.27746%
5.1635%
5.15473%
5.20733%
5.20733%

ছবিটি 'x.pbm' হিসাবে লেখা হয়েছে, আমি এটিকে আপলোড করার জন্য পিএনজিতে রূপান্তর করেছি:

x.png

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.