स्ट्रिंग दूरी

Question

चुनौती

ऑल-लोअरकेस स्ट्रिंग के इनपुट को देखते हुए [a-z], अक्षरों के बीच की कुल दूरी को आउटपुट करें।

उदाहरण

Input: golf

Distance from g to o : 8
Distance from o to l : 3
Distance from l to f : 6

Output: 17

नियम

• मानक खामियों से मना किया
• यह कोड-गोल्फ है - बाइट्स जीत में सबसे छोटा जवाब।
• वर्णमाला को किसी भी दिशा से ट्रेस किया जा सकता है। आपको हमेशा सबसे छोटे रास्ते का उपयोग करना चाहिए। (दूरी यानी के बीच xऔर c5 है)।

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

Input: aa
Output: 0

Input: stack
Output: 18

Input: zaza
Output: 3

Input: valleys
Output: 35

Answer 1

जेली , 11 8 बाइट्स

OIæ%13AS

@ मार्टिन एंडर के लिए 3 बाइट्स धन्यवाद सहेजा गया ।

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

व्याख्या

OIæ%13AS  Input: string Z
O         Ordinal. Convert each char in Z to its ASCII value
 I        Increments. Find the difference between each pair of values
  æ%13    Symmetric mod. Maps each to the interval (-13, 13]
      A   Absolute value of each
       S  Sum
          Return implicitly

Comments

मैं æ%दूसरे दिन बिल्ट-इन के माध्यम से पढ़ते हुए आया , और यह इस प्रकार की समस्या के लिए बहुत अधिक था:OIæ%13AS

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

मुझे लगता है कि यह 9 बाइट्स है ( æदो है)।

— अलेक्सी ज़ब्रोद्स्की

: @elmigranto जेली एक कोडपेज कि एक बाइट में अपनी पात्रों में से प्रत्येक को कूटबद्ध है github.com/DennisMitchell/jelly/wiki/Code-page

— Ruds

Answer 2

हास्केल, 57 56 बाइट्स

q=map$(-)13.abs
sum.q.q.(zipWith(-)=<<tail).map fromEnum

प्रयोग उदाहरण: sum.q.q.(zipWith(-)=<<tail).map fromEnum $ "valleys"-> 35।

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

q=map$(-)13.abs                -- helper function.
                               -- Non-pointfree: q l = map (\e -> 13 - abs e) l
                               -- foreach element e in list l: subtract the
                               -- absolute value of e from 13

               map fromEnum    -- convert to ascii values
      zipWith(-)=<<tail        -- build differences of neighbor elements
  q.q                          -- apply q twice on every element
sum                            -- sum it up

संपादित करें: @Damien ने एक बाइट को बचाया। धन्यवाद!

Comments

घूर्णी दूरी चाल के लिए धन्यवाद ( q.q)

— लीफ विलर्ट

वाह अच्छा है! आप एक बाइट कम mapकी परिभाषा में जोड़ सकते हैंq

— डेमियन

@ डैमियन: अच्छी तरह से देखा। धन्यवाद!

— नागी

Answer 3

MATL , 14 , 10 बाइट्स

dt_v26\X<s

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

धन्यवाद @ बाइट बचाने के लिए 4 बाइट्स!

स्पष्टीकरण:

d           % Take the difference between consecutive characters
 t_         % Make a copy of this array, and take the negative of each element
   v        % Join these two arrays together into a matrix with height 2
    26\     % Mod 26 of each element
       X<   % Grab the minimum of each column
         s  % Sum these. Implicitly print

पुराना वर्जन:

d26\t13>26*-|s

Answer 4

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

lambda s:sum([13-abs(13-abs(ord(a)-ord(b)))for a,b in zip(s,s[1:])])

टूट - फूट:

lambda s:
         sum(                                                      )
             [                             for a,b in zip(s,s[1:])]
              13-abs(13-abs(ord(a)-ord(b)))

Comments

इससे पहले कि आप अंतरिक्ष को हटाकर एक बाइट खो सकते हैंfor

— डैनियल

@ डोप्प्प ओह हां, धन्यवाद!

— बसुकक्सुआन

आप इनपुट को पात्रों की एक सूची के रूप में ले सकते हैं और 3 बाइट्स को बचाने के लिए पुनरावर्तन का उपयोग कर सकते हैं:f=lambda a,b,*s:13-abs(13-abs(ord(a)-ord(b)))+(s and f(b,*s)or 0)

— जोनाथन एलन

Answer 5

जावा, 126 120 117 बाइट्स

int f(String s){byte[]z=s.getBytes();int r=0,i=0,e;for(;++i<z.length;r+=(e=(26+z[i]-z[i-1])%26)<14?e:26-e);return r;}

मूल संस्करण में एक बग को इंगित करने के लिए @ केविनक्रूजसेन का धन्यवाद और फॉर-लूप को खाली करने का सुझाव दिया गया।

का उपयोग (26 + z[i] - z[i - 1]) % 26)किसी अन्य उत्तर पर @Neil की टिप्पणी से प्रेरित है। (26 + ...)%26के Math.abs(...)कारण के रूप में एक ही उद्देश्य में कार्य करता है ...? e : 26 - e।

अधूरा :

int f(String s) {
    byte[]z = s.getBytes();
    int r = 0, i = 0, e;
    for (; ++i < z.length; r += (e = (26 + z[i] - z[i - 1]) % 26) < 14 ? e : 26 - e);
    return r;
}

Comments

साइट पर आपका स्वागत है! यह कौनसी भाषा है? कितने अक्षर / बाइट है? आपको चाहिये [edit] those details into the top of your post, with this markdown: #Language, एन bytes`

— DJMcMayhem

ठीक है। धन्यवाद। मैंने इसे संपादित किया है। कोई सुधार? :)

— todeale

आप अपने ungolfed संस्करण में -पहले से गायब हैं e।

— नील

PPCG में आपका स्वागत है! हम्म, मुझे एक "टाइप मिसमैच: इंट से बाइट में परिवर्तित नहीं कर सकता" त्रुटि हो रही है e=z[i]-z[i-1];इसलिए आपको या तो एक कास्ट की आवश्यकता है (byte)या इसे बदलना eहै int। : इसके अलावा, आप के अंदर के लिए लूप, इस तरह सब कुछ रखकर के लिए लूप कोष्ठक निकाल सकते हैं int f(String s){byte[]z=s.getBytes();int r=0,i=0,e;for(;++i<z.length;r+=(e=z[i]-z[i-1])>0?e<14?e:26-e:-e<14?-e:e+26);return r;}(पुनश्च: उलट के लिए लूप दुर्भाग्य से एक ही लंबाई है: int f(String s){byte[]z=s.getBytes();int r=0,i=z.length-1,e;for(;i>0;r+=(e=z[i]-z[--i])>0?e<14?e:26-e:-e<14?-e:e+26);return r;}।

— केविन Cruijssen

बहुत बहुत धन्यवाद @ केविनक्रूजसेन: डी। आपके सुझाव से बहुत मदद मिली है।

— टॉडल

Answer 6

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

साइओस को 3 बाइट्स से बचा लिया गया:

f=([d,...s],p=parseInt,v=(26+p(s[0],36)-p(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0

स्पष्टीकरण:

f=(
  [d,...s],                    //Destructured input, separates first char from the rest
  p=parseInt,                  //p used as parseInt
  v=(26+p(s[0],36)-p(d,36))%26 //v is the absolute value of the difference using base 36 to get number from char
  )
)=>
  s[0]?                        //If there is at least two char in the input
    f(s)                       //sum recursive call
    +                          //added to
    (v>13?26-v:v)              //the current shortest path
  :                            //else
    0                          //ends the recursion, returns 0

उदाहरण:
कॉल: f('golf')
आउटपुट:17

---

पिछले समाधान:

नील को 82 बाइट्स धन्यवाद:

f=([d,...s],v=(26+parseInt(s[0],36)-parseInt(d,36))%26)=>s[0]?f(s)+(v>13?26-v:v):0

84 बाइट्स:

f=([d,...s],v=Math.abs(parseInt(s[0],36)-parseInt(d,36)))=>s[0]?f(s)+(v>13?26-v:v):0

Comments

इसके बजाय Math.abs(...)आप का उपयोग कर सकते हैं (26+...)%26; यह काम करता है क्योंकि आप 13 से ऊपर के मूल्यों को वैसे भी फ़्लिप कर रहे हैं। (मुझे लगता है कि यह कैसे MATL उत्तर काम करता है।)

— नील

कोड को p=parseInt;पहले से उपयोग करके और फिर p()इसके बजाय का उपयोग करके कुछ बाइट्स सहेजेंparseInt()

— Cyoce

Answer 7

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

->x{eval x.chars.each_cons(2).map{|a,b|13-(13-(a.ord-b.ord).abs).abs}*?+}

Answer 8

PHP, 93 बाइट्स

for(;++$i<strlen($s=$argv[1]);)$r+=13<($a=abs(ord($s[$i-1])-ord($s[$i])))?$a=26-$a:$a;echo$r;

Answer 9

05AB1E , 12 बाइट्स

SÇ¥YFÄ5Ø-}(O

व्याख्या

SÇ                   # convert to list of ascii values
  ¥                  # take delta's
   YF    }           # 2 times do
     Ä5Ø-            # for x in list: abs(x) - 13
          (O         # negate and sum

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

Comments

यह 12 प्रतीक हैं, बाइट्स नहीं। यूटीएफ -8 के लिए बाइट की लंबाई 16 होगी।

— अलेक्सी ज़ब्रोद्स्की

@elmigranto: वास्तव में। UTF-8 में ऐसा ही होगा, लेकिन 05AB1E CP-1252 का उपयोग करता है जहां यह 12 बाइट्स है।

— 10

Answer 10

पर्ल, 46 बाइट्स

+3 के लिए -p(कोड शामिल हैं ')

अंतिम नई लाइन के बिना STDIN पर इनपुट दें:

echo -n zaza | stringd.pl

stringd.pl:

#!/usr/bin/perl -p
s%.%$\+=13-abs 13-abs ord($&)-ord$'.$&%eg}{

Answer 11

रैकेट 119 बाइट्स

(λ(s)(for/sum((i(sub1(string-length s))))(abs(-(char->integer
(string-ref s i))(char->integer(string-ref s(+ 1 i)))))))

परिक्षण:

(f "golf")

आउटपुट:

17

विस्तृत संस्करण:

(define(f s)
  (for/sum((i(sub1(string-length s))))
    (abs(-(char->integer(string-ref s i))
          (char->integer(string-ref s(+ 1 i)))))))

Comments

आप के (define(f s)साथ प्रतिस्थापित कर सकते हैं (lambda(s), 2 बाइट्स छोटे (अनाम फ़ंक्शन ठीक हैं)।

— फेड एस।

रुको, रैकेट को (λ(s)भी लेना चाहिए , जो अगर utf8 में 6 बाइट्स है, तो मुझे लगता है

— फेड एस।

हो गया। धन्यवाद।

— रंसो

Answer 12

सी #, 87 85 बाइट्स

बेहतर समाधान - 2 बाइट्स को बचाने के लिए जोड़ें और modulo चाल के साथ Math.Abs ​​() को बदल दिया गया:

s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=(s[i]-s[++i]+26)%26)>13?26-d:d;return l;};

प्रारंभिक समाधान:

s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};

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

पूर्ण स्रोत, परीक्षण मामलों सहित:

using System;

namespace StringDistance
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,int>f= s=>{int l=0,d,i=0;for(;i<s.Length-1;)l+=(d=Math.Abs(s[i]-s[++i]))>13?26-d:d;return l;};

            Console.WriteLine(f("golf"));   //17
            Console.WriteLine(f("aa"));     //0
            Console.WriteLine(f("stack"));  //18
            Console.WriteLine(f("zaza"));   //3
            Console.WriteLine(f("valleys"));//35
        }
    }
}

Answer 13

दरअसल, 21 बाइट्स

आंशिक रूप से cia_rana के रूबी जवाब पर आधारित है ।

एक बग के साथ O(इस मामले में, मैप ऑर्ड (एक स्ट्रिंग के ऊपर)) जहां यह पहली बार नक्शे को एक सूची में बदलने के बिना d(dequeue निचला तत्व) और p(पॉप पहले तत्व) के साथ काम नहीं करेगा #। इस बग को ठीक कर दिया गया है, लेकिन जैसा कि इस चुनौती से नया तय है, इसलिए मैंने इसमें रखा #है।

संपादित करें: और बाइट की गिनती सितंबर के बाद से गलत है। ओह।

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

O#;dX@pX♀-`A;úl-km`MΣ

Ungolfing

         Implicit input string.
          The string should already be enclosed in quotation marks.
O#       Map ord() over the string and convert the map to a list. Call it ords.
;        Duplicate ords.
dX       Dequeue the last element and discard it.
@        Swap the with the duplicate ords.
pX       Pop the last element and discard it. Stack: ords[:-1], ords[1:]
♀-       Subtract each element of the second list from each element of the first list.
          This subtraction is equivalent to getting the first differences of ords.
`...`M   Map the following function over the first differences. Variable i.
  A;       abs(i) and duplicate.
  úl       Push the lowercase alphabet and get its length. A golfy way to push 26.
  -        26-i
  k        Pop all elements from stack and convert to list. Stack: [i, 26-i]
  m        min([i, 26-i])
Σ        Sum the result of the map.
         Implicit return.

Answer 14

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

 int f(String s){char[]c=s.toCharArray();int t=0;for(int i=1,a;i<c.length;a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);return t;}

Ungolfed

 int f(String s){
 char[]c=s.toCharArray();
 int t=0;
 for(int i=1,a;
     i<c.length;
   a=Math.abs(c[i]-c[i++-1]),t+=26-a<a?26-a:a);
return t;
 }

Answer 15

अजगर, 20 बाइट्स

Lm-13.adbsyy-M.:CMQ2

एक प्रोग्राम जो STDIN पर एक उद्धृत स्ट्रिंग का इनपुट लेता है और परिणाम प्रिंट करता है।

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

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

Lm-13.adbsyy-M.:CMQ2  Program. Input: Q
L                     def y(b) ->
 m      b              Map over b with variable d:
  -13                   13-
     .ad                abs(d)
                CMQ   Map code-point over Q
              .:   2  All length 2 sublists of that
            -M        Map subtraction over that
          yy          y(y(that))
         s            Sum of that
                      Implicitly print

Answer 16

डीसी + ओडी, ६५ बाइट्स

od -tuC|dc -e'?dsN0sT[lNrdsNr-d*vdD[26-]sS<Sd*vlT+sTd0<R]dsRxlTp'

स्पष्टीकरण:

क्योंकि डीसी में आप स्ट्रिंग के पात्रों तक नहीं पहुंच सकते हैं, मैंने ASCII मान प्राप्त करने के लिए od का उपयोग किया । इन्हें स्टैक (LIFO कंटेनर) से रिवर्स ऑर्डर में संसाधित किया जाएगा, जैसे:

dsN0sT             # initialize N (neighbor) = top ASCII value, and T (total) = 0
[lNrdsNr-          # loop 'R': calculate difference between current value and N,
                   #updating N (on the first iteration the difference is 0)
   d*vdD[26-]sS<S  # get absolute value (d*v), push 13 (D) and call 'S' to subtract
                   #26 if the difference is greater than 13
   d*vlT+sT        # get absolute value again and add it to T
d0<R]dsR           # repeat loop for the rest of the ASCII values
xlTp               # the main: call 'R' and print T at the end

चलाएँ:

echo -n "golf" | ./string_distance.sh

आउटपुट:

17

Answer 17

सी, 82 86 83 76 बाइट्स

t,u;f(char*s){for(t=0;*++s;u=*s-s[-1],t+=(u=u<0?-u:u)>13?26-u:u);return t;}

इनपुट स्ट्रिंग मानती है कि कम से कम एक वर्ण लंबा है। इसकी आवश्यकता नहीं है#include<stdlib.h>

संपादित करें: Argh, अनुक्रम अंक!

Ideone पर इसे आज़माएं

Comments

ideone संकलक में स्ट्रिंग "nwlrbb" और सभी रैंड स्ट्रिंग मैं 6 लेन को सभी 0 पर वापस करने की कोशिश करता हूं, लेकिन यह 0 परिणाम नहीं लगता है ....

— RosLuP

हाँ अब ठीक लगता है ...

— RosLuP

Answer 18

सी, 70 बाइट्स 76 बाइट्स

k,i;f(char *s){for(i=0;*++s;i+=(k=abs(*s-s[-1]))>13?26-k:k);return i;}

Answer 19

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

def f(s:String)=(for(i<-0 to s.length-2)yield (s(i)-s(i+1)).abs).sum

आलोचना का स्वागत है।

Answer 20

सी #, 217 बाइट्स

golfed:

IEnumerable<int>g(string k){Func<Char,int>x=(c)=>int.Parse(""+Convert.ToByte(c))-97;for(int i=0;i<k.Length-1;i++){var f=x(k[i]);var s=x(k[i+1]);var d=Math.Abs(f-s);yield return d>13?26-Math.Max(f,s)+Math.Min(f,s):d;}}

Ungolfed:

IEnumerable<int> g(string k)
{
  Func<Char, int> x = (c) => int.Parse("" + Convert.ToByte(c)) - 97;
  for (int i = 0; i < k.Length - 1; i++)
  {
    var f = x(k[i]);
    var s = x(k[i + 1]);
    var d = Math.Abs(f - s);
    yield return d > 13 ? 26 - Math.Max(f, s) + Math.Min(f, s) : d;
  }
}

आउटपुट:

aa: 0
stack: 18
zaza: 3
valleys: 35

बाइट्स में परिवर्तित होने पर 'a' 97 होता है, इसलिए 97 को प्रत्येक से घटाया जाता है। यदि अंतर 13 (यानी, वर्णमाला का आधा) से अधिक है, तो प्रत्येक वर्ण (बाइट मान) के बीच के अंतर को 26 से घटाएं। "उपज वापसी" के अंतिम मिनट के अलावा ने मुझे कुछ बाइट्स बचाए!

Comments

दो बेकार व्हाट्सएप: दोनों 'एस' से पहले।

— यति

Answer 21

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

समझ में सूची के साथ ।

d=input()
print(sum([min(abs(x-y),x+26-y)for x,y in[map(lambda x:(ord(x)-97),sorted(d[i:i+2]))for i in range(len(d))][:-1]]))

Comments

अच्छा जवाब। आप बदल सकते abs(x-y)द्वारा y-xकरने के लिए कॉल के बाद से sortedबनाने के x < y।

— ताड़ी

Answer 22

PHP, 79 बाइट्स

for($w=$argv[1];$w[++$i];)$s+=13-abs(13-abs(ord($w[$i-1])-ord($w[$i])));echo$s;

Answer 23

जावा, 109 बाइट्स

int f(String s){int x=0,t,a=0;for(byte b:s.getBytes()){t=a>0?(a-b+26)%26:0;t=t>13?26-t:t;x+=t;a=b;}return x;