हिब्रू वर्णमाला का उत्पादन

24

आपका कार्य इस सटीक पाठ को प्रिंट करना है:

אבגדהוזחטיכךלמםנןסעפףצץקרשת

(आपको एक अनुगामी न्यूलाइन प्रिंट करने की अनुमति है)

पाठ की UTF-8 एन्कोडिंग का SHA256 हैश:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Base64 एन्कोडिंग:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

नियम

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

सौभाग्य!

code-golf  kolmogorov-complexity  unicode 
— TuxCrafting
स्रोत
5
मैंने देखा कि कोड पॉइंट सीधे क्रम में नहीं हैं। आपके पास है 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1499, 1498, 1500, 1502, 1501, 1504, 1503, 1505, 1506, 1508, 1507, 1510, 1509, 1511, 1512, 1513, 1514। मैं हिब्रू के बारे में बहुत अधिक नहीं जानता, इसलिए क्या आप इस बात की पुष्टि कर सकते हैं कि यह वास्तव में जानबूझकर है?
— DJMcMayhem
11
@DJMcMayhem यूनिकोड सूची को सामान्य अक्षरों से पहले अंतिम अक्षर लेकिन प्रश्न में पाठ में सामान्य अक्षरों को पहले सूचीबद्ध किया गया है। यह वास्तव में जानबूझकर नहीं था, लेकिन कम से कम यह उन उत्तरों को प्रोत्साहित करता है जो उबाऊ नहीं होते हैंprint(map(chr, range(x, y)))
— TuxCrafting
6
א איי מדבר עברית!
— OldBunny2800
6
एलेफ नल, एलेफ वन, एलेफ 2, ...
— क्रिक्टी लिथोस
2
@ क्योंकि यह वास्तव में मेल नहीं खाता है। echo 15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq | base64 -d | sha256sumपैदा करता है f1d4b9c12a197912a4bdb80fb3e4d3fad5a0d9b7edd243fae7b2ab3450618036।
— hvd

जवाबों:

25

MATLAB, 52 51 बाइट्स

[cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']

उदाहरण का उपयोग करें:

>> [cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']
ans =
אבגדהוזחטיכךלמםנןסעפףצץקרשת

व्याख्या

'CCCCCCCCCDADDAEADCDAEADCCC'-66सरणी पैदा करता है [1 1 ... -1 2 1 1 1], जिसमें वांछित वर्णों के कोडपाइंट के बीच लगातार अंतर होता है।

[1488 ...]प्रीपेंड करता है 1488, इसलिए सरणी अब है [1488 1 1 ... -1 2 1 1 1]।

cumsum(...)संचयी योग की गणना करता है [1488 1489 ... 1514]:।

[... '']खाली स्ट्रिंग के साथ। इसमें चार को परिवर्तित करने का प्रभाव है (और एक बाइट से छोटा है char(...))

— लुइस मेंडो
स्रोत
19

जेली , 22 21 20 बाइट्स

27R+“¿ÇÑÞ摦2Ụ+1487Ọ

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

विचार

यदि हम प्रत्येक कोड बिंदु से 1487 घटाते हैं , तो हमें सरणी R मिलता है जो इस प्रकार है।

1 2 3 4 5 6 7 8 9 10 12 11 13 15 14 17 16 18 19 21 20 23 22 24 25 26 27

यह सिर्फ 1 से 27 तक की सीमा है , लेकिन आरोही क्रम में नहीं; जोड़े (11, 12) , (14, 15) , (16, 17) , (20, 21) , और (22, 23) की अदला-बदली हुई है।

यदि हम आरोही सीमा लेते हैं और 2 से 11 , 14 , 16 , 20 , और 22 जोड़ते हैं , तो हमें सरणी A मिलती है जो इस प्रकार है।

1 2 3 4 5 6 7 8 9 10 13 12 13 16 15 18 17 18 19 22 21 24 23 24 25 26 27

यह अब श्रेणी का क्रमपरिवर्तन नहीं है, लेकिन यदि हम उस सरणी में मानों द्वारा श्रेणी को क्रमबद्ध करते हैं, तो हम मूल सरणी को फिर से बना सकते हैं।

कोड

27R+“¿ÇÑÞ摦2Ụ+1487Ọ  Main link. No arguments.

27R                   Yield [1, ..., 27].
           ¦          Conditional application:
    “¿ÇÑÞæ‘             At indices 11, 14, 16, 20, and 22...
   +        2           add 2 to the corresponding value.
                      This yields the array A from the previous section.
             Ụ        Grade up; sort the indices of the result by its corresponding
                      values. This yields the array R from the previous section.
              +1487   Add 1487 to each integer in R.
                   Ọ  Unordinal; convert integers to characters.
— डेनिस
स्रोत
15

PowerShell v2 +, 58 बाइट्स (UTF-16)

'אבגדהוזחטיכךלמםנןסעפףצץקרשת'

PowerShell यूनिकोड UTF-16 है जब तक कि स्पष्ट रूप से अन्यथा निर्दिष्ट नहीं किया गया है, और तब यह वैसे भी एक क्रैम्पशूट है क्योंकि यह पृष्ठभूमि में सभी UTF-16 है।

यह सिर्फ पाइपलाइन पर शाब्दिक स्ट्रिंग डालता है और Write-Outputप्रोग्राम निष्पादन के अंत में डिफ़ॉल्ट इसे स्क्रीन पर प्रिंट करता है।

सबसे छोटा मैं ASCII संस्करण प्राप्त कर सकता है 63

-join([char[]]'ABCDEFGHIJLKMONQPRSUTWVXYZ['|%{[char](1423+$_)})

जो स्ट्रिंग के ASCII मान को लेता है ABC...और उपयुक्त स्ट्रिंग प्राप्त करने के 1423लिए प्रत्येक charको जोड़ता है ।

— AdmBorkBork
स्रोत
6
केवल इसलिए पोस्ट किया गया क्योंकि आपका ASCII संस्करण चतुर है। चाहिए ... समर्थन ... चालाक ... गोल्फ!
— wizzwizz4
1
मुझे यह महसूस करने में कम से कम 5 मिनट लगे कि यह ASCII संस्करण में वास्तविक वर्णमाला नहीं थी।
— caird coinheringaahing
11

05AB1E , 36 29 26 25 23 बाइट्स

सहेजे गए 2 बाइट्स के लिए धन्यवाद अदनान बचाए

CP-1252 एन्कोडिंग का उपयोग करता है ।

1488•’ÉÇW–moû•5Bvy<+Dç?

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

व्याख्या

1488            # push 1488 (accumulator)
•’ÉÇW–moû•      # push 2235174277545950437
5B              # convert from base-5 to base-10 (122222222230330403230403222)
  v             # for each digit in above number
   y<           # decrease it by 1
     +          # add to accumulator
      Dç?       # print a copy of accumulator converted from code point
— Emigna
स्रोत
आधार संख्या के रूप में बड़ी संख्या की व्याख्या करना दो बाइट्स को बचाता है 1488•’ÉÇW–moû•5Bvy<+Dç?:।
— अदनान
@ अदनान: आह। महान सोच!
— एमिग्ना
9

ब्रेन-फ्लैक , 172 बाइट्स

यह उत्तर काफी हद तक एक DJMcMayhem के समाधान पर आधारित है, इसलिए मैं इसे पुनः जाँचता हूं।

DJMcMayhem के समाधान की तरह यह -rAध्वज का उपयोग आउटपुट को रिवर्स करने और यूनिकोड को प्रिंट करने के लिए करता है।

(((((()()()()()){})))<(((({}{}{}()){({}[()])}{})){}{})>){({}[()]<(({})())>)}{}(((((()()())((((((((({}(((({}())[()])()())()())[()]))[()])()())())()())[()]))[()])()())())())())

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

व्याख्या

मैंने DJMcMayhem द्वारा प्रदान किए गए मूल समाधान पर सूक्ष्म-अनुकूलन का एक समूह चलाकर यह उत्तर दिया। बाइट्स को बचाने के दौरान ये अनुकूलन, कोड को अपठनीय बनाते हैं और एल्गोरिथ्म obtuse। मैं, ईमानदार होने के लिए, वास्तव में यह नहीं समझता कि मेरा कोड कैसे या क्या करता है।

शायद किसी दिन मैं समझूंगा कि यह कैसे काम करता है ...

— गेहूं का जादूगर
स्रोत
6

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

#coding:cp862
print('אבגדהוזחטיכךלמםנןסעפףצץקרשת')

फ़ाइल CP862 एन्कोडिंग का उपयोग करके या निम्नलिखित हेक्सडंप को उलट कर बनाया जाना चाहिए।

0000000: 23 63 6f 64 69 6e 67 3a 63 70 38 36 32 0a 70 72  #coding:cp862.pr
0000010: 69 6e 74 28 27 80 81 82 83 84 85 86 87 88 89 8b  int('...........
0000020: 8a 8c 8e 8d 90 8f 91 92 94 93 96 95 97 98 99 9a  ................
0000030: 27 29                                            ')

इसे संभवतः पायथन 2 (इस प्रकार दो बाइट्स को सहेजना) में पोर्ट किया जा सकता है, लेकिन मुझे इसे जांचने के लिए उचित स्थान की कमी है। अजगर 3 वर्णानुक्रम में UTF-8 एन्कोडेड संस्करण (या जो भी वर्तमान स्थान के लिए उपयुक्त है) को मुद्रित करता है।

सत्यापन

$ base64 > hebrew.py -d <<< I2NvZGluZzpjcDg2MgpwcmludCgngIGCg4SFhoeIiYuKjI6NkI+RkpSTlpWXmJmaJyk=
$ wc -c hebrew.py
50 hebrew.py
$ echo $LANG
en_US.UTF-8
$ python3 hebrew.py
אבגדהוזחטיכךלמםנןסעפףצץקרשת
— डेनिस
स्रोत
5

सीजेएम , 23 बाइट्स

27,"%(*.0"{i_)e\}/'אf+

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

यह काम किस प्रकार करता है

27,                     Push [0 ... 26].
   "%(*.0"              Push that string. Its code points are [37 40 42 46 48],
                        which are [10 13 15 19 21] modulo the length of the string.
          {     }/      For each character:
           i              Compute its code point.
            _)            Push an incremented copy.
              e\          Swap the integers of [0 ... 26] at those indices.
                  'אf+  Add all resulting integers to the first character of the
                        Hebrew alphabet.
— डेनिस
स्रोत
4

ब्रेन-फ्लैक , 186 बाइट्स

(((((((((((((((((((((((((((((((((()()()()()){})){}{}()){({}[()])}{})){}{})())())())())())())())())())()())[()])()())()())[()])()()())[()])()())())()())[()])()()())[()])()())())())())

यह कोड 182 बाइट्स लंबा है, और मैंने दो कमांड लाइन झंडे के लिए 4 बाइट्स जोड़े: -rऔर-u

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

इस शानदार पूर्णांक मेटाफ़र के लिए @Neil को बहुत-बहुत धन्यवाद जिसने 1488 को धक्का देने का यह मधुर तरीका बनाया (प्रथम चरित्र का कोड बिंदु)

(((((((()()()()()){})){}{}()){({}[()])}{})){}{})

स्पष्टीकरण:

ब्रेन-फ्लैक में बड़ी संख्या में पुश करना अपेक्षाकृत कठिन है। हालाँकि, चूँकि किसी संख्या को धकेलने का कार्य भी उस संख्या का मूल्यांकन करता है, हम बड़े पैमाने पर बाइट बचत के लिए एक ही समय में कई संख्याओं को आगे बढ़ा सकते हैं। यहाँ एक और अधिक ठोस उदाहरण है। पसिडो कोड में अंतरतम हिस्सा (जो मैंने ऊपर लिखा था) है

push(1488)

यह अभिव्यक्ति 1488 का मूल्यांकन करती है, इसलिए हम पूरी बात को एक और धक्का बयान में लपेटते हैं:

push(push(1488) + 1)

यह 1488 और 1489 को धक्का देता है , साथ ही साथ 1489 का मूल्यांकन करता है। इसलिए हम इसे लपेटते हैं:

push(push(push(1488) + 1) + 1)

जो 1488, 1489, और 1490, साथ ही साथ 1490 का मूल्यांकन करता है। प्रत्येक संख्या के लिए इस चरण को दोहराएं जिसे हमें पुश करने की आवश्यकता है।

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

(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
#Push 1488
(((((((()()()()()){})){}{}()){({}[()])}{})){}{})
())     # + 1
())
())
())
())
())
())
())
())
()())   # + 2
[()])   # - 1
()())   # + 2
()())
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
()())   # + 2
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
())
())
— DJMcMayhem
स्रोत
मैंने सोचा कि यह +1 है -rक्योंकि -गिनती नहीं है
— NoOneIsHere
6
@NoOneIsHere की -गिनती नहीं होती है यदि यह पहले से ही एक अलग विकल्प (जैसे पर्ल में -e) से मौजूद है। ब्रेन-फ्लैक के पास मौजूदा विकल्प नहीं है, इसलिए -, विकल्प, और कुल मिलाकर कुल गणना के बाद का स्थान।
— रिले
बस थोड़ा सा सुधार मैंने ब्रेन-flak.tryitonline.net/…
— गेहूं जादूगर
@HeatWizard यदि मुझे वह लेना है, तो मैं एक स्पष्टीकरण नहीं लिख पाऊंगा। यह सिर्फ मुझे कोष्ठक की गड़बड़ी की तरह लग रहा है। : पी
— DJMcMayhem
इसका बहुत छोटा परिवर्तन है। मैंने अभी ()()()शुरुआत के दो उदाहरणों को स्थानांतरित किया और उन्हें नीचे और ऊपर रखा।
— गेहूं जादूगर
4

/// , 27 बाइट्स

ABCDEFGHIQSRTVUXWYbdcfeghiq

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

आउटपुट CP424 में एन्कोडेड है ।

इसे स्वयं सत्यापित करने के लिए:

$ echo ABCDEFGHIQSRTVUXWYbdcfeghiq | ./slashes.pl | python3 -c 'print(bytes(input(), "utf-8").decode("cp424"))' | base64
15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeqCg==
— मै जाऊं
स्रोत
यह किस तरह का कोड है? मुझे लगता है कि किसी भी तरह से प्रयोजनों को देखने के लिए इसे यूटीएफ -8 में परिवर्तित करने की आवश्यकता है। ऐसा नहीं है कि यह आवश्यक रूप से अमान्य है: P के पास एक +1 है
— आउटऑफ़्फ़र
@EriktheGolfer को इसे UTF-8 में बदलने की कोई आवश्यकता नहीं है। यह चुनौती में कहीं भी एक आवश्यकता नहीं है।
— Mego
मुझे लगता है कि आप तब चढ़ाव को आकर्षित कर सकते हैं । कृपया ध्यान दें कि, आपकी जगह पर, मैंने UTF-8 संस्करण और मूल के एक हेक्सडंप को शामिल किया होगा ...
— आउटगॉल्फ
4

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

_=>"אבגדהוזחטיכךלמםנןסעפףצץקרשת"

सर्वश्रेष्ठ मैं ASCII में कर सकता था 80 79 78 बाइट्स:

_=>String.fromCharCode(...[...0x377babbcf7f.toString(3)].map(c=>++n-c,n=1488))

यदि कोई वर्ण सरणी स्वीकार्य है, तो 75 बाइट्स:

_=>[...0x377babbcf7f.toString(3)].map(c=>String.fromCharCode(++n-c),n=1488)

संपादित करें: @IsmaelMiguel के लिए धन्यवाद कुछ बाइट्स सहेजे गए। @ETHproductions के लिए एक और बाइट धन्यवाद दिया। यदि आप फ़ायरफ़ॉक्स 30-57 का उपयोग करते हैं, तो आप जनरेटर या सरणी समझ का उपयोग करके @ETHproductions के लिए एक और 2 बाइट्स बचा सकते हैं:

_=>String.fromCharCode(...(for(c of 0x377babbcf7f.toString(3,n=1488))++n-c))
_=>[for(c of 0x377babbcf7f.toString(3,n=1488))String.fromCharCode(++n-c)]
— नील
स्रोत
आप का उपयोग करके अपने ASCII विकल्प पर एक बाइट बचा सकते हैं 0x377BABBCF7F.toString(3)। इसके साथ मिलाएं .map(), आप _=>0x377BABBCF7F.toString(3,n=1488).split``.map(_=>String.fromCharCode(++n-_))78 बाइट्स के लिए कर सकते हैं । यह वर्णों की एक सरणी देता है।
— इस्माइल मिगुएल
@IsmaelMiguel पर अच्छी पकड़ है, ..लेकिन हम splitयहाँ के आसपास का उपयोग नहीं करते ।
— नील
अच्छा लगा। आप पाने के लिए चार-सरणी संस्करण को थोड़ा संशोधित कर सकते हैं _=>String.fromCharCode(...[...0x377babbcf7f.toString(3)].map(c=>++n-c,n=1488)), 1 बाइट वर्तमान 79 बाइट्स से कम है।
— ETHproductions
@ETHproductions बाह, मैंने साथ खेला था String.fromCharCode(...)और खुद को समझाने में कामयाब रहा था कि यह हमेशा लंबा रहेगा। वास्तव में यह मेरे आधार 2 समाधान पर 4 बाइट्स बचाता है (जो अभी भी 84 बाइट्स है क्योंकि इसे डिकोड करने में अधिक बाइट्स लगते हैं)।
— नील
यदि आप सरणी समझ का उपयोग करने के लिए तैयार हैं, तो आप प्रत्येक से 2 बाइट्स प्राप्त कर सकते हैं; string:, _=>String.fromCharCode(...[for(c of 0x377babbcf7f.toString(3,n=1488))++n-c])char-array:_=>[for(c of 0x377babbcf7f.toString(3,n=1488))String.fromCharCode(++n-c))
— ETHproductions
3

05AB1E , 28 * 2-1 = 55 बाइट्स

"אבגדהוזחטיכךלמםנןסעפףצץקרשת

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

एमिग्ना के लिए 1 बाइट धन्यवाद + डीजेएमसीमैहेम के लिए 28 बाइट्स धन्यवाद;)।

— जादू ऑक्टोपस Urn
स्रोत
4
मुझे नहीं पता कि एन्कोडिंग 05AB1E क्या उपयोग करता है, लेकिन मुझे अत्यधिक संदेह है कि यह जो भी है उसमें एक बाइट चार्ट हैं।
— DJMcMayhem
@DJMcMayhem मुझे लगता है कि TIO में एक बग है, वे वर्ण CP-1252 में मौजूद नहीं हैं।
— E में
@EriktheGolfer सबसे अधिक संभावना है कि यह सुविधा के लिए UTF-8 का उपयोग करता है और फिर 05AB1E दुभाषिया आवश्यक आंतरिक रूपांतरण करता है। यही मैं वी के लिए करता हूं (जो लैटिन 1 का उपयोग करता है)।
— DJMcMayhem
@DJMcMayhem यहां मुझे UTF-8 के रूप में दिखाया गया है, लेकिन यह CP-1252 का भी समर्थन करता है, जिसका उपयोग आप अपनी बाइट की संख्या को कम करने के लिए कर सकते हैं। यह शुद्ध CP-1252 नहीं है, हालाँकि, इसे UTF-8 स्ट्रिंग्स के साथ चलाया जाना चाहिए।
— को आउटगोल्फर
2

स्काला / ग्रूवी / पायथन 3, 9 अस्की-चरस + 27 2-बाइट चार्ट = 63 बाइट्स

print("אבגדהוזחטיכךלמםנןסעפףצץקרשת")

यूटीएफ -8 ग्रहण करना

स्काला, 59 बाइट्स

print("ABCDEFGHIJLKMONQPRSUTWVXYZ["map(x=>(x+1423).toChar))

x+1423 के समान है x-'A'+1488

— corvus_192
स्रोत
पॉलीगोट, यह ग्रूवी में भी काम करता है; यह भी देखें, मेरा उत्तर देखें, बायटेकाउंट बंद है।
— मैजिक ऑक्टोपस यूरन
1
अजगर 3 में भी (अजगर 2 भी लेकिन फिर कोष्ठक आवश्यक नहीं हैं)
— user49822
1
@caruscomputing मैं किसी अन्य उपयोगकर्ता की बाइट गिनती संपादित करने से सावधान रहूंगा क्योंकि आप एक निश्चित एन्कोडिंग मानते हैं। क्या आप सुनिश्चित हैं कि स्काला केवल UTF-8 को संभाल सकती है या नहीं कर सकती है? इसके अलावा, हिब्रू वर्णमाला में 27 अक्षर हैं, इसलिए 61 गलत एक तरह से या कोई अन्य है।
— डेनिस
पहला विकल्प PHP पर भी काम करता है।
— इस्माइल मिगेल
1

सी # 6 +, 76 86 82 बाइट्स

void f()=>Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");

गोल्फिंग में पहला प्रयास। क्या मैं इसे ठीक से कर रहा हूं?

EDIT : किसी फ़ंक्शन में संलग्न करने के लिए भूल जाने के लिए +6 बाइट्स। धन्यवाद @ केविन

सी # 5 और नीचे के संस्करण, 86 82 बाइट्स

void f(){Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}
— भयानक-कोडर
स्रोत
असल में, आपको या तो एक फंक्शन या पूरा प्रोग्राम प्रिंट करना चाहिए। तो void F(){Console.WriteLine("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}मान्य होगा, या ()=>{Console.WriteLine("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}साथ ही मुझे लगता है (इस अंतिम के बारे में निश्चित नहीं है, हालांकि)। इसके अलावा, आप इसके .Writeबजाय का उपयोग करके इसे गोल्फ कर सकते हैं .WriteLine। :) यह कहा जा रहा है, PPCG में आपका स्वागत है! आप के माध्यम से पढ़ने के लिए सी # में दिलचस्प गोल्फ के लिए सुझाव मिल सकता है । यहां रहने का आनंद।
— केविन क्रूज़सेन
आप जानते हैं, आप <s>your text</s>अजीब अक्षरों का उपयोग करने के बजाय कुछ पाठ का उपयोग कर सकते हैं ।
— आउटगॉल्फ
मुझे इस बारे में जानकारी नहीं थी। वैसे भी धन्यवाद @EriktheGolfer
— भयानक-कोडर
1

अर्नोल्ड, 112 बाइट्स

IT'S SHOWTIME
TALK TO THE HAND "אבגדהוזחטיכךלמםנןסעפףצץקרשת"
YOU HAVE BEEN TERMINATED
— Uriel
स्रोत
1

केजी , 34 बाइट्स

एक पॉवर्सशेल समाधान से प्रेरित।

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

— A̲̲
स्रोत
0

बाकोन , 57 बाइट्स

  • अधिकांश BASICs में, प्रश्न चिह्न केवल PRINT का प्रतिनिधित्व करता है।

  • पहली नज़र में, नीचे का समाधान 30 बाइट्स जैसा दिखता है, लेकिन यूबीएफ -8 के कारण हिब्रू पात्रों को भंडारण के 2 बाइट्स की आवश्यकता होती है। तो 'के लिए 27 अक्षर x 2 बाइट + 1 बाइट हैं?' और दोहरे उद्धरण = 57 बाइट्स के लिए 2 बाइट्स।

समाधान:

?"אבגדהוזחטיכךלמםנןסעפףצץקרשת"
— पीटर
स्रोत
30 के लिए CP862 VGA BIOS के साथ GW-BASIC आज़माएं। (एक ही पाठ)
— जोशुआ
0

zsh, 25 21 बाइट्स

echo ${(j..):-{ת..א}}

मेरा ब्राउज़र इसे गड़बड़ कर रहा है: ת को पहला अक्षर होना चाहिए, फिर ई.एन. यदि आप कहीं और पेस्ट करते हैं, हालांकि, यह काम करना चाहिए। पुराना संस्करण:

for i in {ת..א};printf $i
— Elronnd
स्रोत
अमान्य, क्योंकि अंतिम पत्र और सामान्य पत्र यूनिकोड में उलट हैं
— TuxCrafting
इसके अलावा, यह वास्तव में 27 बाइट्स है
— TuxCrafting
ओह और रेंज वास्तव में पहले और tav पिछले होना चाहिए। यदि स्ट्रिंग प्रश्न में उलट है, तो इसका कारण यह है कि हिब्रू एक RTL भाषा है
— TuxCrafting
@ T itxCräftîñg मेरे टर्मिनल में, यह केवल सही ढंग से केवल पहली बार aphph लास्ट के साथ प्रदर्शित होता है। आपका क्या मतलब है "अंतिम पत्र और सामान्य पत्र यूनिकोड में उलट हैं"?
— Elronnd
प्रश्न में पाठ में, כךउदाहरण के लिए (सामान्य kaf पहले, अंतिम kaf दूसरा) है, लेकिन यूनिकोड में, अंतिम अक्षर सामान्य अक्षरों ( ךכ) से पहले हैं , इसलिए मुद्रित पाठ अमान्य में है। और अगर यह पहले tav के साथ प्रदर्शित होता है, तो इसका कारण यह है कि हिब्रू एक RTL भाषा है, इसलिए पहला वर्ण सबसे सही प्रदर्शित होता है
— TuxCrafing
0

जावा 7, 85 बाइट्स

void c(){System.out.print("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}

मैं भी परीक्षण कोड या 'यहाँ यह कोशिश करो' जैसे मैं आमतौर पर पोस्ट करने से परेशान नहीं हूँ ..

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

पर्ल 6 (74)

(map (*+1488).chr,[\+] '122222222230330403230403222'.comb >>->>1.join.say
— bb94
स्रोत
0

सी, 49 बाइट्स

f(i){for(i=0x5d0;i<=0x5ea;i++)wprintf(L"%lc",i);}

कुछ उपयोगकर्ताओं को इसका setlocaleउपयोग करने से पहले कॉल करने की आवश्यकता हो सकती है लेकिन यह मेरे लिए ठीक काम करता है।

— गोविंद परमार
स्रोत
for(i=1488;putwchar(i++)<1514;);इसके बजाय सुझावfor(i=0x5d0;i<=0x5ea;i++)wprintf(L"%lc",i);
— सीलिंगकैट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.