कार्य

कार्य 7-खंड प्रदर्शन के 128 संभावित राज्यों में से किसी को प्रदर्शित करना है ।

आपके कार्यक्रम को 7 अक्षरों ("बिट्स") की एक स्ट्रिंग को स्वीकार करना चाहिए जो 0या तो हैं या 1। इनपुट का पहला भाग निम्नलिखित चित्रण के खंड A से संबंधित है, दूसरा B से, आदि (अनदेखा dp)

7seg

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

प्रदर्शन के सभी 128 संभावित राज्य हैं:

नियम

Codegolf
जैसा कि मैंने कहा, किसी भी प्रकार के आउटपुट की अनुमति है, लेकिन यदि आप इसे निर्दिष्ट करते हैं तो यह अच्छा होगा।
इनपुट स्टड या कमांड लाइन तर्क हो सकता है।

उदाहरण

इनपुट

उत्पादन

ASCII / यूनिकोड के रूप में:

ASCII कला के विभिन्न प्रकार (मैं इस पर बहुत अच्छा नहीं हूं)

 _   ╺┓  ╒╗   ---
 _|  ┏┛  ╔╝     |
|_   ┗╸  ╚╛   ---
              |
              ---

code-golf

— daniero
स्रोत

कोडगॉल्फ.स्टैकएक्सचेंज . com/questions/997/… से निकटतम रूप से संबंधित है ?

— डेविड डिक

@DavidCarraher: वे संबंधित हैं, हां; मैंने इसे खुद से भी जोड़ा। हालाँकि, यह थोड़ा कठिन है, मैं कहूंगा, क्योंकि आपके पास उत्पन्न करने के लिए 118 और 'संख्याएँ' हैं। अन्य प्रश्न के उत्तरों का अधिकांश (?) यहाँ काम नहीं करेगा, या भारी पुनर्लेखन करना होगा। इसके अलावा, यहां आपको अलग-अलग नंबरों को एनकोड करने की जरूरत नहीं है, इसलिए अन्य ऑप्टिमाइज़ेशन शल्ड संभव हो सकते हैं।

— दानिएरो

तुम सही हो। यह बात बताने के लिए धन्यवाद।

— 23

यह एक आवश्यकता है कि हम आपके द्वारा दिए गए एन्कोडिंग का उपयोग करें? उदाहरण के लिए "1101101" को हमेशा "2" का प्रतिनिधित्व करना चाहिए?

— 17

@ कर्णदेव: हाँ। इनपुट में बिट्स की स्थिति को पहली तस्वीर में सेगमेंट A से G तक के अल्फाबेटिकल ऑर्डर पर मैप करना चाहिए।

— डेनिएरो

5

जे (51)

1 2 1#"1[5 3$' #'{~,|:>0;(88707#:~7#7){>".&.>1!:1[1

उत्पादन:

1101101
 ## 
   #
 ## 
#   
 ##

— मारीनस
स्रोत

1

यह थोड़ा प्रयास के साथ 38 चार तक नीचे मुंडा जा सकता है 1 2 1#"1' #'{~5 3$,0,.502 A.".&>1!:1]1:।

— एल्गोरिद्मशर्क

16

सी, 106

यदि "W00WG5WW1GW66WG4WW2WW33WG" प्रोग्राम का नाम बदलने की अनुमति दी जाती है, तो आकार 74 चार्ट है।

main(int i,char**s){
    for(s[0]="W00WG5WW1GW66WG4WW2GW33WG";i=*s[0]++;putchar(s[1][i&7]-49?i==71?10:32:42));
}

चल रहा है:

./a.out 1101101
 ** 
   *
 ** 
*   
 **

टिप्पणियाँ:

'W' और 'G' (0x47 और 0x57) को इस तरह चुना जाता है कि मान और 7 = 7, यानी वे इनपुट स्ट्रिंग को समाप्त करने वाले अशक्त वर्ण को सुरक्षित रूप से अनुक्रमित करते हैं।

— बच्चे-खरगोश
स्रोत

15

ब्रेनफक - 224

++++++++++[>+>+++<<-]
>>++>,>,>,>,>,>,>,
<<<<<<<.
>[<+.->-]<<.
>>
>>>>>[<<<<<+<+>>>>>>-]<<<<<<.>[<->-]<.>>[<<+.->>-]<<<.>.
>>>>>>>[<<<<<<<+.->>>>>>>-]<<<<<<<<.
>>>>>>[<<<<+<+>>>>>-]<<<<<.>[<->-]<.
>>>[<<<+.->>>-]<<<<.>.
>>>>[<<<<+.>]

विस्मयादिबोधक बिंदुओं का उपयोग करने वाले प्रिंट:

 ! 
! !
 !
! !
 !

सबसे पठनीय नहीं है, लेकिन बहुत भयानक भी नहीं है।

अंतिम स्थान पर नहीं होने के कारण यह देखकर आश्चर्य हुआ।

— captncraig
स्रोत

13

पोस्टस्क्रिप्ट 121 107

1 12 moveto{}5 0{0 -5 rmoveto}0 5 0 5 -5 0 0 -5 0 -5 5 0
n{49 eq{rlineto}{rmoveto}ifelse exec}forall stroke

nइस तरह की प्रक्रिया के लिए स्ट्रिंग के रूप में परिभाषित करने की आवश्यकता है

gs -g7x14 -sn=1101101 lcd.ps

लेना

नंबर दो की छवि

पूरा सेट है

वर्णों का पूरा सेट

— ज्योफ की कॉमेडी
स्रोत

11

गणित: 135 129 118, छवि प्रदर्शन

Image[MorphologicalComponents@Import@"http://goo.gl/j3elE" /. 
      Thread[Range@7 -> IntegerDigits[#, 2, 7][[{7, 2, 6, 1, 3, 5, 4}]]]] &

रिक्त स्थान "स्पष्टता के लिए" जोड़े गए

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

संपादित करें

उन picky साथी साइट उपयोगकर्ताओं के लिए: बाहरी मास्क का उपयोग किए बिना:

Image[MorphologicalComponents[ColorNegate@Rasterize@8, CornerNeighbors -> False] /. 
    Thread[Range@7 ->IntegerDigits[#, 2, 7][[{7, 2, 6, 1, 3, 5, 4}]]]] &

— डॉ। बेलिसरियस
स्रोत

कोड अपूर्ण प्रतीत होता है। मुझे नहीं लगता कि आप अपना कार्यक्रम समाप्त करना चाहते थे &।

— डेविड डिक

@DavidCarraher यह एक फ़ंक्शन है , इसलिए यह समाप्त होता है &।

— डॉ। बेलिसियस

हां, लेकिन यह किसी भी चीज पर लागू नहीं होता है। आउटपुट कैसे प्राप्त होता है?

— डेविड डिक

2

@ अविश्वास मैं अभी भी इस तथ्य को पसंद नहीं करता हूं कि आप बाहरी ressources एम्बेड करते हैं।

— 19

1

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

— फूजएक्सएल

10

एपीएल, ५ AP ५५

' _|'[1+3 3⍴0,x[1],0,(x←1 2 2 1 2 2 1×⍞='1')[6 7 2 5 4 3]]

उदाहरण इनपुट:

आउटपुट:

 _ 
 _|
|_

⍞='1' इनपुट को एक वर्ण सरणी के रूप में लेता है और इसे एक संख्यात्मक सरणी में परिवर्तित करता है।

1 2 2 1 2 2 1×⍞='1'उस सरणी को: 0रिक्त, के 1लिए _, 2के लिए , में कनवर्ट करता है|

(x←1 2 2 1 2 2 1×⍞='1')[6 7 2 5 4 3]xखंड, F, G, B, E, D, C का प्रतिनिधित्व करने के लिए उस सरणी को चर और पुनः नियत करें

0,x[1],0,(x←1 2 2 1 2 2 1×⍞='1')[6 7 2 5 4 3] एक खाली, खंड ए और दूसरे रिक्त को सामने की ओर ले जाता है

3 3⍴0,x[1],0,(x←1 2 2 1 2 2 1×⍞='1')[6 7 2 5 4 3] एक 3x3 मैट्रिक्स पर फिर से क्लिक करें

1+3 3⍴0,x[1],0,(x←1 2 2 1 2 2 1×⍞='1')[6 7 2 5 4 3] 1-आधारित अनुक्रमण में कनवर्ट करता है

अंत में स्ट्रिंग ' _|'को संकेतों में बदलने के लिए उपयोग करता है

संपादित करें

' _|'[1+3 3⍴(0,1 2 2 1 2 2 1×⍞='1')[1 2 1 7 8 3 6 5 4]]

0सरणी को सामने रखने और डुप्लिकेट संकेतों का उपयोग करके, एक चर असाइनमेंट को रोकने के द्वारा 3 वर्णों को बंद कर दिया

— TwiNight
स्रोत

अपने एपीएल यह समर्थन करता है iff, मुझे लगता है से समारोह {ब्रैकेट अनुक्रमण से कम 1-चार कम है []।

— लूसर ने

9

PHP 66 बाइट्स

<?for(;11>$i;)echo++$i&3?$argv[1][md5(¡æyÚ.$i)%8]?$i&1?~ƒ:_:~ß:~õ;

एक मामूली सुधार एक का उपयोग कर md5: जादू फार्मूला है, लेकिन 3 अतिरिक्त द्विआधारी बाइट्स की आवश्यकता है
¡, æऔर Úकर रहे हैं वर्ण 161, 230, और 218 क्रमशः। यह काम करना चाहिए जैसे कि सीधे कॉपी किया जाता है, और ANSI प्रारूप के रूप में सहेजा जाता है।

PHP 73 (70) बाइट्स

<?for($s=327638584;3<$s;)echo++$i&3?$argv[1][7&$s/=8]?$i&1?'|':_:' ':'
';

यदि आप मुझे तीन बाइनरी वर्णों की अनुमति देंगे, तो इसे 70 बाइट्स तक कम किया जा सकता है :

<?for($s=327638584;3<$s;)echo++$i&3?$argv[1][7&$s/=8]?$i&1?~ƒ:_:~ß:~õ;

जहां ƒ, ß, और õक्रमशः पात्रों 131, 223, और 245 है।

कमांड लाइन तर्क के रूप में इनपुट प्राप्त करता है। नमूना उपयोग:

$ php seven-seg.php 1101101
 _
 _|
|_

$ php seven-seg.php 0111011

|_|
 _|

— Primo
स्रोत

मैंने आपके कोड को चलाने की कोशिश की, लेकिन मुझे भार कम हो रहा है :( मैं आपके तर्क को नहीं समझता लेकिन दिलचस्प लगता है।

— D34dman

1

@ D34dman केवल संदेश जो इसे उत्पन्न करेंगे वे नोटिस (अपरिभाषित चर, आदि) हैं। इन्हें या तो बंद किया जा सकता है php.ini(डिफ़ॉल्ट रूप से वे पहले से ही हैं), या परीक्षण के लिए, आप स्क्रिप्ट के लिए निम्न कोड प्रस्तुत कर सकते हैं:<? error_reporting(E_ALL & ~E_NOTICE); ?>

— Primo

बहुत बढ़िया! मैं इसे काम कर रहा हूँ: D naice!

— D34dman

7

जावास्क्रिप्ट + jQuery + एचटीएमएल + सीएसएस ( 210) 201)

यह समाधान सीएसएस स्प्राइट्स और उदाहरण के रूप में प्रदान की गई छवि का उपयोग करता है :

HTML (3)

<a>

सीएसएस ( 82) 71)

" पृष्ठभूमि: url " चाल के लिए xem का धन्यवाद :

a{background:url(//bit.ly/VesRKL);width:13px;height:23px;display:block}

जावास्क्रिप्ट (125 पठनीयता के लिए यहां जोड़े गए नए सिरे को हटाने के बाद)

i=prompt();
x=-parseInt(i.substr(0,3),2)*23;
y=-parseInt(i.substr(3),2)*13.75;
$('a').css('background-position',y+'px '+x+'px');

ऑनलाइन टेस्ट: http://jsfiddle.net/zhqJq/3/

— क्रिस्टियन लुपस्कू
स्रोत

1

अरे, लेकिन छवि के 17.937 बाइट्स के बारे में क्या ?? ;)

— थॉमस डब्ल्यू।

@ThomasW। मैं नहीं जानता कि क्या इसे भी गिना जाना चाहिए। इसे ओपी के पास तय करने के लिए छोड़ दें।

— क्रिस्टियन लुपस्कू

आप अंतरिक्ष को बचाने के लिए सीएसएस पर <p>टैग और उपयोग से बच सकते हैंdisplay:block

— रॉबर्टो माल्डोनैडो

पृष्ठभूमि-छवि: url ( bit.ly/VesRKL ); => पृष्ठभूमि: url (// bit.ly/VesRKL);

— xem

@xem टिप के लिए धन्यवाद; मैंने अपना जवाब संपादित कर लिया है

— क्रिस्टियान लुपस्कू

6

आर (65 वर्ण):

plot((3^(1i*1.5:-4.5)*(1:7!=7)),col=strsplit(readline(),'')[[1]])

कुछ पारलौकिक बारीकियों के लिए कुछ ढीले सन्निकटन पर निर्भर ...

— पैट्रिक कैलडन
स्रोत

6

अजगर 2 - 65

s=raw_input()+'0\n'
for i in`0x623C239E38D2EAA1`:print s[int(i)],

उदाहरण:

echo 1101101|python2 7seg.py
0 1 0 
0 0 1 
0 1 0 
1 0 0 
0 1 0

— aditsu
स्रोत

5

पोस्टस्क्रिप्ट: ~~53 बाइनरी, 87 एएससीआईआई~~ 52 बाइनरी, 86 एएससीआईआई

बाइनरी टोकन का उपयोग करके कार्यक्रम का हेक्सडंप:

$ hexdump -C lcd_binary.ps 
00000000  28 34 34 30 34 30 38 30  34 30 34 30 30 30 30 34  |(440408040400004|
00000010  30 34 30 34 34 34 34 34  38 34 38 30 38 29 7b 7d  |0404444484808){}|
00000020  92 49 6e 7b 92 70 31 92  04 92 96 92 6b 92 63 92  |.In{.p1.....k.c.|
00000030  a7 7d 92 49                                       |.}.I|
00000034

इसे आज़माने के लिए इस फ़ाइल को डाउनलोड करें ।

ASCII टोकन का उपयोग करना:

(4404080404000040404444484808){}forall
n{not 1 and setgray moveto lineto stroke}forall

पहले forallलूप स्टैक पर सभी आवश्यक निर्देशांक रखता है। निर्देशांक आवश्यक स्थान को कम करने के लिए एक स्ट्रिंग में संग्रहीत होते हैं। निर्देशांक उलटे क्रम में कर रहे हैं, यानी पिछले 4 वर्ण खंड ए के लिए कर रहे हैं हम से एक रेखा खींच (0,8)करने के लिए(4,8) इस सेगमेंट (वास्तव में, हम, सभी निर्देशांक के लिए 48 को जोड़ने के लिए है, क्योंकि के लिए forallकहते हैं ढेर पर सभी ASCII कोड)।

इनपुट स्ट्रिंग में forallसभी 0s और 1s के माध्यम से दूसरा लूप होता है और उन्हें ग्रे वैल्यू में बदल देता है। 0s को सफ़ेद (ग्रे वैल्यू 1) और 1s को ब्लैक (ग्रे वैल्यू 0) से ड्रा किया जाता है। तब हम निर्देशांक का उपयोग करते हैं कि पहलेforall लाइनों को खींचने के लिए स्टैक पर छोड़ा गया लूप।

भूतहाट का उपयोग करके कार्यक्रम का आह्वान करें, जैसे ज्योफ कॉमेडी का:

gs -sn=1101101 lcd.ps

यह प्रदर्शित करता है: नमूना उत्पादन

— थॉमस डब्ल्यू।
स्रोत

मुझे लगता है कि आप बदल सकते हैं neg 49 add(जो कि बहुत बढ़िया btw है) 1 and।

— लूसर डॉग

@luserdroog: शानदार, बिटवाइज़ ऑपरेटर, उनके बारे में नहीं सोचा है। लेकिन यह होना चाहिए not 1 and, है ना? अभी भी ASCII और बाइनरी दोनों में एक बाइट बचाता है।

— थॉमस डब्ल्यू।

मुझे लगता है कि 1 बिट बिटमैप के साथ एक साफ-सुथरा तरीका होना चाहिए। लेकिन bitshiftइतना लंबा शब्द है।

— लूजर ड्रॉ

लेकिन यह केवल एक दो बाइट बाइनरी टोकन है

— थॉमस डब्ल्यू।

हाँ। लेकिन यह अभी भी मुझे किसी तरह एक धोखा की तरह लगता है । :) मुझे लगता है कि मुझे बाइनरी का सहारा लेने से पहले पठनीय स्रोत के साथ जितना संभव हो उतना संभव है।

— luser droog

4

एपीएल 101 86 73 69

m←45⍴' '⋄m[¯40+⎕av⍳(⍎∊3/' ',¨⍕⍞)/')*+16;EJOQRSAFK-27=>?']←'⎕'⋄9 5⍴m

इनपुट स्क्रीन से via के माध्यम से होता है

जो रिक्त स्थान और follows से बना 9x5 वर्ण मैट्रिक्स का उत्पादन करता है:

 ⎕⎕⎕
     ⎕
     ⎕
     ⎕
 ⎕⎕⎕
⎕
⎕
⎕
 ⎕⎕⎕

The सह-निर्देशांकों का चयन करने के लिए सात अंकों की संख्या को एक विभाजन वेक्टर में परिवर्तित किया जाता है।

— ग्राहम
स्रोत

मेरा सिर दर्द करता है ...

— रॉब

4

रेखांकन का उपयोग करते हुए गणितज्ञ 112 103 100 100 96 88

HighlightGraph[z=GridGraph@{3,2},Pick[EdgeList[z][[{3,4,1,2,6,7,5}]],Characters@#,"1"]]&

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

Using it to show a calculator display

l = {7-> 7, 1-> 6, 0-> 63, 8-> 127, 9-> 111,3 -> 79, 5-> 109,  2-> 91, 4-> 102, 6-> 125}; 
GraphicsRow[
  HighlightGraph[z = GridGraph[{3,2}, EdgeStyle-> {White}, GraphHighlightStyle-> {"Thick"}], 
    EdgeList[z][[{3, 4, 1, 2, 6, 7, 5}]][[IntegerDigits[#, 2, 7] Range@7]]] & /@
            (IntegerDigits[8736302] /. l)]

गणितज्ञ ग्राफिक्स

— डॉ। बेलिसरियस
स्रोत

आप किस तरह के इनपुट की उम्मीद करते हैं? न तो [123]और न ही "" 123 ", और न ही IntegerDigits[123]मेरे लिए काम करते हैं। मैं केवल zहाइलाइटिंग के साथ मिलता हूं ।

— डेविड जेएन

@ डूड ट्राय `हाईलाइटग्राफ [z = GridGraph @ {3, 2}, उठाओ [एजलिस्ट] [z] [[{3, 4, 1, 2, 6, 7, 5}], अक्षर @ #," 1 "] ] & @ "1111111" `` :)

— डॉ। बेलिसियस

3

पायथन (107)

निश्चित रूप से अधिक गोल्फ।

a=map(int,raw_input())
for i in(0,6,3):print' .. '*a[i]+('\n'+' .'[a[5-i/6]]+'  '+' .'[a[1+i/6]])*(2*(i!=3))

आउटपुट:

1101101
 .. 
   .
   .
 .. 
.   
.   
 ..

स्पष्टीकरण:

a is a list of booleans extracted from the input.
When you multiply a string with a number, it will return the string repeated (number) times.
If that number happens to be zero, it returns an empty string.
i is iterated through 0 (pos A), 6 (pos G), and 3 (pos D).
' .. ' will print either section A, G, or D, depending on the value of i.
([string here])*(2*(i!=3)) will print [string here] twice only if i!=3.
Breaking down [string here]:
 - '\n' will print a newline for each repetition.
 - '  ' is the null space between horizontal sections.
 - ' .'[(bool)] will return either ' ' if (bool) is 0, and '.' if (bool) is 1.
 - 5-i/6 will return 5 if i=0 and 4 if i=6. a[5] is section F and a[4] is section E.
 - 1+i/6 will return 1 if i=0 and 2 if i=6. a[1] is section B and a[2] is section C.

— beary605
स्रोत

3

पायथन 2.7 (93 वर्ण):

print (' {0}\n{5} {1}\n {6}\n{4} {2}\n {3}').format(*map(lambda x:int(x)and'*'or' ',raw_input()))

स्पष्टीकरण:

स्टडिन इनपुट के साथ, *सच और झूठे के लिए जगह देने के लिए एक मेकशिफ्ट टर्नेरी ऑपरेटर का उपयोग करें । उन मानों को लें और उन्हें एक प्रारूप विवरण में प्लग करें जो 7 अंकों के प्रदर्शन के प्रारूप में है। यह सबसे अधिक 83 वर्णों पर होगा यदि प्रदर्शन इस तरह से काम करता है:

 a
b c
 d
e f
 g

लेकिन आदेश इसे लंबे समय तक बनाता है। किसी को भी इस के आसपास एक रास्ता है?

उदाहरण:

$ ./7seg.py
111000

 *
  *

  *

$ ./7seg.py


1111111

 *
* *
 *
* *
 *

— बटमार
स्रोत

1

अच्छा है, लेकिन यह लैंबडा अनावश्यक लगता है print' {0}\n{5} {1}\n {6}\n{4} {2}\n {3}'.format(*[' *'[i=='1']for i in raw_input()]):;) प्रिंट स्टेटमेंट के लिए कोष्ठक और स्थान की भी आवश्यकता नहीं है।

— दानियारो

वाह! मुझे नहीं पता था कि आप इंडेक्स में बूलियन डाल सकते हैं। धन्यवाद :-)

— ब्रिगांड

Np। इसके अलावा, और (के >'0'बजाय चारों ओर backticks के साथ, लेकिन इसके बजाय यहाँ स्वरूपण के कारण नहीं दिखाई देगा) । =='1'input()raw_input()

— डेनियरियो

यदि आप कोड में backticks की जरूरत है तो फी, आप ट्रिपल बैकटिक्स का उपयोग कर सकते हैंx = `input()`

— ब्रिगैंड

ठंडा। फिर मैंने आज भी कुछ सीखा :)

— daniero

3

मुझे लगा कि हमें एक जवाब की जरूरत है ...

क्लोजर, 159 चरस

(print(apply str(flatten(interpose\newline(partition 3(map(fn[x](if(= x\1)\o" "))(str" "(apply str(interpose" "(map(vec(read-line))[0 5 1 6 4 2 3])))" ")))))))

उपरोक्त REPL में चलेगा और सही उत्तर प्रदान करेगा। उदाहरण के लिए:

1111111
 o 
o o
 o 
o o
 o

छोटे संशोधनों के साथ इस पर संख्या फेंकना:

(doseq [i ["1111110" "0110000" "1101101" "1111001" "0110011" "1011011" "1011111" "1110000" "1111111" "1111011"]]
(println (apply str(flatten(interpose\newline(partition 3(map(fn[x](if(= x\1)\o" "))(str" "(apply str(interpose" "(map(vec i)[0 5 1 6 4 2 3])))" "))))))) 
(println))

पैदावार:

 o 
o o

o o
 o 


  o

  o


 o 
  o
 o 
o  
 o 

 o 
  o
 o 
  o
 o 


o o
 o 
  o


 o 
o  
 o 
  o
 o 

 o 
o  
 o 
o o
 o 

 o 
  o

  o


 o 
o o
 o 
o o
 o 

 o 
o o
 o 
  o
 o 

nil

पढ़ना आसान नहीं है, लेकिन वे वहाँ हैं!

— Joanis
स्रोत

3

जावास्क्रिप्ट 123

s=prompt(i=o='');for(m=' 0516423';i++<15;i%3==0?o+='\n':1)o+=' ─│'[~i%2&(A=+s[+m[~~(i/2)]])+(A&+'110'[i%3])];console.log(o)

मैं वर्ण गणना को निम्न (101) में ला सकता हूं यदि हम "ऑन" राज्य के लिए केवल एक वर्ण का उपयोग करते हैं, लेकिन यह कम सुपाठ्य है:

s=prompt(i=o='');for(m=' 0516423';i++<15;i%3==0?o+='\n':1)o+=' ■'[~i%2&s[+m[~~(i/2)]]];console.log(o)

— Shmiddty
स्रोत

+1 यह प्रभावशाली है। मैं अब भी इसे रिवर्स करने की कोशिश कर रहा हूं। यह मुझे कुछ चीजें पहले से ही सिखाई गई हैं!

— ग्वारसी

2

पोस्टस्क्रिप्ट 136

विजेता नहीं, बल्कि एक अलग दृष्टिकोण।

15 string exch{1 and 255 mul}forall
[7 3 9 13 11 5 1]{count 1 sub index 3 1 roll exch put}forall
3 5 8[.02 0 0 .05 0 0]{}image showpage

स्टैक पर इनपुट स्ट्रिंग की अपेक्षा करता है:

$ echo '(1101101)'|cat - 7seg.ps |gs -sDEVICE=png16 -sOutputFile=6c.png -

यह और भी बुरा है। 294 "बाइनरी" बिटमैप बनाने के लिए। मुझे यह याद करने में थोड़ा समय लगा कि प्रत्येक पंक्ति को एक बाइट तक गद्देदार किया जाता है। तो एक 3x5 बिटमैप 3 एमएसबी बिट्स के साथ पांच बाइट्स महत्वपूर्ण है।

2#1101101
(12345)exch
2 copy 64 and 0 exch put %A
2 copy 2 and 6 bitshift 2 index 32 and or 1 exch put %F B
2 copy 1 and 6 bitshift 2 exch put %G
2 copy 4 and 5 bitshift 2 index 16 and 1 bitshift or 3 exch put %E C
2 copy 8 and 3 bitshift 4 exch put
pop
3 5 1[.02 0 0 .02 0 0]{}image showpage

आउटपुट अन्य के समान ही बदसूरत है। :(

यहाँ ठीक है जो अच्छा लग रहा है। 190

संपादित करें: यह उल्टा और पीछे था। अब तय हो गया।

(1101101)
{neg 49 add 255 mul
1 string dup 0 4 3 roll put}forall
(\377){@/g/f/e/d/c/b/a}{exch def}forall
@ a a @
b @ @ f
b @ @ f
@ g g @
c @ @ e
c @ @ e
@ d d @
4 7 8[.01 0 0 .01 0 0]{}image showpage

— luser droog
स्रोत

यह मुझे कुछ अजीब पैटर्न दिखाता है। क्या अब भी कहीं बग है?

— थॉमस डब्ल्यू।

हम्म। हाँ। (1111110) शून्य जैसा नहीं दिखता है। यह सिर्फ एक बढ़े हुए बाईटैप है। मुझे लगता है कि बक्से की देखरेख की जाती है। :(

— लूसर डॉग

मुझे लगता है कि इस बिटमैप दृष्टिकोण की प्रकृति में यह दयालु है। मुझे यकीन नहीं है कि यह कैसे बदसूरत नहीं है।

— लूसर डॉग

कुछ हल्की टिप्पणी यहाँ उपलब्ध है ।

— लूजर

2

गणितज्ञ 264

सही कई बाइट्स देखने के लिए आउटपुट प्राप्त करना, इसलिए इस बार कोई सिगार नहीं। लेकिन यहाँ क्रिया (264 वर्ण) कोड वैसे भी है।

{a, b, c, d, e, g} = {{-1, 5}, {1, 5}, {1, 3}, {1, 1}, {-1, 1}, {-1, 3}};
f@n_ := Graphics[{Yellow, Thickness[.1], CapForm["Round"],
   Line /@ {{g, c}, {g, a}, {g, e}, {e, d}, {d, c}, {c, b}, {b, a}}[[Flatten@
   Position[IntegerDigits[n, 2, 7], 1]]]}, 
   Background -> Blue, PlotRange -> {{-1, 1}, {1, 5}}, PlotRangePadding -> 1]

पात्रों का पूरा सेट:

GraphicsGrid[Partition[Table[f[p], {p, 0, 128}], 16]]

characteris

अंक:

{f[63], f[6], f[91], f[79], f[102], f[109], f[125], f[7], f[127], f[111]}

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

— DavidC
स्रोत

2

PHP - 155 अक्षर

<?php
$y=array("   \n"," - \n","   \n","  |\n","|  \n","| |\n"); $x = $argv[1]; echo $y[$x[0]].$y[2*$x[6]+$x[2]+2].$y[$x[7]].$y[2*$x[5]+$x[3]+2].$y[$x[4]];

अगर हम php 5.4 प्रकार के ऐरे डिक्लेरेशन का उपयोग करते हैं तो यह 150 अक्षर होगा, लेकिन मैंने अपने लैपटॉप पर स्थापित नहीं किया है इसलिए यह परीक्षण नहीं कर सका।

नमूना बाहर डालता है।

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

स्पष्टीकरण:

पहले मैंने 7 खंड प्रदर्शन को पांच पंक्तियों और 3 स्तंभों में विभाजित किया। मध्य स्तंभ में पहली, तीसरी और 5 वीं पंक्ति हैविमग '-' के साथ और अन्यथा।

दूसरी और चौथी पंक्ति में एक पाइप है '|' पहले और आखिरी कॉलम में चरित्र। अब इन चरित्रों की उपस्थिति को इनपुट मूल्यों द्वारा निर्देशित किया जाना चाहिए।

मैंने एक लुकअप टेबल बनाई, जो मूल रूप से दो लुकअप टेबल है। 1, 3 और 5 वीं पंक्ति के लिए मानों की गणना के लिए पहला। और दूसरी पंक्ति 2 और 4 की गणना के लिए ऑफसेट 2 (3 आइटम) पर एक और।

— D34dman
स्रोत

2

जावा - 204 वर्ण

class A{public static void main(String[]a){char[]c=new char[7];for(int i=0;i<7;i++)c[i]=a[0].charAt(i)==49?i%3==0?95:'|'):32;System.out.printf(" %c %n%c%c%c%n%c%c%c",c[0],c[5],c[6],c[1],c[4],c[3],c[2]);}}

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

 _ 
 _|
|_

ठीक से प्रारूपित:

class A {
    public static void main(String[] a) {
        char[] c = new char[7];
        for (int i = 0; i < 7; i++)
            c[i] = a[0].charAt(i) == 49 ? (i % 3 == 0 ? 95 : '|') : 32;
        System.out.printf(" %c %n%c%c%c%n%c%c%c", c[0], c[5], c[6], c[1], c[4], c[3], c[2]);
    }
}

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

संपादित करें: कक्षा में "सार्वजनिक" से छुटकारा पा सकता है, मुझे 7 वर्ण बचाता है!

और धन्यवाद, daniero, मुझे प्रिंटफ दिखाने के लिए! (18 वर्ण सहेजे गए)

आउटपुट स्वरूप को फिर से लिखें, वर्ण शाब्दिकों को दशमलव में बदल दिया, 12 वर्ण सहेजे गए।

— कोड ब्रेकर
स्रोत

Codegolf.se में आपका स्वागत है! जावा ने printfकुछ संस्करणों में एक विधि शुरू की , जो मूल रूप से printlnऔर formatएक में है (सी फ़ंक्शन की तरह); यह आपको कुछ पात्रों को बचाएगा,

— daniero

यहाँ एक और चाल है: आप forलूप के "बॉडी" और अपडेट पार्ट को एक में जोड़ सकते हैं , एक कैरेक्टर को सेव कर सकते हैं:for(int i=7;i>0;c[--i]=a[0].charAt(i)==49?(i%3==0?95:'|'):32);

— daniero

1

VBA - 263

यह बदसूरत है लेकिन यह काम करता है, मुझे लगता है। मुझे उचित बिट क्रम को देखने में परेशानी हो रही है, इसलिए मैं दूसरों के उत्तरों का उल्लेख कर रहा हूं। भले ही वह टुकड़ा गलत हो, कोड की लंबाई समान होनी चाहिए।

Sub d(b)
Dim c(1 To 7)
For a=1 To 7
c(a)=Mid(b,a,1)
Next
x=" - "
y="|"
z=" "
w="   "
v=vbCr
MsgBox IIf(c(1)=1,x,w) & v & IIf(c(6)=1,y,z) & z & IIf(c(2)=1,y,z) & v & IIf(c(7)=1,x,w) & v & IIf(c(5)=1,y,z) & z & IIf(c(3)=1,y,z) & v & IIf(c(4)=1,x,w)End Sub

— Gaffi
स्रोत

1

VBScript - 178 वर्ण

m=Split("2 7 11 10 9 5 6")
s=" _ "&vbCr&"|_|"&vbCr&"|_|"
For x=1 To 7
If Mid(WScript.Arguments.Item(0),x,1)=0 Then r=m(x-1):s=Left(s,r-1)&" "&Right(s,Len(s)-r)
Next
MsgBox s

— Comintern
स्रोत

धन्यवाद! कपल बोनहेड की गलतियों से मुझे 6 किरदार निभाने पड़ते हैं। मैं फ़ंक्शन लाइन तर्क प्राप्त करने के लिए बेतुके लंबे कॉल के साथ भी लगभग VBA एक के आकार तक इसे नीचे ला सकता हूं।

— कॉमिनटर्न

जब तक आपका कोड newline वर्ण के बिना कार्यात्मक नहीं है, आपको उन्हें भी गिनना होगा। इसमें मेरी गिनती के अनुसार 178 अक्षर हैं।

— मैनटवर्क

1

CJam - 29

l0N]s7078571876784728737Ab\f=

CJam एक नई भाषा है जिसे मैं विकसित कर रहा हूं, जैसे कि GolfScript - http://sf.net/p/cjam । यहाँ स्पष्टीकरण है:

l इनपुट से एक पंक्ति पढ़ता है
0 संख्या 0 है
Nयह एक वैरिएबल है जिसे न्यूलाइन स्ट्रिंग में प्रीइंस्टिग्रेट किया जाता है,
]जो स्टैक पर मौजूद तत्वों को इकट्ठा करता है एक एरे
sमें एक वैल्यू (एरे) को स्ट्रिंग में कनवर्ट करता है, इस प्रकार एक शून्य और एक न्यूलाइन को दिए गए इनपुट
7078571876784728737में जोड़ देता है। संख्या (वही संख्या जो मैंने अजगर में इस्तेमाल की थी, लेकिन यह वहां हेक्स में था)
Aएक चर है जो 10
bमें आधार रूपांतरण करता है, जिससे सरणी उत्पन्न होती है [7 0 7 8 ... 3 7]
\स्टैक पर अंतिम दो मानों को स्वैप करता है। इनपुट स्ट्रिंग (प्लस जीरो और न्यूलाइन) और प्रत्येक संख्या 7, 0, 7, पर ऑपरेटर (यहाँ, अनुक्रमित ऐक्सेस एक्सेस) को
f=लागू करता है =...
। इंडेक्स 7 एप्लाइड शून्य से मेल खाता है, और 8 एप्लाइड न्यूलाइन से मेल खाता है।

मेरा अजगर समाधान ठीक वैसा ही करता है (स्ट्रिंग पृथक्करण के माध्यम से डिजिट पृथक्करण को छोड़कर)

— aditsu
स्रोत

मैं यहाँ क्या देख रहा हूँ? कोड की संक्षिप्त व्याख्या प्रदान करने के लिए देखभाल?

— डैनियोरो

@daniero मैंने एक स्पष्टीकरण जोड़ा

— aditsu

1

VBA, 188 वर्ण

ध्यान दें कि यदि किसी व्यक्ति को अनिवार्य व्हाट्सएप सहित 188 वर्णों को टाइप करना है - जब आप इसे VBA संपादक में कॉपी करते हैं, तो IDE इसका विस्तार करता है।

Sub f(i)
Dim c() As Byte
m=Split("1 6 10 9 8 4 5")
c=StrConv(" _  |_| |_|",128)
c(3)=10
c(7)=10
For x=1 To 7
If Mid(i,x,1) = 0 Then c(m(x-1))=32
Next
MsgBox StrConv(c,64)
End Sub

अफसोस की बात है, VBScript के पास दृढ़ता से टाइप किया गया बाइट नहीं है, या कि इस विधि का उपयोग करके बहुत कम किया जा सकता है।

— Comintern
स्रोत

1

जावास्क्रिप्ट (ECMAScript 2016) - 108 बाइट्स

console.log(([a,b,c,d,e,f,g]=[...prompt()].map((x,i)=>+x?'_||'[i%3]:' '),` ${a}
${f}${g}${b}
${e}${d}${c}`))

यह शायद आगे गोल्फ हो सकता है, लेकिन मैं कुछ भी नहीं सोच सकता।

— एम डिरर
स्रोत

साइट पर आपका स्वागत है! यह एक अच्छी पहली प्रविष्टि है :)

— daniero

1

जावास्क्रिप्ट, 148 बाइट्स

e=>(e[0]==1?" #\n":"\n")+(e[5]==1?"#":" ")+(e[1]==1?" #\n":"\n")+(e[6]==1?" #\n":"\n")+(e[4]==1?"#":" ")+(e[2]==1?" #\n":"\n")+(e[3]==1?" #\n":"\n")

इसे ऑनलाइन आज़माएं! _{(पाद लेख पढ़ने के लिए Node.js है .input.tio)}

बाइनरी फ़्लैग और रिटर्न में ABCDEFG का इनपुट स्वीकार करता है:

 #
# #
 #
# #
 #

— facepalm42
स्रोत

0

स्माइलबासिक, 136 बाइट्स

DIM A[7,2]COPY A,@L@L?DATA.,1,1,3,4,3,6,1,4,0,1,0,3,1INPUT X$FOR I=0TO 6M=I MOD 3GBOX A[I,1],A[I,0],A[I,1]+!M,A[I,0]+!!M,-VAL(X$[I])NEXT

आउटपुट चित्रमय है।

— 12Me21
स्रोत

0

05AB1E , 4 बाइट्स

C₄+ç

इसे ऑनलाइन आज़माएं या सभी संभावित जानकारी सत्यापित करें ।

देखें सभी संभव आदानों की पुष्टिप्रत्येक इनपुट के लिए उपयोग की गई मैपिंग देखने के लिए ऊपर दिए गए लिंक ।

स्पष्टीकरण:

यह उन नियमों का दुरुपयोग करता है जहां यह बताता है:

आप किस तरह से प्रदर्शन का प्रतिनिधित्व करते हैं, यह आपके ऊपर है - एक एकल यूनिकोड या एएससीआईआई प्रतीक , एएससीआईआई कला, आलेखीय रूप से, या आप जो भी लेकर आ सकते हैं। हालाँकि, प्रत्येक इनपुट का अपना अलग आउटपुट होना चाहिए।

C       # Convert the (implicit) input from binary to integer
 ₄+     # Increase it by 1000
   ç    # Convert it to a unicode character with this value (and output implicitly)

आउटपुट-प्रारूप का उपयोग करके चुनौती की भावना में वैकल्पिक अधिक:

 -
| |
 -
| |
 -

38 बाइट्स :

Σ•L7×•Nè}εi" -| | "14∍2ôNèëðº]J24S5∍£»

निश्चित रूप से गोल्फ हो सकता है ..

इसे ऑनलाइन आज़माएं या सभी संभावित जानकारी सत्यापित करें ।

स्पष्टीकरण:

Σ       }          # Sort the (implicit) input-digits by:
 •L7×•Nè           #  The digit at the same index in the compressed integer 1367524
                   #   i.e. "1101101" → ["1","0","1","1","1","0","1"]
ε                  # Then map each digit to:
 i                 #  If it's a 1:
  " -| | "         #   Push string " -| | "
          14∍      #   Lengthen it to size 14: " -| |  -| |  -"
             2ô    #   Split it into parts of 2: [" -","| ","| "," -","| ","| "," -"]
               Nè  #   Index into it
 ë                 #  Else (it's a 0):
  ðº               #   Push "  " (two spaces) instead
    ]              # Close both the if-else and map
                   #  i.e. ["1","0","1","1","1","0","1"]
                   #   → [" -","  ","| "," -","| ","  "," -"]
J                  # Join everything together to a single string
                   #  i.e. [" -","  ","| "," -","| ","  "," -"] → " -  |  -|    -"
 24S               # Push [2,4]
    5∍             # Lengthened to size 5: [2,4,2,4,2]
      £            # Split the string into parts of that size
                   #  i.e. " -  |  -|    -" → [" -","  | "," -","|   "," -"]
       »           # Join by newlines (and output implicitly)
                   #  i.e. [" -","  | "," -","|   "," -"] → " -\n  | \n -\n|   \n -"

मेरा 05AB1E टिप देखें (यह समझने के लिए कि बड़े पूर्णांक को संपीड़ित कैसे करें? ) क्यों •L7×•है 1367524।

— केविन क्रूज़सेन
स्रोत

0

PHP 5.6, 65 बाइट्स प्लेन ASCII

for(;$p++<9;)echo$argn[_707561432[$p]]?"||_"[$p%3]:" ","\n"[$p%3];

या, अनुगामी लाइनब्रेक के बिना, लेकिन कुछ बिटवाइज़ मज़े के साथ:

for(;$p++<11;)echo$argn[_70785618432[$p]]?L|Sx[$p&1]:a^kAAA[$p&3];

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उन्हें आज़माएं ।

टूटना १

for(;$p++<9;)echo           # loop through positions
    $argn[_707561432[$p]]   # map position to input bit
        ?"||_"[$p%3]            # if set: underscore in 2nd column, pipe symbol else
        :" "                    # else space
    ,"\n"[$p%3]             # add newline every 3 columns
;

टूटना २

for(;$p++<11;)echo          # loop through positions
    $argn[_70785618432[$p]] # map position to input bit (bit 8 for EOL, never set)
        ?L|Sx[$p&1]             # if set: underscore in the middle, pipe symbol else
        :a^kAAA[$p&3]           # else: newline in 4th column, space else

— टाइटस
स्रोत

1

चाहे भाषा नई हो या पुरानी अब 2017 की गर्मियों से कोई फर्क नहीं पड़ता । इसलिए आपको गैर-प्रतिस्पर्धा का उल्लेख नहीं करना होगा।

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद मुझे याद आया। लेकिन यह पुराने PHP संस्करणों को पुनर्जीवित करने के लिए एक अच्छी चुनौती भी है; यह कभी-कभी अधिक हाल की विशेषताओं पर एक अलग दृष्टिकोण देता है: मैंने पाया, अवसरों पर, "पुराना" तरीका अधिक कुशल है (आकार में, प्रदर्शन में, पठनीयता और कभी-कभी तीनों में) उस सामान का उपयोग करने की तुलना में जो PHP में बाद में जोड़ा गया था। इस मामले में कोई गोल्फ लाभ, हालांकि: पहला दृष्टिकोण 8 अतिरिक्त बाइट्स, दूसरे की आवश्यकता होगी एक 5.

— टाइटस

7-सेगमेंट डिस्प्ले का अनुकरण करें

कार्य

नियम

उदाहरण

इनपुट

उत्पादन

जे (51)

सी, 106

ब्रेनफक - 224

पोस्टस्क्रिप्ट 121 107

गणित: 135 129 118, छवि प्रदर्शन

एपीएल, ५ AP ५५

संपादित करें

PHP 66 बाइट्स

PHP 73 (70) बाइट्स

जावास्क्रिप्ट + jQuery + एचटीएमएल + सीएसएस ( 210) 201)

HTML (3)

सीएसएस ( 82) 71)

जावास्क्रिप्ट (125 पठनीयता के लिए यहां जोड़े गए नए सिरे को हटाने के बाद)

आर (65 वर्ण):

अजगर 2 - 65

एपीएल 101 86 73 69

रेखांकन का उपयोग करते हुए गणितज्ञ 112 103 100 100 96 88

पायथन (107)

पायथन 2.7 (93 वर्ण):

स्पष्टीकरण:

उदाहरण:

क्लोजर, 159 चरस

जावास्क्रिप्ट 123

पोस्टस्क्रिप्ट 136

गणितज्ञ 264

जावा - 204 वर्ण

VBA - 263

CJam - 29

VBA, 188 वर्ण

जावास्क्रिप्ट (ECMAScript 2016) - 108 बाइट्स

जावास्क्रिप्ट, 148 बाइट्स

स्माइलबासिक, 136 बाइट्स

05AB1E , 4 बाइट्स

38 बाइट्स :

PHP 5.6, 65 बाइट्स प्लेन ASCII