Crea un calcolatore gematria bidirezionale, per ogni sequenza di caratteri Unicode come alfabeto.

Gematri-Cosa?

La gematria è un sistema di assegnazione di valori numerici ai simboli, sviluppato dagli antichi greci e adottato dagli antichi ebrei. È in un modo come ASCII o Unicode, è solo non lineare ... Vedi la tabella seguente (la tabella completa è disponibile nel link sopra):

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

           ...

I nomi delle lettere non sono importanti, ma solo il loro indice nella "Matrice" dell'alfabeto e il rispettivo valore numerico. L'alfabeto ebraico ha solo 22 lettere (escluse le lettere "finali"), quindi il valore massimo disponibile è 400.

Se prendiamo in prestito questo sistema con l'alfabeto inglese (AZ) finiremo con A = 1, B = 2 ... L = 30 ... U = 300 ... Z = 800.

Due cose che dobbiamo sapere.

1. Una delle caratteristiche più importanti di questo sistema è il calcolo del "valore Gematria" di una parola , riassumendo i valori delle sue lettere. (Alcuni dicono che esiste una connessione mistica tra parole o frasi (quando il valore dello spazio è zero) - che condividono lo stesso valore Gematria).

2. Qualsiasi numero intero non negativo può essere rappresentato in simboli. Ad esempio (e restiamo con l'alfabeto inglese per ora) il valore di 32 è LB (L = 30 + B = 2). Il valore di 1024 è ZTKD (800 + 200 + 20 + 4. Si noti che anche ZSSKD è 1024, ma questa non è una rappresentazione legale, poiché può essere compattata).

La sfida

Scrivi un programma / una funzione / uno snippet di codice nella tua lingua preferita, che viene prima impostato con un alfabeto (vedi API di seguito) e quindi accetta un argomento. Tale argomento può essere un numero intero o una parola / frase. Se è un numero intero - il tuo programma dovrebbe generare / restituire la sua rappresentazione nei simboli alfabetici - il più compatto (vedi (2) sopra). Se è una parola o una frase, il tuo programma dovrebbe generare / restituire il valore Gematria (sommando i valori dei simboli, non contando gli spazi bianchi, vedi (1) sopra).

API

Il tuo programma / funzione dovrebbe accettare 3 argomenti. Puoi ottenerli da STDIN o, come argomenti di funzione, puoi persino supporre che siano variabili inizializzate a livello di codice prima dell'invocazione della tua funzione.

• Primo argomento: il primo carattere (in Unicode) dell'alfabeto.
• Secondo argomento: l'ultimo carattere (in Unicode) dell'alfabeto.
• Terzo argomento - Un numero intero, da rappresentare in simboli, O una frase che viene creata dal dato alfabeto.

Valore di output / ritorno: a seconda del terzo argomento, come spiegato sopra.

ipotesi

• I primi due argomenti saranno sempre lunghi un carattere ciascuno e il secondo sarà sempre più grato del primo.
• La sequenza (dalla prima all'ultima, compresa) non includerà mai nessuno dei valori 30-39 (che rappresentano le cifre 0-9), altrimenti renderà ambiguo il terzo argomento. EDIT: non conterrà anche spazio, poiché nelle frasi gli spazi vengono contati come zeri.
• Il terzo argomento, nel caso sia una frase, può contenere solo spazi e lettere dell'alfabeto specificato. La stringa vuota non è un input valido (si può presumere che non sia vuoto). Nel caso in cui sia un numero intero, puoi presumere che sia un numero intero positivo.

Esempi

Input                Output

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

punteggio

Score = upvotes - length/100.0

Il tuo codice dovrebbe essere breve, ma soprattutto popolare. I punteggi negativi possono anche giocare insieme. Il vincitore sarà la risposta con il punteggio più alto tra una settimana, 29/11/2014 alle 19:20:00 UTC.

CJam, 80 75 70 byte, Voti positivi - 0.7

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

Provalo qui.

Questo è un programma completo, che prende input da STDIN e stampa il risultato su STDOUT.

Non sono davvero sicuro di come dovrei sparare per la popolarità qui, quindi sto semplicemente giocando a golf, sperando di ottenere una dimensione del codice ragionevolmente impressionante. ;)

Credo che la conversione da int a stringa possa ancora essere migliorata, ma al momento non la vedo.

Grazie a Optimizer per avermi ricordato l'intersezione impostata e che gli array vuoti sono falsi.

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.";

Nel secondo caso, il risultato viene lasciato in pila, che viene stampato automaticamente alla fine del programma.

Java 7, Punteggio = Voti positivi - 3.97

Sìì!!! Giava!!! La lingua di golf preferita al mondo nel mondo. Cosa, puoi davvero giocare a golf a Java ??? Beh, è ​​un po 'come usare un bulldozer per mettere.

adovrebbe contenere il primo carattere. bdovrebbe contenere l'ultimo carattere. cdovrebbe avere la stringa di input.

Ecco la funzione golf:

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);}

Qui è rientrato con il codice di struttura:

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);
        }
    }
}

Qui è completamente espanso:

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);

        }
    }
}

APL (voti positivi - 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}⍵}

Questa è una funzione che accetta i due caratteri a sinistra e l'argomento da convertire a destra:

      '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

Versione non golfata:

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
   }⍵
}

Haskell, 188 byte; Voti positivi: 1,88

Questo è un vero e proprio programma STDIN-to-STDOUT, fortemente giocato a golf. EDIT: ora in meno di 200 byte! EDIT2: salvato un byte con il suggerimento di @ proudhaskeller.

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

Costruisce l'elenco infinito di valori x = [1,2,3,4,5,6,7,8,9,10,20,30,..]sulla prima riga e esegue I / O sulla terza riga. Il valore di una lettera c, dato l'intervallo [a..b], è quindi il valore nella posizione length [a..c] - 1di x. Sulla seconda riga, ramifichiamo la prima lettera udel terzo argomento e sommiamo i suoi valori di gematria (se unon è una cifra) o costruiamo avidamente una parola con il valore dato (se uè una cifra).

Versione non golfata con nomi di variabili più leggibili:

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

CJam, 70 byte, #Upgrade - 0.7

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

Ciò presuppone che verrà passato un input valido. Riceve input da STDIN come dice la specifica API e stampa i risultati su STDOUT.

Esempi:

Input                Output

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

Provalo online qui

Blocca saggia spiegazione :

{{_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."