आइये हम ओकारिना खेलते हैं

42

जैसा कि हम सभी जानते हैं कि ज़ेल्डा सीरीज़ अब तक की सबसे बेहतरीन गेम सीरीज़ में से एक है। उसके सम्मान में, आइए हम ओकारिना पर कुछ गाने बजाएँ।

चुनौती:

एक कार्यक्रम लिखें, जो एक गीत दिया जाता है, उस विशेष गीत के लिए स्कोर को आउटपुट करता है।

इनपुट:

नीचे दिए गए दृश्य के अनुसार आपको जो गाना प्रस्तुत करना होगा, वह एक अद्वितीय तीन वर्ण संयोजन द्वारा दिया जाएगा:

zel - Zelda's Lullaby
sas - Saria's Song
eps - Epona's Song
sos - Sun's Song
sot - Song of Time
sst - Song of Storms

बोनस गीत, -7% प्रत्येक:

mof - Minuet of Forest
bof - Bolero of Fire
sow - Serenade of Water
nos - Nocturne of Shadow
ros - Requiem of Spirit
pol - Prelude of Light

बोनस गीत 2, -8%:

scs - Scarecrow's song

जैसा कि हम सभी जानते हैं कि स्केयरक्रो का गीत एक ऐसा गीत है जिसे आप खुद गाते हैं। इस गाने के लिए आठ नोट होना जरूरी है। एक ऐसा स्कोर तैयार करें जो आप स्वयं लिखें जो अन्य सभी अंकों से अलग हो।

यदि आप सभी गाने शामिल करने का निर्णय लेते हैं, तो यह आपके बाइट स्कोर के लिए -50% बोनस होगा।

आउटपुट:

आउटपुट में नोट्स निम्नलिखित वर्णों के प्रतीक हैं:

^
<
>
V
A

निम्नलिखित प्रारूप पर एक अंक का उत्पादन करें:

-^-^-^-^-^-^-^-^-
-<-<-<-<-<-<-<-<-
->->->->->->->->-
-V-V-V-V-V-V-V-V-
-A-A-A-A-A-A-A-A-

प्रति कॉलम केवल एक नोट की अनुमति है। सादगी के लिए मैंने मूल चार पंक्तियों में एक और पंक्ति जोड़ दी है।

प्रत्येक नोट एक अलग पंक्ति के अनुरूप है:

^: ----------------
<: ----------------
>: ----------------
V: ----------------
A: ----------------

आउटपुट को stdout को लिखा जाएगा। अनुगामी newlines की अनुमति है।

उदाहरण:

इनपुट (ज़ेल्डा लोरी):

zel

आउटपुट:

---^-----^-------
-<-----<---------
----->----->-----
-----------------
-----------------

इनपुट (बोलेरो ऑफ़ फायर):

bof

आउटपुट:

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------

नोट धोखा शीट:

zel
<^><^>
sas
V><V><
eps
^<>^<>
sos
>V^>V^
sot
>AV>AV
sst
AV^AV^
mof
A^<><>
bof
VAVA>V>V
sow
AV>><
nos
<>>A<>V
ros
AVA>VA
pol
^>^><^

चूंकि हम ऑकरीना कोड गोल्फ खेलते हैं , बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है!

गीत संदर्भ:

http://www.thonky.com/ocarina-of-time/ocarina-songs

http://www.zeldadungeon.net/Zelda05-ocarina-of-time-ocarina-songs.php

code-golf  ascii-art  music 
— sweerpotato
स्रोत
4
शायद आपको बाइट बोनस के बजाय एक% बोनस का उपयोग करना चाहिए। व्यावहारिक रूप से इनमें से किसी भी गाने को <7 बाइट्स में एनकोड करना असंभव है, इसलिए वर्तमान में कोई भी बोनस इसके लायक नहीं होगा। आपको यह भी उल्लेख करना चाहिए कि बिजूका गीत 8 वास्तविक नोटों से बना होना चाहिए; अन्यथा कोई सिर्फ एक खाली अंक प्रिंट कर सकता है। लेकिन इसके अलावा, अच्छी चुनौती!
— ETHproductions
9
तथ्य यह है कि मैं इन गीतों को अपने सिर में सुन सकता हूं इस प्रश्न को पढ़कर मुझे आश्चर्य होता है कि मैं अपने जीवन के साथ क्या कर रहा हूं। मेरा मतलब है, मैं उस समय काम कर रहा हूं जब मैं
— ओओटी का
11
मुझे उम्मीद है कि यह किसी भी मौजूदा जवाब को अमान्य नहीं करता है, लेकिन ध्यान दें कि मूल ज़ेल्डा में बिजूका के गीत को दो अलग-अलग नोटों से बना होना चाहिए , इसलिए जैसे AAAAAAAA एक मान्य बिजूका गीत नहीं होगा ।
— Jan
4
मुझे लगता है कि लोअरकेस vबेहतर लगेगा।
— mbomb007
3
मैं वास्तव में यह देखने के लिए इंतजार कर रहा हूं कि क्या कोई इस समस्या का हल वेलाटो या फग्यू में कर सकता है और इसे ओकारिना पर खेल सकता है
— user902383

जवाबों:

8

पायथ, 56.5 (113 बाइट्स - 6 × 7% - 8%)

VtJ" ^<>VA"+K\-sm+?qNdNKK@LJj@jC"þØí§V^G¤×¹z1«bëë¶ñRõr¤çM"1391423xcs@LGjC"cc0Á:xqç÷\rS  Íó׺:9"lG3z6

इसमें xxdअनपेक्षित वर्ण शामिल हैं, इसलिए यहां एक प्रतिवर्ती हेक्सडंप है:

0000000: 5674 4a22 205e 3c3e 5641 222b 4b5c 2d73  VtJ" ^<>VA"+K\-s
0000010: 6d2b 3f71 4e64 4e4b 4b40 4c4a 6a40 6a43  m+?qNdNKK@LJj@jC
0000020: 2207 fe85 d880 ed0e a756 5e47 8ba4 d7b9  "........V^G....
0000030: 7a9e 0531 ab1b 62eb ebb6 f112 52f5 72a4  z..1..b.....R.r.
0000040: e74d 2231 3339 3134 3233 7863 7340 4c47  .M"1391423xcs@LG
0000050: 6a43 229a 6317 6330 c13a 9278 71e7 10f7  jC".c.c0.:.xq...
0000060: 5c72 5309 87cd f3d7 ba3a 3922 6c47 337a  \rS......:9"lG3z
0000070: 36                                       6

आप इसे ऑनलाइन भी आज़मा सकते हैं ।

व्याख्या

मैं बेस -6 नंबरों में गाने को स्टोर करता हूं, फिर से अंतरिक्ष को बचाने के लिए बेस 1391423 और फिर बेस 256 पर एनकोड किया गया। कुछ गानों के साथ शुरू होने से मुझे बेस 6 को चुनना पड़ा ^, और नंबर डिकोडिंग के बाद वास्तव में 0 से शुरू नहीं हो सकते।

  J" ^<>VA"                                                      save characters in J
 t                                                               discard the space
V                                                                loop over all characters
                               C"..."                            parse base256 string (songs) to int
                              j      1391423                     convert to base 1391423 (separate songs)
                                                   C"..."        parse base256 string (codes) to int
                                                  j      lG      convert to base-26
                                               @LG               replace indices by corresponding letters
                                              s                  concatenate
                                             c             3     chop to 3-character codes
                                            x               z    find index of input code
                             @                                   get correct song
                            j                                6   convert to base 6
                         @LJ                                     replace indices by corresponding ^<>VA
                m                                                map d over the above
                  ?qNdNK                                         take the current character if at its row,
                                                                 otherwise a dash
                 +      K                                        add a dash
               s                                                 concatenate
           +K\-                                                  add a dash and print
— PurkkaKoodari
स्रोत
44

फंकिटॉन , 4322 - 50% = 2161

वास्तव में यहां गोल्फ की कोशिश नहीं की जा रही है। ब्यूटी एंगल के लिए ज्यादा जाना। मुझे लगता है कि मुख्य कार्यक्रम वास्तव में साफ-सुथरा दिखता है, एक सही पर आयताकार बॉक्स दूर से टिक गया।

हमेशा की तरह, आप $('pre').css('line-height',1)अपने ब्राउज़र कंसोल में निष्पादित करके एक बेहतर प्रतिपादन प्राप्त कर सकते हैं ।

                 ┌─────────────────────────┐
               ┌─┴─╖                     ┌─┴─╖
      ┌────────┤ · ╟─────────────────────┤ · ╟─────────────┐    ╔═════════╗   ╔════╗  ╔════╗
      │        ╘═╤═╝     ╔═════════╗     ╘═╤═╝ ╓───╖       │    ║ 1257283 ║ ┌─╢ 40 ║  ║ 25 ║
      │          │       ║ 2097151 ║       ├───╢ ʫ ╟───┐   │    ║ 6456094 ║ │ ╚════╝  ╚══╤═╝
    ┌─┴─╖        │       ╚════╤════╝     ┌─┴─╖ ╙─┬─╜ ┌─┴─╖ │    ║ 8219021 ║ │  ┌───╖   ┌─┴─╖
┌───┤ · ╟────────┴────┐       └─────┬────┤ · ╟───┴───┤ · ╟─┤    ║ 4660190 ║ └──┤ × ╟───┤ % ║
│   ╘═╤═╝             │            ┌┴┐   ╘═╤═╝       ╘═╤═╝ │    ╚════════╤╝    ╘═╤═╝   ╘═╤═╝
│     │               │            └┬┘     │           │   │    ╔═══╗  ┌─┴─╖  ┌──┴─╖   ╔═╧═╗
│     │  ╔═══╗ ┌────╖ │           ┌─┴─╖ ┌┐ │           │   │    ║ 8 ╟──┤ ʫ ╟──┤ >> ║   ║   ║
│     │  ║ 1 ╟─┤ >> ╟─┘       ┌───┤ ? ╟─┤├─┤           │   │    ╚═══╝  ╘═╤═╝  ╘══╤═╝   ╚═══╝
│     │  ╚═══╝ ╘══╤═╝         │   ╘═╤═╝ └┘ │           │   │    ╔════════════════╧═════════╗
│     │         ┌─┴─╖ ┌───╖ ┌─┴─╖ ┌─┴─╖  ╔═╧═╗         │   │    ║ 609678112368778425678534 ║
│   ┌─┴─────────┤ ʫ ╟─┤ ‼ ╟─┤ · ╟─┤ ‼ ║  ║ 1 ║         │   │    ║ 616189712722605554111376 ║
│   │           ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝  ╚═══╝         │   │    ║ 461573643915077926310571 ║
│   │             │     │     │   ╔═╧══╗               │   │    ║ 355541007599150245813976 ║
│   │   ╔══════╗  │     │     └───╢ 45 ║               │   │    ║ 426564826002362964111793 ║
│   │   ║ 2097 ║  │   ┌─┴─╖ ┌───╖ ╚════╝               │   │    ║ 714054902293682079346275 ║
│   │   ║ 1565 ║  └───┤ · ╟─┤ ♭ ╟─┐                    │   │    ║ 663973372550500581508544 ║
│   │   ╚═╤════╝      ╘═╤═╝ ╘═══╝ ├────────────────────┘   │    ║ 874263187322344354338195 ║
│   │   ┌─┴─╖         ┌─┴─╖       │                        │    ║ 642609790172899326178321 ║
│   │   │ ‼ ╟─────────┤ ? ╟───────┘                        │    ║ 071643306454414932126243 ║
│   │   ╘═╤═╝         ╘═╤═╝                                │    ║ 308860823981077902637848 ║
│ ┌─┴─╖ ┌─┴─╖ ╔═══╗   ┌─┴─╖                                │    ║ 322657399386789617074176 ║
└─┤ · ╟─┤ ʫ ╟─╢ 8 ║ ┌─┤ ? ╟────────────────────────────────┘    ╚══════════════════════════╝
  ╘═╤═╝ ╘═╤═╝ ╚═══╝ │ ╘═╤═╝
    │ ┌───┴╖ ╔════╗ │ ╔═══╗
    └─┤ >> ╟─╢ 21 ║ └─╢ 0 ║
      ╘════╝ ╚════╝   ╚═══╝

Funciton कार्यों एक भी, अजीब, शायद ही कभी इस्तेमाल किया यूनिकोड वर्ण से मिलकर नाम देने की परंपरा में जारी रखते हुए, मैं क्या सबसे अच्छा इस चुनौती का प्रतिनिधित्व कर सकता है के बारे में सोचा है, और यह मेरे लिए हुआ है कि लिंक और ज़ेल्डा (या, अगर आप चाहते हैं, कथा की ज़ेल्डा ) आपको एलजेड देता है , इसलिए लोअर-केस डिग्राफ U (U + 02AB, ʟᴀᴛɪɴ sᴍᴀʟʟ ᴅɪɢʀᴀᴘʜ L L) उपयुक्त लगता है।

व्याख्या

जैसा कि एसोलैंग्स लेख में बताया गया है, फ़नसीटन प्रोग्राम इनपुट को इनकोडेड के रूप में प्राप्त करता है, जिसे मैं "यूटीएफ -21" कहूंगा, लेकिन एक एकल विनम्र पूर्णांक के रूप में। अगर मैं इस नंबर को हैशमैप (शब्दकोश, साहचर्य सरणी) की कुंजी के रूप में उपयोग करना चाहता था, तो मुझे एक हैश फ़ंक्शन की आवश्यकता होगी जो दो मानदंडों को पूरा करे: एक, यह फनसिटोन में लागू करने के लिए पर्याप्त सरल है, और दो, सभी 13 की उम्मीद है इनपुट स्ट्रिंग्स एक अलग हैश मान देते हैं। सबसे सरल हैश फ़ंक्शन मैं सोच सकता था input % mकि कुछ मूल्य के लिए m। इसलिए, मैंने m= 13, 14, 15 आदि की कोशिश की , जब तक कि मुझे सबसे छोटा पूर्णांक नहीं मिला, जिसके लिए सभी हैश मूल्य अद्वितीय हैं। यह संख्या 25 है।

हैश मान हैं:

zel =  6
sas = 19
eps = 10
sos = 22
sot =  1
sst =  9
mof = 14
bof =  3
sow = 13
nos = 17
ros = 21
pol = 16
scs = 23

हम प्रत्येक गीत को एक बिट की उपस्थिति या अनुपस्थिति का प्रतिनिधित्व करते हुए सांकेतिक शब्दों में बदलना करते हैं। उदाहरण के लिए, ज़ेल्डा की लोरी को निम्नानुसार एन्कोड किया जाएगा:

---^-----^------- = 01001000
-<-----<--------- = 10010000
----->----->----- = 00100100
----------------- = 00000000
----------------- = 00000000

सिवाय इसके कि बिट्स विपरीत क्रम में हैं; शीर्ष बाईं सेल कम से कम महत्वपूर्ण बिट में है। इसका मतलब है कि हर गीत 40 बिट लंबा है।

हम इस प्रकार 40 × 25 = 1000-बिट संख्या लेकर और हैश मान के अनुसार सही जगह पर प्रत्येक गीत के लिए बिट पैटर्न रखकर एक (मामूली विरल) हैश तालिका बनाते हैं। कार्यक्रम में राक्षसी संख्या वास्तव में यह हैश तालिका है।

यहां बताया गया है कि शेष संख्याओं में से प्रत्येक का क्या अर्थ है:

  • 45= 0x2Dके लिए यूनिकोड है -।
  • 1257283645609482190214660190: यह ^<>VAUTF-21 में स्ट्रिंग है। हंडसाइट में मैं प्रति वर्ण 7 बिट्स का उपयोग कर सकता था, जिससे संख्या कम हो जाती है, लेकिन UTF-21 फ़नसिटॉन में इतना गहरा पारंपरिक है कि यह मेरे लिए बस नहीं हुआ।
  • 2097151= 0x1FFFFF= (1 << 21) - 1. उपरोक्त स्ट्रिंग से पहला वर्ण प्राप्त करने के लिए प्रयुक्त।
  • 20971565: यह वह स्ट्रिंग है -\n, जिसे प्रत्येक पंक्ति के अंत में जोड़ा जाता है।
    • यह उत्सुक लग सकता है कि यह संख्या और पिछला समान समान है, लेकिन अगर आप इसके बारे में सोचते हैं, तो ऐसा इसलिए है क्योंकि हम दशमलव और यूनिकोड का उपयोग कर रहे हैं \n10. ऐसा होता है। अंतिम संख्या (10 << 21) + 45 है।

कार्यक्रम अब आगे बढ़ता है:

  • मुख्य कार्यक्रम ʫनिम्नलिखित 3 मापदंडों के साथ कहता है :
    • बी : हैश तालिका, इनपुट के हैश मान से 40 बिट गुणा सही स्थानांतरित हुई। जिस गीत को हम आउटपुट करना चाहते हैं वह अब 40 सबसे महत्वपूर्ण बिट्स में है।
    • c : स्ट्रिंग ^<>VA।
    • a : संख्या 8।
  • के प्रत्येक पुनरावृत्ति में ʫ,
    • यदि ग खाली नहीं है,
      • अगर एक शून्य, के नीचे बिट पर नज़र नहीं है बी । आउटपुट -, दूसरे के बाद -अगर यह शून्य है या अन्यथा सी का पहला चरित्र है । एक बिट को हटाने के लिए एक से दाएं B को शिफ्ट करें और एक को घटाएं ।
      • अगर एक शून्य, उत्पादन होता है -\n, तो से पहले वर्ण बंद काटना सी और के साथ एक और पाश शुरू एक = 8।
    • अगर सी खाली है, तो हम कर रहे हैं।
— Timwi
स्रोत
अच्छा किया, वह प्रभावशाली है!
— स्वेरापॉटो
6
<grumble> वह डेंजरस म्यूजिकल फ़्लैट ... मोनोपॉज़िंग फेंक रहा है ... </ grumble>
— टेलर लोपेज़
1
@iAmMortos: सहमत। इस कारण से, मैंने लंबे समय तक for चरित्र से परहेज किया और अपने आप को आश्वस्त किया कि मैं सिर्फ बिटवाइज़-नहीं कर सकता, फिर avoid, फिर बिटवाइज़-नहीं। लेकिन अब मैं Funciton को संपादित करने के लिए Deja Vu Sans Mono का उपयोग करता हूं और इसमें ja है। तो अब हम सभी की जरूरत है StackExchange के लिए है कि फ़ॉन्ट के लिए भी कोड के लिए स्विच ;-)
— Timwi
4
इसके अलावा, आपको निश्चित रूप से स्वीकार करना चाहिए कि ♭ और ♭ की तुलना में वेतन वृद्धि और वेतन वृद्धि के लिए कोई बेहतर फिटिंग यूनिकोड चरित्र नहीं है। वे एकदम सही हैं ।
— तिमवी
हाहा, पूरी तरह से। मैं फ़ंक्शन के बारे में कुछ नहीं जानता, लेकिन यह कुल समझ में आता है!
— टेलर लोपेज
11

पायथन 2, 143.5 (287 बाइट्स - 50%)

i='^<>VA'
u=dict(zel="<^>"*2,sas="V><"*2,eps="^<>"*2,sos=">V^"*2,sot=">AV"*2,sst="AV^"*2,mof="A^<><>",bof="VAVA>V>V",sow="AV>><",nos="<>>A<>V",ros="AVA>VA",pol="^>^><^",scs="<"*8)[raw_input()]
r=[17*['-']for _ in[1]*5]
x=0
for g in u:r[i.find(g)][x*2+1]=g;x+=1
for h in r:print''.join(h)

ग्रिड डैश के साथ उत्पन्न होता है; फिर अनुक्रमित और नोटों के साथ बदल दिया गया।

— Zach Gates
स्रोत
इसे बहुत अधिक नहीं देखा गया, लेकिन आप jप्रत्येक अल्पविराम को एक स्थान के साथ बदलकर और splitबिना किसी तर्क के कॉल करने की घोषणा में बाइट्स को बचा सकते हैं
— भूमिगत
मुझे नहीं लगता कि आपको ऐसा करने की आवश्यकता है, यह अभी भी आपका एल्गोरिथ्म है इसलिए मुझे लगता है कि आप प्रतिनिधि के लायक हैं, लेकिन वैसे भी मैं छुटकारा पाने में कामयाब रहा range। अफसोस की बात है कि आप सिर्फ आंतरिक सूची को 5 से गुणा नहीं कर सकते क्योंकि वे सभी एक ही वस्तु हैं और एक को बदलने से दूसरों में परिवर्तन होता है: / हम पर्ल (अब के लिए) को हरा देते हैं!
— फ्राईमईएग्गमैन
क्या आप "<^><^>"=> जैसे सामान करके 6 बाइट्स (पहले छह गानों में से प्रत्येक के लिए 1) को खत्म नहीं कर सकते थे "<^>"*2?
— एल'एंडिया स्ट्रैटन
scs="<"*8 मुझे आपका बिजूका गाना पसंद नहीं है।
— केसी कुबैल
जब मैं इसे चलाने की कोशिश करता हूं तो यह सिर्फ लाइन 2 पर रुकता है और कभी खत्म नहीं होता।
— कोरी क्लेन
7

पर्ल 5, 125 ( 320 260 250 बाइट्स -6 x 7% बोनस गाने -8% बिजूका गीत)

अंत में, उस पेरीश हैश सिंटैक्स के साथ प्रयोग करने का अवसर। 

$_=pop;@B={qw(zel <^><^> sas V><V>< eps ^<>^<> sos >V^>V^ sot >AV>AV sst AV^AV^ mof A^<><> bof VAVA>V>V sow AV>>< nos <>>A<>V ros AVA>VA pol ^>^><^ scs <^V>>V^<)}->{$_}=~/./g;map{@L=('-')x17;for$i(0..@B){$L[1+2*$i]=$_,if$B[$i]eq$_}say@L}qw(^ < > V A)

परीक्षा

$ perl -M5.010 ocarina.pl scs
---^---------^---
-<-------------<-
------->->-------
-----V-----V-----
-----------------
— LukStorms
स्रोत
1
का प्रयोग करें qw()वसा के लिए अल्पविराम के बजाय वाक्य रचना ( %h=qw(zel <^><^> sas >'V><' ...)कुछ बाइट्स को बचाने के लिए
— भीड़
1
@ एमओबी कि सलाह सिर्फ "कुछ" बाइट्स की तुलना में अधिक मुंडा। :) धन्यवाद!
— लुकस्टॉर्म
1
@Lके रूप में अधिक सफलतापूर्वक लिखा जा सकता है @L=('-')x17। इसके अलावा, मुख्य हैश को अनाम के रूप में छोड़ा जा सकता है @B={qw(zel <^><^> ... scs <^V>>V^<)}->{$_}=~/./g।
— प्राइमो
1
मैं देख रहा हूँ, थोड़ा क्रिया विभाजन से बचने के लिए वे अच्छी चालें हैं। दस और बाइट्स शून्य करने के लिए बलिदान किया गया। ट्यूमर
— LukStorms
5

पर्ल, 75 (150 बाइट्स - 50%)

#!perl -nl
$i=vec~$_,0,32;print+qw(- - ^ < > V A)[0,map{vec('w2$$W4F4w7DeweTFwR$Ew$C2wVdeVe3cw4B#EEVVwC5Tw44bwR&e',$i/480%15*8-$_,4)==$.&&$.,0}1..8]while$.++<6

शेबंग को 2 के रूप में गिना जाता है, इनपुट स्टड से लिया जाता है।

नमूना उपयोग

$ echo zel | perl zelda.pl
---^-----^-------
-<-----<---------
----->----->-----
-----------------
-----------------

$ echo bof | perl zelda.pl
-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------

$ echo scs | perl zelda.pl
-----------------
---<-<-<---------
-----------------
-----------V-V---
-A-------A-----A-
— Primo
स्रोत
1
इसके लिए बिटशिफ्टिंग vec फंक्शन का उपयोग कर रहे हैं? गजब का।
— LukStorms
@LukStorms मेरी इच्छा है कि यह 2 की शक्तियों के बजाय 3 बिट्स कर सकता है;)
— प्राइमो
4

हास्केल, 344 - 50% = 172 बाइट्स

import Data.List
s"zel"=82
s"sas"=69
s"eps"=86
s"sos"=48
s"sot"=128
s"sst"=50
z"mof"=11055
z"bof"=373854
z"sow"=1720
z"nos"=73217
z"ros"= -12730
z"pol"=4791
z"scs"=304236
z n=s n*126
p n|n*n== -n="   "|0<1="A^<>V"!!(n`mod`5):p(n`div`5)
o=putStr.unlines.transpose.(l:).concatMap(\c->[map(e c)"^<>VA",l]).take 8.p.z
e c d|c==d=c|0<1='-'
l="-----"

o काम करता है।

सोचा कि मैं इन एन्कोडिंग्स का उपयोग करके अजगर को हरा सकता हूं (मुझे एक लंबा समय लग गया ।_)।, लेकिन नहीं। वे वास्तव में अभी तक बहुत सारे बाइट्स नहीं बचाते हैं। कोई सुझाव?

हां, यह एन्कोडिंग के सामने एक माइनस है "ros"। थॉट्स क्योंकि इसकी 'शीट' 0मेरे बेस -5 में मौजूद चरित्र के साथ समाप्त होती है , क्योंकि यह नकारात्मक चाल 'आसान गीतों' के लिए काम नहीं करेगी, जो इनकोडिंग में डूबा हुआ है s। जब तक आप quotशायद उपयोग नहीं करते हैं , लेकिन तब आप p (-1)विशेष रूप से संभाल नहीं सकते हैं quot (-5) = 0, इसलिए नकारात्मकता गायब हो जाएगी। जो कुछ।

— लीफ़ विलर्ट्स
स्रोत
4

PHP: 130 बाइट्स (260 270 279 बाइट्स - 6 × 7% - 8%)

अधिक बाइट बचाने के लिए कुछ बेहतरीन विचारों के लिए इस्माइल मिगुएल और ब्लैकहोल को धन्यवाद!

<?php $f=str_split;for($z='*^<>VA';++$i<6;print"-
")foreach($f(base_convert(substr(current(preg_grep("/^$argv[1]/",$f(bofttmmeps8jf0mofvff0nosfnfopol99d0rosyxt0sasrgk0scs8m8msosm9p0sotnry0sowylc0sstybp0zeldk90,7))),-4),36,6),1)as$c)echo$i-$c?'--':'-'.$z[$c-0];

इसके बाद print"-, यह एक गाड़ी वापसी का शाब्दिक सम्मिलन है। यह विंडोज में दो बाइट्स में अनुवाद कर सकता है।

बिजूका के गीत सहित सभी बोनस गीत शामिल हैं।

प्रत्येक गीत को कोड के सात बाइट्स में दर्शाया गया है। मुझे नया स्कोरिंग पसंद है क्योंकि पुराने स्कोरिंग के साथ मुझे कुल मिलाकर केवल एक मील बोनस अंक प्राप्त होगा!

हाल ही के संपादन PHP को बहुत सारी चेतावनियाँ उत्पन्न करते हैं, इसलिए चीजों को अच्छा और सुव्यवस्थित रखने के लिए, जिन्हें मोड़ दिया जाता है /dev/null।

के रूप में सहेजें zelda.phpऔर कमांड लाइन पर चलाएं:

$ php zelda.php zel 2> /dev/null
---^-----^-------                                                                                                                                   
-<-----<---------                                                                                                                                   
----->----->-----                                                                                                                                   
-----------------                                                                                                                                   
-----------------

$ php zelda.php bof 2> /dev/null                                                                                                                            
-----------------                                                                                                                                   
-----------------                                                                                                                                   
--------->--->---                                                                                                                                   
-V---V-----V---V-                                                                                                                                   
---A---A--------- 

$ php zelda.php scs 2> /dev/null                                                                                                                          
-^-------^-------                                                                                                                                   
---<-------<-----                                                                                                                                   
----->------->---                                                                                                                                   
-------V-------V-                                                                                                                                   
-----------------
क्या आपका मतलब है "के रूप में सहेजें main.php"?
— Zach गेट्स
@ZachGates - इसे पकड़ने के लिए धन्यवाद, किए गए परिवर्तन।
आप की जरूरत नहीं है ()चारों ओर ($i-$c)पर echo($i-$c)?'--':'-'.$z[$c-0];। इसके अलावा, अपने स्ट्रिंग के अंदर अपने splitबिना इस्तेमाल किया जा सकता है '। और के '/^'.$argv[1].'/'रूप में लिखा जा सकता है"/^$argv[1]/"
— इस्माइल मिगुएल
1
धन्यवाद! मुझे लगता है कि आउटपुट को साफ करने के लिए सीजीएसई में पाइप चेतावनियों / देव / नल को इसकी अनुमति है?
@ ब्लेकहोल - धन्यवाद! यह पर्ल 5 सबमिशन के साथ जुड़ा हुआ है, बहुत अच्छा कर रहा है ...
4

पायथन 3 - 138.5 ( 292 280 277 बाइट्स - 50%)

बदली विधि के बजाय प्रिंट-ए-यू-गो विधि को करते हुए, वर्तमान पायथन नेता से कुछ बाइट्स को हटा दिया।

ऑनलाइन प्रयास करें

s=dict(zel="<^><^>",sas="V><V><",eps="^<>^<>",sos=">V^>V^",sot=">AV>AV",sst="AV^AV^",mof="A^<><>",bof="VAVA>V>V",sow="AV>><",nos="<>>A<>V",ros="AVA>VA",pol="^>^><^",scs="AV><^AV>")[input()]
s+=" "*8
for c in "^<>VA":
 o="-"
 for x in range(8):o+=["--",c+"-"][s[x]==c]
 print(o)

Daud:

> python3 loz.py
bof [return]

आउटपुट:

-----------------
-----------------
--------->--->---
-V---V-----V---V-
---A---A---------
— टेलर लोपेज
स्रोत
आप ['--',c+'-'][s[x]==c]सशर्त के बजाय का उपयोग करके कुछ बाइट्स बचा सकते हैं
— रूथ फ्रैंकलिन
ऊह, अच्छा कॉल, धन्यवाद!
— टेलर लोपेज
3

रूबी, 1, 192 - 50% = 96 को संशोधित करें

गोल्फ में शामिल हैं:

मैजिक स्ट्रिंग में अक्षरों के समूहों के बीच व्हाट्सएप को हटाना (और लाइन के अंत में हर का संशोधन /4।) कुछ अन्य अनावश्यक व्हाट्सएप को हटाना।

भागने के दृश्यों को एकल वर्णों में परिवर्तित करना (स्टैक एक्सचेंज उन्हें प्रदर्शित नहीं करेगा, इसलिए मैंने ?एक प्लेसहोल्डर के रूप में रखा है )

g17 के पांच रन वाले एकल तार के पुनर्परिवर्तन के रूप में- के पांच तार होते हैं, 17 के पांच तार के बजाय-

s=gets.chop
s[?s<=>s[0]]=''
n=("owEkrswuns=;gcsbfbYuze33as&&es77os??otaast??mf?9pl
?"=~/#{s}/)/4
g=(?-*17+'
')*5
(n<4? n+5:6).times{|i|x=$'[i/3].ord/5**(i%3)%5;g[x*18+i*2+1]='^<>VA'[x]}
puts g

रूबी, 0, 223 - 50% = 111.5 (अपंग)

इनपुट कोड 2 अक्षरों में घटाया गया है। यह एक से शुरू होता है s, sहटा दी जाती है, अगर यह करने के बाद एक अक्षर से शुरू होता sहै (केवल लागू करने के लिएzel अंतिम अक्षर हटा दिया गया है, और अगर यह एक अक्षर से शुरू होता इससे पहले sमध्य पत्र हटाया जाता है।

मैजिक स्ट्रिंग (जिसमें अनगुल्ड वर्जन में स्पष्टता के लिए रिक्त स्थान होते हैं) में 2-अक्षर कोड होते हैं, जिसके बाद संगीत डेटा होता है। यह मैच ऑपरेटर का उपयोग करके खोजा जाता है=~ जो स्ट्रिंग में स्थिति लौटाता है।

5, 7, और 8 नोटों में से प्रत्येक में एक गाना है (प्लस scs जिसमें 8 नोट भी हैं।) ये, एक मनमाने 6-नोट गीत rosके साथ मैजिक स्ट्रिंग की शुरुआत में बंडल किया जाता है ताकि nदिए गए मूल्य द्वारा खेलने के लिए नोटों की संख्या की गणना करने के लिए स्ट्रिंग में स्थिति का उपयोग किया जा सकता है। csपहले में निचोड़ा हुआ है bf, और छंटनी के साथ जब संख्या nगोल हो जाती है तो हम दोनों के लिए सही गणना के साथ दूर हो जाते हैं। चौथे क्लस्टर के बाद, सभी गानों में 6 नोट होते हैं, इसलिए यदि nबड़े नोटों की संख्या 6 के डिफ़ॉल्ट पर कम हो जाती है।

-आउटपुट के लिए एक सरणी सेट की जाती है और नोटों को एक-एक करके प्रतिस्थापित किया जाता है। आवश्यक संगीत डेटा चर से निकाला जाता है$' जिसमें मूल जादू स्ट्रिंग का हिस्सा मैच के दाईं ओर होता है। इस तरह, अप्रासंगिक आंकड़ों को नजरअंदाज कर दिया जाता है।

नोटों को जादू स्ट्रिंग में एक समय में 3 एन्कोड किया गया है, प्रासंगिक 2-अक्षर गीत कोड के बाद। वे विभाजन द्वारा निकाले जाते हैं 5**(i%3)और एक पात्र gउसी के अनुसार अद्यतन किया जाता है। कार्यक्रम के अंत में gमुद्रित किया जाता है।

s=gets.chop
s[?s<=>s[0]]=''
n=("owEk rswu ns=;g csbfbYu ze33 as&& es77 os\21\21 otaa st\23\23 mf\35\71 pl\n\a"=~/#{s}/)/5

g=(0..4).map{'-'*17}
(n<4? n+5 : 6).times{|i|x=$'[i/3].ord/5**(i%3)%5;g[x][i*2+1]='^<>VA'[x]}
puts g
— स्तर नदी सेंट
स्रोत
2

पायथन 2, 141.5 बाइट्स -50% (283 बाइट्स)

s='D  2)AE0*  A2)D  AD )2 A  )D2A 0,"!A D2) A  (2EA"4H !A )2D A 1F`(A)2D  A  p\xc5*'.split("A")['sst pol zel sos sot sow sas ros mof scs nos eps bof'.split().index(raw_input())]
for c,n in zip(s,"^<>VA"):print"-".join([("-"+n)[i>"0"]for i in bin((ord(c)-32)%255)[2:].zfill(8)][::-1])

प्रत्येक नोट को बाइट के रूप में संग्रहीत करता है क्योंकि प्रत्येक पंक्ति 8 नोट लंबी है। बाइनरी प्रतिनिधित्व को याद करता है और फिर सही पात्रों के साथ बदल देता है।

— नीला
स्रोत
1

लुआ, 249 बाइट्स - 50% = 124.5

w=io.write for j=1,5 do n={sst=41881,pol=44915,zel=30814,sos=42315,sot=17577,sow=5953,sas=35588,ros=11065,mof=29335,nos=122170,eps=29729,bof=719576,scs=999999}[...]for i=1,8 do d=n%6 n=(n-d)/6 c=d==6-j and'AV><^':sub(d,d)or'-'w('-',c)end w('-\n')end

बहुत सरल, बस आधार -6 नंबर के रूप में एन्कोड किए गए बैक गानों को पढ़ता है।

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