आरजीबी स्नातक पीढ़ी


18

चुनौती

दो बड़े हेक्साडेसिमल तार को देखते हुए (दोनों 6 वर्ण, XXXXXX और yyyyyy) आरजीबी मूल्यों का प्रतिनिधित्व (से लेकर 000000को FFFFFFसम्मिलित), और एक सकारात्मक गैर शून्य एन पूर्णांक, N + 2 XXXXXX से yyyyyy करने के लिए उत्पन्न रंग की एक रेखीय संक्रमण प्रदर्शित यह एक रंग ढाल में परिणाम होगा।

उदाहरण

इनपुट

FF3762
F08800
9

उत्पादन

कृपया हमारे उदाहरण पर ध्यान दें, मैंने दोनों रंगों के बीच 9 अंतरिम चरणों का अनुरोध किया है, इसलिए प्रारंभिक रंग से अंतिम रंग तक 11 रेखाएं प्रदर्शित की जाएंगी

FF3762
FD3F58
FC474E
FA4F44
F9573A
F75F31
F66727
F46F1D
F37713
F17F09
F08800

चेतावनियां

हालांकि मैं अंतरिम रंगों के पूर्णांक मानों को हेक्साडेसिमल में वापस परिवर्तित करने से पहले एक सरल रैखिक प्रक्रिया के साथ गया हूं, आपके तरीके भिन्न हो सकते हैं। कृपया उन विभिन्न तरीकों पर विचार करें , जिनके अनुसार आप अपनी संख्याओं को बढ़ा / घटा सकते हैं

परिक्षण

इसे दिलचस्प बनाने के लिए, मैंने आपके कोड के परीक्षण की अनुमति देने के लिए एक स्निपेट प्रदान किया है, जिसमें एक बटन शामिल है जो आपको आपके कोड के परीक्षण के लिए दो यादृच्छिक रंग प्रदान करेगा। अपने परिणाम प्रदर्शित करना वैकल्पिक है, लेकिन यह प्रोत्साहित किया जाता है!

c1=()=>('00000'+(Math.random()*(1<<24)|0).toString(16)).slice(-6);

$("#col").click(function(){
  alert("Your two colors are: "+c1()+" and "+c1()+".");
});
        
$("#colors").blur(function(){
  $("#test").empty();
	var colArr = $("#colors").val().split("\n");
	for(c in colArr){
  	$("#test").append('<div class="tester" style="background-color:#'+colArr[c]+';">'+colArr[c]+'</div>')
  }
  
});
.tester{height: 20px;
width: 60px;padding: 4px;border: 1px solid black;}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<button id="col">Your two colors</button><br />
<textarea id="colors"></textarea>
<div id="test">

</div>

1) आप "अपने दो रंगों" बटन पर क्लिक करके अपने परीक्षण के लिए दो यादृच्छिक रंगों का उपयोग कर सकते हैं। 2) अंतरिम चरणों की संख्या आपके PPCG उपयोगकर्ता नाम के रिक्त स्थान में शामिल वर्णों की संख्या के समान होगी, "WallyWest" के मामले में यह 9 होगा (ऊपर मेरे उदाहरण के अनुसार)। 3) अपने कोड को दो रंगों और संख्या के साथ चलाएं और एक बार आपकी जनरेट की गई सूची के बाद, आपके पास अपने उत्पन्न टेक्स्ट ग्रैडिएंट को प्राप्त करने के लिए अपने आउटपुट को टेक्स्टारिया में चिपकाने और इसे दूर करने का विकल्प होता है।

मेरा उदाहरण यहाँ दिखाया गया है:

ढ़ाल

मुझे मानना ​​होगा, कि बहुत बढ़िया लग रहा है!

कृपया ध्यान दें: जैसा कि मैंने उल्लेख किया है, स्निपेट का उपयोग करके अपने आउटपुट का परीक्षण दिखाना वैकल्पिक है, लेकिन इसे प्रोत्साहित किया जाता है! :)

उत्पादन

सूची आउटपुट एन + 2 सेट 6 अंकों के हेक्स संख्या के रूप में होना चाहिए जो लाइन फीड (\ n) द्वारा अलग किया गया है जैसा कि ऊपर मेरे उदाहरण में दिखाया गया है। आउटपुट अलग-अलग लाइनों, स्पेस / अल्पविराम से अलग सूची, एक सरणी या जो कुछ भी आपकी भाषा के लिए सबसे उपयुक्त है, के रूप में हो सकता है ... (हेड अप के लिए धन्यवाद @nimi) कृपया याद रखें, यदि आप अपने कोड के परीक्षण के साथ योजना बनाते हैं स्निपेट, हालांकि आप प्रत्येक "रंग" को अलग करते हैं, आप पर निर्भर है।

नियम

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



सुप्रसिद्ध, और अद्यतन ... शीर्ष के लिए धन्यवाद (+1)
वैलीवेस्ट

जिज्ञासा से बाहर, क्या इलस्ट्रेटर जैसे छवि एप्लिकेशन कुछ अवधारणात्मक रंग स्थान में रैखिक ग्रेडिएंट या ग्रेडिएंट का उपयोग करते हैं? मैं दोनों के लिए मामलों का उपयोग कर सकता हूं (हो सकता है कि आप बाद में अवधारणात्मक रूपांतर कर रहे हों जैसे किसी खेल के लिए बनावट)।
रॉबर्ट फ्रेजर

जवाबों:


1

MATL , 31 बाइट्स

2+1yhjjh2e!1ZA3e!b:1&Ynk8W5Y2Za

यह नीचे गोलाई के साथ रैखिक प्रक्षेप का उपयोग करता है। इनपुट प्रारूप है

9
FF3762
F08800

इसे ऑनलाइन आज़माएं!

ग्राफिकल आउटपुट, 31 बाइट्स

2+1yhjjh2e!1ZA3e!b:t2YG1&Ynk2ZG

यह इनपुट के लिए परिणाम है

5
FF3762
F08800

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

MATL ऑनलाइन में यह कोशिश करो ! दुभाषिया वर्तमान में प्रायोगिक है। यदि आपको कोई आउटपुट नहीं मिलता है तो पेज को रिफ्रेश करें और फिर से "रन" दबाएं।


4

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

g=
(f,t,n)=>[...Array(++n+1)].map((_,i)=>f.replace(/../g,(e,j)=>((`0x${e}`*(n-i)+`0x${t[j]+t[j+1]}`*i)/n|256).toString(16).slice(1)))
;
p=_=>g(f.value,t.value,+n.value).map(e=>o.insertRow().insertCell().appendChild(document.createTextNode(e)).parentNode.bgColor=e);
<input id=f value=e14f09><input id=t value=9a04f6><input id=n value=4 type=number><input type=button onclick=p() value=Go!><table id=o bgcolor=black cellpadding=4>


3

दलयोग एपीएल , 44 बाइट्स

एन के लिए संकेत , फिर बी ईजिनिंग-कलर, फिर एनडिंग-कलर। ⎕IO←0कई प्रणालियों पर डिफ़ॉल्ट की आवश्यकता है।

h[↑⌊B∘+¨(⍳2+N)×(-/E B←(h←⎕D,⎕A)∘⍳¨⍞⍞)÷1+N←⎕]

h[... h] में अनुक्रमणिका (जिसका मान तब होता है जब हम ब्रैकेट की सामग्री का मूल्यांकन करते हैं)

N←⎕संख्यात्मक N के लिए संकेत (4)

1+ एक को जोड़ें N (5) में जोड़ें

(... का उपयोग करें कि परिणाम को विभाजित करने के लिए ...

  ⍞⍞ दो चरित्र तार के लिए संकेत ["7E0E7E", "FF3762"]

  (... )∘⍳¨प्रत्येक स्ट्रिंग के वर्णों के सूचक ढूंढें ...

   ⎕D,⎕A डी के बाद igits एक वर्णमाला

   h← को सौंपना एच

  अब हमारे पास "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" है

  E B←E और B को संकेत दें [[7,14,0,14,7,14], [15,15,3,7,6,2]

  -/E से B को घटाएं और घेरें [[-8, -1, -3,7,1,12] घेरें]

  अब तक का परिणाम [[-1.6, -0.2, -0.6,1.4,0.2,2.4]] है

(... इससे गुणा करें ...

  2+Nदो प्लस एन (6)

   पहला पूर्णांक [0,1,2,3,4,5]

 यह हमें [[0,0,0,0,0,0], - - 1.6, -0.2, -0.6,1.4,0.2,2.4], [- 3.2, -0.4, -1.2,2.8,0.4,4.8 देता है। ], ...]

B∘+¨जोड़ने बी करने के लिए प्रत्येक [[15,15,3,7,6,2], [13.4,14.8,2.4,8.4,6.2,4.4], [11.8,14.6,1.8,9.8,6.4,6.8], ... ]

राउंड डाउन [[15,15,3,7,6,2], [13,14,2,8,6,4], [11,14,1,9,6,6], ...]

तालिका में सूचियों की सूची बनाएं

[[15,15, 3, 7, 6, 2]
 [13,14, 2, 8, 6, 4]
 [11,14, 1, 9, 6, 6]
 [10,14, 1,11, 6, 9]
 [ 8,14, 0,12, 6,11]
 [ 7,14, 0,14, 7,14]]

में हम सूचकांक यहां , दे रही है

[["F","F","3","7","6","2]
 ["D","E","2","8","6","4]
 ["B","E","1","9","6","6]
 ["A","E","1","B","6","9]
 ["8","E","0","C","6","B]
 ["7","E","0","E","7","E]]

जो जैसा है वैसा है

[["FF3762"]
 ["DE2864"]
 ["BE1966"]
 ["AE1B69"]
 ["8E0C6B"]
 ["7E0E7E"]]

और प्रिंट करता है

FF3762
DE2864
BE1966
AE1B69
8E0C6B
7E0E7E

ढाल

TryAPL ऑनलाइन!


अच्छा काम! संक्रमण बहुत अच्छा लग रहा है!
WallyWest

@WallyWest धन्यवाद। यह शायद सबसे अलग से एक अलग रैखिक संक्रमण है: प्रत्येक अक्षर अलग-अलग रूपांतरित होता है।
आदम

2

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

बुरी तरह से घायल, बस छोड़ दिया।

j++hQsMCm.HMsM:F+dc-FdvzCmiR16cd2Qe

इसे यहाँ ऑनलाइन आज़माएँ

उदाहरण:

उदाहरण


मैं ग्रेडिएंट की 11 पंक्तियाँ गिनता हूँ, हालाँकि आपके PPCG नाम में केवल 8 अक्षर हैं ... तो क्या आपको 7cb472 93fb8a 8अपने कोड का परीक्षण करते समय केवल 10 लाइनों का आउटपुट नहीं मिला होगा?
3

@ पूरी तरह से उपयोगकर्ता नाम के बारे में ओपी में उस हिस्से को पूरी तरह से याद किया, मैंने सिर्फ 9 cuz का उपयोग किया, जिसे आप ठीक कर रहे हैं।
माल्टीसेन

@WallyWest अपडेट किया गया
Maltysen

हे @ मेल्टीसेन, ग्रेडिएंट थोड़ा अजीब लगता है ... आपको दो संदर्भ मिल गए हैं 93fb8a... क्या आपके कोड ने समान मान की दो पंक्तियाँ तैयार की थीं?
वैलीवेस्ट

2

PowerShell v2 +, 176 159 150 बाइट्स

param($a,$b,$n)$x=$a-split'(..)'-ne'';$a;++$n..1|%{$j=$_;-join($x=$x|%{"{0:x2}"-f(+"0x$_"-[int]((+"0x$_"-"0x$(($b-split'(..)'-ne'')[$i++%3])")/$j))})}

इनपुट को दो स्ट्रिंग्स और एक संख्या के रूप में लेता है, फिर स्टार्ट स्ट्रिंग को हर दो वर्णों पर विभाजित स्ट्रिंग्स के एक सरणी में बदल देता है, इसमें स्टोर करता है $x। फिर हम $aअपने शुरुआती सेक्शन के रूप में आउटपुट करते हैं, और लूप ++$nटू से1 (उचित fenceposting सुनिश्चित करने के लिए)।

प्रत्येक पुनरावृत्ति, सहायक $jसंख्या को वर्तमान संख्या में सेट करती है (बाद में यह सुनिश्चित करने के लिए उपयोग किया जाता है कि हमें उन चरणों के बीच सही संख्या मिली है जहाँ हम वर्तमान में अपने गंतव्य पर हैं) और अगले चरण की गणना लूप के आधार पर करते हैं$x

प्रत्येक आंतरिक लूप केवल एक असाइनमेंट है। हम ormat ऑपरेटर का उपयोग करके $xएक नए स्ट्रिंग के बराबर उपयुक्त स्थान पर सेट कर रहे हैं । यहां एक दो अंकों हेक्साडेसिमल उत्पादन निर्दिष्ट करती है और इनपुट के दाएँ हाथ की ओर है ऑपरेटर। PowerShell में एक देशी हेक्साडेसिमल-टू-दशमलव ऑपरेटर है , इसलिए यह लंबा लंबित-नेस्टेड अभिव्यक्ति वर्तमान ऑपरेटर को संख्याओं में बदलने के लिए उस ऑपरेटर का उपयोग कर रहा है, जिससे अंतर को खोजने के लिए घटाना अभी तक जाना है (डायनेमिक रूप से शानदार तरीके से यहां किया गया है जैसे हमने किया था । और सही तत्व का चयन करने के लिए मोडुलो का उपयोग करके), (PowerShell डिफ़ॉल्ट रूप से बैंकर की गोलाई ) को विभाजित करता है, और उस चरण-गणना को वर्तमान हेक्स से घटाकर प्राप्त करता है जो हमारे अगले हेक्स को होना चाहिए।"{0:x2}"-fx2-f0x$b$a$j शेष चरणों से , कास्टिंग करना[int]

उस गणना का परिणाम $xतीन हेक्स तत्वों के रूप में वापस संग्रहीत किया जाता है। यही कारण है कि पाइप लाइन पर एक प्रतिलिपि बनाने के लिए, और -joinएक ही स्ट्रिंग में एक साथ एड करने के लिए Parens में समझाया गया है । उन सभी परिणामी तारों को पाइप लाइन पर छोड़ दिया जाता है, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम निष्पादन पर होता है।


उदाहरण

मुझे मेरे दो रंगों के लिए 0ba7c5 और 6c0e50 दिया गया , और इसमें TimmyD के 6 अक्षर हैं।

PS C:\Tools\Scripts\golfing> .\rgb-gradients-generation.ps1 '0ba7c5' '6c0e50' 6
0ba7c5
1991b4
277ba3
356592
434f82
513971
5f2361
6c0e50

स्नातक उदाहरण


1

पायथन 2, 189 बाइट्स

w='[int(%s[i:i+2],16)for i in range(0,6,2)]'
def f(a,b,n):
 l=lambda x,y:'%02x'%int((x*(n-i)+y*i)/n);c,d,e=eval(w%'a');f,g,h=eval(w%'b');n+=1
 for i in range(n+1):print l(c,f)+l(d,g)+l(e,h)

ढाल स्क्रीनशॉट


रंगों की भव्य जोड़ी, @AndrewEpstein ... कोड के साथ अच्छा काम!

1

[Groovy] अंतिम अद्यतन (199 बाइट्स) - अनुरोध के अनुसार

गैर गोल्फ

def g(a,b,n){
  (0..(1.0/n)).collect{
    c->
    x={s->s.split("(?<=\\G.{2})").collect{Integer.parseInt(it,16)}};
    (0..2).collect {
      (int)(x(a).get(it)*n*c+x(b).get(it)*(1-n*c))
    }.collect {
      String.format("%X", it)
    }.join()
  }
}
g('FFFFFF','000000',1/10​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​)​​​​​​​​​​​​​​

गोल्फ़

g(a,b,n){(0..(1.0/n)).collect{c->x={s->s.split("(?<=\\G.{2})").collect{Integer.parseInt(it,16)}};(0..2).collect {(int)(x(a).get(it)*n*c+x(b).get(it)*(1-n*c))}.collect{String.format("%X",it)}.join()}}

यहां अंतिम प्रयास करें: https://groovyconsole.appspot.com/script/513069676796405760


पुराने संस्करण कम हो जाते हैं, ओपी द्वारा घोषित


ग्रूवी (123 बाइट्स)

गोल्फ़

def g(r,g,b,r2,g2,b2,s){(1..(1.0/s)).collect{c->[(int)(r*s*c+r2*(1-s*c)),(int)(g*s*c+g2*(1-s*c)),(int)(b*s*c+b2*(1-s*c))]}}

गैर गोल्फ

def g(r,g,b,r2,g2,b2,s){
  (1..(1.0/s)).collect {
    c ->
    [(int)(r*s*c+r2*(1-s*c)),(int)(g*s*c+g2*(1-s*c)),(int)(b*s*c+b2*(1-s*c))]
  }
}

इनपुट

r,g,b -> Starting RGB Color
r2,g2,b2 -> Ending RGB Color
s -> Gradient step

आउटपुट उदाहरण

(00,00,00,255,255,255,.5)

का परिणाम

[
  [255, 255, 255]
  [127, 127, 127]
  [0, 0, 0]
]

इसे स्वयं आज़माएँ: https://groovyconsole.appspot.com/script/5184465357777656

हेक्स रूपांतरण के साथ शामिल हैं

मुझे लगता है मैं भी धोखा दे रहा हूँ ... यहाँ हेक्स का उपयोग करने के साथ स्क्रिप्ट है:

हेक्स रूपांतरण के साथ नया कोड:

​    def g(r,g,b,r2,g2,b2,s){
      (0..(1.0/s)).collect {
        c ->
        String.format("%X", ((int)(r*s*c+r2*(1-s*c)))) +  String.format("%X", ((int)(g*s*c+g2*(1-s*c)))) + "" +  String.format("%X", ((int)(b*s*c+b2*(1-s*c))))
      }
    }

    g(126,34,166,218,26,33,0.0625)​

१ अक्षर जब गॉल्फर्ड होते हैं:

def g(r,g,b,r2,g2,b2,s){(0..(1.0/s)).collect {c->String.format("%X",((int)(r*s*c+r2*(1-s*c))))+String.format("%X",((int)(g*s*c+g2*(1-s*c))))+String.format("%X",((int)(b*s*c+b2*(1-s*c))))}}

000000 से FFFFFF और 16 के लिए आउटपुट (उपयोगकर्ता नाम लंबाई)

g(00,00,00,255,255,255,0.0625).each{println it}​

1/16 चरणों के साथ मोनोक्रोमेटिक ग्रेडिएंट


Err ... थोड़ा अमान्य, उपयोग किया गया मूल संस्करण "(0 .. (1.0 / s))", होना चाहिए था "(1 .. (1.0 / s))"।
मैजिक ऑक्टोपस उर्फ़

1
हाय @carusocomputing ... इनपुट को दो हेक्साडेसिमल स्ट्रिंग्स और एक पूर्णांक होने की आवश्यकता है ... मुझे यकीन नहीं है कि अगर ग्रूवी इस तरह से इनपुट ले सकता है, लेकिन आपने संक्षिप्त रूप से किसी का नाम नहीं लिया है ... क्या आप अपडेट कर सकते हैं चुनौती अनुभाग में उल्लिखित इनपुट के आधार पर आपका कोड?
वॉलीवेस्ट

{s-> s.split("(?<=\\G.{2})").collect{Integer.parseInt(it,16)}}('FFFFFF') [२५५,२५५,२५५] में परिणाम मैं उस रूपांतरण का उपयोग करके अपने कोड में ६२ बाइट जोड़ सकता हूं यदि आप वास्तव में मुझे चाहते हैं।
मैजिक ऑक्टोपस उर्फ़

1
वैली, मैंने एक अपडेटेड वर्जन जोड़ा है और अपने फाइनल बाइट काउंट को 199 के साथ रूपांतरण के साथ जोड़ दिया है।
मैजिक ऑक्टोपस उर्फ़

1

आर, 68 बाइट्स

एक अंतर्निहित फ़ंक्शन है जो दो रंगों को प्रक्षेपित करता है:

a=scan(,'')
colorRampPalette(paste0("#",a[1:2]))(as.numeric(a[3])+2)

इनपुट:

d9e7a5
3ef951
15

आउटपुट: मानों के साथ एक वेक्टर

"#D9E7A5" "#CFE89F" "#C5E99A" "#BBEA95" "#B2EB90" "#A8EC8A" "#9EED85" "#95EE80"
"#8BF07B" "#81F175" "#78F270" "#6EF36B" "#64F466" "#5BF560" "#51F65B" "#47F756"
"#3EF951"

R में कलर स्पेसिफिकेशन के लिए हैश सिंबल की जरूरत होती है।

रंग रैंप

चलो एक समारोह की तरह कुछ, साजिश:

filled.contour(outer(1:20, 1:20, function(x,y) sin(sqrt(x*y)/3)),
    col = colorRampPalette(paste0("#",a[1:2]))(as.numeric(a[3])+2))

पाप (sqrt (एक्स * वाई) / 3)


शानदार उत्तर, लेकिन संक्षिप्त रूप में आपके PPCG उपयोगकर्ता नाम में कई चरणों का उपयोग करने के लिए कहता है, जो अंतरिक्ष की गिनती 15 बनाता है ... क्या आप कृपया अपने उत्तर को अपडेट कर सकते हैं FF3762 F08800 15?
वॉलीवेस्ट

@WallyWest क्षमा करें, मैं उस हिस्से को याद कर रहा था जहाँ कोई दो रंग प्राप्त करता है और अपनी स्वयं की उपयोगकर्ता नाम की लंबाई गिनता है। अब जवाब पूरी तरह से विनिर्देश के अनुरूप होना चाहिए!
आंद्रे

1

सी, 175 169 168 बाइट्स

i;j;x[6];f(a,b,n)char*a,*b;{char*f="%2x%2x%02x";for(n++;i<=n;i++,puts(""))for(j=sscanf(a,f,x,x+1,x+2)-sscanf(b,f,x+3,x+4,x+5);j++<printf(f+6,x[j]+(x[j+3]-x[j])*i/n););}

Ungolfed:

int i, j;
int x[3], y[3];

f(char *a, char *b, int n) {
  sscanf(a, "%2x%2x%2x", &x[0], &x[1], &x[2]);
  sscanf(b, "%2x%2x%2x", &y[0], &y[1], &y[2]);

  for(i = 0, n++; i <= n; i++) {
    for(j = 0; j < 3; j++)
      printf("%02x", x[j] + (y[j] - x[j]) * i / n);
    puts("");
  }
}

5 बाइट्स से शेविंग करने के लिए @ h-walters का धन्यवाद!


मुझे याद दिलाएं कि putsवाक्यविन्यास फिर से क्या करता है?
वैलीवेस्ट

यह पसंद है printf(), लेकिन कोई स्वरूपण नहीं करता है, इसके बजाय यह दिए गए स्ट्रिंग को केवल प्रिंट करता है, और यह एक नई पंक्ति जोड़ता है।
जी। स्लीपेन

आह, तो वहाँ गोल्फ का कोई रास्ता नहीं है कि ... सी की तरह थोड़ा प्रतिबंधक है, यह नहीं है?
20

"तो वहाँ गोल्फ का कोई रास्ता नहीं है कि" ... यकीन है कि वहाँ है! puts("")लूप के लिए पहले के तीसरे भाग में स्थानांतरित करें ( पहले ;बनने के बाद ,) ... +0 बाइट्स। हालांकि, यह आपको दूसरे लूप के बाद घुंघराले ब्रेसिज़ को हटाने की अनुमति देता है ... -2 बाइट्स। आप 3 में से 3 को हटाकर एक और 1 बाइट बचा सकते हैं j<3, और इसे अपने printfबयान के साथ बदल सकते हैं (यह डरपोक है ... प्रिंटफ केवल 2 वापस आएगा, लेकिन इसे अभी भी तीसरी बार मूल्यांकन करना है)।
एच वाल्टर्स

... दो और बाइट्स को आपके sscanf रिटर्न वैल्यू को एक दूसरे से घटाकर बचाया जा सकता है (परिणामस्वरूप 0), और इसके बजाय शाब्दिक 0का उपयोग करें j=0। एक बार यहां सब कुछ होने के बाद आपका प्रोग्राम 5 बाइट्स छोटा होना चाहिए, और कम से कम 50% अजनबी होना चाहिए।
एच वाल्टर्स

1

sh + ImageMagick, 81 बाइट्स

convert -size 1x$((2+$3)) gradient:#$1-#$2 -depth 8 txt:-|grep -o "[A-F0-9]\{6\}"

उपयोग:

> ./grad.sh FF3762 F08800 9
FF3762
FE3F58
FC474E
FB4F45
F9573B
F86031
F66827
F5701D
F37814
F2800A
F08800

("-depth 8" आवश्यक नहीं है यदि आपका IM डिफ़ॉल्ट के रूप में 8bpp के साथ संकलित है)

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