पिक्सेल को क्रमबद्ध करें


35

आपका कार्य एक ऐसा प्रोग्राम बनाना है, जो इनपुट छवि को देखते हुए, उसी आकार की आउटपुट छवि बनाता है, जहाँ सभी पिक्सेल को xx मान द्वारा ऑर्डर किया जाता है।

आपका कार्यक्रम हो सकता है:

  • पिक्सेल को बाएं से दाएं और फिर नीचे या पहले स्तंभों में छांटें और फिर दाएं क्रमबद्ध करें। किसी भी मामले में, शीर्ष बाएं पिक्सेल सबसे छोटा है, और नीचे दायां सबसे बड़ा है।
  • पारदर्शिता का उपयोग करें, लेकिन इसकी आवश्यकता नहीं है।
  • RGB द्वारा क्रमबद्ध करें, लेकिन आप कम से कम 3 मानों के साथ CMY, या किसी अन्य प्रारूप का उपयोग कर सकते हैं। आप चुन सकते हैं कि किन मूल्यों को क्रमबद्ध करना है। (HSV कुछ अच्छी तस्वीरें दे सकता है)
  • किसी भी प्रसिद्ध छवि प्रारूप का उपयोग करें जिसे अधिकांश कंप्यूटर खोल सकते हैं।

नियम:

  • आउटपुट को डिस्क पर लिखा जाना चाहिए या फ़ाइल में पाइप करने योग्य होना चाहिए।
  • इनपुट को कमांडलाइन तर्क के रूप में दिया जाता है, छवि के सापेक्ष पथ के रूप में, या कमांडलाइन से पाइप किया जाता है।
  • यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा कोड है!

जवाबों:


20

पायथ - 10 बाइट्स

छवि पढ़ता है, बिटमैप को ढहता है, सॉर्ट करता है, और फिर बिटमैप को फिर से विभाजित करता है, फिर लिखता है।

.wclK'zSsK

स्पष्ट कारणों के लिए ऑनलाइन काम नहीं करता है। छवि फ़ाइल के सापेक्ष पथ के रूप में इनपुट लेता है और इसमें आउटपुट करता है o.png

अमेरिकी गोथिक से उत्पादन:


3
मुझे आशा है कि मुझे केवल एक ही आभास नहीं है कि चित्र चल रहा है ...
क्वेंटिन

यह लकड़ी की तरह दिखता है।
जो जेड

19

जावास्क्रिप्ट (ईएस 6), 383 377 354 बाइट्स

f=s=>{d=document,i=new Image,i.src=s,i.onload=$=>{c=d.createElement`canvas`,x=c.getContext`2d`,c.width=w=i.width,c.height=h=i.height,x.drawImage(i,0,0),D=x.getImageData(0,0,w,h),t=D.data,t.set([].concat(...[...t].map((v,i,T)=>i%4?[,,,0]:T.slice(i,i+4)).sort((a,b)=>a.some((v,i)=>k=v-b[i])&&k)).slice(12*w*h)),x.putImageData(D,0,0),d.body.appendChild(c)}}

नमूना उत्पादन

चलने योग्य डेमो:

यह कोड कैसे काम करता है इसका उपयोग getImageDataफॉर्म की एक सरणी प्राप्त करने के लिए करना है

[R,G,B,A,
 R,G,B,A,
 R,G,B,A,
 ...]

और mapयह फार्म की एक सरणी के लिए

[[R,G,B,A],[0,0,0,0],[0,0,0,0],[0,0,0,0],
 [R,G,B,A],[0,0,0,0],[0,0,0,0],[0,0,0,0],
 [R,G,B,A],[0,0,0,0],[0,0,0,0],[0,0,0,0],
 ...]

ताकि R मान RGBA सेट के सरणियों के लिए मैप किए जाते हैं, और B, G, और A मान न्यूनतम-मूल्य शून्य सरणियों में बदल जाते हैं। जब हम इस सरणी को क्रमबद्ध करते हैं, तो सभी [0,0,0,0]सरणियाँ नीचे की ओर छँट जाती हैं और वास्तविक मूल्य के सरणियाँ सामान्य रूप से शीर्ष पर छाँटती हैं:

[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],
 [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],
 [0,0,0,0],..., [R,G,B,A],[R,G,B,A],[R,G,B,A],...]
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
               extract & flatten these sorted pixels

हम सरणी के शीर्ष चौथे को स्केम करते हैं (हमारे द्वारा बनाए गए खाली मूल्यों को खोने के लिए), इसे समतल करें [].concat.apply, और पहले फॉर्म के एक सरणी के साथ फिर से समाप्त करें, लेकिन इस बार, यह क्रमबद्ध है।

व्हाट्सएप और टिप्पणियों के साथ थोड़ा डी-गोल्फ:

f=s=>{ 
  // first, load image, then do everything else onload
  i=new Image,
  i.src = s,
  i.onload=$=>{
    // set up the canvas
    d=document,
    c=d.createElement`canvas`,
    w=c.width=i.width,
    h=c.height=i.height,
    x=c.getContext`2d`,

    // draw image to canvas and capture pixel data
    x.drawImage(i,0,0),
    D=x.getImageData(0,0,w,h),
    t=D.data,

    // set pixel data to...
    t.set(
      // the flattened array...
      [].concat(...
        // that is a mapping of the pixel data...
        [...t].map(
          // that clumps RGBA families into subarrays
          // by replacing every fourth value with [R,G,B,A]
          // and all other values to [0,0,0,0]...
          (v,i,T)=>i%4?[,,,0]:T.slice(i,i+4)
        )
        // and is then sorted...
        .sort(
          // by reducing each array to a positive, negative, or zero
          // by comparing R,G,B,& A until the first nonzero difference
          (a,b)=>a.some((v,i)=>k=v-b[i])&&k
        )
      )
      // then eliminate the low-sorted empty [0,0,0,0] values we created,
      // leaving only the top fourth, with real values
      // (note that 3*4*w*h is the same as 3*t.length)
      .slice(3*4*w*h)
    ),

    // now that `t` is set, store `D` in canvas
    x.putImageData(D,0,0),

    // show canvas
    d.body.appendChild(c)
  }
}

ध्यान दें कि अधिकांश ब्राउज़र बड़ी छवियों के लिए इस कोड को चलाने में विफल हो सकते हैं, क्योंकि यह बड़ी संख्या में तर्कों को पारित करता है [].concat। ब्राउज़र पर्यावरण सभी तर्कों के लिए पर्याप्त स्मृति की अनुमति नहीं है जब, एक वैकल्पिक दृष्टिकोण शीर्ष चौथे सरणियों सरणी पर वापस, के कुल स्कोर के लिए से बाहर RGBA मूल्यों को फिर से मैप करने के लिए है 361 बाइट्स :

f=s=>{d=document,i=new Image,i.src=s,i.onload=$=>{c=d.createElement`canvas`,x=c.getContext`2d`,c.width=w=i.width,c.height=h=i.height,x.drawImage(i,0,0),D=x.getImageData(0,0,w,h),t=D.data,t.set([...t].map((v,i,T)=>i%4?[,,,0]:T.slice(i,i+4)).sort((a,b)=>a.some((v,i)=>k=v-b[i])&&k).map((v,i,A)=>A[3*w*h+(i>>2)][i%4])),x.putImageData(D,0,0),d.body.appendChild(c)}}

हम बस के [].concat(...{stuff}).slice(12*w*h)साथ की जगह {stuff}.map((v,i,A)=>A[3*w*h+(i>>2)][i%4]))


क्या आप एक उदाहरण आउटपुट शामिल कर सकते हैं?
पाओलो एबरमन

@ Pa @loEbermann किया।
अप्सिलर्स

@insertusernamehere ओह, खतरे, मैंने केवल छोटी छवियों पर परीक्षण किया। मेरी concat.applyकॉल बहुत सारे तर्कों की आपूर्ति कर रही है concatऔर जेएस इंजन इसे अस्वीकार कर रहा है। D:धन्यवाद! मैं उसे ठीक करूँगा और दो स्कोर नोट करूँगा। (और मुझे खुशी है कि मैं मदद कर सकता हूँ!)
अप्सिलर्स

@insertusernamehere आकार सीमा के बारे में सिर-अप के लिए धन्यवाद; मैंने अब थोड़ा लंबा संस्करण भी प्रकाशित किया है जो बड़ी छवियों पर काम करता है।
अप्सिलर्स

@ रैपिलर्स अच्छा काम करते हैं। दुर्भाग्य से फिर से आगे नहीं बढ़ सकता। :)
१ .

14

मैथेमेटिका 86 83 72 बाइट्स

 f=Flatten;Image[f[Sort[f[s=ImageData@#1,1]]]~ArrayReshape~Dimensions@s]&

14 बाइट्स के साथ @ मॉर्टिन बटनर को धन्यवाद दिया।


उदाहरण

छवि स्वयं इनपुट है। वैकल्पिक रूप से, छवि वाले एक चर का उपयोग किया जा सकता है।

गोथिक


चुनौती निर्दिष्ट करती है कि पिक्सेल को हेक्स मान द्वारा क्रमबद्ध किया जाता है, लेकिन अगर मैं इसे सही ढंग से पढ़ता हूं, तो आप {R, G, B} या {R, G, B, अल्फ़ा} सूचियों के लिए Mathematica के डिफ़ॉल्ट सॉर्ट का उपयोग करते हैं। यह मेरे लिए स्पष्ट नहीं है कि ये समान हैं।
माइकल स्टर्न

@MichaelStern मैं मैथमैटिक को नहीं जानता, लेकिन अगर यह अधिकांश भाषाओं की तरह टुपल्स एलिमेंट को सॉर्ट करता है, तो वे समतुल्य हैं: हेक्स जैसे नंबर प्रत्येक अंक द्वारा सॉर्ट किए जाते हैं, जिनमें से दो ट्यूपल में प्रत्येक तत्व द्वारा दर्शाए जाते हैं।
मैलेनसेन

@ मिचेल स्टर्न, माल्टीसेन सही है। आरजीबी सॉर्ट और हेक्स सॉर्ट समतुल्य हैं: आर द्वारा छँटाई, फिर जी, फिर बी मान हेक्स में जगह मूल्य सॉर्ट की तरह काम करता है।
DavidC

ठीक है, मेरे से +1।
माइकल स्टर्न

ImageDataऔर ArrayReshapeinfix संकेतन का उपयोग कर सकता है। Flattenयह करने के लिए आवंटित करके बाइट्स के एक जोड़े को बचाने के लिए काफी लंबा है f। और क्या आपको वास्तव में ज़रूरत है "Byte"? क्या डिफॉल्ट सिर्फ चैनल वैल्यू को [0,1]इस तरह से स्केल नहीं करेगा कि सॉर्टिंग और इमेज पुनर्निर्माण अभी भी ठीक काम करेगा?
मार्टिन एंडर

5

जावास्क्रिप्ट ईएस 6, 334 बाइट्स

f=s=>{with((d=document).body.appendChild(c=d.createElement`canvas`).getContext`2d`)(i=new Image).src=s,drawImage(i,0,0,w=c.width=i.width,h=c.height=i.height),t=(g=getImageData(0,0,w,h)).data,t.set([...t].map(i=>(0+i.toString(16)).slice(-2)).join``.match(/.{8}/g).sort().join``.match(/../g).map(i=>parseInt(i,16))),putImageData(g,0,0)}

Ungolfed:

f=s=>{                                   // create function that accepts image name
 with((d=document).body.appendChild(     // use "with" to exclude having to prepend "<context2d>." to drawImage, getImageData and putImageData
   c=d.createElement`canvas`).getContext`2d`) // create canvas to get pixels from and draw output to
  (i=new Image).src=s,                   // create image, define source filename
  drawImage(i,0,0,w=c.width=i.width,     // draw image to canvas
                  h=c.height=i.height),
  t=(g=getImageData(0,0,w,h)).data,      // get image data from canvas in form of Uint8Array
  t.set([...t]                           // convert image data from Uint8Array to standard array
   .map(i=>(0+i.toString(16)).slice(-2)) // convert R,G,B,A bytes to base16 strings with leading zeros
   .join``.match(/.{8}/g)                // convert array of [R,G,B,A,R,G,B,A,...] to [RGBA,RGBA,...]
   .sort()                               // sort pixel values
   .join``.match(/../g)                  // convert array of [RGBA,RGBA,...] to [R,G,B,A,R,G,B,A,...]
   .map(i=>parseInt(i,16))),             // convert hex strings back to integers, reassign to image data
  putImageData(g,0,0)                    // dump image data onto canvas
}

@insertusernamehere यह नवीनतम फ़ायरफ़ॉक्स पर काम करता है। आपके उत्तर की तरह, यह मानता है कि कैनवास को जोड़ने के लिए एक निकाय है और स्रोत छवि उसी डोमेन से है।
डेंड्रोबियम

+1 बहुत चिकना उपाय। यह 1600 x 1900px तक की छवियों को भी संसाधित करता है।
us

2
आज मैंने सीखा कि appendChildइसका तर्क लौटाता है। बहुत उपयोगी! आपने मुझे 377 से 354 तक मेरी प्रविष्टि को कम करने के लिए प्रेरित किया, लेकिन मैं आपको बहुत हरा नहीं सकता :)। (जब मैं आपकी appendChild-चैनिंग और withतकनीक का उपयोग करता हूं तो मैं इसे 347 तक ले जा सकता हूं, लेकिन अभी भी 13 दूर!) बहुत बढ़िया काम!
एनपीएस

5

C (SDL1.2 का उपयोग करके), 333 322 315 बाइट्स

सी शायद इस तरह के काम के लिए 'शेल्फ में सबसे तेज चाकू' नहीं है, मैं इसे वैसे भी आजमाना चाहता था। मेरे उत्तर को बेहतर बनाने की युक्तियों का स्वागत है। प्रोग्राम को क्ली तर्क के रूप में इनपुट छवि फ़ाइल का नाम मिलता है।

#include <SDL.h>
#include <SDL_image.h>
#define X SDL_Surface*
#define Y const void*
C(Y a,Y b){return*(Uint32*)a-*(Uint32*)b;}main(int o,char**a){X i=IMG_Load(a[1]);X s=SDL_SetVideoMode(i->w,i->h,32,0);i=SDL_ConvertSurface(i,s->format,0);qsort(i->pixels,i->w*i->h,4,C);SDL_BlitSurface(i,0,s,0);for(;;SDL_Flip(s));}

संकलित करें और चलाएं: gcc -I/usr/include/SDL snippet.c -lSDL -lSDL_image && ./a.out

यहाँ छवि विवरण दर्ज करें

मैं आमतौर पर सी में गोल्फ नहीं करता, लेकिन मैंने कल ही इस चुनौती का जवाब दिया है और मैं बस उस नए खिलौने के साथ खेलना जारी रखना चाहता था :)

5 बाइट बचाने में मेरी मदद करने के लिए @ pseudonym117 को धन्यवाद


अपने बाइट whileको अंत में बदलकर 1 बाइट बचा सकते हैं for(;;SDL_Flip(s));, और मुझे विश्वास है कि आप intइस विधि को छोड़ सकते हैं Cऔर 4 और बचा सकते हैं ।
छद्मनाम

4

जावास्क्रिप्ट (ईएस 6), 452 480 484 487 511 बाइट्स

वाह, यह उम्मीद से अधिक समय मिल गया:

f=u=>{i=new Image;i.src=u;i.onload=_=>{c=(d=document).createElement`canvas`;c.width=w=i.width;c.height=h=i.height;x=c.getContext`2d`;x.drawImage(i,0,0,w,h);p=x.getImageData(0,0,w,h).data;t=[];f=[];for(j=0;j<p.length;++j)t.push([p[j],p[++j],p[++j],p[++j]]);t.sort((a,b)=>a[0]>b[0]||a[0]==b[0]&&a[1]>b[1]||a[0]==b[0]&&a[1]==b[1]&&a[2]>b[2]).map(u=>f.push.apply(f,u));x.putImageData(new ImageData(new Uint8ClampedArray(f),w,h),0,0);d.body.appendChild(c)}}

फ़ंक्शन अपने इनपुट के रूप में एक URL लेता है f('test.jpg');और परिणाम को एक canvasसेलेमेंट में खींचता है जिसे जोड़ा जाता है body

ध्यान दें कि स्रोत एक ही डोमेन पर होना चाहिए या स्क्रिप्ट सुरक्षा समस्या के साथ रुक जाएगी।


सीमाएं

मैंने इसे फॉयरफॉक्स 42 में ओएस एक्स (10.10) पर 2.5 गीगाहर्ट्ज आई 7 और 16 जीबी रैम वाली मशीन पर टेस्ट किया है। फ़ायरफ़ॉक्स के बिना मैं जो अधिकतम इमेज साइज़ प्रोसेस कर सकता था वो स्क्रिप्ट एक्ज़ीक्यूटिव जारी रखने के लिए कह रहा था 1600 x 1932 px


Ungolfed

f = u => {
    i = new Image;
    i.src = u;
    i.onload = _ => {
        c = (d = document).createElement`canvas`;
        c.width = w = i.width;
        c.height = h = i.height;

        x = c.getContext`2d`;
        x.drawImage(i, 0, 0, w, h);

        p = x.getImageData(0, 0, w, h).data;

        t = [];
        f = [];

        for (j = 0; j < p.length;++j)
            t.push([p[j], p[++j], p[++j], p[++j]]);

        t.sort( (a,b) => a[0] > b[0] || a[0] == b[0] && a[1] > b[1] || a[0] == b[0] && a[1] == b[1] && a[2] > b[2] )
         .map(u => f.push.apply(f,u));

        x.putImageData( new ImageData( new Uint8ClampedArray(f), w, h), 0, 0);
        d.body.appendChild(c)
    }
}

उत्पादन

एक बेहतर तुलना के लिए मैंने उदाहरण के रूप में " अमेरिकन गोथिक " भी लिया :

यहाँ छवि विवरण दर्ज करें


संपादित करता

  • के बजाय का उपयोग करके 24 बाइट्स बचाता है । Ar34z के लिए धन्यवादfor (a in b)for(;;)
  • एक चर में संग्रहीत करके 3 बाइट्स सहेजे गए document
  • सहेजा 4 बाइट इनमें से कुछ छोड़ने के द्वारा ()
  • टैग किए गए टेम्प्लेट स्ट्रिंग्स का उपयोग करके 10 बाइट्स सहेजे गए , ()ऑब्जेक्ट क्रिएशन को छोड़ कर बेमानी जोड़ी को हटा दें ()थैंक्स टू अप्सिलर्स
  • सॉर्ट करने के बाद रंग सरणी को समतल करने वाले कोड के बड़े पैमाने पर रीफ़ैक्टरिंग द्वारा 14 बाइट्स सहेजे गए। एक -दूसरे को कम आंकने के लिए apsillers और Ypnypn को बहुत-बहुत धन्यवाद ।
  • प्रत्येक पिक्सेल के रंगों को -loop को रिफ्लेक्ट करके 1 बाइट को बचायाfor

1
आप फॉर-लूप को कम से कम कर सकते हैं, for(k in t)जिसके उपयोग से कुछ और बाइट्स
बचेंगे

1
अच्छा काम! कुछ सुधार: खो ()में new Image(); का उपयोग टैग टेम्पलेट तार अपने स्ट्रिंग तर्क के लिए ( createElement`canvas`, getContext`2d`), एक तीर कार्यों मापदंडों के लिए कोष्ठक का उपयोग नहीं करते (बस कर f=u=>{...}; कोष्ठक केवल बहु पैरामीटर या शून्य पैरामीटर तीर funcs के लिए कर रहे हैं)। इसके अलावा आपके पास एक या दो एकल-स्टेटमेंट forलूप हो सकते हैं जिनमें कोष्ठक होते हैं, जो आवश्यक नहीं हैं।
अप्सिलर्स 14

ओह, वास्तव में, शून्य-तर्क तीर फ़ंक्शंस के लिए, दो-चार खाली पैरेंस के बजाय एकल-वर्ण डमी तर्क का उपयोग करें। ( i.onload=$=>...इसके बजाय i.onload=()=>...)
अप्सिलर्स

मुझे लगता है कि for(l in u)f.push(u[l]);हो सकता हैfor(z of u)f.push(z);
Ypnypn

@Ypnypn यह उससे भी छोटा हो सकता है :)। - for(u of t)for(z of u)f.push(z)बहुत कम खतरा है, लेकिन इसे और छोटा किया जा सकता है t.map(u=>u.map(z=>f.push(z)))। बहुत सारे मामलों में, एक तीर फ़ंक्शन का उपयोग करना .mapया उसके .someसाथ forलूप का उपयोग करने की तुलना में कम होना है । आप जाना चाहते हैं, तो वास्तव में पागल, आप और भी अधिक यहाँ से बचा सकता है t.map(u=>f.push.apply(f,u));कहते हैं, "जो हर सरणी के लिए uमें t, आपूर्ति uकरने के लिए तर्कों की सूची के रूप में f.pushके माध्यम से apply(के बाद से pushबहस का एक असीम संख्या को स्वीकार कर सकते हैं और यह क्रम में उन सभी को धक्का)।
अप्सिलर्स

4

बाश + जीएनयू के बर्तन, 80

s()(sed 1d $1|cut -d\  -f$2)
sed 1q $1
s $1 2-|sort -t_ -k1.16|paste <(s $1 1) -

यह मानता है कि इनपुट / आउटपुट फॉर्मेट इमेजमैजिक पिक्सेल एन्यूमरेशन .txt प्रारूप में है। इनपुट को फ़ाइल नाम के रूप में पास किया जाता है और आउटपुट STDOUT में चला जाता है।


यदि उपरोक्त को एक प्रसिद्ध छवि प्रारूप नहीं माना जाता है, तो हम आवश्यक रूपांतरण में जोड़ सकते हैं:

बैश + जीएनयू के बर्तन + इमेजमैजिक, 108

s()(sed 1d t|cut -d\  -f$1)
convert $1 txt:t
(sed 1q t
s 2-|sort -t_ -k1.16|paste <(s 1) -)|convert txt:- $2

इनपुट और आउटपुट फाइलनाम के रूप में निर्दिष्ट हैं। ImageMagick यह निर्धारित करता है कि उत्तीर्ण फ़ाइल एक्सटेंशन द्वारा किस फ़ाइल प्रारूप का उपयोग किया जाए, इसलिए हम किसी भी सामान्य का उपयोग कर सकते हैं:

$ ./sortpixels.sh 398px-Grant_Wood_-_American_Gothic_-_Google_Art_Project.jpg o.png
$ 

परिणामी o.png ऐसा दिखता है:

यहाँ छवि विवरण दर्ज करें


3

अजगर 2, 128 बाइट्स

from PIL import*
a=Image.open('a')
b=a.load()
c,d=a.size
a.putdata(sorted(b[e,f]for f in range(d)for e in range(c)))
a.save('b')

बशर्ते छवि एक फाइल है जिसका aकोई एक्सटेंशन नहीं है, आउटपुट एक फाइल होगा जिसका bकोई एक्सटेंशन नहीं है।

अमेरिकन गोथिक अमेरिकन गोथिक (क्रमबद्ध)


मैंने जाँच नहीं की है, लेकिन आपको a.putdata(sorted(b[f/c,f%d]for f in range(d*c)))इसके बजाय कुछ करने में सक्षम होना चाहिए (मैं अभी उठा, इसलिए मैंने चर मिलाया हो सकता है)।
केड

जैसा कि आपने इसे लिखा है, यह काम नहीं किया (सूचकांक से बाहर), लेकिन मैंने किसी भी चर के आसपास स्विच करने की कोशिश नहीं की है (मेरे पास इस समय बहुत समय नहीं है)। @ शेबबैंग
जैच गेट्स

3

जावा, 316 बाइट्स

import javax.imageio.*;class C{public static void main(String[]a)throws Exception{java.awt.image.BufferedImage i=ImageIO.read(new java.io.File(a[0]));int w=i.getWidth(),h=i.getHeight(),v[]=i.getRGB(0,0,w,h,null,0,w);java.util.Arrays.sort(v);i.setRGB(0,0,w,h,v,0,w);ImageIO.write(i,"png",new java.io.File("a.png"));}}

एक सरणी में पिक्सेल रंगों के हेक्साडेसिमल मानों को रखता है। सरणी को सॉर्ट किया जाता है, और रंग को छवि में पिक्सेल पर रीमेक किया जाता है। परिणामी छवि का नाम है a.png

पीले ट्यूलिप इनपुट पीला ट्यूलिप उत्पादन
अमेरिकी गॉथिक इनपुट यहाँ छवि विवरण दर्ज करें


3

स्माइलबासिक, 39 35 बाइट्स

मान लें कि छवि 512 * 512 ग्राफिक्स पृष्ठ पर भरी हुई है:

DIM A[0]GSAVE A,0SORT A
GLOAD A,0,1

व्याख्या की:

DIM IMG[0] 'create array
GSAVE IMG,0 'save graphics to array
SORT IMG 'sort
GLOAD IMG,0,1 'load graphics from array

यह इत्ना आसान है! दुर्भाग्य से हमें पूर्णांक का उपयोग करना पड़ता है, जो टाइप प्रत्यय के कारण प्रोग्राम आकार में 4 बाइट जोड़ता है।


मुझे वास्तव में यकीन नहीं है कि क्यों ints की आवश्यकता है। ऐसा लगता है कि फ्लोट का उपयोग करने से वास्तव में परिणाम सही हो जाते हैं। इस कोड को इन्टस पर चलाने से ऊपर बाईं ओर और नीचे दाईं ओर SYS/DEFSP.GRPएक पुट होता है, जो प्रश्न के स्पष्ट विपरीत होता है। फ्लोट्स का उपयोग करने से ऊपर बाईं ओर और नीचे दाईं ओर, जो सही है। (बेशक, यह हेक्स रंगों को अहस्ताक्षरित / उच्चतर चैनल के रूप में मानता है, जो शायद सही है।)FF0000000010101000000000FFF8F8F8
घोंघा_

मुझे लगता है कि यह मान्य है, क्योंकि प्रश्न किसी विशिष्ट क्रम को निर्दिष्ट करने के लिए निर्दिष्ट नहीं करता है (और चूंकि मान हस्ताक्षरित हैं, 0xFF000000उससे छोटा है 0x00101010), लेकिन वैसे भी, मुझे वास्तव में यकीन नहीं है कि मैंने यहां पूर्णांक का उपयोग क्यों किया ... मुझे लगता है जिस समय मुझे समझ नहीं आया कि जब आप फ्लोट ऐरे का उपयोग करते हैं तो GLOAD ने अहस्ताक्षरित मानों का उपयोग कैसे किया, और यह मान लिया कि यह काम नहीं किया।
12M2121

2

जावा, 424 417 404 बाइट्स

खैर, यह एक ऐसी भाषा नहीं है जिसे आप गोल्फ में करना चाहते हैं ...

import java.awt.image.*;import java.io.*;import javax.imageio.*;class F{public static void main(String[]x)throws Exception{BufferedImage i,o;i=ImageIO.read(new File(x[0]));o=new BufferedImage(i.getWidth(),i.getHeight(),BufferedImage.TYPE_INT_RGB);o.setData(i.getRaster());int[]p=((DataBufferInt)o.getRaster().getDataBuffer()).getData();java.util.Arrays.sort(p);ImageIO.write(o,"png",new File("o.png"));}}

2

सी #, 497 बाइट्स

पहली बार पोस्ट, पहला गोल्फ। स्पष्ट रूप से गोल्फ के लिए सबसे अच्छा नहीं है

वास्तव में पाइपिंग का सम्मान नहीं। एक छवि पथ को एक इनपुट के रूप में लेता है और नाम के साथ "ओ" प्रीपेंड के साथ इसे आउटपुट करता है।

बिटमैप्स के साथ बेहतर काम करता है, दूसरों के साथ परिणाम होता है

using System.Linq;using System.Drawing;using System.Runtime.InteropServices;class Program{static void Main(string[]args){using(var im=(Bitmap)Image.FromFile(args[0])){int h=im.Height;int w=im.Width;var b=im.LockBits(new Rectangle(0,0,w,h),System.Drawing.Imaging.ImageLockMode.ReadWrite,System.Drawing.Imaging.PixelFormat.Format32bppRgb);var p=new int[h*w];Marshal.Copy(b.Scan0,p,0,h*w);var q=p.ToList();q.Sort();p=q.ToArray();Marshal.Copy(p,0,b.Scan0,h*w);im.UnlockBits(b);im.Save("o"+args[0]);}}}

1

हास्केल, 195 बाइट्स

import Data.List
import Graphics.GD
f p=do 
 a<-loadPngFile p;(x,y)<-imageSize a;let l=[(i,j)|j<-[0..y],i<-[0..x]]
 mapM(flip getPixel a)l>>=mapM(\(d,c)->setPixel d c a).zip l.sort;savePngFile"o"a

यह GDपुस्तकालय का उपयोग करता है । उपयोग f <filename>। इनपुट फ़ाइल pngप्रारूप में होनी चाहिए । आउटपुट फ़ाइल का नाम हैo

यह कैसे काम करता है: सीधा, यानी चित्र पढ़ें, सभी निर्देशांकों पर चलें और पिक्सेल प्राप्त करें, पिक्सेल छाँटें, फिर से निर्देशांक पर चलें, लेकिन इस बार क्रमबद्ध सूची में दिखाई देने वाले क्रम में पिक्सेल सेट करें, फ़ाइल को लिखें डिस्क।

यहाँ छवि विवरण दर्ज करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.