ท้าทาย

เมื่อรับภาพท้องฟ้าคุณจะต้องเอาเมฆปกคลุมออกใน oktas รูปภาพที่ให้มาจะเป็นไฟล์รูปภาพ (ชนิดนั้นขึ้นอยู่กับคุณ) และเอาต์พุตควรเป็น STDOUT

Oktas

ในอุตุนิยมวิทยา okta เป็นหน่วยการวัดที่ใช้เพื่ออธิบายปริมาณการปกคลุมของเมฆที่ตำแหน่งใด ๆ เช่นสถานีอากาศ สภาพท้องฟ้ามีการประเมินในแง่ของจำนวนแปดสิบของท้องฟ้าที่ปกคลุมไปด้วยเมฆตั้งแต่ 0 oktas (ท้องฟ้าใสสมบูรณ์) ถึง 8 Oktas (มืดครึ้มอย่างสมบูรณ์)

ท้องฟ้ามักจะเป็นภาพจากประมาณเที่ยงวัน (ดังนั้นท้องฟ้าสีฟ้าไม่ใช่ท้องฟ้าสีแดง / กลางคืน)

สีของคลาวด์จะเป็นสีที่ตามรูปแบบต่อไปนี้:

#ABCDEF

ที่ไหนAB >= C0, และCD >= C0EF >= C0

หรือใน RGB:

(A, B, C)

ที่ไหนA >= 192, และB >= 192C >= 192

นี่คือเปอร์เซ็นต์การครอบคลุมที่เกี่ยวข้องกับ oktas:

0%    - 0 oktas
12.5% - 1 okta
25%   - 2 oktas
37.5% - 3 oktas
50%   - 4 oktas
62.5% - 5 oktas
75%   - 6 oktas
87.5% - 7 oktas
100%  - 8 oktas

เปอร์เซ็นต์คือเปอร์เซ็นต์ของรูปภาพซึ่งเป็นคลาวด์

หากคุณเปอร์เซ็นต์คลาวด์ของรูปภาพไม่ใช่หลายเท่าของ 12.5 คุณควรปัดเศษให้ใกล้ที่สุด

เอาท์พุต

ผลลัพธ์ควรเป็นหมายเลข okta (คุณไม่จำเป็นต้องพูดหน่วย)

ตัวอย่าง

1 okta (18.030743615677714% คลาวด์)

0 oktas (0.0% คลาวด์)

3 oktas (42.66319444444445% คลาวด์)

1 okta (12.000401814778645% คลาวด์)

รหัส Python ใช้ในการคำนวณตัวเลข

การชนะ

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

Python 2 , 114 110 98 ไบต์

^{-4 ไบต์ขอบคุณ TheLethalCoder
-12 ไบต์ขอบคุณ Ruud}

import PIL.Image as P
i=P.open(input()).getdata()
print round(8.*sum(min(x)>191for x in i)/len(i))

ลองออนไลน์!

MATL , 18 17 ไบต์

Yi191>3&A1eYm8*Yo

ตัวอย่างทำงานกับภาพที่มีให้สี่ภาพ (ขออภัยเกี่ยวกับคุณภาพตัวอย่าง; คลิกเพื่อดูความละเอียดเต็ม):

หรือลบอักขระสี่ตัวสุดท้ายเพื่อดูผลลัพธ์โดยไม่ต้องปัดเศษ:

คำอธิบาย

Yi     % Implicitly input filename or URL. Read image. Gives an M×N×3 array
191>   % Does each entry exceed 191?
3&A    % True for 3rd-dim "lines" that only contain true. Gives an M×N matrix
1e     % Linearize (flatten) into a 1×L row vector, with L = M*N
Ym     % Mean of vector
8*     % Multiply by 8
Yo     % Round. Implicitly display

Java (OpenJDK 8) , 204 ไบต์

i->{int x=0,y=0,t=0,w=i.getWidth(),h=i.getHeight();for(;x<w;)for(y=0;y<h;){java.awt.Color c=new java.awt.Color(i.getRGB(x++,y++));if(c.getRed()>191&&c.getBlue()>191&&c.getGreen()>191)t++;}return 8*t/w/h;}

ลองออนไลน์! ฉันลืมเสมอว่า TIO เอาท์พุท STDERR ไปยังแท็บการแก้ปัญหา .. บางทีมันอาจจะเน้นสีแดงในกรณีที่มีข้อผิดพลาด?

C #, 150 146 ไบต์

b=>{int t=0,c=0,w=0,h;for(;w<b.Width;++w)for(h=0;h<b.Height;++t){var p=b.GetPixel(w,h++);if(p.R>191&p.G>191&p.B>191)c++;}return(int)(c/(t+0d)*8);}

บันทึกแล้ว 4 ไบต์ขอบคุณ @Ian H.

เวอร์ชันเต็ม / ฟอร์แมต:

using System.Drawing;

namespace System
{
    class P
    {
        static void Main()
        {
            Func<Bitmap, int> f = b =>
            {
                int t = 0, c = 0, w = 0, h;
                for (; w < b.Width; ++w)
                    for (h = 0; h < b.Height; ++t)
                    {
                        var p = b.GetPixel(w, h++);

                        if (p.R > 191 & p.G > 191 & p.B > 191)
                            c++;
                    }

                return (int)(c / (t + 0d) * 8);
            };

            string[] testCases =
            {
                @"Appearance_of_sky_for_weather_forecast,_Dhaka,_Bangladesh.JPG",
                @"spanish-sky.jpeg",
                @"why-is-sky-blue-1.jpg",
            };

            foreach (string testCase in testCases)
            {
                using (Bitmap bitmap = new Bitmap(testCase))
                {
                    Console.WriteLine(f(bitmap));
                }
            }

            Console.ReadLine();
        }
    }
}

C #, 313 ไบต์

namespace System.Drawing.Imaging{b=>{unsafe{int t=0,c=0,y=0,x,w=b.Width,h=b.Height;var d=b.LockBits(new Rectangle(0,0,w,h),(ImageLockMode)1,(PixelFormat)137224);for(;y<h;++y){var r=(byte*)d.Scan0+y*d.Stride;for(x=0;x<w*3;++t)if(r[x++]>191&r[x++]>191&r[x++]>191)c++;}b.UnlockBits(d);return(int)(c/(t+0d)/0.125);}}}

เห็นได้ชัดว่านานกว่าคำตอบอื่น ๆ ของฉัน แต่อันนี้ใช้LockBitsและunsafeรหัสเพื่อเข้าถึงรูปภาพในหน่วยความจำโดยตรง อย่างรวดเร็วอย่างไม่น่าเชื่อ ฉันอาจจะลบการโทรออกUnlockBitsแต่ก็ถูกต้องกว่า

เวอร์ชันเต็ม / ฟอร์แมต:

namespace System.Drawing.Imaging
{
    class P
    {
        static void Main()
        {
            Func<Bitmap, int> f = b =>
            {
                unsafe
                {
                    int t = 0, c = 0, y = 0, x, w = b.Width, h = b.Height;

                    var d = b.LockBits(new Rectangle(0, 0, w, h), (ImageLockMode)1, (PixelFormat)137224);
                    for (; y < h; ++y)
                    {
                        var r = (byte*)d.Scan0 + y * d.Stride;

                        for (x = 0; x < w * 3; ++t)
                            if (r[x++] > 191 & r[x++] > 191 & r[x++] > 191)
                                c++;
                    }
                    b.UnlockBits(d);

                    return (int)(c / (t + 0d) / 0.125);
                }
            };

            string[] testCases =
            {
                @"Appearance_of_sky_for_weather_forecast,_Dhaka,_Bangladesh.JPG",
                @"spanish-sky.jpeg",
                @"why-is-sky-blue-1.jpg",
            };

            foreach (string testCase in testCases)
            {
                using (Bitmap bitmap = new Bitmap(testCase))
                {
                    Console.WriteLine(f(bitmap));
                }
            }

            Console.ReadLine();
        }
    }
}

PowerShell , 200 ไบต์

$a=New-Object System.Drawing.Bitmap $args[0]
0..($a.Height-1)|%{$h=$_;0..($a.Width-1)|%{$i+=(("$($a.GetPixel($_,$h)|select R,G,B)"|iex)['R','G','B']-ge192).count-eq3}}
[int]($i/($a.Height*$a.Width)*8)

ได้รับการป้อนข้อมูล$args[0]ทั้งรูปแบบไฟล์เส้นทางโครงสร้างวัตถุเข้าNew Bitmap $aนี่เป็นเพียงชื่อวัตถุภายใน รองรับ JPG, PNG, ฯลฯ

จากนั้นเราวนซ้ำผ่าน.heightและจากนั้น.widthแตะที่ภาพแต่ละpixelภาพ เราดึงR,G,Bค่าออกมาแล้วเลือกค่าที่มี-gคุณสมบัติตามที่eกำหนด192และตรวจสอบให้แน่ใจว่าcountเป็นเช่นนั้น3 (นั่นคือทั้งหมดนั้นเป็น white-ish) $iว่าผลบูลีนจะถูกเพิ่มเข้าไปสะสมของเรา

จากนั้นเราหารออกเพื่อให้ได้เปอร์เซ็นต์แล้วคูณด้วย8เพื่อให้ได้จำนวน oktas และจากนั้น[int]รับเอาท์พุทเป็นจำนวนเต็ม (โปรดทราบว่าวิธีนี้จะทำการปัดเศษของธนาคาร - หากไม่ได้รับอนุญาตจะมีอีกหลายไบต์เพื่อเปลี่ยนวิธีการปัดเศษ)

dc, 74 ไบต์

???*sa?[1+]ss[r1+r]st[?191<s]su0ddsd[0luxluxlux3=t1+dla>r]dsrxr8*la2/+la/p

อินพุตถูกใช้เป็นไฟล์ P3 ppm โดยมีช่องว่างทั้งหมดเป็นบรรทัดใหม่ เอาต์พุตคือ STDOUT

ลองออนไลน์!

JavaScript, 83 77 ไบต์

-6 ไบต์โดยETHproductions

f=i=>(z=a=b=0,i.map(e=>{z=e<192||z;(++b%4)||((z||(a+=64))&&(z=0))}),a/b+1>>1)

ปัจจัยการผลิต

รูปภาพ # 1

รูปภาพที่ 2

รูปภาพ # 3

รูปภาพ # 4

การสาธิต

f=i=>(z=a=b=0,i.map(e=>{z=e<192||z;(++b%4)||((z||(a+=64))&&(z=0))}),a/b+1>>1)


window.onload = function(){
	var input = document.getElementById('input');
	input.addEventListener('change', handleFiles);
}
function handleFiles(e){
	var canvas = document.getElementById('canvas')
	var ctx = canvas.getContext('2d');
	var img = new Image;
	img.onload = function(){
		canvas.height = img.height
		canvas.width = img.width
		ctx.drawImage(img, 0,0);
		data = ctx.getImageData(0,0,canvas.width,canvas.height).data;
		console.log(f(data))//invoke f, send imageData as input
	}
	img.src = URL.createObjectURL(e.target.files[0]);
}

<input type="file" id="input"/><br>
<canvas id="canvas" style="max-width:400px"/>

C (POSIX), 103 ไบต์

ถือว่าอินพุตเป็นไฟล์ BMP บน stdin

b,c,i,m=0xc0c0c0;main(){lseek(0,54,0);for(;read(0,&b,3);c+=(b&m)==m,i++);printf("%d",(i+16*c)/(2*i));}

x86 รหัสเครื่อง, 34 ไบต์

51
31 D2
AD
F7 D0
25 C0 C0 C0 00
75 01
42
E2 F3
C1 E2 03
DB 04 24
52
DB 04 24
DE F1
DB 1C 24
58
5A
C3

ไบต์ของโค้ดเหล่านี้จะกำหนดฟังก์ชั่นที่รับอินพุตบิตแมปและส่งกลับค่าจำนวนเต็มเพื่อระบุว่า oktas เช่นเดียวกับใน Cอาร์เรย์ (เช่นบิตแมป) จะแสดงเป็นตัวชี้ไปยังองค์ประกอบแรกและขนาด / ความยาว ดังนั้นฟังก์ชั่นนี้ใช้สองพารามิเตอร์: จำนวนพิกเซลทั้งหมดในบิตแมป (แถว×คอลัมน์) และตัวชี้ไปยังบิตแมปตัวเอง

รหัสนี้ใช้แบบแผนการลงทะเบียนแบบกำหนดเองซึ่งตัวชี้บิตแมปถูกส่งผ่านในการESIลงทะเบียนและขนาดบิตแมปถูกส่งผ่านในการECXลงทะเบียน ผลที่ตามมา (oktas) EAXเป็นต่อตามปกติกลับมาใน

ตามที่ระบุไว้ข้างต้นอินพุตจะถูกใช้เป็นบิตแมป โดยเฉพาะจะใช้รูปแบบ 32-bpp ในรูปแบบเล็ก ๆ น้อย ๆ แต่จะไม่สนใจช่องอัลฟา (ไบต์เรียงลำดับสูงสุด) สิ่งนี้ทำให้สิ่งต่างๆง่ายขึ้นมากทำให้เราสามารถวนซ้ำแต่ละพิกเซลและตรวจสอบค่าสี RGB แบบ 32 บิต การเพิ่มประสิทธิภาพที่ฉลาดยังใช้ที่นี่ แทนที่จะแยกแต่ละองค์ประกอบสีและตรวจสอบว่ามันเป็น> = 192 เราเพียงปกปิดค่า 32- บิตทั้งหมดโดย 0xC0C0C0 และทดสอบว่าผลลัพธ์คือ> = 0xC0C0C0 สิ่งนี้จะประเมินว่าเป็นจริงสำหรับทุกสี "เมฆ" และเป็นเท็จสำหรับสี "ท้องฟ้า" (ไม่ใช่เมฆ) ทั้งหมด ดีฉันคิดว่ามันเป็นฉลาด! :-) มันช่วยประหยัดจำนวนไบต์ได้อย่างแน่นอน

ดังนั้นเพื่อทดสอบรหัสนี้คุณจะต้องแปลงภาพอินพุตเป็นบิตแมป 32-bpp คุณไม่สามารถใช้ Windows Paint สำหรับสิ่งนี้เนื่องจากรองรับสูงสุด 24 บิตต่อพิกเซล อย่างไรก็ตามมีโซลูชันซอฟต์แวร์อื่น ๆ อีกจำนวนมากที่สามารถทำได้เช่น Adobe Photoshop ฉันใช้เครื่องมือฟรีนี้ซึ่งแปลง PNG เป็น BMP แบบ 32 bpp บน Windows หมายความว่าคุณต้องแปลงจาก JPEG เป็น PNG เท่านั้น (ซึ่ง Paint สามารถทำได้)

สมมติฐานอื่น ๆ ที่ฉันวางไว้มีเหตุผลชัดเจน:

• บิตแมปจะถือว่ามีขนาดใหญ่กว่า 0 ( กล่าวคือจะมีขนาดอย่างน้อยหนึ่งพิกเซล) สิ่งนี้สมเหตุสมผลเนื่องจากเมื่อท้องฟ้าไม่ว่างเรามีปัญหาใหญ่กว่าอุตุนิยมวิทยา
• ทิศทางธง ( DF) จะถือว่าชัดเจนเพื่อให้เราทำซ้ำอย่างถูกต้องผ่านบิตแมปโดยใช้LODSDคำสั่ง นี่คือสมมติฐานเดียวกันที่ทำโดยอนุสัญญาการเรียก x86 ส่วนใหญ่ดังนั้นจึงดูเหมือนยุติธรรม หากคุณไม่ชอบให้เพิ่ม 1 ไบต์ไปยังจำนวนสำหรับ aCLDคำสั่ง
• โหมดการปัดเศษสำหรับ x87 FPU นั้นถูกกำหนดให้เป็นแบบปัดเศษเป็นแบบใกล้เคียงที่สุด สิ่งนี้ช่วยให้มั่นใจได้ว่าเราได้รับพฤติกรรมที่ถูกต้องเมื่อเราแปลงจำนวน oktas จากจุดลอยตัวชั่วคราวเป็นผลลัพธ์จำนวนเต็มสุดท้ายตามที่ตรวจสอบโดยกรณีทดสอบ # 4 สมมติฐานนี้มีเหตุผลเพราะนี่คือสถานะเริ่มต้นสำหรับ FPU และจำเป็นต้องได้รับการดูแลแม้ในรหัส C (โดยที่การตัดปลายเป็นพฤติกรรมการปัดเศษเริ่มต้นบังคับให้คอมไพเลอร์ที่ต้องการให้เป็นไปตามมาตรฐานเพื่อสร้างรหัสที่ไม่มีประสิทธิภาพ โหมดทำการแปลงและเปลี่ยนโหมดการปัดเศษกลับ)

คำย่อของชุดประกอบ Ungolfed:

; int ComputeOktas(void*    bmpBits  /* ESI */,
;                  uint32_t bmpSize  /* ECX */);
   push  ecx                  ; save size on stack
   xor   edx, edx             ; EDX = 0 (cloudy pixel counter)

CheckPixels:
   lodsd                      ; EAX = DS:[ESI]; ESI += 4
   not   eax
   and   eax, 0x00C0C0C0
   jnz   NotCloudy
   inc   edx
NotCloudy:
   loop  CheckPixels          ; ECX -= 1; loop if ECX > 0

   shl    edx, 3              ; counter *= 8
   fild   DWORD PTR [esp]     ; load original size from stack
   push   edx
   fild   DWORD PTR [esp]     ; load counter from stack
   fdivrp st(1), st(0)        ; ST(0) = counter*8 / size
   fistp  DWORD PTR [esp]     ; convert to integer, rounding to nearest even
   pop    eax                 ; load result
   pop    edx
   ret

แน่นอนคุณยังไม่ได้ทำให้มันลงและยังคงสงสัยว่ารหัสทำงานอย่างไร :-)
ดีมันค่อนข้างง่าย เราแค่วนซ้ำบิตแมปหนึ่งค่า 32- บิตในแต่ละครั้งตรวจสอบเพื่อดูว่าค่าพิกเซล RGB นั้นเป็น "ขุ่น" หรือ "ไม่ขุ่น" ถ้ามันมีเมฆมากเราจะเพิ่มตัวนับที่เป็นศูนย์ล่วงหน้า ในตอนท้ายเราคำนวณ: ^{พิกเซลมีเมฆมาก} / _{พิกเซลรวม}  × 8
(ซึ่งเทียบเท่ากับ: ^{พิกเซลมีเมฆมาก} / _{พิกเซลรวม}  ÷ 0.125)

ฉันไม่สามารถรวมลิงค์ TIO สำหรับสิ่งนี้ได้เนื่องจากความต้องการใช้ภาพอินพุต อย่างไรก็ตามฉันสามารถมอบสายรัดให้คุณทดสอบบน Windows:

#include <stdio.h>
#include <assert.h>
#include <Windows.h>

int main()
{
   // Load bitmap as a DIB section under Windows, ensuring device-neutrality
   // and providing us direct access to its bits.
   HBITMAP hBitmap = (HBITMAP)LoadImage(NULL,
                                        TEXT("C:\\...\\test1.bmp"),
                                        IMAGE_BITMAP,
                                        0, 0,
                                        LR_LOADFROMFILE  | LR_CREATEDIBSECTION);
   assert(hBitmap != NULL);

   // Get the bitmap's bits and attributes.
   DIBSECTION dib;
   GetObject(hBitmap, sizeof(dib), &dib);
   assert(dib.dsBm.bmBitsPixel == 32);
   uint32_t cx = dib.dsBm.bmWidth;
   uint32_t cy = abs(dib.dsBm.bmHeight);
   uint32_t sz = cx * cy;
   assert(sz > 0);

   int oktas = ComputeOktas(sz, dib.dsBm.bmBits);

   printf("%d\n", oktas);

   return 0;
}

ระวังตัวด้วยล่ะ! ตามที่นิยามไว้ข้างต้นComputeOktasใช้หลักการเรียกที่กำหนดเองซึ่งคอมไพเลอร์ C จะไม่เคารพ คุณต้องเพิ่มรหัสที่ด้านบนสุดของขั้นตอนภาษาแอสเซมบลีเพื่อโหลดค่าจากสแต็กไปยังรีจิสเตอร์ที่คาดไว้เช่น :

mov  ecx, DWORD PTR [bmpSize]
mov  esi, DWORD PTR [bmpBits]

JavaScript (ES6), 218 ไบต์

(a,c=document.createElement`canvas`,w=c.width=a.width,h=c.height=a.height,x=c.getContext`2d`)=>x.drawImage(a,0,0)||x.getImageData(0,0,w,h).data.reduce((o,_,i,d)=>o+(i%4|d[i++]<192|d[i++]<192|d[i]<192?0:1),0)/w/h*8+.5|0

นำImageวัตถุเป็นอินพุตซึ่งสามารถสร้างได้จาก<image>องค์ประกอบ

ทดสอบที่นี่ใน CodePen!

ทางเลือก

หากอินพุตสามารถนำมาเป็นอาร์เรย์แบบแบนของค่า RGBA โดยมีขนาด: 82 ไบต์

(d,w,h)=>d.reduce((o,_,i)=>o+(i%4|d[i++]<192|d[i++]<192|d[i]<192?0:1),0)/w/h*8+.5|0

รูปแบบการป้อนข้อมูลนี้คล้ายกับคำตอบของเมตาที่แนะนำ

Mathematica 89 ไบต์

ภาพต่อไปนี้จะทำการจำแนกภาพและกำหนดสัดส่วนของเมฆเช่นพิกเซลสีขาว จากนั้นจะกำหนดจำนวนครั้งที่. 125 เหมาะสมกับผลลัพธ์ มันส่งคืนพื้นของค่านั้น

o@i_:=⌊8Tr@Flatten[ImageData@MorphologicalBinarize[i,.932],1]/Times@@ImageDimensions@i⌋