बीबीसी माइक्रो उल्लू लोगो का एक संस्करण प्रस्तुत करना [बंद]

Question

क्या आप कोड से ऊपर बीबीसी माइक्रो उल्लू लोगो का एक संस्करण प्रदान कर सकते हैं?

नियम:

• आप अपनी पसंद की किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं।
• आउटपुट टेक्स्ट या ग्राफिक हो सकता है।
• मंडलियों को ओवरलैप करने की ज़रूरत नहीं है।

विजेता:

• सबसे upvotes के साथ जवाब जीतता है।

बीबीसी बेसिक में इसे आज़माने वाले किसी के लिए भी कुदोस।

आप बीबीसी माइक्रो के बारे में यहां पढ़ सकते हैं

Comments

"अधिकांश आविष्कारशील" और "सबसे अधिक मूल की तरह" व्यक्तिपरक है। कृपया एक उद्देश्य जीतने वाली कसौटी प्रदान करें। (मैं, बंद करने के लिए मतदान कर रहा हूँ के अनुसार "एक उद्देश्य प्राथमिक जीतने कसौटी बिना सवाल, विषय से कर रहे हैं के रूप में वे यह असंभव निर्विवाद रूप से तय करने के लिए जो प्रवेश जीतने पर हैं।")

— दरवाज़े

मैंने जीत के मानदंड को सबसे छोटे कोड में बदल दिया है जो मुझे आशा है कि सभी के लिए कम व्यक्तिपरक है।

— बेन पैटन

हो सकता है कि कोड-गोल्फ ठीक है, लेकिन मुझे लगता है कि यह प्रश्न एक लोकप्रियता-प्रतियोगिता टैग के बजाय उपयुक्त हो सकता है । सबसे ज्यादा वोट मिले। यही उद्देश्य है। मोब तय करता है। यह कोड के कुछ वर्णों को बचाने के लिए आउटपुट गुणवत्ता / रचनात्मकता का त्याग किए बिना दिलचस्प परिणामों को प्रोत्साहित करता है। फ्रीस्टाइल ओलंपिक के छल्ले सवाल का गवाह ।

— डेरेन स्टोन

अच्छा विचार है कि मैंने इसे सबसे अधिक जीत के लिए बदल दिया है जो कि उचित है। मैं इसे कैसे पकड़ कर ले जाऊं?

— बेन पैटन

मुझे नहीं लगता कि बारह साल के उत्तर के साथ छह साल पुराने सवाल को बंद करना फलदायी है।

— जोनाथन फ्रीच

Answer 1

बीबीसी बेसिक

मैंने उचित हलकों को आकर्षित करने के लिए ट्रिगर फ़ंक्शंस का उपयोग करने की कोशिश की, लेकिन यह बहुत धीमा था। इसके बजाय इसके साथ आया:

10 MODE 1
20 GCOL 0,1 : VDU 19,1,3,0,0,0
30 FOR Y%=0 TO 20
40 READ N% : P%=65536
50 FOR X%=0 TO 16
60 IF (N% AND P%)=0 THEN GOTO 160
70 X0% = X%*32+384 : Y0% = 872-Y%*32
80 FOR DX%=-16 TO 16 STEP 8
90 FOR DY%=-8 TO 8 STEP 8
100 PLOT 69,X0%+DX%,Y0%+DY%
110 NEXT DY% : NEXT DX%
120 FOR DX%=-8 TO 8 STEP 8
130 FOR DY%=-16 TO 16 STEP 32
140 PLOT 69,X0%+DX%,Y0%+DY%
150 NEXT DY% : NEXT DX%
160 P%=P%/2
170 NEXT : NEXT
1000 DATA 87381,33410,69905,10280
1010 DATA 69649,33410,82181,40968
1020 DATA 87377,43520,87297,43520
1030 DATA 21761,10880,5441,2720
1040 DATA 1361,552,1093,43682,1

यहाँ उत्पादन है:

Comments

वाह गंभीरता से अद्भुत किसी ने वास्तव में बीबीसी बेसिक का उपयोग करने के लिए समय लिया। मैं बहुत प्रभावित हूँ!!

— बेन पैटन

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

— लेवल रिवर सेंट

BTW, यदि आप हलकों को जल्दी से खींचना चाहते हैं, तो ट्रिगर कार्यों का उपयोग न करें, पाइथागोरस प्रमेय का उपयोग करें: Y = (R ^ 2-X ^ 2) ^ 0.5 इंद्रधनुष प्रश्न के बारे में मेरा उत्तर देखें। और वास्तव में इसे केवल जोड़ के साथ करने का एक और अधिक उन्नत तरीका है, इस तथ्य पर आधारित है कि (1) + (3) + (5) .... (1 + 2n) = (n + 1) ^ 2।

— स्तर नदी सेंट

Answer 2

GolfScript

"!C-DD[5v`>U8G`J2zX['b#L*\\q>FQp "{32-}%96base 2base{"   *"2/=}%18/{""*1>17/~n@n}/

कोड लोगो के ascii कला संस्करण को प्रिंट करता है ( यहां चलाएं )।

* * * * * * * * * 
 *     * *     * 
*   *   *   *   * 
   * *     * *   
*   *       *   * 
 *     * *     * 
* *     *     * * 
 * *         *   
* * * * * * *   * 
 * * * *         
* * * * *       * 
 * * * *         
  * * * *       * 
   * * * *       
    * * * *     * 
     * * * *     
      * * * *   * 
       *   * *   
      *   *   * * 
 * * * * * *   * 
                * 

Comments

82 पात्रों में वास्तव में प्रभावशाली!

— बेन पैटन

Answer 3

मेथेमेटिका

कुछ भी नहीं बल्कि गंभीर काम।

w = 20; h = 25; r = .7; r2 = .2; t = Table; d = Disk;
owl = Graphics[{Polygon[{{0, 0}, {w, 0}, {w, h}, {0, h}}],
   ColorData[57, 4],
   t[d[{k, 22}, r], {k, 2, 19, 2}],
   t[d[{18, k}, r], {k, 2, 21, 2}],
   t[d[{k, #}, r], {k, #2}] & @@@ {{21, {3, 9, 10, 11, 17}}, {20, {2, 
       6, 10, 14, 18}},
     {19, {5, 6, 7, 13, 14, 15}}, {18, {6, 9, 11, 14}}, {17, {10, 
       17}, {16, {16}}, {15, {15}}, {14, {8, 10, 12, 14}},
      {13, {9}}, {12, {9}}}},  
   t[d[{# - k, k}, r], #2] & @@@ {{20, {k, 18, 3, -1}}, {19, {k, 16, 
       6, -1}}, {18, {k, 16, 5, -1}}, {17, {k, 14, 7, -1}}, {16, {k, 
       14, 6, -1}}, {14, {k, 11, 5, -1}}, {14, {k, 12, 5, -1}}},
   t[d[{k, 4}, r], {k, {8, 12}}],
   t[d[{k, 3}, r], {k, 3, 13, 2}],
   d[{8, 13}, r],
   Black, d[{10, 21}, r2], d[{8, 13}, r2], d[{9, 12}, r2],
   t[d[{19 - k, k}, r2], {k, 16, 6, -1}],
   t[d[{17 - k, k}, r2], {k, 14, 7, -1}],
   t[d[{15 - k, k}, r2], {k, 12, 6, -1}],
   t[d[{k, 19}, r2], {k, {6, 14}}]}, ImageSize -> 220]

Answer 4

आर

image(t(matrix(as.integer(sapply(c(1397760,567810,1070336,141954,1381696,133794,
                                   1054036,559786,1332560,557218,1052756,131114,
                                   1380368,139272,1064964,557058,1398101),
                                   intToBits)[1:21,]),nr=21)),ax=F)

का परिणाम:

मूल रूप से यह विचार 17 संख्या (1397760, 567810, 1070336, 141954, 1381696, 133794, 1054036, 559786, 1332560, 552518, 1052756, 1311148, 1380368, 139272, 1064964, 557058, 5570, 552, 55708) का आधार -2 प्रतिनिधित्व लेने का है। , इसे 1 और 0 के 21x17 मैट्रिक्स में बनाएँ और मैट्रिक्स को प्लॉट करें।

Answer 5

पीओवी रे

background{color<.14,.01,.01>}
camera{orthographic location z*-2 up y*24 right x*20}
#macro s(X,Y)sphere{<X,Y,0>,1.07,2.6}#end
#declare b=array[17]{1397760,567810,1070336,141954,1381696,133794,1054036,
559786,1332560,557218,1052756,131114,1380368,139272,1064964,557058,1398101}
blob{threshold 0.9 #for(j,0,16,1)#declare V=b[j];#for(i,0,28,1)
#if(mod(V,2))s(j-8,i-10)#end #declare V=floor(V/2);#end #end
pigment{color<1,1,.8>}finish{ambient 1}}

'संकलन povray +Ibbc.pov -Obbc.png +A0.1 +R9 -W240 -H285

Answer 6

दे घुमा के

चूंकि आपने कोई बाहरी संसाधन निर्दिष्ट नहीं किए ...

curl -s http://codegolf.stackexchange.com/questions/19214/render-a-version-of-the-bbc-micro-owl-logo | grep '* * *' | sed -n '/code>\*/,/<pre>/p' | sed '$d' | sed 's/<pre><code>//'

हावर्ड - अपनी अस्की कला चुरा लिया, धन्यवाद।

या मैं इसे यहाँ अपलोड करने के बाद -

curl -s http://textuploader.com/1ojd | sed -n '/<code/,/<\/code>/p' | sed 's/<[^>]\+>//g'

Comments

खैर यह पार्श्व सोच है कि मुझे लगता है ...

— बेन पैटन

Answer 7

बीबीसी बेसिक, यादृच्छिक रंग, गोल्फ!

149 अक्षर। मैं गोल्फ पर इतना बड़ा नहीं हूं (मैं कोड चुनौतियों को पसंद करता हूं) लेकिन मुझे बीबीसी बेसिक में गोल्फिंग की हास्यास्पदता पसंद थी। Http://www.bbcbasic.co.uk/ पर बीबीसी एमुलेटर । कमांड लाइन पर स्क्रीन मोड 6 में चलता है।

FORK = 6TO185S = K MOD9 = 5VDU-32 * (K MOD18 = 15), 17,128 + RND (6) * (ASCMID $ ("? OSUuLEMSS ^ H? = A_W", K / 6,1) / 2 ^ (K) MOD6) And1), 32,17,128,32, -13 * एस, -10 * एस: अगले

स्पष्टीकरण (अनछुए संस्करण)

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

मुझे पसंद है कि कैसे बीबीसी बेसिक के बाद एक पहचानकर्ता को पहचान सकता है, यहां तक ​​कि बिना सफेद स्थान के भी। FORE, FORD, FORK, FORM, FORS, FORT :-)

 FOR K=6 TO 185

     REM Set S to true(-1) if K mod 9 = 5, otherwise set S to false(0)

     S = K MOD 9=5

     REM If K mod 18 = 15, send asc(space)=32 to the VDU controller,otherwise send 0.  
     REM This causes staggering every 2 lines.

     VDU-32*(K MOD18=15)

     REM Vdu 17 for colour. foreground colours start at 0, background colours at 128.
     REM Rnd(6) to choose a bright color. Multiply by the horrible expression. 
     REM The horrible expression evaluates to 1 if the pixel is to be printed, 0 if not.
     REM Picture data is stored in base 64 in the string.
     REM MID$ extracts the characters in order. 
     REM The FOR loop starts at K=6 so that this will work properly.
     REM Extracted character SHR ((K mod 6)) AND 1 to decide to
     REM colour pixel or not. BBC basic does not have SHR operator.
     REM so we divide by 2^(K mod 6) instead.

     VDU 17,128+RND(6)*
      (ASC(MID$( "?OSUuLEMSS^H?=A_<A^tC|dGxEMh>W" ,K/6,1))/2^(K MOD 6)AND 1)

     REM Print a space in the new background colour

     VDU 32

     REM Change background colour back to black

     VDU 17,128

     REM Print another space 

     VDU 32

     REM If S is true (-1) print a carriage return and linefeed. otherwise two 0's

     VDU -13*S,-10*S

 NEXT

Comments

योगदान देने के लिए धन्यवाद कि यह वास्तव में चतुर समाधान है और एक अच्छा बहुरंगी उल्लू है, मैंने पहले कभी बीबीसी को बुनियादी रूप से नहीं देखा।

— बेन पाटन

मुझे जाने और बीबीसी बेसिक एमुलेटर देखने के लिए प्रेरित करने के लिए धन्यवाद। यह एक महान भाषा है जिसका मैंने 20 वर्षों में उपयोग नहीं किया है। इसमें ऐड-ऑन लाइब्रेरी को शामिल किए बिना बहुत सारी ग्राफिक्स सुविधाओं का निर्माण किया गया है, जो इसे इस तरह के कार्य के लिए गोल्फ के लिए एक उत्कृष्ट भाषा बनाता है।

— स्तर नदी सेंट

इसके अलावा, पहली बार मैंने आधार 64 का उपयोग किया है। यह इस छवि के लिए सही था, प्रत्येक 2 लाइनों के लिए 18 पिक्सेल। मैं फिर से इसका इस्तेमाल जरूर करूंगा। तथ्य यह है कि 6 बिट बिट अपरकेस / लोअरकेस है इसका मतलब है कि आपको वास्तव में अन्य पांच के बारे में सोचना होगा। मैंने पाया कि एक बार जब मैं इसमें शामिल हो गया तो इसे लगभग आसान बना दिया।

— लेवल रिवर सेंट

मैंने बस आपकी कुछ तकनीकों के आधार पर यह twitter.com/bbcmicrobot/status/1229933895401058304 किया , बहुत बहुत धन्यवाद; हालाँकि, आपने कुछ गोल्फ के अवसरों को याद किया है। BBC बेसिक आपको कमांड्स संक्षिप्त करने देता है, जैसे 'For' = 'F', 'VDU' = 'V'।, प्लस x / 2 ^ z और 1 सिर्फ x और 2 ^ z है, आपको SHR

— bazzargh की

Answer 8

सी

ASCII आउटपुट।

x[]={256,191,424,104,376,60,316,30,286,15,287,15,383,67,403,153,325,102,341,153,511};i=20;mai
n(){for(;i>=0;i--){i&1&&putchar(32);while(x[i]){putchar(x[i]&1?42:32);x[i]>>=1;putchar(32);}pu
tchar(10);}}

कोड आउटपुट:

* * * * * * * * * 
 *     * *     * 
*   *   *   *   * 
   * *     * *   
*   *       *   * 
 *     * *     * 
* *     *     * * 
 * *         *   
* * * * * * *   * 
 * * * *         
* * * * *       * 
 * * * *         
  * * * *       * 
   * * * *       
    * * * *     * 
     * * * *     
      * * * *   * 
       *   * *   
      *   *   * * 
 * * * * * *   * 
                * 

Answer 9

जावास्क्रिप्ट - 326 307 285 अक्षर (ASCII)

a=[1716886015,1133746501,253693823,1010572830,3215485048,0];s="";with(Math)
for(y=0;44>y;y++,s+="\n")for(x=0;90>x;x++,s+="#8*+=:-. "[min(floor(d),8)])
for(j=d=0;22>j;j++)for(i=0;9>i;i++)1==((8==i?j+1:a[floor(j/4)]>>i+j%4*8)&1)
&&(d+=50/pow(pow(x-10*(i+j%2/2)-4,2)+pow(2*y-4*j-4,2),1.5));s;

शायद सबसे छोटा कोड नहीं। मैंने केवल ASCII का उपयोग करके मूल लोगो के जितना संभव हो सके उतना करीब रहने की कोशिश की।

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

Comments

आप इसे छोटा कर सकते हैं m=Math;और फिर कर रहे हैं m.floor, m.powआदि

— eithed

यहां तक ​​कि सबसे बाहरी- forलूप को एक में लपेटकर with (Math)और फिर Math.प्रत्येक घटना को छोड़कर । कुछ ब्रेसिज़ से छुटकारा पाने के s+=लिए भागों को फॉर-लूप हैडर ( y++/ के आगे x++) में ले जाएँ । मुझे लगता है कि इसका इस्तेमाल करने के ठेठ है alert/ promptजब जे एस में गोल्फ, तो मैं के साथ जाना चाहते हैं मैं / हे के लिए alert(s)बजाय अंत में।

— फायरफली

सुझावों और टिप्पणियों के लिए धन्यवाद। जब यह कोड आकार अनुकूलन की बात आती है तो मैं एक शुरुआत करता हूं :) सतर्क / त्वरित सुझाव के बारे में: मैंने उनका उपयोग करने की कोशिश की, लेकिन कुछ मुद्दे हैं: ब्राउज़र (क्रोम कम से कम) स्वचालित रूप से पाठ को लपेटने के लिए लगता है यदि रेखा बहुत लंबी है, जो टूट गई प्रतीक चिन्ह।

— बाघिन

Answer 10

CoffeeScript

कोड गोल्फ नहीं है। यह हलकों के "चिपचिपाहट" का अनुकरण करने के लिए कुछ मेटाबॉल- आईश एल्गोरिथ्म का उपयोग करता है । ASCII उल्लू को बेशर्मी से दूसरे जवाबों से चुराया गया :)

canvas = document.createElement 'canvas'
canvas.style.backgroundColor = '#240202'
canvas.style.transform = 'scale(0.5) translate(-480px,-570px)'
W = canvas.width = 960
H = canvas.height = 1140
D = 50
R = D / 2
ctx = canvas.getContext '2d'
imageData = ctx.getImageData 0, 0, W, H
data = imageData.data
owl = '''

\ * * * * * * * * *
\  *     * *     *
\ *   *   *   *   *
\    * *     * *
\ *   *       *   *
\  *     * *     *
\ * *     *     * *
\  * *         *
\ * * * * * * *   *
\  * * * *
\ * * * * *       *
\  * * * *
\   * * * *       *
\    * * * *
\     * * * *     *
\      * * * *
\       * * * *   *
\        *   * *
\       *   *   * *
\  * * * * * *   *
\                 *
'''.split '\n'

insideDot = (x, y) ->
  w = 0
  for du in [-1..1] then for dv in [-1..1]
    u = x // D + du
    v = y // D + dv
    continue unless owl[v]?[u] is '*'
    dx = x - (u * D + R)
    dy = y - (v * D + R)
    d = dx * dx + dy * dy
    w += 1 / (d * d)
    return yes if w > 0.0000008
  no

for y in [0...H] then for x in [0...W] when insideDot x, y
  i = (y * W + x) * 4
  data[i] = data[i+1] = data[i+3] = 255
  data[i+2] = 214

ctx.putImageData imageData, 0, 0
document.body.appendChild canvas

देखो यह coffeescript.org डॉक्यूमेंटेशन को नष्ट कर देता है (भागो भागो):

Answer 11

पीएचपी

लोगो के ascii कला संस्करणों पर निर्माण और जीडी पुस्तकालय का उपयोग कर एक चित्रमय संस्करण प्रस्तुत करने के लिए सरणी के रूप में इसका उपयोग करते हुए।

$circleWidth = 34;
$circleHeight = 34;
$movement = 24;
$canvasWidth = 480;
$canvasHeight = 570;
$image = imagecreatetruecolor($canvasWidth, $canvasHeight);
$backgroundColour = imagecolorallocate($image, 36, 2, 2);
ImageFillToBorder($image, 0, 0, $backgroundColour, $backgroundColour);
$circleColour = imagecolorallocate($image, 255, 255, 214);
$coordinates ='
* * * * * * * * * 
 *     * *     *  
*   *   *   *   * 
   * *     * *    
*   *       *   * 
 *     * *     *  
* *     *     * * 
 * *         *    
* * * * * * *   * 
 * * * *          
* * * * *       * 
 * * * *          
  * * * *       * 
   * * * *        
    * * * *     * 
     * * * *      
      * * * *   * 
       *   * *    
      *   *   * * 
 * * * * * *   *  
                * ';
$coordinates = str_split($coordinates);
$coordinateX = $movement;
$coordinatY = $movement;
$i=1;
foreach ($coordinates as $coordinate) {
    if ($i < 19) {
        if ($coordinate == '*') { 
            ImageFilledEllipse($image, $coordinateX, $coordinatY, $circleWidth, $circleHeight, $circleColour);  
        }
        $coordinateX = $coordinateX + $movement;
        $i++;
    } else {
        $i=1;
        $coordinateX = $movement;
        $coordinatY = $coordinatY + $movement;
    }
}
header("Content-type: image/png");
imagepng($image);
imagedestroy($image);

का परिणाम:

Answer 12

बीबीसी बेसिक + जीएक्सआर

इस पर बहुत देर से लेकिन: ट्विटर पर cm bbcmicrobot ’खाता जो प्रोग्स <280 चार्ट चलाता है या इसलिए एकोर्न GXR ROM को जोड़ा गया है, जिससे ड्राइंग सर्कल और ईलिप्स की अनुमति मिलती है। मैंने सोचा, मैं दो मंडलियों के साथ क्या आकर्षित कर सकता हूं? और यह मेरे पास आया। यह @Level River Street के उत्तर पर आधारित है, थियो मैंने संक्षिप्त कमांड का उपयोग किया है, SHR के बजाय बिट टेस्टिंग का उपयोग किया है और बिट प्रतिनिधित्व को बदल दिया है:

2MO.2:P."HOW TO DRAW AN OWL":MOV.200,700:PL.&91,120,0:MOV.250,450:PL.0,-200,0:PL.&C1,155,250:V.29,640;130;
5F.G=0TO188:Z=(G MOD18)>8:X=G MOD9*2-Z:Y=G DIV18*2-Z
6IFASC(MID$("@|WhFMxeG|tC^|A_|A?]HSNSEuLUMS?G",(G+6)DIV6,1))AND2^(G MOD6) MOV.X*36,Y*36:PL.&99,24,0
8N.G

मेरा मूल ट्वीट यहां है