सामान्यीकृत जेमेट्रिया कैलकुलेटर

Question

वर्णमाला के रूप में यूनिकोड वर्णों के किसी भी अनुक्रम के लिए एक द्विदिश जेमेट्रिया कैलकुलेटर बनाएं।

Gematri-क्या?

जेमेट्रिया प्रतीकों के लिए संख्यात्मक मूल्यों को निर्दिष्ट करने की एक प्रणाली है, जिसे प्राचीन यूनानियों द्वारा विकसित और प्राचीन यहूदियों द्वारा अपनाया गया है। यह एक तरह से ASCII या यूनिकोड है, यह सिर्फ गैर-रैखिक है ... निम्न तालिका देखें (ऊपर दी गई लिंक में पूरी तालिका उपलब्ध है):

Index     Letter   Letter name  Value
--------------------------
  0         א         "Alef"     1
  1         ב         "Bet"      2

           ...

  8         ט         "Tet"      9
  9         י         "Yud"      10
 10         כ         "Kaf"      20

           ...

 17         צ        "Tsady"     90
 18         '        "Kuf"       100
 19         ר        "Resh"      200

           ...

अक्षरों के नाम महत्वपूर्ण नहीं हैं, केवल वर्णमाला के "ऐरे" और संबंधित संख्यात्मक मान में उनका सूचकांक। हिब्रू वर्णमाला में केवल 22 अक्षर हैं ("अंतिम" अक्षर शामिल नहीं हैं), इसलिए अधिकतम उपलब्ध मूल्य 400 है।

यदि हम इस प्रणाली को अंग्रेजी वर्णमाला (AZ) में उधार लेते हैं तो हम A = 1, B = 2 ... L = 30 ... U = 300 ... Z = 800 के साथ समाप्त हो जाएंगे।

दो बातें हमें जाननी जरूरी हैं।

1. इस प्रणाली में सबसे महत्वपूर्ण सुविधाओं में से एक एक के "Gematria मान" गणना कर रहा है शब्द , द्वारा संक्षेप अपने पत्र 'मान। (कुछ लोग कहते हैं कि शब्दों, या वाक्यांशों के बीच एक रहस्यमय संबंध है (जब अंतरिक्ष का मूल्य शून्य है) - जो एक ही रत्न मूल्य साझा करता है)।

2. किसी भी गैर-नकारात्मक पूर्णांक को प्रतीकों में दर्शाया जा सकता है। उदाहरण के लिए (और अब अंग्रेजी वर्णमाला के साथ रहने के लिए) 32 का मूल्य एलबी (एल = 30 + बी = 2) है। 1024 का मूल्य ZTKD (800 + 200 + 20 + 4 है। ध्यान दें कि ZSSKD भी 1024 है, लेकिन यह कानूनी प्रतिनिधित्व नहीं है, क्योंकि यह संकुचित हो सकता है)।

चुनौती

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

एपीआई

आपके कार्यक्रम / समारोह को 3 तर्क स्वीकार करने चाहिए। आप उन्हें STDIN से प्राप्त कर सकते हैं, या फ़ंक्शन तर्क के रूप में, आप यह भी मान सकते हैं कि वे वैरिएबल हैं जो आपके फ़ंक्शन इनवोकेशन से पहले प्रोग्रामेटिक रूप से आरंभीकृत करते हैं।

• पहला तर्क - वर्णमाला का पहला चरित्र (यूनिकोड में)।
• दूसरा तर्क - वर्णमाला का अंतिम चरित्र (यूनिकोड में)।
• तीसरा तर्क - एक पूर्णांक, प्रतीकों में प्रतिनिधित्व करने के लिए, या एक वाक्यांश जो दिए गए वर्णमाला द्वारा बनाया गया है।

आउटपुट / रिटर्न वैल्यू: तीसरे तर्क पर निर्भर करता है, जैसा कि ऊपर बताया गया है।

मान्यताओं

• पहले दो तर्क हमेशा एक वर्ण लंबे होंगे, और दूसरा हमेशा पहले की तुलना में ग्रेटर होगा।
• अनुक्रम (पहले तक अंतिम, समावेशी) में 30-39 (जो अंक 0-9 का प्रतिनिधित्व करते हैं) का कोई भी मान शामिल नहीं होगा, अन्यथा यह तीसरे तर्क को अस्पष्ट बना देगा। संपादित करें: इसमें स्थान भी नहीं होगा, क्योंकि वाक्यांशों में स्थान शून्य के रूप में गिने जाते हैं।
• तीसरा तर्क, यदि यह एक वाक्यांश है, इसमें केवल दिए गए वर्णमाला के स्थान और अक्षर हो सकते हैं। खाली स्ट्रिंग एक वैध इनपुट नहीं है (आप मान सकते हैं कि यह खाली नहीं है)। यदि यह एक पूर्णांक है, तो आप इसे एक सकारात्मक पूर्णांक मान सकते हैं।

उदाहरण

Input                Output

A Z CODE GOLF        175
a s 512              sssssjb
A B 7                BBBA
≐ ⊐ ≤≫ ≥            1700

स्कोरिंग

Score = upvotes - length/100.0

आपका कोड संक्षिप्त होना चाहिए, लेकिन अधिक महत्वपूर्ण रूप से लोकप्रिय होना चाहिए। नकारात्मक स्कोर भी साथ खेल सकते हैं। विजेता अब से एक सप्ताह में उच्चतम स्कोर के साथ जवाब होगा, 2014-11-29 19:20:00 यूटीसी।

Comments

मैंने आपके प्रश्न को कैच-ऑल कोड-चैलेंज के रूप में दोहराया, क्योंकि मुझे लगता है कि स्कोरिंग या तो कोड गोल्फ या एक मानक लोकप्रियता प्रतियोगिता से अलग है।

— मार्टिन एंडर

ठीक है। यह बहुत सारे टैग है :) धन्यवाद।

— याकूब

पहले दो वर्णों द्वारा बनाई गई सूची में क्या स्थान शामिल है?

— ऑप्टिमाइज़र

इसके अलावा, दूसरी धारणा से आपका क्या मतलब है? 0 के लिए ASCII कोड 30 नहीं है।

— ऑप्टिमाइज़र

@proudhaskeller यह एक सामान्य गलती है क्योंकि आप किंडरगार्टन में सीखते हैं "pe tsady kuf resh" जो tsadik kuf की तरह लगता है ... हिब्रू के लिए अकादमी के साथ इसकी पुष्टि करने के लिए आपका स्वागत है।

— जैकब

Answer 1

सीजेएम, 80 75 70 बाइट्स, अपवोट्स - 0.7

Arc:Irc\-):N,f#{9,:)f*~}%N<lS-_A,s&{i{1${1$)<},)\,I+o-}h;;}{If-\f=:+}?

इसका परीक्षण यहां करें।

यह एक पूर्ण कार्यक्रम है, जो STDIN से इनपुट लेता है और परिणाम को STDOUT में प्रिंट करता है।

मुझे वास्तव में यकीन नहीं है कि मैं यहां लोकप्रियता के लिए शूटिंग कैसे कर सकता हूं, इसलिए मैं बस इसे गोल्फ कर रहा हूं, इसके बजाय एक उचित प्रभावशाली कोड आकार प्राप्त करने की उम्मीद कर रहा हूं। ;)

मेरा मानना ​​है कि इंट-टू-स्ट्रिंग रूपांतरण अभी भी सुधार किया जा सकता है, लेकिन मैं इसे अभी नहीं देखता हूं।

ऑप्टिमाइज़र के लिए धन्यवाद मुझे सेट चौराहे के बारे में याद दिलाने के लिए और कि खाली सरणियाँ झूठी हैं।

A                                   "Push integer 10.";
 rc:I                               "Read token, convert to character, save in I.";
     rc                             "Read token, convert to character.";
       \-)                          "Swap, subtract, increment.";
          :N                        "Store number of characters in N.";
            ,                       "Turn into range [0 1 2 ... N-1].";
             f#                     "Map 10^i onto that range.";
               {       }%           "Map this block onto the powers of 10.";
                9,                  "Create range [0 1 2 ... 8].";
                  :)                "Increment each element.";
                    f*              "Multiply each by the current power of 10.";
                      ~             "Unwrap/dump the resulting array.";
                                    "Now we've got the values of the first 9N digits.";
                         N<         "That's too much, so truncate to the first N.";
                           l        "Read the rest of the line.";
                            S-      "Remove spaces.";
                              _     "Duplicate string and get first character.";
                               A,   "Create range [0 1 2 ... 9].";
                                 s  "Turn into string '0123456789'.";
                                  & "Intersection of characters.";

{                      }{        }? "If/else depending on whether the result is empty.";
                                    "If it was a digit...";
 i                                  "Convert string to integer.";
  {                }h               "While that integer isn't zero...";
   1$                               "Copy digit values.";
     {    },                        "Filter digit values.";
      1$                            "Copy remaining integer.";
        )<                          "Increment, compare.";
                                    "This discards values greater than the integer.";
            )\                      "Slice off last digit value, and swap with list.";
              ,I+                   "Get length of list and add to I.";
                 o                  "Print character.";
                  -                 "Subtract digit value from integer.";
                     ;;             "Empty stack.";
                                    "If the string was not a number...";
                         I          "Push initial character.";
                          f-        "Subtract it from each character in string.";
                            \       "Swap differences and digit values.";
                             f=     "Use differences to index into the values.";
                               :+   "Sum up all the values.";

दूसरे मामले में, परिणाम स्टैक पर छोड़ दिया जाता है, जो प्रोग्राम के अंत में स्वचालित रूप से मुद्रित होता है।

Answer 2

जावा 7, स्कोर = अपवोट्स - 3.97

वाह!!! जावा!!! दुनिया में दुनिया की पसंदीदा गोल्फिंग भाषा। क्या, आप वास्तव में जावा में गोल्फ कर सकते हैं ??? खैर, यह एक बुलडोजर का उपयोग पुट की तरह है।

aपहला चरित्र शामिल होने की उम्मीद है। bअंतिम वर्ण शामिल होने की उम्मीद है। cइनपुट स्ट्रिंग होने की उम्मीद है।

यहाँ फ़ंक्शन गोल्फ है:

int d=0;try{d=Integer.parseInt(c);}catch(Exception e){}int l=b-a+1;char[]f=new char[l];int[]g=new int[l];int h=1;int i=1;g[0]=1;f[0]=a;int j;for(j=1;j<b-a+1;){g[j]=(h+=i);f[j]=(char)(f[j++-1]+1);i*=h==10*i?10:1;}if(d==0){h=0;for(char k:c.toCharArray()){for(j=0;j<l;j++){if(f[j]==k){h+=g[j];}}}System.out.println(h);}else{c="";for(j=l;j>0;){if(g[--j]<=d){c+=f[j];d-=g[j++];}}System.out.println(c);}

यहाँ यह संरचना कोड के साथ प्रेरित है:

public class G{

    public static void main(String[] args){
        new G(args);
    }

    public G(String[] args){
        a = args[0].charAt(0);
        b = args[1].charAt(0);
        for (int i = 2; i < args.length; i++){
            c += args[i];
        }
        function();
    }

    char a;

    char b;

    String c = "";

    void function(){
        int d=0;
        try{
            d=Integer.parseInt(c);
        }catch(Exception e){}
        int l=b-a+1;
        char[]f=new char[l];
        int[]g=new int[l];
        int h=1;
        int i=1;
        g[0]=1;
        f[0]=a;
        int j;
        for(j=1;j<b-a+1;){
            g[j]=(h+=i);
            f[j]=(char)(f[j++-1]+1);
            i*=h==10*i?10:1;
        }
        if(d==0){
            h=0;
            for(char k:c.toCharArray()){
                for(j=0;j<l;j++){
                    if(f[j]==k){
                        h+=g[j];
                    }
                }
            }
            System.out.println(h);
        }else{
            c="";
            for(j=l;j>0;){
                if(g[--j]<=d){
                    c+=f[j];
                    d-=g[j++];
                }
            }
            System.out.println(c);
        }
    }
}

यहाँ यह पूरी तरह से विस्तारित है:

public class Generator{

    public static void main(String[] args){
        beginning = args[0].charAt(0);
        end = args[1].charAt(0);
        for (int i = 2; i < args.length; i++){
            phrase += args[i];
        }
        function();
    }

    static char beginning;

    static char end;

    static String phrase = "";

    static void function(){
        int convertTo = 0;
        try{
             convertTo = Integer.parseInt(phrase);
        } catch (Exception e){}
        char[] alphabet = new char[end - beginning + 1];
        int[] values = new int[alphabet.length];
        int value = 1;
        int base = 1;
        values[0] = 1;
        alphabet[0] = beginning;
        int i;
        for (i = 1; i < values.length;){
            values[i] = (value += base);
            alphabet[i] = (char)(alphabet[i++-1]+1);
            base*=value==10*base?10:1;
        }
        if(convertTo==0){
            value = 0;
            for (char character : phrase.toCharArray()){
                for (i = 0; i < alphabet.length;i++){
                    if (alphabet[i] == character){
                        value += values[i];
                    }
                }
            }
            System.out.println(value);


        } else {
            phrase = "";
            for (i = values.length;i > 0;){
                if (values[--i] <= convertTo){
                    phrase += alphabet[i];
                    convertTo -= values[i++];
                }
            }
            System.out.println(phrase);

        }
    }
}

Answer 3

एपीएल (अपवोट्स - 1.05)

{U←⎕UCS⋄A←V↑∊(10*0,⍳⌊9÷⍨V←1+|-/U⍺)∘.×⍳9⋄⍬≢0↑⍵:+/A[1+(U⍵~' ')-U⊃⍺]⋄U(U⊃⍺)+{⍵≤0:⍬⋄(¯1+A⍳T),∇⍵-T←⊃⌽A/⍨⍵≥A}⍵}

यह एक ऐसा कार्य है जो बाईं ओर दो वर्णों को ले जाता है, और तर्क को दाईं ओर परिवर्तित किया जाता है:

      'A' 'Z'{U←⎕UCS⋄A←V↑∊(10*0,⍳⌊9÷⍨V←1+|-/U⍺)∘.×⍳9⋄⍬≢0↑⍵:+/A[1+(U⍵~' ')-U⊃⍺]⋄U(U⊃⍺)+{⍵≤0:⍬⋄(¯1+A⍳T),∇⍵-T←⊃⌽A/⍨⍵≥A}⍵}'CODE GOLF'
175
      gematria←{U←⎕UCS⋄A←V↑∊(10*0,⍳⌊9÷⍨V←1+|-/U⍺)∘.×⍳9⋄⍬≢0↑⍵:+/A[1+(U⍵~' ')-U⊃⍺]⋄U(U⊃⍺)+{⍵≤0:⍬⋄(¯1+A⍳T),∇⍵-T←⊃⌽A/⍨⍵≥A}⍵}
      'A' 'Z' gematria 'CODE GOLF'
175
      'a' 's' gematria 512
sssssjb
      'A' 'B' gematria 7
BBBA
      '≐' '⊐' gematria '≤≫ ≥'
1700

Ungolfed संस्करण:

gematria←{
   ⍝ get Unicode values for characters
   first last←⎕UCS¨⍺
   amount←1+last-first
   ⍝ find the value for each character in the alphabet
   alphabet←amount↑∊(10*0,⍳⌊amount÷9)∘.×⍳9

   ⍝ right arg is string: calculate number
   ⍬≢0↑⍵: +/ alphabet[1+(⎕UCS ⍵~' ')-first]

   ⍝ otherwise, right arg is number: find string
   ⎕UCS first+{
      ⍝ number ≤ 0? empty string
      ⍵≤0:⍬

      ⍝ find highest value we can subtract
      val←⊃⌽(⍵≥alphabet)/alphabet

      ⍝ return it, followed by the conversion of the rest of the number
      (¯1+alphabet⍳val), ∇⍵-val
   }⍵
}

Answer 4

हास्केल, 188 बाइट्स; अपवोट्स - 1.88

यह एक पूर्ण विकसित STDIN-to-STDOUT कार्यक्रम है, भारी गोल्फ है। संपादित करें: अब अंडर 200 बाइट्स में! EDIT2: @ बाइटसैलर के सुझाव के साथ एक बाइट को बचाया।

x=[1..9]++map(*10)x
f(a:_:b:_:z@(u:_))|u>'/'&&u<':'=w$read z|1<2=show.sum$map v z where v ' '=0;v c=x!!(length[a..c]-1);w 0="";w n=(\c->c:w(n-v c))$last[d|d<-[a..b],v d<=n]
main=interact$f

यह मूल्यों की अनंत सूची का निर्माण करता है x = [1,2,3,4,5,6,7,8,9,10,20,30,..] पहली पंक्ति पर करता है, और तीसरी पंक्ति पर I / O करता है। एक अक्षर का मान c, सीमा को देखते हुए [a..b], तब की स्थिति length [a..c] - 1में मूल्य है x। दूसरी पंक्ति में, हम uतीसरे तर्क के पहले अक्षर पर शाखा करते हैं , और या तो उसके जेम्रिया मूल्यों (यदि uकोई अंक नहीं है) को योग करते हैं , या दिए गए मूल्य के साथ एक शब्द का लालच बनाते हैं (यदि uएक अंक है)।

अधिक पठनीय चर नामों के साथ अनगुल्ड संस्करण:

values = [1..9] ++ map (*10) values
f (low:_:high:_:rest@(first:_))
  | first > '/' && first < ':' = construct $ read rest
  | otherwise                  = show . sum $ map value rest
  where value ' '   = 0
        value c     = values !! (length [low..c] - 1)
        construct 0 = ""
        construct n = (\c -> c : construct (n - value c)) $
                      last [d | d <- [low..high], value d <= n]
main = interact $ f

Comments

आप {}एक बाइट हासिल करने के लिए क्लॉज को कहां से हटा सकते हैं

— गर्वित हेकेलर

Answer 5

सीजाम, 70 बाइट्स, # यूपोट्स - 0.7

{{_9%)A@9/#*}%}:M;rcrc),\i>:QlS-_@&{Qf#M:+}{i{Q,,M{1$)<},)Q@,=@@-}h;}?

यह मानता है कि एक वैध इनपुट पारित किया जाएगा। STDIN से इनपुट लेता है जैसे API युक्ति कहती है और परिणाम STDOUT को प्रिंट करती है।

उदाहरण:

Input                Output

A Z CODE GOLF        175
a s 512              sssssjb
A B 7                BBBA
≐ ⊐ ≤≫ ≥            1700

इसे यहाँ ऑनलाइन आज़माएँ

ब्लॉक वार स्पष्टीकरण :

{{_9%)A@9/#*}%}:M;
{             }:M;              "Define a function M which takes an input array of"
                                "indeces and calculates the Gematri number for them";
 {          }%                  "Run this code block for each element of the array";
  _9%)                          "Copy the number, take modulus by 9 and increment it";
      A@                        "Put 10 on stack, and rotate to get the number on top";
        9/                      "Integer divide the number by 9";
          #                     "Calculate 10 to the power the above quotient";
           *                    "Multiply the above result by modulus 9";

rcrc),\i>:QlS-_@&
rcrc                            "Read the first two characters, representing the lower"
                                "and upper end of the character list";
    ),                          "Increment the upper end and get a list of U to ASCII 0"
                                "characters where U is the upper limit";
      \i                        "Swap and convert the lower limit to its ASCII number";
        >:Q                     "Slice the character list to get our desired character"
                                "list range and store it in Q";
           lS-                  "Read the rest of the line as string and remove spaces";
              _@&               "Take a copy, get Q on top of stack and take"
                                "intersection with the input string. If the resulting"
                                "string is empty, then the third input was a number";
                 {...}{...}?    "First code block is for string input and second for"
                                "number input based on the above intersected string";

{Qf#M:+}
 Qf#                            "For each character of input string, calculate its"
                                "position in Q";
    M                           "Get the Gematri numbers for these inceces";
     :+                         "Sum them all to get the final Gematri number for the"
                                "input string"

{i{Q,,M{1$)<},)Q@,=@@-}h;}
 i                              "Convert the input number string to integer";
  {                   }h        "Run the code block till we get 0 on top of stack";
   Q,,M                         "Get the first length(Q) Gematri numbers";
       {1$)<},                  "Filter and take only which are less than input number";
              )                 "Pop the last number from the filtered array. This is"
                                "The maximum Gematri number that can be deducted";
               Q@               "Put Q on stack and rotate the remaining filtered array"
                                "to top of stack";
                 ,              "Calculate the length of that array, which is also the"
                                "index of the Gematri number used.";
                  =             "Get the corresponding character to that Gematri number";
                   @@-          "Put the number and Gematri number on top and subtract."
                                "The next loop runs on the above result now";
                        ;       "Pop the resedual 0 from stack. The remaining stack now"
                                "contains just the Gematri characters."