देखो माँ! मैंने अपनी खुद की (बेस 10) अंक प्रणाली बनाई! [बन्द है]

Question

हमने यह सब किया है, ठीक है, शायद नहीं, लेकिन अपनी खुद की विदेशी भाषा और नंबरिंग सिस्टम बनाना विशेष रूप से काल्पनिक लेखन का एक मूल है, लेकिन ज्यादातर सिर्फ एक मजेदार गतिविधि है।

कार्य सरल है, दो इनपुट लें:

1. 10 [दस] अद्वितीय 'अंकों' (किसी भी मुद्रण योग्य ASCII चरित्र) की एक आदेशित सूची इनपुट और उन्हें 0, 1, 2, 3, ..., 9 के रूप में क्रम में व्याख्या करते हैं।

   + यहाँ एक अंक क्या हो सकता है इसके अपवाद हैं। अंकगणित ऑपरेटरों (+, -, *, /), कोष्ठक, और रिक्त स्थान को अंकों में से एक के रूप में उपयोग नहीं किया जा सकता है।

2. केवल 'अंक' का उपयोग करके एक अंकगणितीय समस्या

और दिए गए फॉर्म में समतुल्य पूर्णांक परिणाम को आउटपुट करता है।

यहाँ एक उदाहरण है:

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

उदाहरण में, 'abcdefghij' की इनपुट सूची (आप चुन सकते हैं कि कौन सी सूची किस रूप में आती है) '0123456789' से मेल खाती है, जैसे कि 'hjkloiwdfp' भी '1123456789' के साथ 1 से 1 के अनुरूप होगा, जहां 'a' के बजाय 'a' के साथ जुड़ना शून्य, 'एच' करता है। अंकगणित के बाद 'का अनुवाद' 123 + 456 + 789, जो 1368 के बराबर होता है। इसे तब हमारे द्वारा दिए गए फॉर्म में आउटपुट किया जाना चाहिए, इसलिए b (जो 1 का प्रतिनिधित्व करता है) d (2 के लिए) g (6 के लिए) और 6 के लिए (i) 8)।

परीक्षण के मामलों

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

%y83l;[=9|
(83l * 9) + 8%

y9|8

अधिक नियम

• मानक Loopholes निषिद्ध हैं!
• यह कोड गोल्फ है, इसलिए बाइट्स में सबसे कम जवाब जीतता है।
• जो भी प्रारूप आपके लिए सबसे अच्छा काम करता है उसमें इनपुट और आउटपुट लेने के लिए एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए। (इनपुट्स में सिर्फ Additioal जानकारी नहीं जोड़ सकते, सिर्फ 'अंक' और अभिव्यक्ति।
• अपनी इच्छानुसार किसी भी भाषा का उपयोग करें (जब तक वह अन्य नियमों का अनुपालन करता है)

Comments

दूसरा परीक्षण मामला बताता है कि अंतिम आउटपुट गोल है, अन्यथा परिणाम होगा q.ioiopewioyetqorw...। यदि हां, तो किस तरह की गोलाई लागू की जानी चाहिए?

— Arnauld

@ SriotchilismO'Zaic के बिंदु में जोड़ने के लिए, हमारे पास आपके लाभ और हमारे लिए एक सैंडबॉक्स भी है ; आशय यह है कि समुदाय को पोस्ट करने से पहले चुनौतियों को परिष्कृत करने में मदद करें। एक चुनौती के लिए अच्छा विचार है, हालांकि!

— Giuseppe

अलग-अलग भाषाओं में समान समीकरण का अलग-अलग मूल्यांकन करने की संभावना है, मुझे यकीन नहीं है कि इसके आसपास कोई रास्ता है। उदाहरण के लिए, पूर्णांक विभाजन (गोलाई नहीं) के कारण , टी-एसक्यूएल रिटर्न के 1लिए 5/3, नहीं 2। यह चुनौती को अमान्य नहीं करता है, लेकिन आपको एक ही परीक्षण मामले के लिए अलग स्वीकार्य उत्तर देने की अनुमति देनी पड़ सकती है (नीचे मेरा टी-एसक्यूएल उत्तर देखें)।

— ब्रैडेक

@Giuseppe वाह, मैं एक लंबे समय के लिए इस स्टैक ब्राउज़ किया है और उस के बारे में कभी नहीं पता था! निश्चित रूप से मददगार रहा होगा, विशेष रूप से पहली बार पोस्टर (लंबे समय के श्रोता) के रूप में जो मैं हूं। अगली बार के लिए ध्यान रखेंगे! आपकी टिप्पणी और उत्तर के लिए धन्यवाद।

— बिल डब्ल्यू

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

— डारेल हॉफमैन

Answer 1

05AB1E , 10 9 बाइट्स

žh‡.Eò¹Åв

(अब) पात्रों की सूची के रूप में आउटपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

  ‡        # Transliterate the second (implicit) input, replacing every character of 
           # the first (implicit) input with:
žh         # The builtin "0123456789"
   .E      # Then evaluate it as Elixir code
     ò     # Round it to the nearest integer
      ¹Åв  # And change it back by using a custom base-conversion with the first input as
           # base (which results in a character list)
           # (after which that result is output implicitly)

05AB1E के नए संस्करण का निर्माण में निर्माण है अमृत । .Eसमारोह कॉल करेंगे call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a), जहां Code.eval_stringएक अमृत builtin है ।

ध्यान दें कि 05AB1E का विरासत संस्करण इसके लिए काम नहीं करेगा, क्योंकि यह पायथन में निर्मित है। अग्रणी 0s के साथ संख्याओं का मूल्यांकन नहीं किया जाएगा:
विरासत संस्करण में सभी परीक्षण मामलों को देखें (जो 10-बाइट संस्करण का उपयोग करता है क्योंकि Åвबिल्टिन नया है)।

Answer 2

आर , 58 बाइट्स

function(d,s,`[`=chartr)'0-9'[d,eval(parse(t=d['0-9',s]))]

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

उपयोग चरित्र अनुवाद chartrस्वैप करने के लिए अंक, parseहै और evalअभिव्यक्ति है, और फिर chartrवापस मूल अंक के लिए है।

यदि निकटतम पूर्णांक तक गोलाई आवश्यक है, तो यह है

आर , 65 बाइट्स

function(d,s,`[`=chartr)'0-9'[d,round(eval(parse(t=d['0-9',s])))]

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

Comments

[3 मापदंडों वाले फ़ंक्शन के लिए एक छोटे नाम के रूप में उपयोग करना बहुत स्मार्ट है। बहुत बढ़िया।

— रॉबिन राइडर

Answer 3

टी-एसक्यूएल, 117 बाइट्स

DECLARE @ CHAR(99)
SELECT @='SELECT TRANSLATE('+TRANSLATE(e,c,'0123456789')+',''0123456789'','''+c+''')'FROM t
EXEC(@)

लाइन ब्रेक केवल पठनीयता के लिए हैं।

इनपुट हमारे पूर्व नियमों के अनुसार टेक्स्ट कॉलम c (अक्षर) और e (समीकरण) के साथ पहले से मौजूद टेबल टी के माध्यम से है ।

TRANSLATEवर्णों के बीच स्विच करने और एक स्ट्रिंग उत्पन्न करने के लिए SQL 2017 फ़ंक्शन का उपयोग करता है जिसमें न केवल समीकरण होता है, बल्कि मूल वर्णों में वापस अनुवाद करने के लिए कोड होता है:

SELECT TRANSLATE(123 + 456 + 789,'0123456789','abcdefghij') 

इस स्ट्रिंग का उपयोग करके मूल्यांकन किया जाता है EXEC()।

कुछ वर्ण (जैसे कि एक एकल उद्धरण ') हो सकते हैं जो इस कोड को तोड़ देंगे; मैंने ASCII के सभी पात्रों का परीक्षण नहीं किया है।

चुनौती के अनुसार, मैं अभिव्यक्ति का मूल्यांकन कर रहा हूँ, इस विषय के अनुसार कि मेरी भाषा उन ऑपरेटरों की व्याख्या कैसे करती है। जैसे, पूर्णांक विभाजन के कारण दूसरा टेस्ट केस 1 ( w), और 2 ( e) नहीं ।

Answer 4

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

{*.trans($_=>^10).EVAL.trans(^10=>$_)}

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

मुझे यकीन नहीं है कि राउंडिंग को कैसे काम करना चाहिए। यदि यह अंत में गोल है तो मैं +6 बाइट्स के.round लिए जोड़ सकता हूं । यदि व्यवहार अलग होना चाहिए तो अधिक लंबा हो सकता है। इनपुट करी की तरह लेता है ।/f(arithmetic)(numerals)(arithmetic)

स्पष्टीकरण:

{                                    }  # Anonymous codeblock
 *                                      # Returning a whatever lambda
  .trans($_=>^10)       # That translates the numerals to digits
                 .EVAL  # Evaluates the result as code
                      .trans(^10=>$_)   # And translates it back again

Answer 5

स्टैक्स , 74 66 65 बाइट्स

┼ö8Q#xóπcM~oÖ÷╦├mî☼yº─▐4ç≥e╘o▄ê‼ø_k╜ø8%N╫ ╗e<.╗P[─╛èA±!xêj«w╠°{B♪

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

स्टैक्स यहां अच्छा नहीं करता है, जिसमें एक सच्चे "विकसित" निर्देश का अभाव है। यह डॉक्स में एक "eval" कहा जाता है, लेकिन यह केवल पूर्ण मूल्यों पर नहीं, शाब्दिक मूल्यों पर काम करता है।

Comments

यह ऑपरेटर की पूर्व धारणा का पालन नहीं कर सकता है। यकीन नहीं है कि अगर यह आवश्यक है? staxlang.xyz/…

— dana

@ दाना: अच्छी बात है। मैंने ऐसा नहीं माना। एक फिक्स में कुछ बाइट्स होने की संभावना है, इसलिए मैं उस व्यवहार को बदलने की कोशिश करने से पहले कुछ स्पष्टीकरण की प्रतीक्षा करूंगा।

— पुनरावर्ती

Answer 6

बैश, 97 बाइट्स

IFS=''
read S
read O
A=`echo "$O"|tr "$S" 0-9`
printf %0.f `bc<<<"(${A[@]##0})+0.5"`|tr 0-9 "$S"

कम हो सकता है अगर हम राउंड के बजाय कम कर सकते हैं। इसके अलावा बरखा के रूप में 0 से शुरू होने वाली संख्या की व्याख्या करने के बाद से अग्रणी शून्य (परीक्षण के मामले में # 2 के रूप में) को संभालने के लिए मुश्किल।

Comments

गोल्फिंग के लिए "bc" और "tr" जैसी उपयोगिताओं पर आम सहमति क्या है?

— spuck

मैं कोई विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि उन प्रकार के उत्तरों को आमतौर पर "बैश + कोर्यूटिल्स" के रूप में प्रस्तुत किया जाता है

— Giuseppe

@Giuseppe कोरुटिल trका हिस्सा है, जबकि bcऐसा नहीं है। फिर भी, bcएक बहुत ही सामान्य उपकरण है। इस उत्तर में हर दूसरा कमांड बैश है।

— rexkogitans

-7 से @ मुख्यमंत्री के जवाब चोरी बाइट्स '0-9' '0123456789' को कम करने,

— spuck

टी को परिभाषित करना अब लाभप्रद नहीं है: $Tकेवल एक बाइट की तुलना में कम है 0-9, आप केवल इसे दो बार उपयोग करते हैं, और आप इसे परिभाषित करने के लिए 8 बाइट्स खर्च करते हैं।

— Ruds

Answer 7

बीन , 94 90 बाइट्स

Hexdump

00000000: 53d0 80d6 d800 d3d0 80a0 1f20 8047 53a0  SÐ.ÖØ.ÓÐ. . .GS 
00000010: 1753 d080 d3d0 80a0 5e20 800a a181 8100  .SÐ.ÓÐ. ^ ..¡...
00000020: 40a0 5f52 cac3 4da0 6580 53d0 80a0 5d20  @ _RÊÃM e.SÐ. ] 
00000030: 8089 205f a065 205f 2080 0aa1 8181 0123  .. _ e _ ..¡...#
00000040: 0058 0020 800a a181 8102 40a0 6550 84a0  .X. ..¡...@ eP. 
00000050: 5d20 652e dce2 b02b dc64                 ] e.Üâ°+Üd

जावास्क्रिप्ट

`${Math.round(
  eval(
    b.replace(
      /./g,
      c => ~(i = a.indexOf(c)) ? i : c
    ).replace(
      /\b0+/g,
      ''
    )
  )
)}`.replace(
  /\d/g,
  i => a[i]
)

व्याख्या

यह कार्यक्रम स्पष्ट रूप से इनपुट की पहली और दूसरी लाइनों को चर aऔर bक्रमशः स्ट्रिंग्स के रूप में प्रदान करता है।

cलाइन पर प्रत्येक वर्ण को लाइन पर पाए जाने वाले वर्ण bके संबंधित इंडेक्स iके साथ बदल दिया जाता है a, या यदि यह नहीं पाया जाता है तो स्वयं।

फिर यह 0परिणामी स्ट्रिंग से एक सीमा से पहले एक या अधिक एस के प्रत्येक अनुक्रम को हटा देता है । यह अष्टक शाब्दिक के रूप में eval()शुरू होने वाले अंकों के किसी भी अनुक्रम का मूल्यांकन करने से रोकना है 0।

बाद eval()और Math.round(), परिणाम एक स्ट्रिंग में वापस मजबूर किया जाता है और प्रत्येक अंक चरित्र iलाइन से इसी चरित्र की जगह aसूचकांक पर i।

परीक्षण के मामलों

डेमो

abcdefghij
abcd + efg + hij

bdgi

डेमो

abcdefghij
abc + def - ghij

-gedc

डेमो

qwertyuiop
qwerty / uiop

e

डेमो

%y83l;[=9|
(83l * 9) + 8%

y9|8

Answer 8

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

$p=<>;eval"y/$p/0-9/";s/\b0+\B//g;$_=int.5+eval;eval"y/0-9/$p/"

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

इनपुट की पहली पंक्ति पर अभिव्यक्ति और दूसरी पर अनुवाद सूची लेता है।

Answer 9

पर्ल 5 , 130 बाइट्स

sub f{eval sprintf"'%.0f'=~y/%s/%s/r",eval(eval(sprintf"\$_[1]=~y/%s/%s/r",@r=map"\Q$_",$_[0],'0123456789')=~s,\b0,,gr),reverse@r}

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

हो सकता है कि डबल ईवैल को किसी तरह बदल दिया जाए s/.../.../geer।

Answer 10

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

⍘ＵＶ⭆η⎇№θι⌕θιιθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अभिव्यक्ति का मूल्यांकन पायथन 3 शब्दार्थ के अनुसार किया जाता है, इसलिए उदाहरण के लिए गैर-शून्य संख्या पर शून्य प्रमुख हैं। स्पष्टीकरण:

   ⭆η           Map over expression's characters and join
        ι       Current character
      №θ        Count matches in first input
     ⎇          If non-zero
         ⌕θι    Replace with position in first input
            ι   Otherwise keep character unchanged
 ＵＶ             Evaluate as Python 3
⍘            θ  Convert to base using first input as digits

Comments

दुर्भाग्य से अग्रणी 0पायथन में काम नहीं करता है, जो परीक्षण मामलों में मौजूद है।

— जोनाथन एलन

Answer 11

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

वर्णों का उपयोग करने str.translateऔर str.maketransबदलने के लिए एक गैर-रेगेक्स दृष्टिकोण । मैंने अग्रणी शून्य को ट्रिम करने पर बहुत सारे किरदार खो दिए ...

lambda s,t,d='0123456789',e=str.translate,m=str.maketrans:e(str(round(eval(' '.join(c.lstrip('0')for c in e(t,m(s,d)).split())))),m(d,s))

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

Answer 12

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

import re
a=[*enumerate(input())]
e=input()
for i,c in a:e=re.sub(c,str(i),e)
e=str(round(eval(re.sub(r'\b0+(?!\b)','',e))))
for i,c in a:e=re.sub(str(i),c,e)
print(e)

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

सुधार की गुंजाइश...

Comments

अभी भी अंतिम परीक्षण के मामले में विफल रहता है: tio.run/…

— ruohola

Answer 13

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

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

(r=Thread[StringPartition[#,1]->(t=ToString)/@Range[0,9]];u[(u=StringReplace)[#2,r]//ToExpression//Round//t,Reverse/@r])&

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

Answer 14

लुआ , 162 151 150 बाइट्स

• -11 बाइट्स के loadबजाय उपयोग करने के मेरे विचार के लिए धन्यवादfunction(...) end
• न्यूलाइन को छोड़ कर 1 बाइट

l,p=...print(((math.ceil(load('return '..p:gsub('.',load'n=l:find(...,1,1)return n and n-1'))()-0.5)..''):gsub('%d',load'c=...+1 return l:sub(c,c)')))

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

दुनिया में सबसे छोटी चीज नहीं है (Lua आपको विशेष रूप से विशाल कीवर्ड द्वारा बहुत कठिन कल्पना करने के लिए मजबूर करता है), लेकिन बनाने में बहुत मजेदार था। पूर्ण कार्यक्रम तर्कों और मुद्रण परिणाम के रूप में इनपुट ले रहा है।

व्याख्या

परिचय

l,p=...

तर्कों से चर तक मान निर्दिष्ट करें। हमारा शब्दकोश हैl और अभिव्यक्ति है p।

निम्नलिखित अभिव्यक्ति को समझना काफी कठिन है क्योंकि इसमें निष्पादन का एक अजीब क्रम है, इसलिए मैं इसे चरण-दर-चरण समझाऊंगा:

सामान्य संख्या में परिवर्तित

p:gsub('.',
load'n=l:find(...,1,1)return n and n-1')

अभिव्यक्ति स्ट्रिंग पर प्रतिस्थापन करें: प्रत्येक प्रतीक लें और इसे फ़ंक्शन में पास करें (load यहां सामान्य घोषणा की तुलना में खुद को छोटा साबित किया जाए)।

फंक्शन का उपयोग कर पारित प्रतीक के लिए ताना स्ट्रिंग में घटना की स्थिति का पता चलता है find। ...यहाँ पहले (और केवल) तर्क है जैसा कि हम vARg फ़ंक्शन में हैं (कोई भी loadएड है) जो हमारा वर्तमान प्रतीक है। findविशेष प्रतीकों को अनदेखा करने के लिए निम्नलिखित तर्कों की आवश्यकता होती है ( बूलियन में परिवर्तित होने पर इसका 1मूल्यांकन केवल कम मूल्य है true): प्रारंभिक स्थिति (एक डिफ़ॉल्ट यहां है) और plain, जो वास्तव में पैटर्न हैंडलिंग को अक्षम करता है। उन कार्यक्रमों के बिना तीसरे परीक्षण के मामले पर विफल रहता है% विशेष होने के ।

यदि मैच पाया जाता है, तो लूआ स्ट्रिंग्स (और एरेज़ बीडब्ल्यूटी) के रूप में एक को घटाएं 1-आधारित। यदि कोई मैच नहीं मिला है, तो यह कुछ भी नहीं लौटाएगा, जिसके परिणामस्वरूप कोई प्रतिस्थापन नहीं किया जाएगा।

हल

math.ceil(load('return '..ABOVE)()-0.5)

returnइसे वापस करने के लिए हमारी अभिव्यक्ति के लिए प्रीपेन्ड करें , इसे लुआ फंक्शन के रूप में संकलित करके गणना करें और इसे कॉल करें, इसे राउंडिंग करें यह कम करने के लिए बदल गया दूसरा रास्ता के आसपास)।

यह अंत में हम अपनी समस्या का एक संख्यात्मक समाधान प्राप्त करते हैं, केवल इसे वापस परिवर्तित करना।

इसे फिर से पागल बना रहा है

(ABOVE..'')
:gsub('%d',load'c=...+1 return l:sub(c,c)')

पहली पंक्ति संख्या को स्ट्रिंग में बदलने का एक छोटा तरीका है, इसलिए अब हम थोड़े समय में स्ट्रिंग विधियों को कॉल कर सकते हैं। चलो ऐसा करते हैं!

अब gsubसब कुछ वापस पागलपन को बदलने के लिए कहा जाता है। इस समय %dका उपयोग .प्रतिस्थापन पैटर्न के बजाय किया जाता है क्योंकि हमारे फ़ंक्शन को केवल संख्याओं को संसाधित करना चाहिए ( .नकारात्मक संख्याओं पर त्रुटि का परिणाम होगा)। इस समय फ़ंक्शन ( loadएड फिर बाइट्स को बचाने के लिए) पहले 1अपने पहले (और केवल) वर्गुमेंट में जोड़ता है, इसे तानाशाही स्ट्रिंग में स्थिति में परिवर्तित करता है, फिर उस स्थिति से चरित्र देता है।

हुर्रे, लगभग वहाँ!

नाटकीय समापन, या क्यों ब्रैकेट बात है

print((ABOVE))

खैर ... कोष्ठक के दो जोड़े वैसे भी? यह पराल ... एह के बारे में बात करने का समय है, लुआ में कई वापसी। बात यह है कि एक फ़ंक्शन एक कॉल से कुछ मान वापस कर सकता है ( अधिक उदाहरणों के लिए इस मेटा प्रश्न को देखें)।

यहां, अंतिम gsubदो मान लौटाए गए हैं: उत्तर स्ट्रिंग हमें आवश्यक है और प्रतिस्थापन की राशि (अंकों की गणना वास्तव में, लेकिन कौन परवाह करता है)। यदि यह आंतरिक जोड़ी के लिए नहीं था, तो स्ट्रिंग और संख्या दोनों को मुद्रित किया जाएगा, जो हमें खराब कर देगा। तो यहाँ हम दो बाइट्स का त्याग करते हैं दूसरा परिणाम छोड़ते हैं और अंत में इस पागलपन कारखाने के उत्पाद को प्रिंट करते हैं।

---

ठीक है, मैंने पहली बार में लगभग गोल्फ के बारे में समझाने का आनंद लिया है, आशा है कि आपको यहां मिल रहा है।

Comments

नोट: यह सभी टेस्टेसिस से गुजरता है, लेकिन शायद दूसरों में गलत तरीके से घूमता है। यदि आप एक पा सकते हैं, तो मैं इसे ठीक करने जा रहा हूं।

— वैल