हमेशा एक ही लंबाई के साथ आउटपुट

Question

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

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

इनपुट

एक एकल पूर्णांक $n$ , जो की श्रेणियाँ भाषा की पसंद से निर्धारित होती है। यदि आपकी भाषा में चर लंबाई पूर्णांक है, तो सीमा है $-2^{31} \leq n < 2^{31}$ ।

उत्पादन

एक स्ट्रिंग या पात्रों की सूची, या STDOUT या STDERR के लिए एक प्रिंट। आप केवल इन विधियों में से एक का उपयोग कर सकते हैं। इनपुट की परवाह किए बिना आउटपुट एक ही लंबाई का होना चाहिए, लेकिन यह आप पर निर्भर है कि वह कौन सी लंबाई है। आउटपुट में अंक वर्ण 0-9या ऋण चिह्न नहीं हो सकता है- । आउटपुट निर्धारक होना चाहिए ।

आपको यह साबित करने में सक्षम होना चाहिए कि प्रत्येक आउटपुट के लिए केवल एक ही संभव इनपुट है , या तो औपचारिक प्रमाण द्वारा, एक तर्क, या एक जानवर-बल खोज।

यह एक कोड गोल्फ प्रश्न है, इसलिए किसी भी बाहरी बाइट्स को शेव करें। सभी भाषाओं का स्वागत है, और बेहतर!

Comments

क्या सिद्धांत में कार्यक्रम किसी भी इनपुट के लिए काम करना चाहिए? या यह एक विधि का उपयोग करने के लिए कि केवल निर्दिष्ट सीमा (से घिरा लिए काम करता है के लिए पर्याप्त है भाषा सीमाओं लेकिन विधि सीमाओं के कारण), जरूरी नहीं? $\pm 2^{31}$

— मिस्टर एक्सकोडर

@ Mr.Xcoder यदि आप मनमाने ढंग से लंबाई पूर्णांक के लिए काम करना चाहते हैं तो आप एक लंबाई कैसे चुन सकते हैं?

— स्टीफन

@ Mr.Xcoder आपको केवल यह साबित करना होगा कि यह उस रेंज के लिए काम करता है। यह नियम पायथन जैसी भाषाओं की मदद करने के लिए है, जहां संख्या हजारों अंकों की हो सकती है। उस नियम के बिना, यह पायथन और पायथन डेरिवेटिव दोनों के लिए बहुत कठिन होगा (जिसमें बहुत सी गोल्फिंग भाषाएं शामिल हैं)।

— अधिकतम

एक भाषा चर लंबाई पूर्णांकों नहीं है, तो लेकिन से बड़ा मान समर्थन कर सकते हैं , हम सीमित रेंज के उपयोग की अनुमति दी हैं - 2 31 ≤ n < 2 31 ? $2^{31}$$-2^{31}\le n<2^{31}$

— अरनौलड

@Arnauld अधिकतम सीमा 32 बिट हस्ताक्षरित पूर्णांक है, भाषा की सीमाओं की परवाह किए बिना। भाषा केवल उस सीमा को कम कर सकती है।

— अधिकतम

Answer 1

जावास्क्रिप्ट (ईएस 8), 33 बाइट्स

की सीमा में इनपुट की उम्मीद सुरक्षित जे एस पूर्णांकों: $-2^{53}\le n < 2^{53}$ ।

76 वर्णों की एक स्ट्रिंग देता है।

n=>btoa(n.toString(2)).padEnd(76)

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

कैसे?

चरण 1

इनपुट को पहले बाइनरी में परिवर्तित किया गया है। यह ऋणात्मक संख्याओं के लिए अग्रणी ऋण चिन्ह को संरक्षित करता है।

उदाहरण:

• 123 → "1111011"
• -77 → "-1001101"

चरण 2

परिणामस्वरूप स्ट्रिंग को बेस -64 में एन्कोड किया गया है।

इसका अर्थ है कि 1 से 3 वर्णों के प्रत्येक ब्लॉक को 4 वर्णों के नए ब्लॉक में बदल दिया जाएगा। यह रूपांतरण सुरक्षित है क्योंकि किसी भी परिणामी ब्लॉक में निषिद्ध प्रतीकों (अंक या शून्य चिह्न) नहीं हैं।

3-चरित्र ब्लॉक

"-10" -> "LTEw" | "011" -> "MDEx"
"-11" -> "LTEx" | "100" -> "MTAw"
"000" -> "MDAw" | "101" -> "MTAx"
"001" -> "MDAx" | "110" -> "MTEw"
"010" -> "MDEw" | "111" -> "MTEx"

यदि बाइनरी स्ट्रिंग की लंबाई 3 से अधिक नहीं है, तो 1 या 2 वर्णों के एकल अंतिम ब्लॉक को एन्कोड करना होगा:

1-वर्ण ब्लॉक

"0"   -> "MA==" | "1"   -> "MQ=="

2-चरित्र ब्लॉक

"-1"  -> "LTE=" | "10"  -> "MTA="
"00"  -> "MDA=" | "11"  -> "MTE="
"01"  -> "MDE=" | 

चरण 3

अंतिम आउटपुट ट्रेलिंग स्पेस के साथ गद्देदार है।

Comments

क्या आपको पहले से ही पता था कि चरित्र के इन विशेष संयोजनों में कोई संख्या नहीं है, जब इसे base64 में रूपांतरित किया जाता है, या क्या आपको प्रायोगिक रूप से पता चला है?

— टॉम ज़ातो -

@ TomášZato यह एक आश्वस्त अनुमान था, इस तथ्य के आधार पर कि यह ASCII तालिका के निचले हिस्से में एक बहुत ही छोटा चारसेट है।

— अरनुलद

Answer 2

पायथन 3 , 49 39 बाइट्स

lambda i:[chr(ord(x)*2)for x in"%9x"%i]

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

-10 बाइट्स नकारात्मक सात के लिए धन्यवाद

पूर्णांक को हेक्साडेसिमल में रूपांतरित करता है, और कुल 9 वर्णों तक रिक्त स्थान बनाता है। फिर, स्ट्रिंग में प्रत्येक वर्ण के ASCII कोड को दोगुना कर देता है (कुछ ASCII के बाहर यूनिकोड में विस्तार करता है, लेकिन पायथन इसे ठीक से संभालता है), वर्णों की एक सूची तैयार करता है।

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

पायथन 3 , 59 56 47 बाइट्स

lambda i:[*map(lambda x:chr(ord(x)*2),"%9x"%i)]

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

-3 बाइट्स जित्स की बदौलत

-9 बाइट्स नकारात्मक सात के लिए धन्यवाद

समान एल्गोरिथ्म, लेकिन लूप के mapबजाय का उपयोग करना for।

Comments

आप में 3 बाइट्स बंद दाढ़ी कर सकते हैं mapकी जगह दृष्टिकोण list( ... )के साथ[* ... ]

— Jitse

आप के साथ गद्देदार स्ट्रिंग बना सकते हैं"%9x"%i

— नकारात्मक सात

@negativeseven धन्यवाद, यह वास्तव में प्रतिभाशाली है

— स्टीफन

ASCII के भीतर और पायथन 2 में 39 बाइट्स में रह सकते हैं`4e9+n`

— जोनाथन एलन

Answer 3

05AB1E , 11 5 बाइट्स

тjÇ·ç

-6 बाइट्स पोर्टिंग @ स्टेपेन का दृष्टिकोण , इसलिए उसे उभारना सुनिश्चित करें!

100 अक्षरों तक, के साथ की एक सूची आउटपुट $100-(\text{input length})$ की राशि @(अंतरिक्ष कोडपॉइंट दोगुना), और सभी -0123456789को मैप किया Z`bdfhjlnpr(ASCII कोड पॉइंट्स दोगुना)।

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

स्पष्टीकरण:

 j     # Prepend spaces in front of the (implicit) input-integer to make it of length:
т      # 100
  Ç    # Convert each character to its unicode value
   ·   # Double each
    ç  # And convert it back to a character
       # (after which the resulting list is output implicitly)

---

मूल 11 बाइट्स उत्तर:

Ķ×AIdè«žIj

इसे ऑनलाइन आज़माएं ( 1000इसके बजाय सीमित 2147483648)।

स्पष्टीकरण:

आउटपुट लंबाई हमेशा 2,147,483,648 वर्ण लंबी होती है। इसका उत्पादन $2147483648-|n|-1$ राशि के रिक्त स्थान, के साथ संलग्न $|n|$newlines की राशि, 'a' if $n\lt0$ या 'b' यदि $n\geq0$ साथ जोड़ा गया ।

Ä            # Get the absolute value of the (implicit) input-integer
 ¶×          # And have a string with that many newline characters
   A         # Push the lowercase alphabet
    Id       # Check if the input is non-negative (>=0) (1 if truthy; 0 if falsey)
      è      # Use that to index into the alphabet (so "a" for <0 and "b" for >=0)
       «     # Append that to the newline-string we created earlier
          j  # And prepend spaces to make the string of a length:
        žI   # 2147483648 (this has been replaced with `₄`/1000 in the TIO)
             # (after which the result is output implicitly)

Answer 4

ब्रेनफक , 48 29 28 16 13 बाइट्स

इस कार्यक्रम की कोशिकाओं, जहां की आवश्यकता है $c_n \in \mathbb{N}$ , लेकिन अगर आप लगातार परिणाम चाहते हैं, तो सुनिश्चित करें कि $c_n < 256$

(आउटपुट स्पष्ट रूप से अद्वितीय कोई बात नहीं क्या नंबर आप दर्ज होगा $-\infty \lt n \lt \infty$ )। यदि पूर्णांक छोटा है, तो प्रोग्राम आउटपुट को बिल्कुल ∞ से मिलान करने के लिए बाहर कर देगा$\infty$ बाइट्स, तो लंबाई हमेशा एक ही है।

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

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

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

---

मूल, 28 बाइट उत्तर:

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

यह एक आउटपुट को बिल्कुल $2^8 - 1$ बाइट्स में पैड करेगा । संख्या रूपांतरण तंत्र यहाँ काम करता है। यह प्रोग्राम ऊपर दिए प्रोग्राम की तरह ही है।

Comments

अनंत उत्पादन की अनुमति नहीं है

— जो किंग

@JoKing मैंने यह जवाब देने के बाद कहा था। लेकिन अगर आप वास्तव में इससे आहत महसूस करते हैं, तो मैं केवल चुनौती से बाहर निकल सकता हूं और पहले जवाब को गैर-प्रतिस्पर्धा के रूप में घोषित कर सकता हूं

— Krzysztof Szewczyk

Answer 5

पायथन 3 , 39 बाइट्स

lambda n:f"{n:33b}".translate("abc"*99)

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

दी गई संख्या को बाइनरी स्ट्रिंग प्रतिनिधित्व (रिक्त स्थान के साथ गद्देदार) में बदल देता है, फिर पात्रों (space)-01को मैप करता caabहैstr.translate फ़ंक्शन के करता है।

Answer 6

जेली , 4 बाइट्स

œ?ØẠ

एक पूर्णांक लिंक जो एक पूर्णांक को स्वीकार करता है जो 52 वर्णों की सूची देता है।

इनपुट रेंज कुछ हद तक अधिक हो सकती है $-2^{223} \leq n \lt 2^{223}$ जबसे $52!>2^{224}$।

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

कैसे?

œ?ØẠ - Link: integer, n
  ØẠ - alphabet (Jelly's longest built-in character list containing no digits
     -           or hyphen) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
œ?   - permutation at index (n) if all 52! permutations were written out
     - in lexicographical order.
     - This indexing is modular so when n = -x we fetch the (52!-x)th entry.

इसलिए...

-2147483648 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFEHB
-2147483647 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHBE
-2147483646 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHEB
-2147483645 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKHBEF
    ...
         -4 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDACB
         -3 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBAC
         -2 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBCA
         -1 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCAB
          0 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA
          1 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
          2 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxzy
          3 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz
          4 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyzx
    ...
 2147483644 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsvyu
 2147483645 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyuv
 2147483646 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyvu
 2147483647 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpusvy

Answer 7

रूबी , 27 बाइट्स

->n{('%34b'%n).tr'01','ah'}

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

('%34b'%n)..1एक नकारात्मक संख्या को इंगित करने के लिए अपने बाइनरी प्रतिनिधित्व में एक पूर्णांक देता है, (यह 1s के असीम रूप से लंबे उपसर्ग का प्रतिनिधित्व करने के लिए है), और रिक्त स्थान का उपयोग करके 34 वर्णों तक इसे छोड़ देता है। फिर हम 0'ए' के ​​साथ एस को प्रतिस्थापित करते हैं और 1मैन्थोकल बेस 2 रिप्रेजेंटेशन बनाने के लिए 'एच' के साथ एस: "हाहाहाहाहा" जैसे स्ट्रिंग्स, जो कभी-कभी रिक्त स्थान के साथ आते हैं ..। चूँकि यहाँ हर कदम उलटा है, यह 1: 1 है।

संपादित करें: रिकॉर्ड दिखाएं कि @manatwork ने इस समरूप समाधान को पहले पोस्ट किया है। उफ़। मुझे तरोताजा होना चाहिए था।

Comments

जबरदस्त हंसी। आपका आउटपुट मेरे मुकाबले बहुत मजेदार है।

— मैनटवर्क

Answer 8

जेली , 6 बाइट्स

Ø%+ṃØA

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

चूंकि जेली में मनमाने ढंग से लंबाई पूर्णांक होते हैं, इसलिए यह विडंबना लिंक सीमा में पूर्णांक लेता है $±2^{31}$और एक लंबाई 7 अक्षीय स्ट्रिंग लौटाता है। यह जोड़कर काम करता है$2^{32}$ और फिर कैपिटल अक्षरों में आधार डिकम्प्रेसिंग।

Answer 9

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

f(a,i){for(i=32;i--;putchar(a>>i&1));}

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

यह इनपुट पूर्णांक के प्रत्येक बिट को एक बाइट में विस्तारित करता है जो या तो 0 या 1 होता है (जो दोनों अप्रतिबंधित अक्षर हैं, लेकिन इसके खिलाफ कोई नियम नहीं है)। इसलिए आउटपुट हमेशा 32 बाइट्स होता है, और विशिष्ट होने की गारंटी दी जाती है।

Comments

चतुर दृष्टिकोण, एनयूएल बाइट्स के साथ ब्रेनफॉक प्रतिक्रिया पैडिंग के समान है।

— अधिकतम

मुझे यकीन नहीं है कि एक कार्यक्रम जो समाप्त नहीं होता है वह वास्तव में ऐनक के भीतर है ... लेकिन अगर यह है, तो 28 बाइट्स? f(a){putchar(a&1);f(a/2);}

— जी। स्लीपेन

मैंने Malbolge के लिए एक अपवाद बनाया, लेकिन सामान्य तौर पर कार्यक्रम को समाप्त करना चाहिए। लंबाई के रूप में "अनन्तता" होने के कारण एक धोखा है।

— अधिकतम

Answer 10

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 35 बाइट्स

x=>$"{x,11}".Select(n=>(char)(n+n))

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

Comments

x = int.MinValueइसके लिए क्रैश की उपेक्षा नहीं की जा सकती।

— हाथ-ई-फूड

@ हाथ-ई-फूड एक पूरी तरह से अलग संस्करण में बदलकर तय किया गया

— 1942 में इग्नोरेंस

Answer 11

हास्केल, 31 बाइट्स

map(\d->[d..]!!10).show.(+2^60)

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

2^60इनपुट में जोड़ता है ताकि परिणामी संख्या में पूरे इनपुट रेंज के लिए अंकों की समान मात्रा हो। एक स्ट्रिंग में मुड़ें और प्रत्येक चरित्र को ASCII क्रम में दाईं ओर 10 स्थानों पर स्थानांतरित करें ( 0-> :... ... 9-> C)।

Comments

क्या यह नकारात्मक संख्या को संभालता है?

— अधिकतम

@ maxb: नहीं, लेकिन अब यह ठीक हो गया है।

— nimi

Answer 12

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 52 बाइट्स

x=>(new char[32]).Select(y=>(char)(x%2+65+(x/=2)*0))

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

एसी # समाधान के लिए अलग-अलग दृष्टिकोण, इस तथ्य का लाभ उठाते हैं कि सी # मापांक नकारात्मक संख्याओं के लिए ऋणात्मक है। मुझे लगता है कि यदि आप गैर-प्रदर्शन वर्ण ('\ 0', और इसी तरह) +65...को किसी मानव पठनीय वस्तु के चरित्र मान को ऑफ़सेट नहीं करने के लिए अद्यतन करके अनुमति देते हैं तो आप बाइट या दो को शेव कर सकते हैं।

Comments

44? - मैं गैर-मुद्रण योग्य वर्णों का उत्पादन कर रहा हूं (जो ठीक लगता है) लेकिन आप अपने वर्तमान उत्तर की तरह 65 जोड़कर मुद्रण योग्य में बदल सकते हैं।

— दाना

42 - इस बार मुद्रण योग्य वर्णों के साथ :)

— दाना

Answer 13

पर्ल 5 -MDigest::MD5=md5_hex -p , 23 बाइट्स

$_=md5_hex$_;y/0-9/k-t/

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

पहले:

पर्ल 5 -p , 29 बाइट्स

$_=sprintf'%064b',$_;y/01/ab/

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

अपने 64 बिट द्विआधारी प्रतिनिधित्व करने के लिए धर्मान्तरित संख्या है, तो transliterates 0और 1करने के लिए aऔर b, क्रमशः।

Comments

और आपने पुष्टि की है कि सभी वैध इनपुट के लिए कोई टकराव नहीं हैं?

— Sparr

... और वह नहीं md5 हैश संयोग से एक अंक चरित्र का उत्पादन करता है?

— एलेक्सा

अंकों को बाहर करने की आवश्यकता के बारे में भूल गए। मैंने उसे समायोजित करने के लिए अद्यतन किया है।

— Xcali

9 बाइट्स, एमडी 5 की टक्कर का खतरा ।

— ग्रिमि

Answer 14

टी-एसक्यूएल, 73 70 61 बाइट्स

SELECT TRANSLATE(STR(n,11),'-0123456789','ABCDEFGHIJK')FROM t

मैं -अक्षरों के साथ अंकों (और ) को सीधे बदल रहा हूं , STR11 अक्षरों के पूर्णांक को पैड के बाद । हेक्स या बाइनरी में कोई रूपांतरण आवश्यक नहीं है।

TRANSLATE SQL 2017 में पेश किया गया था।

इनपुट पहले से मौजूद तालिका के माध्यम से है $t$ INT कॉलम के साथ $n$, हमारे IO नियमों के अनुसार । INTSQL में डेटाटाइप की रेंज है$-2^{31} \leq n < 2^{31}$।

संपादित करें : CHAR (11) में रूपांतरण के साथ मैनुअल पैडिंग की जगह 3 बाइट्स सहेजे गए, जो कि एक निश्चित-चौड़ाई वाला वर्ण प्रारूप है जो स्वचालित रूप से रिक्त स्थान के साथ पैड करता है।

EDIT 2 : इसके बजाय फ़ंक्शन का उपयोग करके 9 बाइट्स सहेजे गए । एक संख्या को निर्दिष्ट लंबाई तक गद्देदार पाठ स्ट्रिंग में परिवर्तित करता है।STR()CASTSTR

Answer 15

एपीएल (डायलॉग यूनिकोड) , 28 बाइट्स

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]}

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

सरल Dfn, पूर्णांक तर्क ले रहा है। उपयोग करता है ⎕IO←0।

TIO से एक टेस्ट केस के लिए लिंक -2^10करने के लिए 2^10। 0~⍨भाग डुप्लिकेट को हटा0 को तर्कों से है।

किस तरह:

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]} ⍝ Dfn
              ⎕A[         ]  ⍝ Index the Uppercase Alphabet with
                        ⍕⍵   ⍝ String representation of the argument
                   '¯'~⍨     ⍝ Without the character ¯
                 ⍎¨          ⍝ Executing each digit back into integers
             ,               ⍝ Prepend
    ' Z'[   ]                ⍝ A character from the string ' Z' indexed by
         ⍵≤0                 ⍝ Argument ≤ 0. Returns 1 if true, else 0.
                             ⍝ This will prepend a whitespace to positive numbers, and a Z otherwise.
 11↑                         ⍝ Take the first 11 characters, padding with whitespace.

Answer 16

जाप , 6 बाइट्स

मुझे लगता है कि यह सही है। स्टीफन के पाइथन समाधान से प्रेरित होकर, कृपया +1उसे।

¤ùI cÑ

कोशिश करो

¤ùI cÑ     :Implicit input of integer
¤          :Convert to binary string
 ù         :Left pad with spaces
  I        :  To length 64
    c      :Map codepoints
     Ñ     :  Multiply by 2

Answer 17

Malbolge , 2708 बाइट्स

यह उत्तर सुपर धोखा है, क्योंकि यह हमेशा समान मात्रा में इनपुट का उत्पादन करता है, जो इसके बराबर है $\infty$।

bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr)p-,m*)ihh}$#d!awv{^\x[YuXVrUSonQlNdchKIeHFbaD_AWV[><X;988MRQ4O1GFK.,++@ED'B$:9>!};:9zy0wuut1*/p-,mk#"hh}$#"cb}v{^\\[vunWrqTonmOkjMLgf_HcbE`_A]@>ZY<:VONS64P31M0.J-+G*(D'%A$">!}||3876wv321*/p-,mk#"'hf$ec!b`|{^y[qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:VUT76QPONG0KJ-HGFED'%A:9!!6;:9zy654321*q.-n+*j(ig%fd"ca}`^]]rwvYtVlkpSQmPNMMbgfIdF\[`_^A@[ZYXWVUNS6443NMLKJIHG@)DC&A@?!=<}|98765432+r/.-,+k#('&%e{dy~}|uzsx[vuXsrqpoRPledLLafedGF[`C^]\?ZY;W:8T7544INM0.JCBG*(''<A@#!=65:{yxx/43tr0)(-nlkk"'&ge#zy~a_^^sxwZXtmlqTRQQfkjMKg`_dcbEZ_B]\?=SRW:8T75Q42N1/KJ-+G@?D'%A$">!};|z87x5u-,1rp.-n+k#"'hfeez!~}`_t]xwvYtsUTTinmPNjcbgJHdGEa`_BW\?ZY<WVUTS64PIH00EJIH+*?(&&;@#!!~5:{87xv.-2sq/.om+$#(ig%$e"bxw|_]y\ZvuXsUkjoRPOOdihKfH^]bEC_^A\>TS;;PUTS65JO2MLK.,BA))>CBA$9>!}}|3z765v32r0/p-m%$)jh&ge#"c~`vuz][ZZotsVqSihmPNMMbgfIdF\[`CA@@UZY<W9ONS6433HML/J,BAF)'&&;@?"=}549zx6wutt+0/.on%l)('h%$d"ca}`^z][wvYtVlkpSQmPNjiLJf_^cFDCCX]\?=YRQV9766KPO20LEDI,*))>CB%#?87<}{9zx6wu3tr0/.o&m*)('&%fA/cQ>_^;]87%54"32pRA-yejih:s_GGFDDC^{i[T<XQ9b8r_5]O20Li-zB*SdQPO%##]nml43V1TvS@cs0/_'JJH#jhg%BTd!xw_{t99J6$tV21SBR@?kjcbtJ%^F"DD21]@[xfw;)9Nqq5Jmm~LKWVyx@E't&%:]][~YkF8hgv.tssOMp:&ml6Fi&D1T"y?,O<^s\7vX#Wr2}|Rzl+j<bK`r$F"4ZCk|\?-=RQ

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

Comments

यह Malbolge होने के साथ, मैं उस स्लाइड ... शानदार नौकरी!

— अधिकतम

Answer 18

पर्ल 6 , 12 बाइट्स

*~|('@'x 11)

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

अनाम जो भी मेमना है जो एक संख्या लेता है और 11 ओ के साथ स्ट्रिंग करता है @। यह अंकों को pqrstuvwxyऔर डैश को मैप करता है m, फिर @s के साथ 11 वर्णों तक स्ट्रिंग को पैड करता है

Answer 19

पर्ल 5 (-पी), 9 बाइट्स

$_^=A x$=

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

स्ट्रिंग के साथ इनपुट के बिटवॉक्स-एक्सर AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA।

Answer 20

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 44 33 बाइट्स

Echo@Table[Or[i>#+13!,],{i,14!}]&

इसे एक छोटे डोमेन के साथ आज़माएँ

-2 ग्रेग मार्टिन को धन्यवाद

प्रिंट >> , एक सूची की 523069747202-चरित्र स्ट्रिंग प्रतिनिधित्व के बाद$13!+n$ Nullकी Trueलंबाई तक s द्वारा गद्देदार$14!$, और एक नई रूपरेखा। डोमेन पर काम करता है$[-13!,14!-13!)$, जो एक सुपरसेट है $[-2^{31},2^{31})$।

आउटपुट के आकार को देखते हुए, मैंने एक छोटे से डोमेन के साथ एक टेस्ट केस को शामिल किया है $[-2^4,2^4)$ बजाय

Comments

अच्छा :) मुझे लगता है कि आप को बदलने के द्वारा दो बाइट्स बचा सकता है 2^31और 2^32करने के लिए 13!और 14!क्रमशः। आउटपुट में कुछ "संक्षिप्तता" के नुकसान पर ....

— ग्रेग मार्टिन

Answer 21

स्टैक्स , 6 बाइट्स

11){Hm

इसे चलाएं और डीबग करें

प्रक्रिया:

1. 11 अक्षरों के लिए बाएँ पैड इनपुट।
2. डबल प्रत्येक गैर-स्पेस ascii चरित्र।

Answer 22

PHP , 64 54 बाइट्स

strtrमैनुअल चरित्र प्रतिस्थापन के बजाय फ़ंक्शन का उपयोग करके -10 बाइट्स ।

<?=str_pad(strtr($argn,'-0123456789',ADEFGHIJKLM),20);

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

अब तक सबसे बड़ा पूर्णांक मूल्य PHP में संभव है 9223372036854775807जो 19 अंक लंबा, ऋणात्मक संख्याओं में ऋण चिह्न पर विचार, यह 20 की जगह ऋण चिह्न (ऊपर कोड हो जाएगा -के साथ) Aचरित्र और हर अंकों से 0करने 9से एक चरित्र के साथ Dकरने के लिए Mऔर फिर अंतरिक्ष वर्ण के साथ दाईं ओर स्ट्रिंग को हमेशा 20 वर्ण लंबा बनाने के लिए पैड। उदाहरण के लिए, इनपुट के लिए आउटपुट -9876543210है "AMLKJIHGFED " ।

उत्पादन प्रत्येक पूर्णांक इनपुट के लिए अद्वितीय है और आप, सभी रिक्त स्थान को हटाने की जगह इनपुट करने के लिए वापस मिल सकता है Aके साथ -और जगह Dके लिए Mके साथ 0करने के लिए 9।

---

PHP , 44 बाइट्स

<?=str_pad(base64_encode(decbin($argn)),88);

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

यह अरनल्ड के उत्तर के समान विचार है । इनपुट को बाइनरी में परिवर्तित करता है, और फिर इसे बेस -64 में बदल देता है। साथ ही इसे 88 वर्णों तक (सबसे बड़ी लंबाई -9223372036854775807जिसके लिए 88 वर्ण हैं) पैड को अंतरिक्ष में चरित्र के साथ हमेशा आउटपुट में एक ही लंबाई मिलती है।

Answer 23

रेटिना 0.8.2 , 21 बाइट्स

T`p`l
$
10$*o
!`.{11}

इसे ऑनलाइन आज़माएं! हमेशा श्रेणी से 11 वर्णों का उत्पादन होता है n।।z । स्पष्टीकरण:

T`p`l

प्रिंट करने योग्य ASCII वर्णों को निचले अक्षरों में अनुवाद करें। इस नक्शे -को nऔर 0.. 9के लिए q..z । (यह वास्तव में भाग्यशाली है कि अंक 16 वें से 25 वें मुद्रण योग्य ASCII वर्ण हैं!)

$
10$*o

10 oएस लागू करें। चूंकि इनपुट में 1 और 11 अक्षर होंगे, अब 11 और 21 वर्णों के बीच हैं।

!`.{11}

पहले 11 अक्षर निकालें। चूंकि 22 से कम अक्षर हैं, इसलिए यह केवल एक बार मैच करेगा।

Answer 24

चारकोल , 9 बाइट्स

◧⍘﹪ＮＸχχαχ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। हमेशा 10 रिक्त स्थान और बड़े अक्षरों को आउटपुट करता है। स्पष्टीकरण:

   Ｎ        Input as a number
  ﹪         Modulo
     χ      10
    Ｘ       To power
      χ     10
 ⍘     α    Convert to base 26 using uppercase letters
◧       χ   Left pad to length 10

Answer 25

आर , 37 बाइट्स

set.seed(scan())
cat(sample(LETTERS))

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

ऐसा लगता है कि आउटपुट यादृच्छिक है, लेकिन ऐसा नहीं है! इनपुट का उपयोग छद्म-यादृच्छिक संख्या जनरेटर के बीज के रूप में किया जाता है, और हम फिर से एक प्राप्त करते हैं$26!=4\cdot 10^{26}$वर्णमाला के क्रमपरिवर्तन। आउटपुट हमेशा लंबाई 51 (26 अक्षर + 25 रिक्त स्थान) का होता है।

अभी भी बीमा करने का मुद्दा है कि सभी आउटपुट अलग-अलग हैं। हम साथ समाप्त करते हैं$2^{32}\approx 4\cdot 10^9$ क्रमपरिवर्तन (में से) $4\cdot 10^{26}$)। यदि हम दिखावा करते हैं कि क्रमपरिवर्तन यादृच्छिक रूप से समान रूप से वितरित किए जाते हैं, तो संभावना है कि सभी क्रमपरिवर्तन अलग-अलग हैं, जन्मदिन की समस्या के लिए समान गणनाओं के बाद गणना की जा सकती है । संभावना है कि 2 विशिष्ट आउटपुट समान हैं$10^{-17}$, तो संभावना है कि सभी का पहला आदेश सन्निकटन $2^{32}$ आउटपुट अलग हैं

$1-\exp(-2^{64}/26!)\approx0.99999998$

जो मेरे लिए 1 के करीब है।

Comments

हां, यह सांख्यिकीय रूप से असंभव है कि टक्कर हो, इसका मतलब यह नहीं है कि यह असंभव है जैसा कि सवाल पूछता है

— जो किंग

मुझे संभावना गणना पसंद है। मुझे लगता है कि आप सभी 4 बिलियन इनपुट्स के माध्यम से चला सकते हैं यदि आप वास्तव में टकरावों की जांच करना चाहते हैं, लेकिन अगर आपको ऐसा करने का मन नहीं है, तो मैं आपको स्लाइड करने दे सकता हूं। जैसा कि अभी है, आपने एक सम्मोहक तर्क प्रस्तुत किया है, और यदि कोई प्रतिवाद पाता है, तो आपको अपना सबमिशन संशोधित करना होगा।

— अधिकतम

Answer 26

ब्रेनफक , 20 19 बाइट्स

Krzysztof Szewczyk को -1 बाइट

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

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

प्रत्येक अंक के साथ संख्या को आउटपुट करता है और NUL बाइट्स के साथ 255 वर्णों तक गद्देदार 255 आर्डिनल मान को मैप किया जाता है।

Comments

आप एक बाइट बचा सकते हैं:-[>,[->-<]>.[-]<<-]

— Krzysztof Szewczyk

Answer 27

आर , 40 37 बाइट्स

cat(gsub("S","",intToBits(scan())>0))

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

रॉबिन राइडर के जवाब के लिए एक विकल्प ; यह निश्चित रूप से नियतात्मक है।

यह इनपुट को raw32 बाइट्स के वेक्टर में कनवर्ट करता है , प्रत्येक बाइट एक हेक्स संख्या 00या 01पूर्णांक के बिट्स का प्रतिनिधित्व करता है। हम तो logicalतुलना करने के लिए मजबूर करते हैं 0, इसलिए 00मैप किया जाता है FALSEऔर 01करने के लिए TRUE। फिर हमें FALSEसमान लंबाई के आउटपुट की गारंटी देने के लिए प्रत्येक से एक भी पत्र को हटाने की आवश्यकता है , जिसे मनमाने ढंग से चुना जाना है S। परिणाम 169 की लंबाई के लिए (अंतरिक्ष के साथ) मुद्रित किया जाता है।

Answer 28

Zsh , 43 बाइट्स

for c (${(s::)${(l:30::0:)1}})echo \\x$[#c]

---

               ${(l:30:0:)1}                 # left-pad with zeroes to 30 characters
        ${(s::)             }                # split characterwise
 for c (                     )               # for each character
                                      $[#c]  # get character code (in decimal)
                              echo \\x$[#c]  # interpret as hex code, print (with newline)

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

यह समाधान long longकेवल वर्णों के साथ काम करके Zsh के पूर्णांकों की सीमा के आसपास हो जाता है । मैं केवल पठनीयता के लिए अधिकतम 30 वर्णों का यह गद्देदार, लेकिन जगह 30के साथ 99से सभी नंबरों पर काम करने के लिए इस विधि की अनुमति देगा -1E99+1करने के लिए 1E100-1।

हेक्साडेसिमल के रूप में दशमलव कोड की व्याख्या करने का प्रभाव इस प्रकार है:

0 => 48 => H    1 => 49 => I    2 => 50 => P    3 => 51 => Q
4 => 52 => R    5 => 53 => S    6 => 54 => T    7 => 55 => U
8 => 56 => V    9 => 57 => W    - => 45 => E

Zsh , 46 बाइट्स

integer -i2 -Z66 x=$1
<<<${${x//[02-]/a}//1/b}

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

X को एक बाइनरी संख्या के रूप में घोषित करता है, 66 की चौड़ाई पर शून्य-गद्देदार। फिर नक्शे 0→ aऔर 1→ b। हम उन मानचित्रों 2और मानचित्रों को भी देखते हैं -, क्योंकि वे वर्ण [[-]][base]#[num]संकेतन में मुद्रित हैं । यह देखने के लिए कि $xप्रतिस्थापन से पहले कैसा दिखता है, और पूर्णांक प्रकारों को पार्स करने में Zsh की सीमाएँ, TIO लिंक में डीबग आउटपुट की जाँच करें।

Answer 29

जावा (JDK) , 42 बाइट्स

n->"".format("%8x",n).chars().map(i->i|64)

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

सबसे पहले, यह इनपुट के हेक्साडेसिमल प्रतिनिधित्व को बनाता है, रिक्त स्थान के साथ बाएं-पैडेड जो समान लंबाई की बाधा (8 वर्ण-लंबे) प्रदान करता है, माइनस साइन को हटाता है, और प्रत्येक मध्यवर्ती आउटपुट को अद्वितीय रखता है।

यह 17 विभिन्न संभावित वर्णों के साथ एक तार देता है: 0123456789abcdef और स्थान।

तब प्रत्येक वर्ण को एक अंक या स्थान होने पर उसके कोडपॉइंट में 64 जोड़कर स्ट्रीम और मैप किया जाता है। प्रभावी ढंग से, निम्नलिखित मानचित्रण में इस परिणाम: 0123456789abcdef<space>करने के लिए pqrstuvwxyabcdef`जो 17 अलग अलग वर्ण है, इसलिए कोई दो नंबर एक ही उत्पादन में परिणाम होगा।

Answer 30

बैश , 30 बाइट्स

echo $1|md5sum|tr '0-9-' 'A-K'

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

यह साबित करने के लिए कि आउटपुट अद्वितीय है, मैं सिर्फ एमडी 5 टक्करों के लिए googled, और पूर्णांकों के बीच कोई परिणाम नहीं मिला $-2^{31}$ तथा $2^{31}$। आउटपुट में निषिद्ध वर्णों से बचने के लिए, केवल ऊपरी अक्षरों के अक्षर होने के लिए वर्णों का अनुवाद करें। आउटपुट हमेशा परिभाषा द्वारा समान लंबाई है, और किसी भी निषिद्ध वर्ण को शामिल नहीं करने की गारंटी है।