ASCII का विभाजन


33

एएससीआईआई प्लस न्यूलाइन में 95 प्रिंट करने योग्य पात्रों को देखते हुए, इसे दो बराबर, 48 वर्ण समूहों (इसके बाद समूह ए और समूह बी) के रूप में विभाजित करें । दो समूहों के बीच अपनी पसंद का एक-से-एक मानचित्रण (आपके पास कुल विवेक है) बनाएं । दूसरे शब्दों में, इसके विपरीत Aमैप कर सकते हैं a, और Aहो सकता है , लेकिन इसके विपरीत भी मैप कर सकते >हैं, अगर आपको अपने कार्यक्रम की आवश्यकता है।

एक बार जब आप ASCII को दो समूहों में तोड़ चुके होते हैं, तो क्रमशः प्रत्येक समूह में केवल वर्णों का उपयोग करते हुए, दो प्रोग्राम और / या फ़ंक्शन लिखें। दूसरे शब्दों में, एक प्रोग्राम / फ़ंक्शन लिखें जो केवल समूह A में वर्णों का उपयोग करता है, और दूसरा प्रोग्राम / फ़ंक्शन जो केवल समूह B में वर्णों का उपयोग करता है।

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

यह इतना स्पष्ट नहीं हो सकता है, इसलिए यहाँ एक उदाहरण है। यदि आप मानते हैं कि सभी बड़े अक्षर समूह A में हैं, और सभी निचले अक्षर समूह B में हैं, और आपने चुना है कि इन पत्रों के लिए आपकी एक-से-एक मैपिंग एक से दूसरे में है, तो: यहाँ कुछ हैं नमूना इनपुट / आउटपुट:

कार्यक्रम ए:

Input    Output
A        A
D        D
a        A
q        Q

कार्यक्रम बी:

Input    Output
A        a
D        d
a        a
q        q

अन्य नियम:

  • दो कार्यक्रमों को एक ही भाषा में होने की आवश्यकता नहीं है।
  • उन्हें कार्यक्रम या दोनों कार्य करने की आवश्यकता नहीं है; एक प्रोग्राम हो सकता है, दूसरा एक फंक्शन, यह ठीक है।
  • उन्हें उसी तरह काम करने की ज़रूरत नहीं है, समान लंबाई का हो, ऐसा कुछ भी; उन्हें बस ऊपर दिए गए अन्य नियमों को पूरा करना होगा।
  • हां, आपके कार्यक्रमों में से केवल एक का उपयोग किया जा सकता है, और केवल एक स्थान का उपयोग कर सकते हैं (यह एक ही हो सकता है, या एक अलग कार्यक्रम)।
  • आपको प्रत्येक प्रोग्राम में सभी 48 वर्णों का उपयोग करने की आवश्यकता नहीं है।

सामान्य रूप से मानक खामियों पर प्रतिबंध लगा दिया जाता है। सभी कार्यक्रमों में स्वयं को समाहित किया जाना चाहिए, आपके द्वारा चुने गए मैपिंग वाली कोई भी फाइल नहीं।

स्कोरिंग मानदंड: । विशेष रूप से, दो कार्यक्रमों के पाठ के बाइट्स का योग।

कृपया अपना उत्तर इस तरह दें:

भाषा - # बाइट्स + भाषा - # बाइट्स = # बाइट्स

आपके मानचित्रण का एक स्पष्ट विवरण। यदि यह जटिल है, तो इस तरह एक चार्ट का उपयोग करें:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

या, आप इसे केवल (पहले 48 नक्शे में पिछले 48 अनुक्रम में) समझा सकते हैं, इसके बाद सामान्य रूप से अपना जवाब देंगे।


मैं दोनों के लिए समान भाषा का उपयोग करने का प्रयास करने जा रहा हूं। :)
mbomb007

मुझे ईमानदारी से लगता है कि आपको नियमों को बदलना चाहिए, इसे "दोनों कार्यक्रमों को एक ही भाषा होना चाहिए।" अन्यथा यह शायद बहुत आसान / व्यापक है।
mbomb007

मैं वास्तव में आश्चर्य करता हूं कि क्या यह स्व-संशोधित ब्रेनफक में संभव है। आपको बस एक प्रोग्राम का उपयोग करना होगा +और >, और दूसरा उपयोग करके -और <। फिर आपको लापता ऑपरेटरों को उत्पन्न करने का प्रयास करना होगा, जैसे कि ,या .प्रोग्राम में जो उनका उपयोग नहीं कर सकता है।
mbomb007

1
@Ruslan SQL का उपयोग करने का प्रयास करें। यह संवेदनशील नहीं है और कोड ब्लॉक के लिए कीवर्ड (आरंभ और अंत) का उपयोग करता है। यदि आप SQL Server 2014 का उपयोग करते हैं, तो आप एक प्रोग्राम के लिए DBCC बल्क इंसर्ट और दूसरे के लिए एक प्रक्रिया का उपयोग कर सकते हैं। पहले एक में, आप कोष्ठक का उपयोग करने से बच सकते हैं। फिर दोनों प्रोग्राम के लिए स्टेटमेंट का चयन करें। इसके अलावा, मेरा मानना ​​है कि जावा में यह संभव है कि एक प्रोग्राम के लिए \ u ट्रिक का उपयोग करके हर चरित्र को यूनिकोड मानों के साथ बदल दिया जाए और दूसरे के लिए एक फ़ंक्शन का उपयोग किया जाए जो अक्षर यू, बैकस्लैश या संख्याओं का उपयोग नहीं करता है।
18

4
सबसे कठिन। चुनौती। कभी।
ब्लैकहोल

जवाबों:


6

CJam - 11 बाइट्स + CJam - 25 बाइट्स = 36 बाइट्स

अक्षर 16 के वैकल्पिक समूहों में चुने गए हैं:

 !"#$%&'()*+,-./@ABCDEFGHIJKLMNO`abcdefghijklmno
0123456789:;<=>?PQRSTUVWXYZ[\]^_pqrstuvwxyz{|}~\n

यह अच्छा है कि शिफ्टिंग की के साथ कुछ मैपिंग प्राप्त की जा सकती है :)

कार्यक्रम ए:

lL,H-f&'o+c

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

कार्यक्रम बी:

q_S<\_0=16|_127<\S0=42^??

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

स्पष्टीकरण:

कार्यक्रम ए:

l      read a line from the input, this is a 1-character string
        or the empty string if the input was a newline
L,     get the length of an empty string/array (0)
H-     subtract 17, obtaining -17 (~16)
f&     bitwise-"and" each character (based on the ASCII code) with -17
'o+    append the 'o' character
c      convert to (first) character
        the result is the "and"-ed character, or 'o' for newline

कार्यक्रम बी:

q_       read the whole input and duplicate it
S<\      compare with " " and move the result before the input
_0=      duplicate the input again, and get the first (only) character
16|      bitwise-"or" with 16 (based on the ASCII code)
_127<    duplicate and compare (its ASCII code) with 127
\        move the result before the "or"-ed character
S0=      get the space character (first character of the space string)
42^      xor with 42, obtaining a newline character
          stack: (input<" ") (input) ("or"-ed char<127) ("or"-ed char) (newline)
?        if the "or"-ed character is less than 127, use the "or"-ed character
          else use the newline character
?        if the input was smaller than space (i.e. it was a newline),
          use the input, else use the character from the previous step

अच्छा! खुशी है कि यह देखने के लिए कि "सम / विषम" एकमात्र उत्तर नहीं है।
डुर्रोन 597

अभी भी एक 1 बिट टॉगल ... प्रभावशाली आकार! 2 प्रोग्राम w / 'o' का इनपुट आउटपुट को \ n नहीं लगता ... प्रोग्राम या ऑनलाइन cjam में बग?
ब्रायन टक

@BrianTuck यह आउटपुट एक नई लाइन (शाब्दिक नहीं \n) करता है, यह केवल html का निरीक्षण किए बिना देखना आसान नहीं है। आप iASCII कोड को देखने के लिए कार्यक्रम के अंत में (या ciकिसी नईलाइन इनपुट से निपटने के लिए भी
आवेदन कर सकते हैं

ओह, या आप / मैं बदल सकता है _0=करने के लिए 0=_इतना है कि यह हमेशा एक चरित्र आउटपुट
aditsu

16

CJam - 46 44 26 11 बाइट्स + गोल्फस्क्रिप्ट - 142 125 115 93 68 47 40 36 बाइट्स = 47 बाइट्स

गोल्फस्क्रिप्ट प्रोग्राम को 6 बाइट्स के लिए पीटर टेलर के लिए धन्यवाद (और कई और के लिए मार्ग प्रशस्त करना।)

CJam कार्यक्रम से 15 बाइट्स और गोल्फस्क्रिप्ट प्रोग्राम से 4 बाइट्स के लिए डेनिस को धन्यवाद।

समूह ए: यहां तक ​​कि चरित्र कोड के साथ सभी वर्ण।
ग्रुप बी: सभी वर्ण विषम वर्ण कोड के साथ, नईलाइन।

मैं दोनों के बीच यानी स्पष्ट मानचित्रण का उपयोग कर रहा हूँ, उन अक्षरों को जो केवल के रूप में कम से कम महत्वपूर्ण बिट में भिन्न होते हैं, साथ ही साथ जोड़ी ~और \n। यहाँ पूरा नक्शा (कॉलम) है:

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

कार्यक्रम ए (सीजेएम, इसे यहां परीक्षण करें ):

lX~f&"~"|X<

प्रोग्राम बी (गोल्फस्क्रिप्ट, इसे यहां परीक्षण करें ):

{1}'{-'{)}%'115)%11-[9)ie'9/{))}%++%

व्याख्या

कार्यक्रम ए

(आउटडेटेड, कल अपडेट होगा)

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

"r"(  e# Push the string "r" and pull out the character.
(~    e# Decrement to q and eval to read input.
(     e# Pull out the character from the input string.
2(|(  e# (input OR (2-1))-1 == input AND 126
0$    e# Copy the result.
N&    e# Set intersection with a string containing a newline.
"~"   e# Push "~".
"@@"( e# Push "@@" and pull out one @.
(|    e# Decrement to ?, set union with the other string to give "@?".
~     e# Eval to select either the computed character or "~" if it was a newline.

कार्यक्रम बी

(आउटडेटेड, कल अपडेट होगा)

यह कार्यक्रम बस बिटवाइज़ के माध्यम से 1 या अब 1 के साथ कम से कम महत्वपूर्ण बिट सेट कर सकता है। लेकिन इसे दोनों \v(चरित्र कोड 0x0B) और <DEL>(चरित्र कोड 0xFF) के लिए मैन्युअल रूप से जांचना होगा और उन्हें ~इसके बजाय सेट करना होगा। GolfScript में मेरे पास eval तक पहुंच नहीं थी, लेकिन इसके बजाय आप एक स्ट्रिंग को एक ब्लॉक में जोड़ सकते हैं (जो तब उस ब्लॉक में कोड का हिस्सा बन जाता है), जिसे मैं इनपुट पर मैप कर सकता हूं %:

{1}    # Push this block without executing it.
'{--'  # Push this string.
{)}%   # Increment each character to get '|..'.
')1)7?=[11=+9)?ie'
       # Push another string...
7/     # Split it into chunks of 7: [')1)7?=[' '11=+9)?' 'ie']
{))}%  # For each chunk, split off the last character and increment it.
+      # Add the array to the string, flattening the array: '|..)1)7?=\11=+9)@if'
+      # Add it to the block: {1|..)1)7?=\11=+9)@if}
%      # Map the block onto the input, i.e. apply it to the single character.

और ब्लॉक में उत्पन्न कोड के लिए के रूप में:

1|..   # Bitwise OR with 1, make two copies.
)1)7?= # Check if the result is one less than 2^7 == 128 (i.e. if it's <DEL>).
\11=   # Check with the other copy if it's equal to 11 (i.e. if it's \v).
+      # Add them to get something truthy either way.
9)     # Push a 10 (i.e. \n).
@      # Pull up the original value.
if     # Select the correct result.

15

जावा - 1088 बाइट्स + जावा - 1144 बाइट्स = 2232 बाइट्स

पहले कार्यक्रम से 1090 बाइट्स गोल्फ में मदद करने के लिए @ durron597 को धन्यवाद।

सबूत है कि यह एक भाषा में करना संभव है (और उस पर एक गैर-एसोलंग)।

यूनिकोड ट्रिक का प्रयोग करके पहले एक को सभी यूनिकोड वर्णों में परिवर्तित करें। दूसरा उपयोग करने के लिए सिस्टम का उपयोग करने के लिए प्रतिबिंब प्राप्त करने के लिए प्रतिबिंब का उपयोग करता है। बाहर। यह यू का उपयोग नहीं कर सकता क्योंकि इसका उपयोग पहले कार्यक्रम में किया गया था। मुझे पता है कि यह अधिक गोल्फ हो सकता है, लेकिन मैं पहले एक वैध समाधान पोस्ट करना चाहता था।

समूह काफी मनमाने ढंग से मैप किए जाते हैं, लेकिन मूल रूप से, पहले एक को केवल यू, \, और हेक्साडेसिमल अंकों (किसी भी मामले में) की आवश्यकता होती है।

समूह:

!#7$&89'0123456>fB@UXZ\^AKCDEGH_JL`NOkQRxzVWYu~\n
 "%()*+,-./:;<=?FIMPST[]abcdeghijlmnopqrstvwy{|}

पहला कार्यक्रम:

\u0076\u006F\u0069\u0064
k\u0028\u0069\u006E\u0074
x\u0029\u007B\u0069\u006E\u0074\u005B\u005Du\u003D\u007B33\u002C33\u002C35\u002C35\u002C36\u002C55\u002C38\u002C39\u002C36\u002C38\u002C56\u002C57\u002C39\u002C48\u002C49\u002C50\u002C48\u002C49\u002C50\u002C51\u002C52\u002C53\u002C54\u002C55\u002C56\u002C57\u002C51\u002C52\u002C53\u002C54\u002C62\u002C62\u002C64\u002C65\u002C66\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C66\u002C74\u002C75\u002C76\u002C64\u002C78\u002C79\u002C85\u002C81\u002C82\u002C88\u002C90\u002C85\u002C86\u002C87\u002C88\u002C89\u002C90\u002C92\u002C92\u002C94\u002C94\u002C95\u002C96\u002C65\u002C75\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C95\u002C74\u002C107\u002C76\u002C96\u002C78\u002C79\u002C107\u002C81\u002C82\u002C120\u002C122\u002C117\u002C86\u002C87\u002C120\u002C89\u002C122\u002C117\u002C126\u002C10\u002C126\u007D\u003B\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006Fu\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0028x>10\u003F\u0028\u0063\u0068\u0061\u0072\u0029u\u005Bx\u002D32\u005D\u003A'\u005C\u006E'\u0029\u003B\u007D

के बराबर

void
k(int
x){int[]u={33,33,35,35,36,55,38,39,36,38,56,57,39,48,49,50,48,49,50,51,52,53,54,55,56,57,51,52,53,54,62,62,64,65,66,67,68,69,102,71,72,66,74,75,76,64,78,79,85,81,82,88,90,85,86,87,88,89,90,92,92,94,94,95,96,65,75,67,68,69,102,71,72,95,74,107,76,96,78,79,107,81,82,120,122,117,86,87,120,89,122,117,126,10,126};System.out.print(x>10?(char)u[x-32]:'\n');}

दूसरा कार्यक्रम:

void n(int r)throws Throwable{int p=(int)Math.PI;int q=p/p;int t=p*p+q;int w=q+q;int[]g={t*p+w,t*p+w,t*p+q+p,t*p+q+p,t*(q+p),t*p+t-p,t*(q+p)+q,t*(q+p)+q+p,t*(q+p),t*(q+p)+q,t*(q+p)+w,t*(q+p)+p,t*(q+p)+q+p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*p+t-p,t*(q+p)+w,t*(q+p)+p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*(p+p)+p,t*(p+p)+p,t*(t-p)+t-p,t*(t-q)+t-p,t*(t-p)+p,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*(t-p)+p,t*t+p+p,t*(t-q)+t-w,t*t+t-w,t*(t-p)+t-p,t*(t+q),t*(t+q)+q,t*(t-w),t*(t+q)+p,t*(t+q)+q+p,t*(t-w)+p,t*(t-w)+q+p,t*(t-w),t*(t+q)+t-w,t*(t+q)+t-q,t*(t-w)+p,t*(t+w)+q,t*(t-w)+q+p,t*(t-q)+q,t*(t-q)+q,t*(t-q)+p,t*(t-q)+p,t*t+p+w,t*t+t-q,t*(t-q)+t-p,t*(t-q)+t-w,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*t+p+w,t*t+p+p,t*(t+q)+w,t*t+t-w,t*t+t-q,t*(t+q),t*(t+q)+q,t*(t+q)+w,t*(t+q)+p,t*(t+q)+q+p,t*(t+q)+p+w,t*(t+q)+p+p,t*(t+w)+p,t*(t+q)+t-w,t*(t+q)+t-q,t*(t+q)+p+w,t*(t+w)+q,t*(t+q)+p+p,t*(t+w)+p,t*(t+w)+q+p,t*(t+w)+p+w,t*(t+w)+q+p};java.io.PrintStream o=(java.io.PrintStream)System.class.getFields()[p/p].get(p);o.print((r<=t)?"}":(char)g[r-t*p-w]);}

उन्हें यहां देखें: https://ideone.com/Q3gqmQ


ऐसे कोई भी पात्र नहीं हैं जिन्हें आप पहले कार्यक्रम से बाहर निकाल सकते हैं, जिन्हें यूनिकोड के बच जाने की आवश्यकता नहीं है? क्या आप संख्याओं में से कुछ नहीं निकाल सकते? यदि आपने किया है void x(int z), तो वे पहले चारसेट में भी
पात्र

मुझे यकीन है कि यह संभव है। मैं कुछ चर का नाम बदल सकता हूं और सभी स्थानों को नई लाइनों या टैब से बदल सकता हूं। जब मैं घर जाऊंगा तो मैं ऐसा करूंगा। मैं सिर्फ एक ही भाषा समाधान पहले साबित करना चाहता था।
bmarks

5

निर्धारित! पायथ - 23 बाइट्स + पायथ - 30 बाइट्स = 53 बाइट्स

oops फिक्सिंग की त्रुटि --- कृपया धैर्य रखें

मार्टिन के रूप में एक ही ASCII विभाजन:

1: "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
2:!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

प्रोग # 1: टेस्ट ऑनलाइन

.xhft<zT.Dr\¡b:Z140 2\~

प्रोग # 2: टेस्ट ऑनलाइन

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