HTML रंग आउटपुट


30

16-रंग CGA पैलेट ( HTML रंग के रूप में भी जाना जाता है ) 16 ग्राफ़िक्स एडेप्टर द्वारा उपयोग किए जाने वाले 16 रंगों का एक सेट है। इस चुनौती का लक्ष्य उन सभी 16 को हेक्स प्रारूप में ( RRGGBB), हेक्स मान द्वारा आरोही क्रम में, नई सूचियों द्वारा अलग करना है। इस प्रकार, आउटपुट बिल्कुल यही होना चाहिए:

000000
000080
0000FF
008000
008080
00FF00
00FFFF
800000
800080
808000
808080
C0C0C0
FF0000
FF00FF
FFFF00
FFFFFF

एक एकल अनुगामी न्यूलाइन की अनुमति है, लेकिन आवश्यक नहीं है।

जवाबों:


13

जेली , 31 29 27 बाइट्स

“×Ɗ¡‘ŒP»Ṫ¦209ṗ€3Fd⁴ịØHs3ṢQY

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

यह काम किस प्रकार करता है

“×Ɗ¡‘जेली के दशक में उद्धरण के बीच पात्रों में से कोड अंक प्राप्त होते SBCS है, जो कर रहे हैं 0x11 = 17 , 0x91 = 145 , और = 0 0x00

ŒP पैदावार कोड बिंदुओं की सरणी के अधिकार का निर्माण करता है

[[], [17], [145], [0], [17, 145], [17, 0], [145, 0], [17, 145, 0]]

अंतिम दो प्रविष्टियाँ उन संयोजनों के अनुरूप हैं जिनमें 80 और एफएफ दोनों शामिल हैं , इसलिए हमें उन्हें त्यागना होगा।

»Ṫ¦209 तीन भाग होते हैं:

  • (टेल) कोड बिंदुओं के अंतिम सरणी को हटाता है, अर्थात, [17, 145, 0]

  • »209Powerset के शेष में प्रत्येक पूर्णांक की अधिकतम लेता है और 0xD1 = 209 , के साथ उन सभी को जगह 209

  • ¦(विरल) शेष शक्तियों के तत्वों पर आधारित है। यदि संबंधित सूचकांक [17, 145, 0] में पाया जाता है , तो तत्व को सभी 209 के साथ बदल दिया जाता है । यदि नहीं, तो यह अछूता रह गया है।

    ¦मॉड्यूलर नहीं है, इसलिए यह केवल शेष सरणी में अंतिम सरणी (इंडेक्स 0 ) को संशोधित करता है । सूचकांक 17 और 145 बहुत बड़े हैं और इनका कोई प्रभाव नहीं है।

परिणाम इस प्रकार है।

[[], [17], [145], [0], [17, 145], [17, 0], [209, 209]]

ṗ€3 प्रत्येक सरणी के तीसरे कार्टेशियन शक्ति की गणना करता है, अर्थात, प्रत्येक सरणी के तत्वों के सभी 3-ट्यूपल्स की सरणी।

Fd⁴परिणाम को समतल करता है और 16 से विभाजित प्रत्येक पूर्णांक के भागफल और शेष की गणना करता है ।

ịØHअनुक्रमणिका (1-आधारित) में "0123456789ABCDEF , इसलिए 0x11 , 0x91 , 0x00 , और 0xD1 को मैप किया हो " 00 " , " 80 " , " एफएफ " , और " C0 " (resp।)।

s3ṢQ चरित्र युग्मों को 3-टुपल्स में विभाजित करता है, टुपल्स को सॉर्ट करता है, और डुप्लीकेट करता है।

अंत में, Yलाइनअप द्वारा अलग करके, अनोखे ट्यूपल्स से जुड़ जाता है।


11

बैश + जीएनयू यूटिलिटीज, 67

  • 2 बाइट्स ने @manatwork को धन्यवाद दिया
  • 2 बाइट्स @zeppelin की बदौलत बच गए
a={00,80,FF}
eval echo $a$a$a|fmt -w9|sed '16iC0C0C0
/F0*8\|80*F/d'
  • ब्रेस विस्तार {00,80,FF}{00,80,FF}{00,80,FF} सही क्रम (छोड़कर सभी की जरूरत संयोजन देता है C0C0C0), कुछ एक्स्ट्रा कलाकार के साथ। अतिरिक्त वे हैं जिनमें वर्ण Fऔर 8वर्ण दोनों होते हैं ।
  • ब्रेस विस्तार का परिणाम एक सिंगल-स्पेस-लाइन है। fmtप्रत्येक प्रविष्टि को अपनी पंक्ति में रखता है
  • sedअभिव्यक्ति की पहली पंक्ति C0C0C0उपयुक्त पंक्ति में सम्मिलित होती है
  • sedअभिव्यक्ति की दूसरी पंक्ति ऊपर वर्णित "एक्स्ट्रा" को फ़िल्टर करती है।

Ideone


6

जेली , 38 31 बाइट्स

“mạ9ṣṃwɠƁ,¡ẓw’b4µża1$ị“08CF”s3Y

TryItOnline!

किसी संख्या का आधार 250 संपीड़न ( “...’),
आधार 4 में परिवर्तित ( b4),
ज़िपित ( ż) एक सदिश तार्किक के बाद स्वयं की एक प्रति के साथ (और 1 a1$) ( ) *,
अनुक्रमित ( ) चार वर्णों में प्रयुक्त ( “08CF”),
विखंडू में विभाजित। लंबाई 3 ( s3),
और लाइन फीड्स ( Y) के साथ शामिल हुई ।

* इस प्रकार प्रत्येक शून्य अंक को एक शून्य के साथ और किसी एक के साथ किसी भी अन्य अंक को जोड़ते हैं। निम्नलिखित अनुक्रमित इस साधन लाने के साथ-साथ 'F'एक और के साथ रखा जाता है 'F', जबकि '0', '8'और 'C'एक साथ प्रत्येक जोड़ी '0'


माइनर संपादित क्या यह उत्तर ठीक करने के लिए: “0FC8”के रूप में हमारे पास 00, FF, C0, और 80
शर्लक

अरे वाह, मैंने नोटिस नहीं किया! धन्यवाद।
जोनाथन एलन

3

पायथन 3, 134 129 125 108 91 90 बाइट्स

मुझे लगता है कि यहां अभी भी बहुत कुछ गोल्फ करना बाकी है। गोल्फ सुझाव का स्वागत करते हैं!

संपादित करें: -9 बाइट्स और स्ट्रिंग प्रारूपण के साथ मदद करने के लिए मीगो को बहुत धन्यवाद। -17 बाइट्स को पहले स्थान पर स्ट्रिंग को प्रिंट करने के लिए एक बेहतर तरीका समझ से। -17 बाइट्स को पहले स्थान पर लूप के लिए लिखने का एक बेहतर तरीका है। के i%3//2*"\n"बजाय उपयोग करने के लिए xnor की टिप के लिए -1 बाइट धन्यवाद "\n"*(i%3<2)

for i in range(48):print(end="F0C8F000"[0x10114abf7f75c147d745d55//4**i%4::4]+i%3//2*"\n")

Ungolfing

z = 0
a = [0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 2, 2, 2, 3, 3, 3, 1, 3, 3, 3, 1, 3, 1, 1, 3, 0, 0, 1, 1, 0, 1, 3, 3, 1, 1, 3, 1, 0, 1, 1, 3, 1, 1, 1, 1, 1]
for i in range(len(a)):
    z = (z + a[i]) * 4
z //= 4                   # we multiplied by 4 one too many times
for i in range(48):
    m = z // 4**j % 4
    s = "F0C8F000"[c::4]
    if i % 3 == 2:
        s += "\n"
    print(s, end="")

इस तरह की कोशिश करें - आपको तर्क को कोष्ठक (या चौकोर कोष्ठक) में लपेटना होगा और इसके साथ विभाजन करना होगा *
मेगो

i%3//2*"\n"एक बाइट बचाता है।
xnor

यह पी 3 के साथ भी काम करता है
मिगुएल

@ मिगुएल नहीं, यह एक संपादन है जिसे मैंने साफ नहीं किया। यह पायथन 2 के साथ काम नहीं करता है।
शर्लक

2

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

2 बाइट्स बचाए, नील की बदौलत

यह 7 9 बाइट्स है जो बैकटिक्स में कच्चे स्ट्रिंग को वापस करने से कम है।

_=>[...'1121173113106393'].map(v=>[4,2,0].map(x=>'08CF'[x=n>>x&3]+'000F'[x],n+=+v||21).join``,n=-1).join`
`

परीक्षा


1
दिलचस्प .replace(/./g)यह है कि लंबाई समान है .map().join, लेकिन .map(x=>'08CF'[x=n>>x&3]+'000F'[x],n+=+v||21)दो बाइट्स बचाता है।
नील

2

पॉवरशेल, 113 106 बाइट्स

'777
7780
77FF
7807
78080
7FF7
7FFFF
8077
80780
80807
808080
C0C0C0
FF77
FF7FF
FFFF7
FFFFFF'-replace7,'00'

हाँ, मुझे शाब्दिक स्ट्रिंग को छापने से कम कुछ नहीं मिला है ... एक साधारण प्रतिस्थापन (जिसका मैं पूरी तरह से अनदेखा किया गया था) का उपयोग करके 7 बाइट्स नीचे शेव करने के लिए @ मार्टिन स्मिथ का धन्यवाद । तो, हम कम से कम 7 बाइट्स हैं, बस इसे हार्डकोड करने से छोटा है। वाह!

लेकिन यह उबाऊ है!

तो इसकी बजाय ...

PowerShell v4, 128 बाइट्स

[consolecolor[]](0,7+9..15)+-split'Lime Maroon Navy Olive Purple Silver Teal'|%{-join"$([windows.media.colors]::$_)"[3..8]}|sort

[system.consolecolor]नाम स्थान सांत्वना रंग (मूल रूप से) को परिभाषित करता है उपलब्ध PowerShell कंसोल के लिए। यदि हम उन्हें इस तरह एक पूर्णांक सरणी के माध्यम से संदर्भित करते हैं, तो डिफ़ॉल्ट मान नाम है (उदाहरण के लिए, Blackया Whiteजैसे)। हम इसे एक स्ट्रिंग के साथ जोड़ते हैं जो -splitरिक्त स्थान पर है, इसलिए अब हमारे पास रंग नामों के स्ट्रिंग की एक सरणी है।

हम उन लोगों के माध्यम से लूप करते हैं |%{...}और प्रत्येक पुनरावृत्ति इसी [system.windows.media.colors]मूल्य को बाहर निकालते हैं । उन वस्तुओं के लिए डिफ़ॉल्ट #AARRGGBBस्ट्रिंग एक हेक्स मान के रूप में प्रारूप में रंग है , इसलिए हम उस कॉल को एक स्क्रिप्ट ब्लॉक के साथ स्ट्रिंग में एन्क्रिप्ट करके लाभ उठाते हैं "$(...)"। लेकिन, चूंकि हम अल्फा वैल्यू या हैश नहीं चाहते हैं, इसलिए हम [3..8]स्ट्रिंग के पिछले छोर को लेते हैं , और इसके -joinपरिणामस्वरूप- charस्ट्रिंग को वापस करने की आवश्यकता होती है । फिर, Sort-Objectउन्हें सही क्रम में रखने के लिए एक सरल ।


1
के 21 उदाहरण हैं 00और .Replace(7,'00')<21 वर्ण हैं।
मार्टिन स्मिथ

मुझे पता नहीं है कि पावरशेल का उपयोग कैसे किया जाता है, लेकिन यह 80 और एफएफ को बदलने के लिए भी इसके लायक हो सकता है।
nedla2004

@ nedla2004 के -replaceलिए कर रहा है 8और 80एक ही बाइट गिनती है (12 शून्य बचाता है, जो -replace8,80लंबाई है)। के लिए यह कर रहा FFहै, क्योंकि चारों ओर की जरूरत उद्धरण के दो बाइट्स से अधिक लंबी है "FF"में -replace2,"FF"बयान।
AdmBorkBork

ठीक है, मैं सोच रहा था कि क्या आप प्रतिस्थापन को किसी तरह जोड़ सकते हैं।
nedla2004



1

05AB1E , 57 बाइट्स

•P{Ætg7«r¨ëÅ,…}ù¢Ý%Vt®£8ãøÚ$0óDÛY²Zþ…ð7ê‘Ó{òìàYëØU¥•hR6ô»

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

हमें मूल रूप से आउटपुट की आवश्यकता है (उलट और विभाजित):

FFFFFF00FFFFFF00FF0000FF0C0C0C080808000808080008000008FFFF0000FF00080800000800FF0000080000000000

जो, दशमलव में है:

39402003857025890357721060524755992261661062099432941475272448103296644696683709026793043150430945208910007869898752

बेस -214 में कौन सा है:

P{Ætg7«r¨ëÅ,…}ù¢Ý%Vt®£8ãøÚ$0óDÛY²Zþ…ð7ê‘Ó{òìàYëØU¥

यह सबसे सरल उपाय है जिसके साथ मैं आ सकता हूं, क्योंकि नरक में कोई रास्ता नहीं है मैं डेनिस को हरा रहा हूं। एक घंटे की कोशिश की और कुछ भी नहीं अपने विचार को हराया।



0

बैच, 137 बाइट्स

@for %%c in (000000 000080 0000FF 008000 008080 00FF00 00FFFF 800000 800080 808000 808080 C0C0C0 FF0000 FF00FF FFFF00 FFFFFF)do @echo %%c

हाँ, यह उबाऊ है। पिछला 148-बाइट प्रयास:

@if "%2"=="" (call %0 000000 80&call %0 C0C0C0 FF)|sort&exit/b
@echo %1
@for %%c in (0000%2 00%200 00%2%2 %20000 %200%2 %2%200 %2%2%2)do @echo %%c

दुर्भाग्य से आप एक forया एक call:कमांड के आउटपुट को पाइप नहीं कर सकते हैं , इसलिए मुझे खुद को पुनरावर्ती रूप से आह्वान करना होगा।



0

बेफुंज, 83 69 बाइट्स

<v"UVTYZQPefij?EDA@"
v>>9\:4/:\4/>4%:3g,0`
<^_@#:,+55$_^#!-9:,g3
F08C

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

रंग स्ट्रिंग में एन्कोडेड होते हैं जो आप पहली पंक्ति पर देखते हैं, प्रति रंग घटक में दो बिट्स, एएससीआईआई रेंज में प्रत्येक मान को बाध्य करने के लिए एक अतिरिक्त उच्च बिट सेट के साथ (63 के मामले को छोड़कर, जो 127 के रूप में सीमा से बाहर होगा) )।

तब स्टैक पर रंगों की सूची इस प्रकार संसाधित की जाती है:

9\          9 is pushed behind the current colour to serve as a marker.
:4/:\4/     The colour is repeatedly divided by 4, splitting it into 3 component parts.

>           The inner loop deals with each of the 3 components. 
 4%         Modulo 4 masks out the 2 bits of the colour component that we care about.
 :3g,       That is used as an index into the table on line 4 to get the character to output.
 0`3g,      For component values greater than 0 the second char is a '0', otherwise an 'F'. 
 :9-!       Check if the next component is our end marker.
^           If not, repeat the inner loop.

55+,        Output a newline.
:_          Repeat the outer loop until there are no more colours on the stack. 

0

सी #, 195 बाइट्स

void n(){string a="000000\r\n000080\r\n0000FF\r\n008000\r\n008080\r\m00FF00\r\n00FFFF\r\n800000\r\n800080\r\n808000\r\n808080\r\nC0C0C0\r\nFF0000\r\nFF00FF\r\nFFFF00\r\nFFFFFF";Console.Write(a);}

अफसोस की बात है कि यह एक बड़े अंतर से, अधिक दिलचस्प यद्यपि अविश्वसनीय रूप से सजा हुआ है (मुझे इसे लिखने में अधिक मज़ा आया) C #, 270 बाइट्स

void n(){string a,b,c,d;a="00";b="80";c="C0";d="FF";for(int i=0;i<16;i++){Console.WriteLine((i<7?a:i<11?b:i>11?d:c)+(i<3?a:i<5?b:i<7?d:i<9?a:i<11?b:i==11?c:i<14?a:d)+(i==0||i==3||i==5|i==7||i==9||i==12||i==14?a:i==1||i==4||i==8||i==10?b:i==2||i==6||i==13||i==15?d:c));}}

आप सीधे अपने कार्य में स्ट्रिंग वापस कर सकते हैं - इसे एक चर में संग्रहीत करने की आवश्यकता नहीं है और फिर इसे प्रिंट करें। इसके अलावा, ए) आप एक लैम्ब्डा का उपयोग कर सकते हैं, और बी) मुझे यकीन है कि एक समाधान है जो केवल स्ट्रिंग को डंपिंग करता है।
मेगो

@ यह गोल्फ में मेरा पहला C # पोस्ट है, मुझे यकीन नहीं है कि मैं पूरी ईमानदारी से एक लंबोतरा कार्य करता हूं!
अल्फी गुडाक्रे

मैं सुझाव दूंगा कि इस सूची के माध्यम से कुछ सुधार करने के लिए खोज की जाए।
मेगो

@ एलाफ़ी गुडाकरे: सी # लैम्ब्डा जो सिर्फ एक मूल्य लौटाता है: ()=>@"string_here"(यह कास्ट करता है Action<string>)। मैं एक शब्दशः स्ट्रिंग ( @) का उपयोग करने का भी सुझाव देता हूं ताकि आप उन्हें बचने के लिए आवश्यकता के बिना नई लाइनें सीधे स्ट्रिंग में डाल सकें।
दूध

0

सी (जीसीसी) , 99 बाइट्स

f(i){for(i=48;i--;)printf("%.2s%s","FFC08000"+("#&/28MNQRSV]^_ab"[i/3]-35>>i%3*2&3)*2,"\n\0"+i%3);}

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

छँटाई करते समय संख्याओं की एक सूची बनाने और उन्हें आउटपुट करने के प्रयास के बाद, मैंने भोले समाधान की तुलना में, जो कि अवहेलना कर रहा था:

f(){puts("000000\n000080\n0000FF\n008000\n008080\n00FF00\n00FFFF\n800000\n800080\n808000\n808080\nC0C0C0\nFF0000\nFF00FF\nFFFF00\nFFFFFF");}

200 में मेरी कोशिश और परिवर्तन की तुलना में 140 बाइट्स में एक घडी।

इसका समाधान यह था कि इसे किसी अन्य की तरह पाठ के रूप में सोचा जाए, एक छोटी वर्णमाला के साथ। प्रत्येक रंग को वर्णमाला {0xff, 0xc0, 0x80, 00} में 2-बिट सूचकांकों के एक ट्रिपल के रूप में सोचा जा सकता है। रंग की प्रक्रिया -> ट्रिपल -> संख्या -> चरित्र (ऑफसेट +35 के साथ उन सभी को मुद्रण योग्य बनाने और बचने की किसी भी आवश्यकता से बचने के लिए) को इस तरह चित्रित किया जा सकता है:

000000  333     63  b
000080  332     62  a
0000FF  330     60  _
008000  323     59  ^
008080  322     58  ]
00FF00  303     51  V
00FFFF  300     48  S
800000  233     47  R
800080  232     46  Q
808000  223     43  N
808080  222     42  M
C0C0C0  111     21  8
FF0000  033     15  2
FF00FF  030     12  /
FFFF00  003     3   &
FFFFFF  000     0   #

फिर यह परिणामी स्ट्रिंग पर पुनरावृत्ति करने और वर्णमाला स्ट्रिंग के उपयुक्त भागों को काटने का मामला है।

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